esphome 2025.4.2__py3-none-any.whl → 2025.5.0b3__py3-none-any.whl

esphome/components/template/lock/__init__.py

@@ -17,17 +17,11 @@ from .. import template_ns
 
 TemplateLock = template_ns.class_("TemplateLock", lock.Lock, cg.Component)
 
-LockState = lock.lock_ns.enum("LockState")
-
-LOCK_STATES = {
-    "LOCKED": LockState.LOCK_STATE_LOCKED,
-    "UNLOCKED": LockState.LOCK_STATE_UNLOCKED,
-    "JAMMED": LockState.LOCK_STATE_JAMMED,
-    "LOCKING": LockState.LOCK_STATE_LOCKING,
-    "UNLOCKING": LockState.LOCK_STATE_UNLOCKING,
-}
-
-validate_lock_state = cv.enum(LOCK_STATES, upper=True)
+TemplateLockPublishAction = template_ns.class_(
+    "TemplateLockPublishAction",
+    automation.Action,
+    cg.Parented.template(TemplateLock),
+)
 
 
 def validate(config):
@@ -42,9 +36,9 @@ def validate(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    lock.LOCK_SCHEMA.extend(
+    lock.lock_schema(TemplateLock)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(TemplateLock),
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,
             cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
             cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
@@ -54,19 +48,19 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_LOCK_ACTION): automation.validate_automation(single=True),
             cv.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     validate,
 )
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await lock.new_lock(config)
     await cg.register_component(var, config)
-    await lock.register_lock(var, config)
 
     if CONF_LAMBDA in config:
         template_ = await cg.process_lambda(
-            config[CONF_LAMBDA], [], return_type=cg.optional.template(LockState)
+            config[CONF_LAMBDA], [], return_type=cg.optional.template(lock.LockState)
         )
         cg.add(var.set_state_lambda(template_))
     if CONF_UNLOCK_ACTION in config:
@@ -88,17 +82,18 @@ async def to_code(config):
 
 @automation.register_action(
     "lock.template.publish",
-    lock.LockPublishAction,
-    cv.Schema(
+    TemplateLockPublishAction,
+    cv.maybe_simple_value(
         {
-            cv.Required(CONF_ID): cv.use_id(lock.Lock),
-            cv.Required(CONF_STATE): cv.templatable(validate_lock_state),
-        }
+            cv.GenerateID(): cv.use_id(TemplateLock),
+            cv.Required(CONF_STATE): cv.templatable(lock.validate_lock_state),
+        },
+        key=CONF_STATE,
     ),
 )
 async def lock_template_publish_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_STATE], args, LockState)
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_STATE], args, lock.LockState)
     cg.add(var.set_state(template_))
     return var

esphome/components/template/lock/automation.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "template_lock.h"
+
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace template_ {
+
+template<typename... Ts> class TemplateLockPublishAction : public Action<Ts...>, public Parented<TemplateLock> {
+ public:
+  TEMPLATABLE_VALUE(lock::LockState, state)
+
+  void play(Ts... x) override { this->parent_->publish_state(this->state_.value(x...)); }
+};
+
+}  // namespace template_
+}  // namespace esphome

esphome/components/template/text/__init__.py

@@ -46,9 +46,9 @@ def validate(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    text.TEXT_SCHEMA.extend(
+    text.text_schema(TemplateText)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(TemplateText),
             cv.Optional(CONF_MIN_LENGTH, default=0): cv.int_range(min=0, max=255),
             cv.Optional(CONF_MAX_LENGTH, default=255): cv.int_range(min=0, max=255),
             cv.Optional(CONF_PATTERN): cv.string,
@@ -58,7 +58,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
             cv.Optional(CONF_RESTORE_VALUE, default=False): cv.boolean,
         }
-    ).extend(cv.polling_component_schema("60s")),
+    )
+    .extend(cv.polling_component_schema("60s")),
     validate,
 )
 

esphome/components/template/valve/__init__.py

@@ -21,6 +21,10 @@ from .. import template_ns
 
 TemplateValve = template_ns.class_("TemplateValve", valve.Valve, cg.Component)
 
