template triggers

esphome/components/template/cover/__init__.py

@@ -79,16 +79,19 @@ async def to_code(config):
             var.get_close_trigger(), [], config[CONF_CLOSE_ACTION]
         )
     if CONF_STOP_ACTION in config:
+        cg.add_define("USE_TEMPLATE_COVER_STOP_TRIGGER")
         await automation.build_automation(
             var.get_stop_trigger(), [], config[CONF_STOP_ACTION]
         )
         cg.add(var.set_has_stop(True))
     if CONF_TOGGLE_ACTION in config:
+        cg.add_define("USE_TEMPLATE_COVER_TOGGLE_TRIGGER")
         await automation.build_automation(
             var.get_toggle_trigger(), [], config[CONF_TOGGLE_ACTION]
         )
         cg.add(var.set_has_toggle(True))
     if CONF_TILT_ACTION in config:
+        cg.add_define("USE_TEMPLATE_COVER_TILT_TRIGGER")
         await automation.build_automation(
             var.get_tilt_trigger(), [(float, "tilt")], config[CONF_TILT_ACTION]
         )
@@ -99,6 +102,7 @@ async def to_code(config):
         )
         cg.add(var.set_tilt_lambda(tilt_template_))
     if CONF_POSITION_ACTION in config:
+        cg.add_define("USE_TEMPLATE_COVER_POSITION_TRIGGER")
         await automation.build_automation(
             var.get_position_trigger(), [(float, "pos")], config[CONF_POSITION_ACTION]
         )

esphome/components/template/cover/template_cover.cpp

@@ -9,11 +9,25 @@ static const char *const TAG = "template.cover";
 
 TemplateCover::TemplateCover()
     : open_trigger_(new Trigger<>()),
