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

esphome/components/sprinkler/__init__.py

@@ -4,7 +4,6 @@ import esphome.codegen as cg
 from esphome.components import number, switch
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ENTITY_CATEGORY,
     CONF_ID,
     CONF_INITIAL_VALUE,
     CONF_MAX_VALUE,
@@ -296,12 +295,11 @@ SPRINKLER_VALVE_SCHEMA = cv.Schema(
         cv.Optional(CONF_PUMP_SWITCH_ID): cv.use_id(switch.Switch),
         cv.Optional(CONF_RUN_DURATION): cv.positive_time_period_seconds,
         cv.Optional(CONF_RUN_DURATION_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=900): cv.positive_int,
                     cv.Optional(CONF_MAX_VALUE, default=86400): cv.positive_int,
                     cv.Optional(CONF_MIN_VALUE, default=1): cv.positive_int,
@@ -314,7 +312,8 @@ SPRINKLER_VALVE_SCHEMA = cv.Schema(
                         CONF_UNIT_OF_MEASUREMENT, default=UNIT_SECOND
                     ): cv.one_of(UNIT_MINUTE, UNIT_SECOND, lower="True"),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),
@@ -371,12 +370,11 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
         cv.Optional(CONF_NEXT_PREV_IGNORE_DISABLED, default=False): cv.boolean,
         cv.Optional(CONF_MANUAL_SELECTION_DELAY): cv.positive_time_period_seconds,
         cv.Optional(CONF_MULTIPLIER_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=1): cv.positive_float,
                     cv.Optional(CONF_MAX_VALUE, default=10): cv.positive_float,
                     cv.Optional(CONF_MIN_VALUE, default=0): cv.positive_float,