+TemplateValvePublishAction = template_ns.class_(
+    "TemplateValvePublishAction", automation.Action, cg.Parented.template(TemplateValve)
+)
+
 TemplateValveRestoreMode = template_ns.enum("TemplateValveRestoreMode")
 RESTORE_MODES = {
     "NO_RESTORE": TemplateValveRestoreMode.VALVE_NO_RESTORE,
@@ -31,23 +35,30 @@ RESTORE_MODES = {
 CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 
-CONFIG_SCHEMA = valve.VALVE_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TemplateValve),
-        cv.Optional(CONF_LAMBDA): cv.returning_lambda,
-        cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
-        cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
-        cv.Optional(CONF_HAS_POSITION, default=False): cv.boolean,
-        cv.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_TOGGLE_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_POSITION_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_RESTORE_MODE, default="NO_RESTORE"): cv.enum(
-            RESTORE_MODES, upper=True
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    valve.valve_schema(TemplateValve)
+    .extend(
+        {
+            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+            cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
+            cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
+            cv.Optional(CONF_HAS_POSITION, default=False): cv.boolean,
+            cv.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_TOGGLE_ACTION): automation.validate_automation(
+                single=True
+            ),
+            cv.Optional(CONF_POSITION_ACTION): automation.validate_automation(
+                single=True
+            ),
+            cv.Optional(CONF_RESTORE_MODE, default="NO_RESTORE"): cv.enum(
+                RESTORE_MODES, upper=True
+            ),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
@@ -90,10 +101,10 @@ async def to_code(config):
 
 @automation.register_action(
     "valve.template.publish",
-    valve.ValvePublishAction,
+    TemplateValvePublishAction,
     cv.Schema(
         {
-            cv.Required(CONF_ID): cv.use_id(valve.Valve),
+            cv.GenerateID(): cv.use_id(TemplateValve),
             cv.Exclusive(CONF_STATE, "pos"): cv.templatable(valve.validate_valve_state),
             cv.Exclusive(CONF_POSITION, "pos"): cv.templatable(cv.percentage),
             cv.Optional(CONF_CURRENT_OPERATION): cv.templatable(
@@ -103,8 +114,8 @@ async def to_code(config):
     ),
 )
 async def valve_template_publish_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
     if state_config := config.get(CONF_STATE):
         template_ = await cg.templatable(state_config, args, float)
         cg.add(var.set_position(template_))

esphome/components/template/valve/automation.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "template_valve.h"
+
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace template_ {
+
+template<typename... Ts> class TemplateValvePublishAction : public Action<Ts...>, public Parented<TemplateValve> {
+  TEMPLATABLE_VALUE(float, position)
+  TEMPLATABLE_VALUE(valve::ValveOperation, current_operation)
+
+  void play(Ts... x) override {
+    if (this->position_.has_value())
+      this->parent_->position = this->position_.value(x...);
+    if (this->current_operation_.has_value())
+      this->parent_->current_operation = this->current_operation_.value(x...);
+    this->parent_->publish_state();
+  }
+};
+
+}  // namespace template_
+}  // namespace esphome

esphome/components/text/__init__.py

@@ -5,6 +5,8 @@ import esphome.codegen as cg
 from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_MODE,
     CONF_MQTT_ID,
@@ -14,6 +16,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@mauritskorse"]
@@ -39,7 +42,7 @@ TEXT_MODES = {
     "PASSWORD": TextMode.TEXT_MODE_PASSWORD,  # to be implemented for keys, passwords, etc.
 }
 
-TEXT_SCHEMA = (
+_TEXT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -57,6 +60,34 @@ TEXT_SCHEMA = (
 )
 
 
+def text_schema(
+    class_: MockObjClass = cv.UNDEFINED,
+    *,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    mode: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_MODE, mode, cv.enum(TEXT_MODES, upper=True)),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _TEXT_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+TEXT_SCHEMA = text_schema()
+TEXT_SCHEMA.add_extra(cv.deprecated_schema_constant("text"))
+
+
 async def setup_text_core_(
     var,
     config,

esphome/components/text_sensor/__init__.py

@@ -125,7 +125,7 @@ async def map_filter_to_code(config, filter_id):
 
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-TEXT_SENSOR_SCHEMA = (
+_TEXT_SENSOR_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -152,38 +152,33 @@ TEXT_SENSOR_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def text_sensor_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass = cv.UNDEFINED,
     *,
-    icon: str = _UNDEF,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
 ) -> cv.Schema:
-    schema = TEXT_SENSOR_SCHEMA
-    if class_ is not _UNDEF:
-        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
-    if icon is not _UNDEF:
-        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
-    if device_class is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_DEVICE_CLASS, default=device_class
-                ): validate_device_class
-            }
-        )
-    if entity_category is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_ENTITY_CATEGORY, default=entity_category
-                ): cv.entity_category
-            }
-        )
-    return schema
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_DEVICE_CLASS, device_class, validate_device_class),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _TEXT_SENSOR_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+TEXT_SENSOR_SCHEMA = text_sensor_schema()
+TEXT_SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("text_sensor"))
 
 
 async def build_filters(config):

