esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

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/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.climare_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]))

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