@@ -386,18 +384,18 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
                         single=True
                     ),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),
         cv.Optional(CONF_REPEAT): cv.positive_int,
         cv.Optional(CONF_REPEAT_NUMBER): cv.maybe_simple_value(
-            number.NUMBER_SCHEMA.extend(
+            number.number_schema(
+                SprinklerControllerNumber, entity_category=ENTITY_CATEGORY_CONFIG
+            )
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(SprinklerControllerNumber),
-                    cv.Optional(
-                        CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-                    ): cv.entity_category,
                     cv.Optional(CONF_INITIAL_VALUE, default=0): cv.positive_int,
                     cv.Optional(CONF_MAX_VALUE, default=10): cv.positive_int,
                     cv.Optional(CONF_MIN_VALUE, default=0): cv.positive_int,
@@ -407,7 +405,8 @@ SPRINKLER_CONTROLLER_SCHEMA = cv.Schema(
                         single=True
                     ),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
             validate_min_max,
             key=CONF_NAME,
         ),

esphome/components/sprinkler/sprinkler.cpp

@@ -20,7 +20,7 @@ SprinklerSwitch::SprinklerSwitch(switch_::Switch *off_switch, switch_::Switch *o
 bool SprinklerSwitch::is_latching_valve() { return (this->off_switch_ != nullptr) && (this->on_switch_ != nullptr); }
 
 void SprinklerSwitch::loop() {
-  if ((this->pinned_millis_) && (millis() > this->pinned_millis_ + this->pulse_duration_)) {
+  if ((this->pinned_millis_) && (App.get_loop_component_start_time() > this->pinned_millis_ + this->pulse_duration_)) {
     this->pinned_millis_ = 0;  // reset tracker
     if (this->off_switch_->state) {
       this->off_switch_->turn_off();
@@ -148,22 +148,23 @@ SprinklerValveOperator::SprinklerValveOperator(SprinklerValve *valve, Sprinkler
     : controller_(controller), valve_(valve) {}
 
 void SprinklerValveOperator::loop() {
-  if (millis() >= this->start_millis_) {  // dummy check
+  uint32_t now = App.get_loop_component_start_time();
+  if (now >= this->start_millis_) {  // dummy check
     switch (this->state_) {
       case STARTING:
-        if (millis() > (this->start_millis_ + this->start_delay_)) {
+        if (now > (this->start_millis_ + this->start_delay_)) {
           this->run_();  // start_delay_ has been exceeded, so ensure both valves are on and update the state
         }
         break;
 
       case ACTIVE:
-        if (millis() > (this->start_millis_ + this->start_delay_ + this->run_duration_)) {
+        if (now > (this->start_millis_ + this->start_delay_ + this->run_duration_)) {
           this->stop();  // start_delay_ + run_duration_ has been exceeded, start shutting down
         }
         break;
 
       case STOPPING:
-        if (millis() > (this->stop_millis_ + this->stop_delay_)) {
+        if (now > (this->stop_millis_ + this->stop_delay_)) {
           this->kill_();  // stop_delay_has been exceeded, ensure all valves are off
         }
         break;

esphome/components/switch/__init__.py

@@ -72,6 +72,9 @@ _SWITCH_SCHEMA = (
         {
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSwitchComponent),
             cv.Optional(CONF_INVERTED): cv.boolean,
+            cv.Optional(CONF_RESTORE_MODE, default="ALWAYS_OFF"): cv.enum(
+                RESTORE_MODES, upper=True, space="_"
+            ),
             cv.Optional(CONF_ON_TURN_ON): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SwitchTurnOnTrigger),
@@ -87,57 +90,44 @@ _SWITCH_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def switch_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass,
     *,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
-    icon: str = _UNDEF,
     block_inverted: bool = False,
-    default_restore_mode: str = "ALWAYS_OFF",
+    default_restore_mode: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
 ):
-    schema = _SWITCH_SCHEMA.extend(
-        {
-            cv.Optional(CONF_RESTORE_MODE, default=default_restore_mode): cv.enum(
-                RESTORE_MODES, upper=True, space="_"
-            ),
-        }
-    )
-    if class_ is not _UNDEF:
-        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
-    if entity_category is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_ENTITY_CATEGORY, default=entity_category
-                ): cv.entity_category
-            }
-        )
-    if device_class is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_DEVICE_CLASS, default=device_class
-                ): validate_device_class
-            }
-        )
-    if icon is not _UNDEF:
-        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
+    schema = {cv.GenerateID(): cv.declare_id(class_)}
+
+    for key, default, validator in [
+        (CONF_DEVICE_CLASS, device_class, validate_device_class),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+        (
+            CONF_RESTORE_MODE,
+            default_restore_mode,
+            cv.enum(RESTORE_MODES, upper=True, space="_")
+            if default_restore_mode is not cv.UNDEFINED
+            else cv.UNDEFINED,
+        ),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
     if block_inverted:
-        schema = schema.extend(
-            {
-                cv.Optional(CONF_INVERTED): cv.invalid(
-                    "Inverted is not supported for this platform!"
-                )
-            }
+        schema[cv.Optional(CONF_INVERTED)] = cv.invalid(
+            "Inverted is not supported for this platform!"
         )
-    return schema
+
+    return _SWITCH_SCHEMA.extend(schema)
 
 
-SWITCH_SCHEMA = switch_schema()  # for compatibility
+# Remove before 2025.11.0
+SWITCH_SCHEMA = switch_schema(Switch)
+SWITCH_SCHEMA.add_extra(cv.deprecated_schema_constant("switch"))
 
 
 async def setup_switch_core_(var, config):

esphome/components/syslog/__init__.py

@@ -0,0 +1,41 @@
+import esphome.codegen as cg
+from esphome.components import udp
+from esphome.components.logger import LOG_LEVELS, is_log_level
+from esphome.components.time import RealTimeClock
+from esphome.components.udp import CONF_UDP_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LEVEL, CONF_PORT, CONF_TIME_ID
+from esphome.cpp_types import Component, Parented
+
+CODEOWNERS = ["@clydebarrow"]
+
+DEPENDENCIES = ["udp", "logger", "time"]
+
+syslog_ns = cg.esphome_ns.namespace("syslog")
+Syslog = syslog_ns.class_("Syslog", Component, Parented.template(udp.UDPComponent))
+
+CONF_STRIP = "strip"
+CONF_FACILITY = "facility"
+CONFIG_SCHEMA = udp.UDP_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(Syslog),
+        cv.GenerateID(CONF_TIME_ID): cv.use_id(RealTimeClock),
+        cv.Optional(CONF_PORT, default=514): cv.port,
+        cv.Optional(CONF_LEVEL, default="DEBUG"): is_log_level,
+        cv.Optional(CONF_STRIP, default=True): cv.boolean,
+        cv.Optional(CONF_FACILITY, default=16): cv.int_range(0, 23),
+    }
+)
+
+
+async def to_code(config):
+    parent = await cg.get_variable(config[CONF_UDP_ID])
+    time = await cg.get_variable(config[CONF_TIME_ID])
+    cg.add(parent.set_broadcast_port(config[CONF_PORT]))
+    cg.add(parent.set_should_broadcast())
+    level = LOG_LEVELS[config[CONF_LEVEL]]
+    var = cg.new_Pvariable(config[CONF_ID], level, time)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, parent)
+    cg.add(var.set_strip(config[CONF_STRIP]))
+    cg.add(var.set_facility(config[CONF_FACILITY]))

esphome/components/syslog/esphome_syslog.cpp

@@ -0,0 +1,49 @@
+#include "esphome_syslog.h"
+
+#include "esphome/components/logger/logger.h"
+#include "esphome/core/application.h"
+#include "esphome/core/time.h"
+
+namespace esphome {
+namespace syslog {
+
+// Map log levels to syslog severity using an array, indexed by ESPHome log level (1-7)
+constexpr int LOG_LEVEL_TO_SYSLOG_SEVERITY[] = {
+    3,  // NONE
+    3,  // ERROR
+    4,  // WARN
+    5,  // INFO
+    6,  // CONFIG
+    7,  // DEBUG
+    7,  // VERBOSE
+    7   // VERY_VERBOSE
+};
+
+void Syslog::setup() {
+  logger::global_logger->add_on_log_callback(
+      [this](int level, const char *tag, const char *message) { this->log_(level, tag, message); });
+}
+
+void Syslog::log_(const int level, const char *tag, const char *message) const {
+  if (level > this->log_level_)
+    return;
+  // Syslog PRI calculation: facility * 8 + severity
+  int severity = 7;
+  if ((unsigned) level <= 7) {
+    severity = LOG_LEVEL_TO_SYSLOG_SEVERITY[level];
+  }
+  int pri = this->facility_ * 8 + severity;
+  auto timestamp = this->time_->now().strftime("%b %d %H:%M:%S");
+  unsigned len = strlen(message);
+  // remove color formatting
+  if (this->strip_ && message[0] == 0x1B && len > 11) {
+    message += 7;
+    len -= 11;
+  }
+
+  auto data = str_sprintf("<%d>%s %s %s: %.*s", pri, timestamp.c_str(), App.get_name().c_str(), tag, len, message);
+  this->parent_->send_packet((const uint8_t *) data.data(), data.size());
+}
+
+}  // namespace syslog
+}  // namespace esphome

esphome/components/syslog/esphome_syslog.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include "esphome/components/udp/udp_component.h"
+#include "esphome/components/time/real_time_clock.h"
+
+#ifdef USE_NETWORK
+namespace esphome {
+namespace syslog {
+class Syslog : public Component, public Parented<udp::UDPComponent> {
+ public:
+  Syslog(int level, time::RealTimeClock *time) : log_level_(level), time_(time) {}
+  void setup() override;
+  void set_strip(bool strip) { this->strip_ = strip; }
+  void set_facility(int facility) { this->facility_ = facility; }
+
+ protected:
+  int log_level_;
+  void log_(int level, const char *tag, const char *message) const;
+  time::RealTimeClock *time_;
+  bool strip_{true};
+  int facility_{16};
+};
+}  // namespace syslog
+}  // namespace esphome
+#endif

esphome/components/t6615/sensor.py

@@ -19,7 +19,7 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(T6615Component),
-            cv.Required(CONF_CO2): sensor.sensor_schema(
+            cv.Optional(CONF_CO2): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PARTS_PER_MILLION,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_CARBON_DIOXIDE,
@@ -41,6 +41,6 @@ async def to_code(config):
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
 
-    if CONF_CO2 in config:
-        sens = await sensor.new_sensor(config[CONF_CO2])
+    if co2 := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2)
         cg.add(var.set_co2_sensor(sens))

esphome/components/t6615/t6615.cpp

@@ -63,7 +63,8 @@ void T6615Component::loop() {
     case T6615Command::GET_PPM: {
       const uint16_t ppm = encode_uint16(response_buffer[3], response_buffer[4]);
       ESP_LOGD(TAG, "T6615 Received CO₂=%uppm", ppm);
-      this->co2_sensor_->publish_state(ppm);
+      if (this->co2_sensor_ != nullptr)
+        this->co2_sensor_->publish_state(ppm);
       break;
     }
     default:

esphome/components/tca9555/tca9555.cpp

@@ -76,15 +76,20 @@ bool TCA9555Component::read_gpio_modes_() {
 bool TCA9555Component::digital_read_hw(uint8_t pin) {
   if (this->is_failed())
     return false;
-  bool success;
-  uint8_t data[2];
-  success = this->read_bytes(TCA9555_INPUT_PORT_REGISTER_0, data, 2);
-  this->input_mask_ = (uint16_t(data[1]) << 8) | (uint16_t(data[0]) << 0);
-
-  if (!success) {
+  uint8_t data;
+  uint8_t bank_number = pin < 8 ? 0 : 1;
+  uint8_t register_to_read = bank_number ? TCA9555_INPUT_PORT_REGISTER_1 : TCA9555_INPUT_PORT_REGISTER_0;
+  if (!this->read_bytes(register_to_read, &data, 1)) {
     this->status_set_warning("Failed to read input register");
     return false;
   }
+  uint8_t second_half = this->input_mask_ >> 8;
+  uint8_t first_half = this->input_mask_;
+  if (bank_number) {
+    this->input_mask_ = (data << 8) | (uint16_t(first_half) << 0);
+  } else {
+    this->input_mask_ = (uint16_t(second_half) << 8) | (data << 0);
+  }
 
   this->status_clear_warning();
   return true;

esphome/components/tcl112/climate.py

@@ -1,7 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import climate_ir
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
 
 AUTO_LOAD = ["climate_ir"]
 CODEOWNERS = ["@glmnet"]
@@ -9,13 +7,8 @@ CODEOWNERS = ["@glmnet"]
 tcl112_ns = cg.esphome_ns.namespace("tcl112")
 Tcl112Climate = tcl112_ns.class_("Tcl112Climate", climate_ir.ClimateIR)
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(Tcl112Climate),
-    }
-)
+CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(Tcl112Climate)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await climate_ir.register_climate_ir(var, config)
+    await climate_ir.new_climate_ir(config)

esphome/components/template/alarm_control_panel/__init__.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import alarm_control_panel, binary_sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_INPUT, CONF_RESTORE_MODE
+from esphome.const import CONF_BINARY_SENSORS, CONF_INPUT, CONF_RESTORE_MODE
 
 from .. import template_ns
 
@@ -51,6 +51,7 @@ ALARM_SENSOR_TYPES = {
     "DELAYED": AlarmSensorType.ALARM_SENSOR_TYPE_DELAYED,
     "INSTANT": AlarmSensorType.ALARM_SENSOR_TYPE_INSTANT,
     "DELAYED_FOLLOWER": AlarmSensorType.ALARM_SENSOR_TYPE_DELAYED_FOLLOWER,
+    "INSTANT_ALWAYS": AlarmSensorType.ALARM_SENSOR_TYPE_INSTANT_ALWAYS,
 }
 
 
@@ -76,9 +77,9 @@ TEMPLATE_ALARM_CONTROL_PANEL_BINARY_SENSOR_SCHEMA = cv.maybe_simple_value(
 )
 
 TEMPLATE_ALARM_CONTROL_PANEL_SCHEMA = (
-    alarm_control_panel.ALARM_CONTROL_PANEL_SCHEMA.extend(
+    alarm_control_panel.alarm_control_panel_schema(TemplateAlarmControlPanel)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(TemplateAlarmControlPanel),
             cv.Optional(CONF_CODES): cv.ensure_list(cv.string_strict),
             cv.Optional(CONF_REQUIRES_CODE_TO_ARM): cv.boolean,
             cv.Optional(CONF_ARMING_HOME_TIME): cv.positive_time_period_milliseconds,
@@ -99,7 +100,8 @@ TEMPLATE_ALARM_CONTROL_PANEL_SCHEMA = (
                 RESTORE_MODES, upper=True
             ),
         }
-    ).extend(cv.COMPONENT_SCHEMA)
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
 CONFIG_SCHEMA = cv.All(
@@ -109,9 +111,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await alarm_control_panel.new_alarm_control_panel(config)
     await cg.register_component(var, config)
-    await alarm_control_panel.register_alarm_control_panel(var, config)
     if CONF_CODES in config:
         for acode in config[CONF_CODES]:
             cg.add(var.add_code(acode))

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -58,6 +58,9 @@ void TemplateAlarmControlPanel::dump_config() {
       case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
         sensor_type = "delayed_follower";
         break;
+      case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
+        sensor_type = "instant_always";
+        break;
       case ALARM_SENSOR_TYPE_DELAYED:
       default:
         sensor_type = "delayed";
@@ -145,24 +148,25 @@ void TemplateAlarmControlPanel::loop() {
         continue;
       }
 
-      // If sensor type is of type instant
-      if (sensor_info.second.type == ALARM_SENSOR_TYPE_INSTANT) {
-        instant_sensor_not_ready = true;
-        break;
-      }
-      // If sensor type is of type interior follower
-      if (sensor_info.second.type == ALARM_SENSOR_TYPE_DELAYED_FOLLOWER) {
-        // Look to see if we are in the pending state
-        if (this->current_state_ == ACP_STATE_PENDING) {
-          delayed_sensor_not_ready = true;
-        } else {
+      switch (sensor_info.second.type) {
+        case ALARM_SENSOR_TYPE_INSTANT:
           instant_sensor_not_ready = true;
-        }
-      }
-      // If sensor type is of type delayed
-      if (sensor_info.second.type == ALARM_SENSOR_TYPE_DELAYED) {
-        delayed_sensor_not_ready = true;
-        break;
+          break;
+        case ALARM_SENSOR_TYPE_INSTANT_ALWAYS:
+          instant_sensor_not_ready = true;
+          future_state = ACP_STATE_TRIGGERED;
+          break;
+        case ALARM_SENSOR_TYPE_DELAYED_FOLLOWER:
+          // Look to see if we are in the pending state
+          if (this->current_state_ == ACP_STATE_PENDING) {
+            delayed_sensor_not_ready = true;
+          } else {
+            instant_sensor_not_ready = true;
+          }
+          break;
+        case ALARM_SENSOR_TYPE_DELAYED:
+        default:
+          delayed_sensor_not_ready = true;
       }
     }
   }

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -27,7 +27,8 @@ enum BinarySensorFlags : uint16_t {
 enum AlarmSensorType : uint16_t {
   ALARM_SENSOR_TYPE_DELAYED = 0,
   ALARM_SENSOR_TYPE_INSTANT,
-  ALARM_SENSOR_TYPE_DELAYED_FOLLOWER
+  ALARM_SENSOR_TYPE_DELAYED_FOLLOWER,
+  ALARM_SENSOR_TYPE_INSTANT_ALWAYS,
 };
 
 #endif

esphome/components/template/cover/__init__.py

@@ -34,31 +34,37 @@ RESTORE_MODES = {
 CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 
-CONFIG_SCHEMA = cover.COVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TemplateCover),
-        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_TILT_ACTION): automation.validate_automation(single=True),
-        cv.Optional(CONF_TILT_LAMBDA): cv.returning_lambda,
-        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="RESTORE"): cv.enum(
-            RESTORE_MODES, upper=True
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    cover.cover_schema(TemplateCover)
+    .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_TILT_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_TILT_LAMBDA): cv.returning_lambda,
+            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="RESTORE"): cv.enum(
+                RESTORE_MODES, upper=True
+            ),
+        }
+    )
+    .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)
     if CONF_LAMBDA in config:
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(float)

esphome/components/template/fan/__init__.py

@@ -2,7 +2,7 @@ import esphome.codegen as cg
 from esphome.components import fan
 from esphome.components.fan import validate_preset_modes
 import esphome.config_validation as cv
-from esphome.const import CONF_OUTPUT_ID, CONF_PRESET_MODES, CONF_SPEED_COUNT
+from esphome.const import CONF_PRESET_MODES, CONF_SPEED_COUNT
 
 from .. import template_ns
 
@@ -13,21 +13,23 @@ TemplateFan = template_ns.class_("TemplateFan", cg.Component, fan.Fan)
 CONF_HAS_DIRECTION = "has_direction"
 CONF_HAS_OSCILLATING = "has_oscillating"
 
-CONFIG_SCHEMA = fan.FAN_SCHEMA.extend(
-    {
-        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TemplateFan),
-        cv.Optional(CONF_HAS_DIRECTION, default=False): cv.boolean,
-        cv.Optional(CONF_HAS_OSCILLATING, default=False): cv.boolean,
-        cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1),
-        cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    fan.fan_schema(TemplateFan)
+    .extend(
+        {
+            cv.Optional(CONF_HAS_DIRECTION, default=False): cv.boolean,
+            cv.Optional(CONF_HAS_OSCILLATING, default=False): cv.boolean,
+            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1),
+            cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
+    var = await fan.new_fan(config)
     await cg.register_component(var, config)
-    await fan.register_fan(var, config)
 
     cg.add(var.set_has_direction(config[CONF_HAS_DIRECTION]))
     cg.add(var.set_has_oscillating(config[CONF_HAS_OSCILLATING]))