esphome/components/thermostat/climate.py

@@ -516,9 +516,9 @@ def validate_thermostat(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    climate.CLIMATE_SCHEMA.extend(
+    climate.climate_schema(ThermostatClimate)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(ThermostatClimate),
             cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
             cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
             cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
@@ -631,7 +631,8 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(
         CONF_COOL_ACTION, CONF_DRY_ACTION, CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION
     ),
@@ -640,9 +641,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
 
     heat_cool_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
     two_points_available = CONF_HEAT_ACTION in config and (

esphome/components/time_based/cover.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_ASSUMED_STATE,
     CONF_CLOSE_ACTION,
     CONF_CLOSE_DURATION,
-    CONF_ID,
     CONF_OPEN_ACTION,
     CONF_OPEN_DURATION,
     CONF_STOP_ACTION,
@@ -18,25 +17,27 @@ TimeBasedCover = time_based_ns.class_("TimeBasedCover", cover.Cover, cg.Componen
 CONF_HAS_BUILT_IN_ENDSTOP = "has_built_in_endstop"
 CONF_MANUAL_CONTROL = "manual_control"
 
-CONFIG_SCHEMA = cover.COVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TimeBasedCover),
-        cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
-        cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
-        cv.Optional(CONF_MANUAL_CONTROL, default=False): cv.boolean,
-        cv.Optional(CONF_ASSUMED_STATE, default=True): cv.boolean,
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    cover.cover_schema(TimeBasedCover)
+    .extend(
+        {
+            cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
+            cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
+            cv.Optional(CONF_MANUAL_CONTROL, default=False): cv.boolean,
+            cv.Optional(CONF_ASSUMED_STATE, default=True): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     await automation.build_automation(
         var.get_stop_trigger(), [], config[CONF_STOP_ACTION]

esphome/components/time_based/time_based_cover.cpp

@@ -1,6 +1,7 @@
 #include "time_based_cover.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace time_based {
@@ -26,7 +27,7 @@ void TimeBasedCover::loop() {
   if (this->current_operation == COVER_OPERATION_IDLE)
     return;
 
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
 
   // Recompute position every loop cycle
   this->recompute_position_();

esphome/components/tm1638/switch/__init__.py

@@ -8,13 +8,16 @@ from ..display import CONF_TM1638_ID, TM1638Component, tm1638_ns
 TM1638SwitchLed = tm1638_ns.class_("TM1638SwitchLed", switch.Switch, cg.Component)
 
 
-CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TM1638SwitchLed),
-        cv.GenerateID(CONF_TM1638_ID): cv.use_id(TM1638Component),
-        cv.Required(CONF_LED): cv.int_range(min=0, max=7),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    switch.switch_schema(TM1638SwitchLed)
+    .extend(
+        {
+            cv.GenerateID(CONF_TM1638_ID): cv.use_id(TM1638Component),
+            cv.Required(CONF_LED): cv.int_range(min=0, max=7),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):

esphome/components/tormatic/cover.py

@@ -1,17 +1,17 @@
 import esphome.codegen as cg
 from esphome.components import cover, uart
 import esphome.config_validation as cv
-from esphome.const import CONF_CLOSE_DURATION, CONF_ID, CONF_OPEN_DURATION
+from esphome.const import CONF_CLOSE_DURATION, CONF_OPEN_DURATION
 
 tormatic_ns = cg.esphome_ns.namespace("tormatic")
 Tormatic = tormatic_ns.class_("Tormatic", cover.Cover, cg.PollingComponent)
 
 CONFIG_SCHEMA = (
-    cover.COVER_SCHEMA.extend(uart.UART_DEVICE_SCHEMA)
+    cover.cover_schema(Tormatic)
+    .extend(uart.UART_DEVICE_SCHEMA)
     .extend(cv.polling_component_schema("300ms"))
     .extend(
         {
-            cv.GenerateID(): cv.declare_id(Tormatic),
             cv.Optional(
                 CONF_OPEN_DURATION, default="15s"
             ): cv.positive_time_period_milliseconds,
@@ -34,9 +34,8 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
     await uart.register_uart_device(var, config)
 
     cg.add(var.set_close_duration(config[CONF_CLOSE_DURATION]))

esphome/components/toshiba/climate.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import climate_ir
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_MODEL
+from esphome.const import CONF_MODEL
 
 AUTO_LOAD = ["climate_ir"]
 CODEOWNERS = ["@kbx81"]
@@ -16,15 +16,13 @@ MODELS = {
     "RAC-PT1411HWRU-F": Model.MODEL_RAC_PT1411HWRU_F,
 }
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(ToshibaClimate).extend(
     {
-        cv.GenerateID(): cv.declare_id(ToshibaClimate),
         cv.Optional(CONF_MODEL, default="generic"): cv.enum(MODELS, upper=True),
     }
 )
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await climate_ir.register_climate_ir(var, config)
+    var = await climate_ir.new_climate_ir(config)
     cg.add(var.set_model(config[CONF_MODEL]))

esphome/components/touchscreen/touchscreen.cpp

@@ -50,13 +50,15 @@ void Touchscreen::loop() {
       tp.second.x_prev = tp.second.x;
       tp.second.y_prev = tp.second.y;
     }
+    // The interrupt flag must be reset BEFORE calling update_touches, otherwise we might miss an interrupt that was
+    // triggered while we were reading touch data.
+    this->store_.touched = false;
     this->update_touches();
     if (this->skip_update_) {
       for (auto &tp : this->touches_) {
         tp.second.state &= ~STATE_RELEASING;
       }
     } else {
-      this->store_.touched = false;
       this->defer([this]() { this->send_touches_(); });
       if (this->touch_timeout_ > 0) {
         // Simulate a touch after <this->touch_timeout_> ms. This will reset any existing timeout operation.

esphome/components/tuya/climate/__init__.py

@@ -4,7 +4,6 @@ from esphome.components import climate
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FAN_MODE,
-    CONF_ID,
     CONF_PRESET,
     CONF_SUPPORTS_COOL,
     CONF_SUPPORTS_HEAT,
@@ -151,9 +150,9 @@ SWING_MODES = cv.Schema(
 )
 
 CONFIG_SCHEMA = cv.All(
-    climate.CLIMATE_SCHEMA.extend(
+    climate.climate_schema(TuyaClimate)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(TuyaClimate),
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
             cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean,
             cv.Optional(CONF_SUPPORTS_COOL, default=False): cv.boolean,
@@ -186,7 +185,8 @@ CONFIG_SCHEMA = cv.All(
                 "'eco_temperature' has been moved inside of the 'eco' config block under 'preset' as 'temperature'"
             ),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TARGET_TEMPERATURE_DATAPOINT, CONF_SWITCH_DATAPOINT),
     validate_temperature_multipliers,
     validate_cooling_values,
@@ -194,9 +194,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
 
     paren = await cg.get_variable(config[CONF_TUYA_ID])
     cg.add(var.set_tuya_parent(paren))

esphome/components/tuya/cover/__init__.py

@@ -1,12 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import cover
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_MAX_VALUE,
-    CONF_MIN_VALUE,
-    CONF_OUTPUT_ID,
-    CONF_RESTORE_MODE,
-)
+from esphome.const import CONF_MAX_VALUE, CONF_MIN_VALUE, CONF_RESTORE_MODE
 
 from .. import CONF_TUYA_ID, Tuya, tuya_ns
 
@@ -38,9 +33,9 @@ def validate_range(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    cover.COVER_SCHEMA.extend(
+    cover.cover_schema(TuyaCover)
+    .extend(
         {
-            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TuyaCover),
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
             cv.Optional(CONF_CONTROL_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t,
@@ -54,15 +49,15 @@ CONFIG_SCHEMA = cv.All(
                 RESTORE_MODES, upper=True
             ),
         },
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     validate_range,
 )
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     if CONF_CONTROL_DATAPOINT in config:
         cg.add(var.set_control_id(config[CONF_CONTROL_DATAPOINT]))