-      close_trigger_(new Trigger<>),
-      stop_trigger_(new Trigger<>()),
-      toggle_trigger_(new Trigger<>()),
-      position_trigger_(new Trigger<float>()),
-      tilt_trigger_(new Trigger<float>()) {}
+      close_trigger_(new Trigger<>())
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
+      ,
+      stop_trigger_(new Trigger<>())
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
+      ,
+      toggle_trigger_(new Trigger<>())
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
+      ,
+      position_trigger_(new Trigger<float>())
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
+      ,
+      tilt_trigger_(new Trigger<float>())
+#endif
+{
+}
 void TemplateCover::setup() {
   switch (this->restore_mode_) {
     case COVER_NO_RESTORE:
@@ -64,22 +78,30 @@ void TemplateCover::set_assumed_state(bool assumed_state) { this->assumed_state_
 float TemplateCover::get_setup_priority() const { return setup_priority::HARDWARE; }
 Trigger<> *TemplateCover::get_open_trigger() const { return this->open_trigger_; }
 Trigger<> *TemplateCover::get_close_trigger() const { return this->close_trigger_; }
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
 Trigger<> *TemplateCover::get_stop_trigger() const { return this->stop_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
 Trigger<> *TemplateCover::get_toggle_trigger() const { return this->toggle_trigger_; }
+#endif
 void TemplateCover::dump_config() { LOG_COVER("", "Template Cover", this); }
 void TemplateCover::control(const CoverCall &call) {
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
   if (call.get_stop()) {
     this->stop_prev_trigger_();
     this->stop_trigger_->trigger();
     this->prev_command_trigger_ = this->stop_trigger_;
     this->publish_state();
   }
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
     this->toggle_trigger_->trigger();
     this->prev_command_trigger_ = this->toggle_trigger_;
     this->publish_state();
   }
+#endif
   if (call.get_position().has_value()) {
     auto pos = *call.get_position();
     this->stop_prev_trigger_();
@@ -90,15 +112,19 @@ void TemplateCover::control(const CoverCall &call) {
     } else if (pos == COVER_CLOSED) {
       this->close_trigger_->trigger();
       this->prev_command_trigger_ = this->close_trigger_;
-    } else {
+    }
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
+    else {
       this->position_trigger_->trigger(pos);
     }
+#endif
 
     if (this->optimistic_) {
       this->position = pos;
     }
   }
 
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   if (call.get_tilt().has_value()) {
     auto tilt = *call.get_tilt();
     this->tilt_trigger_->trigger(tilt);
@@ -107,24 +133,53 @@ void TemplateCover::control(const CoverCall &call) {
       this->tilt = tilt;
     }
   }
+#endif
 
   this->publish_state();
 }
 CoverTraits TemplateCover::get_traits() {
   auto traits = CoverTraits();
   traits.set_is_assumed_state(this->assumed_state_);
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
   traits.set_supports_stop(this->has_stop_);
+#else
+  traits.set_supports_stop(false);
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
   traits.set_supports_toggle(this->has_toggle_);
+#else
+  traits.set_supports_toggle(false);
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
   traits.set_supports_position(this->has_position_);
+#else
+  traits.set_supports_position(false);
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   traits.set_supports_tilt(this->has_tilt_);
+#else
+  traits.set_supports_tilt(false);
+#endif
   return traits;
 }
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
 Trigger<float> *TemplateCover::get_position_trigger() const { return this->position_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
 Trigger<float> *TemplateCover::get_tilt_trigger() const { return this->tilt_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
 void TemplateCover::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
 void TemplateCover::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
 void TemplateCover::set_has_position(bool has_position) { this->has_position_ = has_position; }
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
 void TemplateCover::set_has_tilt(bool has_tilt) { this->has_tilt_ = has_tilt; }
+#endif
 void TemplateCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();

esphome/components/template/cover/template_cover.h

@@ -21,16 +21,32 @@ class TemplateCover final : public cover::Cover, public Component {
   template<typename F> void set_tilt_lambda(F &&f) { this->tilt_f_.set(std::forward<F>(f)); }
   Trigger<> *get_open_trigger() const;
   Trigger<> *get_close_trigger() const;
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
   Trigger<> *get_stop_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
   Trigger<> *get_toggle_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
   Trigger<float> *get_position_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   Trigger<float> *get_tilt_trigger() const;
+#endif
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
   void set_has_stop(bool has_stop);
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
   void set_has_position(bool has_position);
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   void set_has_tilt(bool has_tilt);
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
   void set_has_toggle(bool has_toggle);
+#endif
   void set_restore_mode(TemplateCoverRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
@@ -44,22 +60,39 @@ class TemplateCover final : public cover::Cover, public Component {
   cover::CoverTraits get_traits() override;
   void stop_prev_trigger_();
 
+  // Ordered to minimize padding on 32-bit: 4-byte members first, then smaller
   TemplateCoverRestoreMode restore_mode_{COVER_RESTORE};
   TemplateLambda<float> state_f_;
   TemplateLambda<float> tilt_f_;
-  bool assumed_state_{false};
-  bool optimistic_{false};
   Trigger<> *open_trigger_;
   Trigger<> *close_trigger_;
-  bool has_stop_{false};
-  bool has_toggle_{false};
-  Trigger<> *stop_trigger_;
-  Trigger<> *toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
+  Trigger<> *stop_trigger_;
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
+  Trigger<> *toggle_trigger_;
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
   Trigger<float> *position_trigger_;
-  bool has_position_{false};
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   Trigger<float> *tilt_trigger_;
+#endif
+  bool assumed_state_{false};
+  bool optimistic_{false};
+#ifdef USE_TEMPLATE_COVER_STOP_TRIGGER
+  bool has_stop_{false};
+#endif
+#ifdef USE_TEMPLATE_COVER_TOGGLE_TRIGGER
+  bool has_toggle_{false};
+#endif
+#ifdef USE_TEMPLATE_COVER_POSITION_TRIGGER
+  bool has_position_{false};
+#endif
+#ifdef USE_TEMPLATE_COVER_TILT_TRIGGER
   bool has_tilt_{false};
+#endif
 };
 
 }  // namespace esphome::template_

esphome/components/template/datetime/__init__.py

@@ -141,6 +141,12 @@ async def to_code(config):
                 cg.add(var.set_initial_value(datetime_struct))
 
     if CONF_SET_ACTION in config:
+        if config[CONF_TYPE] == "DATE":
+            cg.add_define("USE_TEMPLATE_DATE_SET_TRIGGER")
+        elif config[CONF_TYPE] == "TIME":
+            cg.add_define("USE_TEMPLATE_TIME_SET_TRIGGER")
+        elif config[CONF_TYPE] == "DATETIME":
+            cg.add_define("USE_TEMPLATE_DATETIME_SET_TRIGGER")
         await automation.build_automation(
             var.get_set_trigger(),
             [(cg.ESPTime, "x")],

esphome/components/template/datetime/template_date.cpp

@@ -62,7 +62,9 @@ void TemplateDate::control(const datetime::DateCall &call) {
   if (has_day)
     value.day_of_month = *call.get_day();
 
+#ifdef USE_TEMPLATE_DATE_SET_TRIGGER
   this->set_trigger_->trigger(value);
+#endif
 
   if (this->optimistic_) {
     if (has_year)

esphome/components/template/datetime/template_date.h

@@ -22,7 +22,9 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_DATE_SET_TRIGGER
   Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +36,9 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
+#ifdef USE_TEMPLATE_DATE_SET_TRIGGER
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+#endif
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/datetime/template_datetime.cpp

@@ -80,7 +80,9 @@ void TemplateDateTime::control(const datetime::DateTimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
+#ifdef USE_TEMPLATE_DATETIME_SET_TRIGGER
   this->set_trigger_->trigger(value);
+#endif
 
   if (this->optimistic_) {
     if (has_year)

esphome/components/template/datetime/template_datetime.h

@@ -22,7 +22,9 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_DATETIME_SET_TRIGGER
   Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +36,9 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
+#ifdef USE_TEMPLATE_DATETIME_SET_TRIGGER
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+#endif
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/datetime/template_time.cpp

@@ -62,7 +62,9 @@ void TemplateTime::control(const datetime::TimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
+#ifdef USE_TEMPLATE_TIME_SET_TRIGGER
   this->set_trigger_->trigger(value);
+#endif
 
   if (this->optimistic_) {
     if (has_hour)

esphome/components/template/datetime/template_time.h

@@ -22,7 +22,9 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_TIME_SET_TRIGGER
   Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +36,9 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
+#ifdef USE_TEMPLATE_TIME_SET_TRIGGER
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+#endif
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/lock/__init__.py

@@ -64,14 +64,17 @@ async def to_code(config):
         )
         cg.add(var.set_state_lambda(template_))
     if CONF_UNLOCK_ACTION in config:
+        cg.add_define("USE_TEMPLATE_LOCK_UNLOCK_TRIGGER")
         await automation.build_automation(
             var.get_unlock_trigger(), [], config[CONF_UNLOCK_ACTION]
         )
     if CONF_LOCK_ACTION in config:
+        cg.add_define("USE_TEMPLATE_LOCK_LOCK_TRIGGER")
         await automation.build_automation(
             var.get_lock_trigger(), [], config[CONF_LOCK_ACTION]
         )
     if CONF_OPEN_ACTION in config:
+        cg.add_define("USE_TEMPLATE_LOCK_OPEN_TRIGGER")
         await automation.build_automation(
             var.get_open_trigger(), [], config[CONF_OPEN_ACTION]
         )

esphome/components/template/lock/template_lock.cpp

@@ -8,7 +8,27 @@ using namespace esphome::lock;
 static const char *const TAG = "template.lock";
 
 TemplateLock::TemplateLock()
-    : lock_trigger_(new Trigger<>()), unlock_trigger_(new Trigger<>()), open_trigger_(new Trigger<>()) {}
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
+    : lock_trigger_(new Trigger<>())
+#ifdef USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
+      ,
+      unlock_trigger_(new Trigger<>())
+#endif
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
+      ,
+      open_trigger_(new Trigger<>())
+#endif
+#elif defined(USE_TEMPLATE_LOCK_UNLOCK_TRIGGER)
+    : unlock_trigger_(new Trigger<>())
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
+      ,
+      open_trigger_(new Trigger<>())
+#endif
+#elif defined(USE_TEMPLATE_LOCK_OPEN_TRIGGER)
+    : open_trigger_(new Trigger<>())
+#endif
+{
+}
 
 void TemplateLock::setup() {
   if (!this->f_.has_value())
@@ -22,34 +42,55 @@ void TemplateLock::loop() {
   }
 }
 void TemplateLock::control(const lock::LockCall &call) {
+#if defined(USE_TEMPLATE_LOCK_LOCK_TRIGGER) || defined(USE_TEMPLATE_LOCK_UNLOCK_TRIGGER) || \
+    defined(USE_TEMPLATE_LOCK_OPEN_TRIGGER)
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
+#endif
 
   auto state = *call.get_state();
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
   if (state == LOCK_STATE_LOCKED) {
     this->prev_trigger_ = this->lock_trigger_;
     this->lock_trigger_->trigger();
-  } else if (state == LOCK_STATE_UNLOCKED) {
+  }
+#endif
+#ifdef USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
+  else
+#endif
+      if (state == LOCK_STATE_UNLOCKED) {
     this->prev_trigger_ = this->unlock_trigger_;
     this->unlock_trigger_->trigger();
   }
+#endif
 
   if (this->optimistic_)
     this->publish_state(state);
 }
 void TemplateLock::open_latch() {
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
+#if defined(USE_TEMPLATE_LOCK_LOCK_TRIGGER) || defined(USE_TEMPLATE_LOCK_UNLOCK_TRIGGER)
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
+#endif
   this->prev_trigger_ = this->open_trigger_;
   this->open_trigger_->trigger();
+#endif
 }
 void TemplateLock::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 float TemplateLock::get_setup_priority() const { return setup_priority::HARDWARE; }
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
 Trigger<> *TemplateLock::get_lock_trigger() const { return this->lock_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
 Trigger<> *TemplateLock::get_unlock_trigger() const { return this->unlock_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
 Trigger<> *TemplateLock::get_open_trigger() const { return this->open_trigger_; }
+#endif
 void TemplateLock::dump_config() {
   LOG_LOCK("", "Template Lock", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));

esphome/components/template/lock/template_lock.h

@@ -15,9 +15,15 @@ class TemplateLock final : public lock::Lock, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
   Trigger<> *get_lock_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
   Trigger<> *get_unlock_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
   Trigger<> *get_open_trigger() const;
+#endif
   void set_optimistic(bool optimistic);
   void loop() override;
 
@@ -29,10 +35,19 @@ class TemplateLock final : public lock::Lock, public Component {
 
   TemplateLambda<lock::LockState> f_;
   bool optimistic_{false};
+#ifdef USE_TEMPLATE_LOCK_LOCK_TRIGGER
   Trigger<> *lock_trigger_;
+#endif
+#ifdef USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
   Trigger<> *unlock_trigger_;
+#endif
+#ifdef USE_TEMPLATE_LOCK_OPEN_TRIGGER
   Trigger<> *open_trigger_;
+#endif
+#if defined(USE_TEMPLATE_LOCK_LOCK_TRIGGER) || defined(USE_TEMPLATE_LOCK_UNLOCK_TRIGGER) || \
+    defined(USE_TEMPLATE_LOCK_OPEN_TRIGGER)
   Trigger<> *prev_trigger_{nullptr};
+#endif
 };
 
 }  // namespace esphome::template_

esphome/components/template/number/__init__.py

@@ -89,6 +89,7 @@ async def to_code(config):
             cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
 
     if CONF_SET_ACTION in config:
+        cg.add_define("USE_TEMPLATE_NUMBER_SET_TRIGGER")
         await automation.build_automation(
             var.get_set_trigger(), [(float, "x")], config[CONF_SET_ACTION]
         )

esphome/components/template/number/template_number.cpp

@@ -36,7 +36,9 @@ void TemplateNumber::update() {
 }
 
 void TemplateNumber::control(float value) {
+#ifdef USE_TEMPLATE_NUMBER_SET_TRIGGER
   this->set_trigger_->trigger(value);
+#endif
 
   if (this->optimistic_)
     this->publish_state(value);

esphome/components/template/number/template_number.h

@@ -17,7 +17,9 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_NUMBER_SET_TRIGGER
   Trigger<float> *get_set_trigger() const { return set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { optimistic_ = optimistic; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
@@ -27,7 +29,9 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   bool optimistic_{false};
   float initial_value_{NAN};
   bool restore_value_{false};
+#ifdef USE_TEMPLATE_NUMBER_SET_TRIGGER
   Trigger<float> *set_trigger_ = new Trigger<float>();
+#endif
   TemplateLambda<float> f_;
 
   ESPPreferenceObject pref_;

esphome/components/template/select/__init__.py

@@ -17,9 +17,6 @@ from .. import template_ns
 TemplateSelect = template_ns.class_(
     "TemplateSelect", select.Select, cg.PollingComponent
 )
-TemplateSelectWithSetAction = template_ns.class_(
-    "TemplateSelectWithSetAction", TemplateSelect
-)
 
 
 def validate(config):
@@ -42,11 +39,6 @@ def validate(config):
         raise cv.Invalid(
             "Either optimistic mode must be enabled, or set_action must be set, to handle the option being set."
         )
-
-    # Use subclass with trigger only when set_action is configured
-    if CONF_SET_ACTION in config:
-        config[CONF_ID].type = TemplateSelectWithSetAction
-
     return config
 
 
@@ -95,6 +87,7 @@ async def to_code(config):
             cg.add(var.set_restore_value(True))
 
     if CONF_SET_ACTION in config:
+        cg.add_define("USE_TEMPLATE_SELECT_SET_TRIGGER")
         await automation.build_automation(
             var.get_set_trigger(), [(cg.StringRef, "x")], config[CONF_SET_ACTION]
         )

esphome/components/template/select/template_select.cpp

@@ -41,6 +41,10 @@ void TemplateSelect::update() {
 }
 
 void TemplateSelect::control(size_t index) {
+#ifdef USE_TEMPLATE_SELECT_SET_TRIGGER
+  this->set_trigger_->trigger(StringRef(this->option_at(index)));
+#endif
+
   if (this->optimistic_)
     this->publish_state(index);
 
@@ -48,11 +52,6 @@ void TemplateSelect::control(size_t index) {
     this->pref_.save(&index);
 }
 
-void TemplateSelectWithSetAction::control(size_t index) {
-  this->set_trigger_.trigger(StringRef(this->option_at(index)));
-  TemplateSelect::control(index);
-}
-
 void TemplateSelect::dump_config() {
   LOG_SELECT("", "Template Select", this);
   LOG_UPDATE_INTERVAL(this);

esphome/components/template/select/template_select.h

@@ -9,8 +9,7 @@
 
 namespace esphome::template_ {
 
-/// Base template select class - used when no set_action is configured
-class TemplateSelect : public select::Select, public PollingComponent {
+class TemplateSelect final : public select::Select, public PollingComponent {
  public:
   template<typename F> void set_template(F &&f) { this->f_.set(std::forward<F>(f)); }
 
@@ -19,6 +18,9 @@ class TemplateSelect : public select::Select, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_SELECT_SET_TRIGGER
+  Trigger<StringRef> *get_set_trigger() const { return this->set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_initial_option_index(size_t initial_option_index) { this->initial_option_index_ = initial_option_index; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
@@ -28,19 +30,12 @@ class TemplateSelect : public select::Select, public PollingComponent {
   bool optimistic_ = false;
   size_t initial_option_index_{0};
   bool restore_value_ = false;
+#ifdef USE_TEMPLATE_SELECT_SET_TRIGGER
+  Trigger<StringRef> *set_trigger_ = new Trigger<StringRef>();
+#endif
   TemplateLambda<std::string> f_;
 
   ESPPreferenceObject pref_;
 };
 
-/// Template select with set_action trigger - only instantiated when set_action is configured
-class TemplateSelectWithSetAction final : public TemplateSelect {
- public:
-  Trigger<StringRef> *get_set_trigger() { return &this->set_trigger_; }
-
- protected:
-  void control(size_t index) override;
-  Trigger<StringRef> set_trigger_;
-};
-
 }  // namespace esphome::template_

esphome/components/template/switch/__init__.py

@@ -60,10 +60,12 @@ async def to_code(config):
         )
         cg.add(var.set_state_lambda(template_))
     if CONF_TURN_OFF_ACTION in config:
+        cg.add_define("USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER")
         await automation.build_automation(
             var.get_turn_off_trigger(), [], config[CONF_TURN_OFF_ACTION]
         )
     if CONF_TURN_ON_ACTION in config:
+        cg.add_define("USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER")
         await automation.build_automation(
             var.get_turn_on_trigger(), [], config[CONF_TURN_ON_ACTION]
         )

esphome/components/template/switch/template_switch.cpp

@@ -5,7 +5,18 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.switch";
 
-TemplateSwitch::TemplateSwitch() : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
+TemplateSwitch::TemplateSwitch()
+#ifdef USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
+    : turn_on_trigger_(new Trigger<>())
+#ifdef USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
+      ,
+      turn_off_trigger_(new Trigger<>())
+#endif
+#elif defined(USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER)
+    : turn_off_trigger_(new Trigger<>())
+#endif
+{
+}
 
 void TemplateSwitch::loop() {
   auto s = this->f_();
@@ -14,16 +25,22 @@ void TemplateSwitch::loop() {
   }
 }
 void TemplateSwitch::write_state(bool state) {
+#if defined(USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER) || defined(USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER)
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
+#endif
 
   if (state) {
+#ifdef USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
     this->prev_trigger_ = this->turn_on_trigger_;
     this->turn_on_trigger_->trigger();
+#endif
   } else {
+#ifdef USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
     this->prev_trigger_ = this->turn_off_trigger_;
     this->turn_off_trigger_->trigger();
+#endif
   }
 
   if (this->optimistic_)
@@ -32,8 +49,12 @@ void TemplateSwitch::write_state(bool state) {
 void TemplateSwitch::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 bool TemplateSwitch::assumed_state() { return this->assumed_state_; }
 float TemplateSwitch::get_setup_priority() const { return setup_priority::HARDWARE - 2.0f; }
+#ifdef USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
 Trigger<> *TemplateSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
 Trigger<> *TemplateSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
+#endif
 void TemplateSwitch::setup() {
   if (!this->f_.has_value())
     this->disable_loop();

esphome/components/template/switch/template_switch.h

@@ -15,8 +15,12 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
+#ifdef USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
   Trigger<> *get_turn_on_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
   Trigger<> *get_turn_off_trigger() const;
+#endif
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void loop() override;
@@ -31,9 +35,15 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   TemplateLambda<bool> f_;
   bool optimistic_{false};
   bool assumed_state_{false};
+#ifdef USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
   Trigger<> *turn_on_trigger_;
+#endif
+#ifdef USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
   Trigger<> *turn_off_trigger_;
+#endif
+#if defined(USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER) || defined(USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER)
   Trigger<> *prev_trigger_{nullptr};
+#endif
 };
 
 }  // namespace esphome::template_

esphome/components/template/text/__init__.py

@@ -89,6 +89,7 @@ async def to_code(config):
             cg.add(var.set_value_saver(saver))
 
     if CONF_SET_ACTION in config:
+        cg.add_define("USE_TEMPLATE_TEXT_SET_TRIGGER")
         await automation.build_automation(
             var.get_set_trigger(), [(cg.std_string, "x")], config[CONF_SET_ACTION]
         )

esphome/components/template/text/template_text.cpp

@@ -47,7 +47,9 @@ void TemplateText::update() {
 }
 
 void TemplateText::control(const std::string &value) {
+#ifdef USE_TEMPLATE_TEXT_SET_TRIGGER
   this->set_trigger_->trigger(value);
+#endif
 
   if (this->optimistic_)
     this->publish_state(value);

esphome/components/template/text/template_text.h

@@ -68,7 +68,9 @@ class TemplateText final : public text::Text, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
+#ifdef USE_TEMPLATE_TEXT_SET_TRIGGER
   Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
+#endif
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_initial_value(const char *initial_value) { this->initial_value_ = initial_value; }
   /// Prevent accidental use of std::string which would dangle
@@ -79,7 +81,9 @@ class TemplateText final : public text::Text, public PollingComponent {
   void control(const std::string &value) override;
   bool optimistic_ = false;
   const char *initial_value_{nullptr};
+#ifdef USE_TEMPLATE_TEXT_SET_TRIGGER
   Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+#endif
   TemplateLambda<std::string> f_{};
 
   TemplateTextSaverBase *pref_ = nullptr;

esphome/components/template/valve/__init__.py

@@ -78,16 +78,19 @@ async def to_code(config):
             var.get_close_trigger(), [], close_action_config
         )
     if stop_action_config := config.get(CONF_STOP_ACTION):
+        cg.add_define("USE_TEMPLATE_VALVE_STOP_TRIGGER")
         await automation.build_automation(
             var.get_stop_trigger(), [], stop_action_config
         )
         cg.add(var.set_has_stop(True))
     if toggle_action_config := config.get(CONF_TOGGLE_ACTION):
+        cg.add_define("USE_TEMPLATE_VALVE_TOGGLE_TRIGGER")
         await automation.build_automation(
             var.get_toggle_trigger(), [], toggle_action_config
         )
         cg.add(var.set_has_toggle(True))
     if position_action_config := config.get(CONF_POSITION_ACTION):
+        cg.add_define("USE_TEMPLATE_VALVE_POSITION_TRIGGER")
         await automation.build_automation(
             var.get_position_trigger(), [(float, "pos")], position_action_config
         )

esphome/components/template/valve/template_valve.cpp

@@ -9,10 +9,21 @@ static const char *const TAG = "template.valve";
 
 TemplateValve::TemplateValve()
     : open_trigger_(new Trigger<>()),
-      close_trigger_(new Trigger<>),
-      stop_trigger_(new Trigger<>()),
-      toggle_trigger_(new Trigger<>()),
-      position_trigger_(new Trigger<float>()) {}
+      close_trigger_(new Trigger<>())
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
+      ,
+      stop_trigger_(new Trigger<>())
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
+      ,
+      toggle_trigger_(new Trigger<>())
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
+      ,
+      position_trigger_(new Trigger<float>())
+#endif
+{
+}
 
 void TemplateValve::setup() {
   switch (this->restore_mode_) {
@@ -58,8 +69,12 @@ float TemplateValve::get_setup_priority() const { return setup_priority::HARDWAR
 
 Trigger<> *TemplateValve::get_open_trigger() const { return this->open_trigger_; }
 Trigger<> *TemplateValve::get_close_trigger() const { return this->close_trigger_; }
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
 Trigger<> *TemplateValve::get_stop_trigger() const { return this->stop_trigger_; }
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
 Trigger<> *TemplateValve::get_toggle_trigger() const { return this->toggle_trigger_; }
+#endif
 
 void TemplateValve::dump_config() {
   LOG_VALVE("", "Template Valve", this);
@@ -70,18 +85,22 @@ void TemplateValve::dump_config() {
 }
 
 void TemplateValve::control(const ValveCall &call) {
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
   if (call.get_stop()) {
     this->stop_prev_trigger_();
     this->stop_trigger_->trigger();
     this->prev_command_trigger_ = this->stop_trigger_;
     this->publish_state();
   }
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
     this->toggle_trigger_->trigger();
     this->prev_command_trigger_ = this->toggle_trigger_;
     this->publish_state();
   }
+#endif
   if (call.get_position().has_value()) {
     auto pos = *call.get_position();
     this->stop_prev_trigger_();
@@ -92,9 +111,12 @@ void TemplateValve::control(const ValveCall &call) {
     } else if (pos == VALVE_CLOSED) {
       this->close_trigger_->trigger();
       this->prev_command_trigger_ = this->close_trigger_;
-    } else {
+    }
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
+    else {
       this->position_trigger_->trigger(pos);
     }
+#endif
 
     if (this->optimistic_) {
       this->position = pos;
@@ -107,17 +129,37 @@ void TemplateValve::control(const ValveCall &call) {
 ValveTraits TemplateValve::get_traits() {
   auto traits = ValveTraits();
   traits.set_is_assumed_state(this->assumed_state_);
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
   traits.set_supports_stop(this->has_stop_);
+#else
+  traits.set_supports_stop(false);
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
   traits.set_supports_toggle(this->has_toggle_);
+#else
+  traits.set_supports_toggle(false);
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
   traits.set_supports_position(this->has_position_);
+#else
+  traits.set_supports_position(false);
+#endif
   return traits;
 }
 
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
 Trigger<float> *TemplateValve::get_position_trigger() const { return this->position_trigger_; }
+#endif
 
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
 void TemplateValve::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
 void TemplateValve::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
 void TemplateValve::set_has_position(bool has_position) { this->has_position_ = has_position; }
+#endif
 
 void TemplateValve::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {

esphome/components/template/valve/template_valve.h

@@ -20,14 +20,26 @@ class TemplateValve final : public valve::Valve, public Component {
   template<typename F> void set_state_lambda(F &&f) { this->state_f_.set(std::forward<F>(f)); }
   Trigger<> *get_open_trigger() const;
   Trigger<> *get_close_trigger() const;
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
   Trigger<> *get_stop_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
   Trigger<> *get_toggle_trigger() const;
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
   Trigger<float> *get_position_trigger() const;
+#endif
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
   void set_has_stop(bool has_stop);
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
   void set_has_position(bool has_position);
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
   void set_has_toggle(bool has_toggle);
+#endif
   void set_restore_mode(TemplateValveRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
@@ -41,19 +53,32 @@ class TemplateValve final : public valve::Valve, public Component {
   valve::ValveTraits get_traits() override;
   void stop_prev_trigger_();
 
+  // Ordered to minimize padding on 32-bit: 4-byte members first, then smaller
   TemplateValveRestoreMode restore_mode_{VALVE_NO_RESTORE};
   TemplateLambda<float> state_f_;
-  bool assumed_state_{false};
-  bool optimistic_{false};
   Trigger<> *open_trigger_;
   Trigger<> *close_trigger_;
-  bool has_stop_{false};
-  bool has_toggle_{false};
-  Trigger<> *stop_trigger_;
-  Trigger<> *toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
+  Trigger<> *stop_trigger_;
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
+  Trigger<> *toggle_trigger_;
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
   Trigger<float> *position_trigger_;
+#endif
+  bool assumed_state_{false};
+  bool optimistic_{false};
+#ifdef USE_TEMPLATE_VALVE_STOP_TRIGGER
+  bool has_stop_{false};
+#endif
+#ifdef USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
+  bool has_toggle_{false};
+#endif
+#ifdef USE_TEMPLATE_VALVE_POSITION_TRIGGER
   bool has_position_{false};
+#endif
 };
 
 }  // namespace esphome::template_

esphome/components/template/water_heater/__init__.py

@@ -64,6 +64,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
 
     if CONF_SET_ACTION in config:
+        cg.add_define("USE_TEMPLATE_WATER_HEATER_SET_TRIGGER")
         await automation.build_automation(
             var.get_set_trigger(), [], config[CONF_SET_ACTION]
         )

esphome/components/template/water_heater/template_water_heater.cpp

@@ -5,7 +5,12 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.water_heater";
 
-TemplateWaterHeater::TemplateWaterHeater() : set_trigger_(new Trigger<>()) {}
+TemplateWaterHeater::TemplateWaterHeater()
+#ifdef USE_TEMPLATE_WATER_HEATER_SET_TRIGGER
+    : set_trigger_(new Trigger<>())
+#endif
+{
+}
 
 void TemplateWaterHeater::setup() {
   if (this->restore_mode_ == TemplateWaterHeaterRestoreMode::WATER_HEATER_RESTORE ||
@@ -78,7 +83,9 @@ void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
     }
   }
 
+#ifdef USE_TEMPLATE_WATER_HEATER_SET_TRIGGER
   this->set_trigger_->trigger();
+#endif
 
   if (this->optimistic_) {
     this->publish_state();

esphome/components/template/water_heater/template_water_heater.h

@@ -28,7 +28,9 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
     this->supported_modes_ = modes;
   }
 
+#ifdef USE_TEMPLATE_WATER_HEATER_SET_TRIGGER
   Trigger<> *get_set_trigger() const { return this->set_trigger_; }
+#endif
 
   void setup() override;
   void loop() override;
@@ -42,7 +44,9 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
   water_heater::WaterHeaterTraits traits() override;
 
   // Ordered to minimize padding on 32-bit: 4-byte members first, then smaller
+#ifdef USE_TEMPLATE_WATER_HEATER_SET_TRIGGER
   Trigger<> *set_trigger_;
+#endif
   TemplateLambda<float> current_temperature_f_;
   TemplateLambda<water_heater::WaterHeaterMode> mode_f_;
   TemplateWaterHeaterRestoreMode restore_mode_{WATER_HEATER_NO_RESTORE};

esphome/core/defines.h

@@ -232,6 +232,25 @@
 #define ESPHOME_WIFI_CONNECT_STATE_LISTENERS 2
 #define ESPHOME_WIFI_POWER_SAVE_LISTENERS 2
 #define USE_WIFI_RUNTIME_POWER_SAVE
+#define USE_TEMPLATE_NUMBER_SET_TRIGGER
+#define USE_TEMPLATE_SELECT_SET_TRIGGER
+#define USE_TEMPLATE_TEXT_SET_TRIGGER
+#define USE_TEMPLATE_SWITCH_TURN_ON_TRIGGER
+#define USE_TEMPLATE_SWITCH_TURN_OFF_TRIGGER
+#define USE_TEMPLATE_DATE_SET_TRIGGER
+#define USE_TEMPLATE_TIME_SET_TRIGGER
+#define USE_TEMPLATE_DATETIME_SET_TRIGGER
+#define USE_TEMPLATE_WATER_HEATER_SET_TRIGGER
+#define USE_TEMPLATE_LOCK_LOCK_TRIGGER
+#define USE_TEMPLATE_LOCK_UNLOCK_TRIGGER
+#define USE_TEMPLATE_LOCK_OPEN_TRIGGER
+#define USE_TEMPLATE_COVER_STOP_TRIGGER
+#define USE_TEMPLATE_COVER_TOGGLE_TRIGGER
+#define USE_TEMPLATE_COVER_POSITION_TRIGGER
+#define USE_TEMPLATE_COVER_TILT_TRIGGER
+#define USE_TEMPLATE_VALVE_STOP_TRIGGER
+#define USE_TEMPLATE_VALVE_TOGGLE_TRIGGER
+#define USE_TEMPLATE_VALVE_POSITION_TRIGGER
 #define USB_HOST_MAX_REQUESTS 16
 
 #ifdef USE_ARDUINO

tests/components/template/common-base.yaml

@@ -296,16 +296,6 @@ select:
           // Migration guide: Store in std::string
           std::string stored_option(id(template_select).current_option());
           ESP_LOGI("test", "Stored: %s", stored_option.c_str());
-  - platform: template
-    id: template_select_with_action
-    name: "Template select with action"
-    options:
-      - option_a
-      - option_b
-    set_action:
-      - logger.log:
-          format: "Selected: %s"
-          args: ["x.c_str()"]
 
 lock:
   - platform: template

tests/integration/fixtures/select_stringref_trigger.yaml

@@ -56,21 +56,7 @@ select:
             std::string prefix = x.substr(0, 6);
             ESP_LOGI("test", "Substr prefix: %s", prefix.c_str());
 
-  # Second select with set_action trigger (uses TemplateSelectWithSetAction subclass)
-  - platform: template
-    name: "Action Select"
-    id: action_select
-    options:
-      - "Action A"
-      - "Action B"
-    set_action:
-      then:
-        # Test: set_action trigger receives StringRef
-        - logger.log:
-            format: "set_action triggered: %s"
-            args: ['x.c_str()']
-
-  # Third select with numeric options to test ADL functions
+  # Second select with numeric options to test ADL functions
   - platform: template
     name: "Baud Rate"
     id: baud_select

tests/integration/test_select_stringref_trigger.py

@@ -28,8 +28,6 @@ async def test_select_stringref_trigger(
     find_substr_future = loop.create_future()
     find_char_future = loop.create_future()
     substr_future = loop.create_future()
-    # set_action trigger (TemplateSelectWithSetAction subclass)
-    set_action_future = loop.create_future()
     # ADL functions
     stoi_future = loop.create_future()
     stol_future = loop.create_future()
@@ -45,8 +43,6 @@ async def test_select_stringref_trigger(
     find_substr_pattern = re.compile(r"Found 'Option' in value")
     find_char_pattern = re.compile(r"Space at position: 6")  # space at index 6
     substr_pattern = re.compile(r"Substr prefix: Option")
-    # set_action trigger pattern (TemplateSelectWithSetAction subclass)
-    set_action_pattern = re.compile(r"set_action triggered: Action B")
     # ADL function patterns (115200 from baud rate select)
     stoi_pattern = re.compile(r"stoi result: 115200")
     stol_pattern = re.compile(r"stol result: 115200")
@@ -71,9 +67,6 @@ async def test_select_stringref_trigger(
             find_char_future.set_result(True)
         if not substr_future.done() and substr_pattern.search(line):
             substr_future.set_result(True)
-        # set_action trigger
-        if not set_action_future.done() and set_action_pattern.search(line):
-            set_action_future.set_result(True)
         # ADL functions
         if not stoi_future.done() and stoi_pattern.search(line):
             stoi_future.set_result(True)
@@ -96,21 +89,22 @@ async def test_select_stringref_trigger(
         # List entities to find our select
         entities, _ = await client.list_entities_services()
 
-        select_entity = next((e for e in entities if e.name == "Test Select"), None)
+        select_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Test Select"),
+            None,
+        )
         assert select_entity is not None, "Test Select entity not found"
 
-        baud_entity = next((e for e in entities if e.name == "Baud Rate"), None)
+        baud_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Baud Rate"),
+            None,
+        )
         assert baud_entity is not None, "Baud Rate entity not found"
 
-        action_entity = next((e for e in entities if e.name == "Action Select"), None)
-        assert action_entity is not None, "Action Select entity not found"
-
         # Change select to Option B - this should trigger on_value with StringRef
         client.select_command(select_entity.key, "Option B")
         # Change baud to 115200 - this tests ADL functions (stoi, stol, stof, stod)
         client.select_command(baud_entity.key, "115200")
-        # Change action select - tests set_action trigger (TemplateSelectWithSetAction)
-        client.select_command(action_entity.key, "Action B")
 
         # Wait for all log messages confirming StringRef operations work
         try:
@@ -124,7 +118,6 @@ async def test_select_stringref_trigger(
                     find_substr_future,
                     find_char_future,
                     substr_future,
-                    set_action_future,
                     stoi_future,
                     stol_future,
                     stof_future,
@@ -142,7 +135,6 @@ async def test_select_stringref_trigger(
                 "find_substr": find_substr_future.done(),
                 "find_char": find_char_future.done(),
                 "substr": substr_future.done(),
-                "set_action": set_action_future.done(),
                 "stoi": stoi_future.done(),
                 "stol": stol_future.done(),
                 "stof": stof_future.done(),