esphome 2025.5.2__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/stepper/stepper.h

@@ -7,9 +7,11 @@ namespace esphome {
 namespace stepper {
 
 #define LOG_STEPPER(this) \
-  ESP_LOGCONFIG(TAG, "  Acceleration: %.0f steps/s^2", this->acceleration_); \
-  ESP_LOGCONFIG(TAG, "  Deceleration: %.0f steps/s^2", this->deceleration_); \
-  ESP_LOGCONFIG(TAG, "  Max Speed: %.0f steps/s", this->max_speed_);
+  ESP_LOGCONFIG(TAG, \
+                "  Acceleration: %.0f steps/s^2\n" \
+                "  Deceleration: %.0f steps/s^2\n" \
+                "  Max Speed: %.0f steps/s", \
+                this->acceleration_, this->deceleration_, this->max_speed_);
 
 class Stepper {
  public:

esphome/components/sts3x/sts3x.cpp

@@ -18,7 +18,7 @@ static const uint16_t STS3X_COMMAND_HEATER_DISABLE = 0x3066;
 static const uint16_t STS3X_COMMAND_FETCH_DATA = 0xE000;
 
 void STS3XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up STS3x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->write_command(STS3X_COMMAND_READ_SERIAL_NUMBER)) {
     this->mark_failed();
     return;
@@ -36,7 +36,7 @@ void STS3XComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "STS3x:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with ST3x failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 

esphome/components/switch/__init__.py

@@ -159,6 +159,7 @@ async def register_switch(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_switch(var))
+    CORE.register_platform_component("switch", var)
     await setup_switch_core_(var, config)
 
 

esphome/components/switch/switch.cpp

@@ -65,7 +65,24 @@ bool Switch::is_inverted() const { return this->inverted_; }
 
 void log_switch(const char *tag, const char *prefix, const char *type, Switch *obj) {
   if (obj != nullptr) {
-    ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
+    // Prepare restore mode string
+    const LogString *onoff = LOG_STR(""), *inverted = onoff, *restore;
+    if (obj->restore_mode & RESTORE_MODE_DISABLED_MASK) {
+      restore = LOG_STR("disabled");
+    } else {
+      onoff = obj->restore_mode & RESTORE_MODE_ON_MASK ? LOG_STR("ON") : LOG_STR("OFF");
+      inverted = obj->restore_mode & RESTORE_MODE_INVERTED_MASK ? LOG_STR("inverted ") : LOG_STR("");
+      restore = obj->restore_mode & RESTORE_MODE_PERSISTENT_MASK ? LOG_STR("restore defaults to") : LOG_STR("always");
+    }
+
+    // Build the base message with mandatory fields
+    ESP_LOGCONFIG(tag,
+                  "%s%s '%s'\n"
+                  "%s  Restore Mode: %s%s %s",
+                  prefix, type, obj->get_name().c_str(), prefix, LOG_STR_ARG(inverted), LOG_STR_ARG(restore),
+                  LOG_STR_ARG(onoff));
+
+    // Add optional fields separately
     if (!obj->get_icon().empty()) {
       ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon().c_str());
     }
@@ -78,17 +95,6 @@ void log_switch(const char *tag, const char *prefix, const char *type, Switch *o
     if (!obj->get_device_class().empty()) {
       ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class().c_str());
     }
-    const LogString *onoff = LOG_STR(""), *inverted = onoff, *restore;
-    if (obj->restore_mode & RESTORE_MODE_DISABLED_MASK) {
-      restore = LOG_STR("disabled");
-    } else {
-      onoff = obj->restore_mode & RESTORE_MODE_ON_MASK ? LOG_STR("ON") : LOG_STR("OFF");
-      inverted = obj->restore_mode & RESTORE_MODE_INVERTED_MASK ? LOG_STR("inverted ") : LOG_STR("");
-      restore = obj->restore_mode & RESTORE_MODE_PERSISTENT_MASK ? LOG_STR("restore defaults to") : LOG_STR("always");
-    }
-
-    ESP_LOGCONFIG(tag, "%s  Restore Mode: %s%s %s", prefix, LOG_STR_ARG(inverted), LOG_STR_ARG(restore),
-                  LOG_STR_ARG(onoff));
   }
 }
 

esphome/components/switch/switch.h

@@ -2,8 +2,8 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/preferences.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"
 
 namespace esphome {
 namespace switch_ {

esphome/components/sx1509/__init__.py

@@ -1,6 +1,6 @@
-from esphome import pins
+from esphome import automation, pins
 import esphome.codegen as cg
-from esphome.components import i2c
+from esphome.components import i2c, key_provider
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
@@ -8,13 +8,16 @@ from esphome.const import (
     CONF_INVERTED,
     CONF_MODE,
     CONF_NUMBER,
+    CONF_ON_KEY,
     CONF_OPEN_DRAIN,
     CONF_OUTPUT,
     CONF_PULLDOWN,
     CONF_PULLUP,
+    CONF_TRIGGER_ID,
 )
 
 CONF_KEYPAD = "keypad"
+CONF_KEYS = "keys"
 CONF_KEY_ROWS = "key_rows"
 CONF_KEY_COLUMNS = "key_columns"
 CONF_SLEEP_TIME = "sleep_time"
@@ -22,22 +25,47 @@ CONF_SCAN_TIME = "scan_time"
 CONF_DEBOUNCE_TIME = "debounce_time"
 CONF_SX1509_ID = "sx1509_id"
 
+AUTO_LOAD = ["key_provider"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 
 sx1509_ns = cg.esphome_ns.namespace("sx1509")
 
-SX1509Component = sx1509_ns.class_("SX1509Component", cg.Component, i2c.I2CDevice)
+SX1509Component = sx1509_ns.class_(
+    "SX1509Component", cg.Component, i2c.I2CDevice, key_provider.KeyProvider
+)
 SX1509GPIOPin = sx1509_ns.class_("SX1509GPIOPin", cg.GPIOPin)
+SX1509KeyTrigger = sx1509_ns.class_(
+    "SX1509KeyTrigger", automation.Trigger.template(cg.uint8)
+)
 
-KEYPAD_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_KEY_ROWS): cv.int_range(min=1, max=8),
-        cv.Required(CONF_KEY_COLUMNS): cv.int_range(min=1, max=8),
-        cv.Optional(CONF_SLEEP_TIME): cv.int_range(min=128, max=8192),
-        cv.Optional(CONF_SCAN_TIME): cv.int_range(min=1, max=128),
-        cv.Optional(CONF_DEBOUNCE_TIME): cv.int_range(min=1, max=64),
-    }
+
+def check_keys(config):
+    if CONF_KEYS in config:
+        if len(config[CONF_KEYS]) != config[CONF_KEY_ROWS] * config[CONF_KEY_COLUMNS]:
+            raise cv.Invalid(
+                "The number of key codes must equal the number of rows * columns"
+            )
+    return config
+
+
+KEYPAD_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(CONF_KEY_ROWS): cv.int_range(min=2, max=8),
+            cv.Required(CONF_KEY_COLUMNS): cv.int_range(min=1, max=8),
+            cv.Optional(CONF_SLEEP_TIME): cv.int_range(min=128, max=8192),
+            cv.Optional(CONF_SCAN_TIME): cv.int_range(min=1, max=128),
+            cv.Optional(CONF_DEBOUNCE_TIME): cv.int_range(min=1, max=64),
+            cv.Optional(CONF_KEYS): cv.string,
+            cv.Optional(CONF_ON_KEY): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SX1509KeyTrigger),
+                }
+            ),
+        }
+    ),
+    check_keys,
 )
 
 CONFIG_SCHEMA = (
@@ -56,17 +84,22 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
-    if CONF_KEYPAD in config:
-        keypad = config[CONF_KEYPAD]
-        cg.add(var.set_rows_cols(keypad[CONF_KEY_ROWS], keypad[CONF_KEY_COLUMNS]))
+    if conf := config.get(CONF_KEYPAD):
+        cg.add(var.set_rows_cols(conf[CONF_KEY_ROWS], conf[CONF_KEY_COLUMNS]))
         if (
-            CONF_SLEEP_TIME in keypad
-            and CONF_SCAN_TIME in keypad
-            and CONF_DEBOUNCE_TIME in keypad
+            CONF_SLEEP_TIME in conf
+            and CONF_SCAN_TIME in conf
+            and CONF_DEBOUNCE_TIME in conf
         ):
-            cg.add(var.set_sleep_time(keypad[CONF_SLEEP_TIME]))
-            cg.add(var.set_scan_time(keypad[CONF_SCAN_TIME]))
-            cg.add(var.set_debounce_time(keypad[CONF_DEBOUNCE_TIME]))
+            cg.add(var.set_sleep_time(conf[CONF_SLEEP_TIME]))
+            cg.add(var.set_scan_time(conf[CONF_SCAN_TIME]))
+            cg.add(var.set_debounce_time(conf[CONF_DEBOUNCE_TIME]))
+        if keys := conf.get(CONF_KEYS):
+            cg.add(var.set_keys(keys))
+        for tconf in conf.get(CONF_ON_KEY, []):
+            trigger = cg.new_Pvariable(tconf[CONF_TRIGGER_ID])
+            cg.add(var.register_key_trigger(trigger))
+            await automation.build_automation(trigger, [(cg.uint8, "x")], tconf)
 
 
 def validate_mode(value):

esphome/components/sx1509/sx1509.cpp

@@ -8,9 +8,9 @@ namespace sx1509 {
 static const char *const TAG = "sx1509";
 
 void SX1509Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SX1509Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
-  ESP_LOGV(TAG, "  Resetting devices...");
+  ESP_LOGV(TAG, "  Resetting devices");
   if (!this->write_byte(REG_RESET, 0x12)) {
     this->mark_failed();
     return;
@@ -48,6 +48,30 @@ void SX1509Component::loop() {
     uint16_t key_data = this->read_key_data();
     for (auto *binary_sensor : this->keypad_binary_sensors_)
       binary_sensor->process(key_data);
+    if (this->keys_.empty())
+      return;
+    if (key_data == 0) {
+      this->last_key_ = 0;
+      return;
+    }
+    int row, col;
+    for (row = 0; row < 7; row++) {
+      if (key_data & (1 << row))
+        break;
+    }
+    for (col = 8; col < 15; col++) {
+      if (key_data & (1 << col))
+        break;
+    }
+    col -= 8;
+    uint8_t key = this->keys_[row * this->cols_ + col];
+    if (key == this->last_key_)
+      return;
+    this->last_key_ = key;
+    ESP_LOGV(TAG, "row %d, col %d, key '%c'", row, col, key);
+    for (auto &trigger : this->key_triggers_)
+      trigger->trigger(key);
+    this->send_key_(key);
   }
 }
 
@@ -230,9 +254,9 @@ void SX1509Component::setup_keypad_() {
   scan_time_bits &= 0b111;  // Scan time is bits 2:0
   temp_byte = sleep_time_ | scan_time_bits;
   this->write_byte(REG_KEY_CONFIG_1, temp_byte);
-  rows_ = (rows_ - 1) & 0b111;  // 0 = off, 0b001 = 2 rows, 0b111 = 8 rows, etc.
-  cols_ = (cols_ - 1) & 0b111;  // 0b000 = 1 column, ob111 = 8 columns, etc.
-  this->write_byte(REG_KEY_CONFIG_2, (rows_ << 3) | cols_);
+  temp_byte = ((this->rows_ - 1) & 0b111) << 3;  // 0 = off, 0b001 = 2 rows, 0b111 = 8 rows, etc.
+  temp_byte |= (this->cols_ - 1) & 0b111;        // 0b000 = 1 column, ob111 = 8 columns, etc.
+  this->write_byte(REG_KEY_CONFIG_2, temp_byte);
 }
 
 uint16_t SX1509Component::read_key_data() {

esphome/components/sx1509/sx1509.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/key_provider/key_provider.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "sx1509_gpio_pin.h"
@@ -27,7 +28,9 @@ class SX1509Processor {
   virtual void process(uint16_t data){};
 };
 
-class SX1509Component : public Component, public i2c::I2CDevice {
+class SX1509KeyTrigger : public Trigger<uint8_t> {};
+
+class SX1509Component : public Component, public i2c::I2CDevice, public key_provider::KeyProvider {
  public:
   SX1509Component() = default;
 
@@ -47,12 +50,14 @@ class SX1509Component : public Component, public i2c::I2CDevice {
     this->cols_ = cols;
     this->has_keypad_ = true;
   };
+  void set_keys(std::string keys) { this->keys_ = std::move(keys); };
   void set_sleep_time(uint16_t sleep_time) { this->sleep_time_ = sleep_time; };
   void set_scan_time(uint8_t scan_time) { this->scan_time_ = scan_time; };
   void set_debounce_time(uint8_t debounce_time = 1) { this->debounce_time_ = debounce_time; };
   void register_keypad_binary_sensor(SX1509Processor *binary_sensor) {
     this->keypad_binary_sensors_.push_back(binary_sensor);
   }
+  void register_key_trigger(SX1509KeyTrigger *trig) { this->key_triggers_.push_back(trig); };
   void setup_led_driver(uint8_t pin);
 
  protected:
@@ -65,10 +70,13 @@ class SX1509Component : public Component, public i2c::I2CDevice {
   bool has_keypad_ = false;
   uint8_t rows_ = 0;
   uint8_t cols_ = 0;
+  std::string keys_;
   uint16_t sleep_time_ = 128;
   uint8_t scan_time_ = 1;
   uint8_t debounce_time_ = 1;
+  uint8_t last_key_ = 0;
   std::vector<SX1509Processor *> keypad_binary_sensors_;
+  std::vector<SX1509KeyTrigger *> key_triggers_;
 
   uint32_t last_loop_timestamp_ = 0;
   const uint32_t min_loop_period_ = 15;  // ms

esphome/components/t6615/t6615.cpp

@@ -1,4 +1,5 @@
 #include "t6615.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/tc74/tc74.cpp

@@ -15,7 +15,7 @@ static const uint8_t TC74_DATA_READY_MASK = 0x40;
 // It is possible the "Data Ready" bit will not be set if the TC74 has not been powered on for at least 250ms, so it not
 // being set does not constitute a failure.
 void TC74Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TC74...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t config_reg;
   if (this->read_register(TC74_REGISTER_CONFIGURATION, &config_reg, 1) != i2c::ERROR_OK) {
     this->mark_failed();

esphome/components/tca9548a/tca9548a.cpp

@@ -24,7 +24,7 @@ i2c::ErrorCode TCA9548AChannel::writev(uint8_t address, i2c::WriteBuffer *buffer
 }
 
 void TCA9548AComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TCA9548A...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t status = 0;
   if (this->read(&status, 1) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, "TCA9548A failed");

esphome/components/tca9555/tca9555.cpp

@@ -16,7 +16,7 @@ namespace tca9555 {
 static const char *const TAG = "tca9555";
 
 void TCA9555Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TCA9555...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->read_gpio_modes_()) {
     this->mark_failed();
     return;
@@ -30,7 +30,7 @@ void TCA9555Component::dump_config() {
   ESP_LOGCONFIG(TAG, "TCA9555:");
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TCA9555 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 void TCA9555Component::pin_mode(uint8_t pin, gpio::Flags flags) {

esphome/components/tcs34725/tcs34725.cpp

@@ -1,8 +1,8 @@
 #include "tcs34725.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
-#include <algorithm>
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include <algorithm>
 
 namespace esphome {
 namespace tcs34725 {
@@ -18,7 +18,7 @@ static const uint8_t TCS34725_REGISTER_ENABLE = TCS34725_COMMAND_BIT | 0x00;
 static const uint8_t TCS34725_REGISTER_CRGBDATAL = TCS34725_COMMAND_BIT | 0x14;
 
 void TCS34725Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TCS34725...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t id;
   if (this->read_register(TCS34725_REGISTER_ID, &id, 1) != i2c::ERROR_OK) {
     this->mark_failed();
@@ -46,7 +46,7 @@ void TCS34725Component::dump_config() {
   ESP_LOGCONFIG(TAG, "TCS34725:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TCS34725 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 

esphome/components/tee501/tee501.cpp

@@ -1,4 +1,5 @@
 #include "tee501.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -7,7 +8,7 @@ namespace tee501 {
 static const char *const TAG = "tee501";
 
 void TEE501Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TEE501...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t address[] = {0x70, 0x29};
   this->write(address, 2, false);
   uint8_t identification[9];
@@ -25,7 +26,7 @@ void TEE501Component::dump_config() {
   LOG_I2C_DEVICE(this);
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, "Communication with TEE501 failed!");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       break;
     case CRC_CHECK_FAILED:
       ESP_LOGE(TAG, "The crc check failed");

esphome/components/tem3200/tem3200.cpp

@@ -1,7 +1,7 @@
 #include "tem3200.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace tem3200 {
@@ -16,7 +16,7 @@ enum ErrorCode {
 };
 
 void TEM3200Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TEM3200...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint8_t status(NONE);
   uint16_t raw_temperature(0);
@@ -24,7 +24,7 @@ void TEM3200Component::setup() {
 
   i2c::ErrorCode err = this->read_(status, raw_temperature, raw_pressure);
   if (err != i2c::ERROR_OK) {
-    ESP_LOGCONFIG(TAG, "    I2C Communication Failed...");
+    ESP_LOGCONFIG(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
     return;
   }
@@ -43,7 +43,6 @@ void TEM3200Component::setup() {
       this->status_set_warning();
       break;
   }
-  ESP_LOGCONFIG(TAG, "    Success...");
 }
 
 void TEM3200Component::dump_config() {
@@ -115,7 +114,7 @@ void TEM3200Component::update() {
   i2c::ErrorCode err = this->read_(status, raw_temperature, raw_pressure);
 
   if (err != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "I2C Communication Failed");
+    ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->status_set_warning();
     return;
   }

esphome/components/template/alarm_control_panel/__init__.py

@@ -10,6 +10,7 @@ CODEOWNERS = ["@grahambrown11", "@hwstar"]
 CONF_CODES = "codes"
 CONF_BYPASS_ARMED_HOME = "bypass_armed_home"
 CONF_BYPASS_ARMED_NIGHT = "bypass_armed_night"
+CONF_BYPASS_AUTO = "bypass_auto"
 CONF_CHIME = "chime"
 CONF_TRIGGER_MODE = "trigger_mode"
 CONF_REQUIRES_CODE_TO_ARM = "requires_code_to_arm"
@@ -23,6 +24,7 @@ CONF_TRIGGER_TIME = "trigger_time"
 FLAG_NORMAL = "normal"
 FLAG_BYPASS_ARMED_HOME = "bypass_armed_home"
 FLAG_BYPASS_ARMED_NIGHT = "bypass_armed_night"
+FLAG_BYPASS_AUTO = "bypass_auto"
 FLAG_CHIME = "chime"
 
 BinarySensorFlags = {
@@ -30,6 +32,7 @@ BinarySensorFlags = {
     FLAG_BYPASS_ARMED_HOME: 1 << 1,
     FLAG_BYPASS_ARMED_NIGHT: 1 << 2,
     FLAG_CHIME: 1 << 3,
+    FLAG_BYPASS_AUTO: 1 << 4,
 }
 
 
@@ -68,6 +71,7 @@ TEMPLATE_ALARM_CONTROL_PANEL_BINARY_SENSOR_SCHEMA = cv.maybe_simple_value(
         cv.Required(CONF_INPUT): cv.use_id(binary_sensor.BinarySensor),
         cv.Optional(CONF_BYPASS_ARMED_HOME, default=False): cv.boolean,
         cv.Optional(CONF_BYPASS_ARMED_NIGHT, default=False): cv.boolean,
+        cv.Optional(CONF_BYPASS_AUTO, default=False): cv.boolean,
         cv.Optional(CONF_CHIME, default=False): cv.boolean,
         cv.Optional(CONF_TRIGGER_MODE, default="DELAYED"): cv.enum(
             ALARM_SENSOR_TYPES, upper=True, space="_"
@@ -143,6 +147,8 @@ async def to_code(config):
         if sensor[CONF_BYPASS_ARMED_NIGHT]:
             flags |= BinarySensorFlags[FLAG_BYPASS_ARMED_NIGHT]
             supports_arm_night = True
+        if sensor[CONF_BYPASS_AUTO]:
+            flags |= BinarySensorFlags[FLAG_BYPASS_AUTO]
         if sensor[CONF_CHIME]:
             flags |= BinarySensorFlags[FLAG_CHIME]
         cg.add(var.add_sensor(bs, flags, sensor[CONF_TRIGGER_MODE]))

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -29,8 +29,10 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
 
 void TemplateAlarmControlPanel::dump_config() {
   ESP_LOGCONFIG(TAG, "TemplateAlarmControlPanel:");
-  ESP_LOGCONFIG(TAG, "  Current State: %s", LOG_STR_ARG(alarm_control_panel_state_to_string(this->current_state_)));
-  ESP_LOGCONFIG(TAG, "  Number of Codes: %u", this->codes_.size());
+  ESP_LOGCONFIG(TAG,
+                "  Current State: %s\n"
+                "  Number of Codes: %u",
+                LOG_STR_ARG(alarm_control_panel_state_to_string(this->current_state_)), this->codes_.size());
   if (!this->codes_.empty())
     ESP_LOGCONFIG(TAG, "  Requires Code To Arm: %s", YESNO(this->requires_code_to_arm_));
   ESP_LOGCONFIG(TAG, "  Arming Away Time: %" PRIu32 "s", (this->arming_away_time_ / 1000));
@@ -38,18 +40,25 @@ void TemplateAlarmControlPanel::dump_config() {
     ESP_LOGCONFIG(TAG, "  Arming Home Time: %" PRIu32 "s", (this->arming_home_time_ / 1000));
   if (this->arming_night_time_ != 0)
     ESP_LOGCONFIG(TAG, "  Arming Night Time: %" PRIu32 "s", (this->arming_night_time_ / 1000));
-  ESP_LOGCONFIG(TAG, "  Pending Time: %" PRIu32 "s", (this->pending_time_ / 1000));
-  ESP_LOGCONFIG(TAG, "  Trigger Time: %" PRIu32 "s", (this->trigger_time_ / 1000));
-  ESP_LOGCONFIG(TAG, "  Supported Features: %" PRIu32, this->get_supported_features());
+  ESP_LOGCONFIG(TAG,
+                "  Pending Time: %" PRIu32 "s\n"
+                "  Trigger Time: %" PRIu32 "s\n"
+                "  Supported Features: %" PRIu32,
+                (this->pending_time_ / 1000), (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
   for (auto sensor_info : this->sensor_map_) {
     ESP_LOGCONFIG(TAG, "  Binary Sensor:");
-    ESP_LOGCONFIG(TAG, "    Name: %s", sensor_info.first->get_name().c_str());
-    ESP_LOGCONFIG(TAG, "    Armed home bypass: %s",
-                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME));
-    ESP_LOGCONFIG(TAG, "    Armed night bypass: %s",
-                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT));
-    ESP_LOGCONFIG(TAG, "    Chime mode: %s", TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME));
+    ESP_LOGCONFIG(TAG,
+                  "    Name: %s\n"
+                  "    Armed home bypass: %s\n"
+                  "    Armed night bypass: %s\n"
+                  "    Auto bypass: %s\n"
+                  "    Chime mode: %s",
+                  sensor_info.first->get_name().c_str(),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
+                  TRUEFALSE(sensor_info.second.flags & BINARY_SENSOR_MODE_CHIME));
     const char *sensor_type;
     switch (sensor_info.second.type) {
       case ALARM_SENSOR_TYPE_INSTANT:
@@ -71,7 +80,7 @@ void TemplateAlarmControlPanel::dump_config() {
 }
 
 void TemplateAlarmControlPanel::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Template AlarmControlPanel '%s'...", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
   switch (this->restore_mode_) {
     case ALARM_CONTROL_PANEL_ALWAYS_DISARMED:
       this->current_state_ = ACP_STATE_DISARMED;
@@ -101,6 +110,15 @@ void TemplateAlarmControlPanel::loop() {
       delay = this->arming_night_time_;
     }
     if ((millis() - this->last_update_) > delay) {
+#ifdef USE_BINARY_SENSOR
+      for (auto sensor_info : this->sensor_map_) {
+        // Check for sensors left on and set to bypass automatically and remove them from monitoring
+        if ((sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor_info.first->state)) {
+          ESP_LOGW(TAG, "%s is left on and will be automatically bypassed", sensor_info.first->get_name().c_str());
+          this->bypassed_sensor_indicies_.push_back(sensor_info.second.store_index);
+        }
+      }
+#endif
       this->publish_state(this->desired_state_);
     }
     return;
@@ -137,6 +155,11 @@ void TemplateAlarmControlPanel::loop() {
     }
     // Check for triggered sensors
     if (sensor_info.first->state) {  // Sensor triggered?
+      // Skip if auto bypassed
+      if (std::count(this->bypassed_sensor_indicies_.begin(), this->bypassed_sensor_indicies_.end(),
+                     sensor_info.second.store_index) == 1) {
+        continue;
+      }
       // Skip if bypass armed home
       if (this->current_state_ == ACP_STATE_ARMED_HOME &&
           (sensor_info.second.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
@@ -255,6 +278,9 @@ void TemplateAlarmControlPanel::control(const AlarmControlPanelCall &call) {
       }
       this->desired_state_ = ACP_STATE_DISARMED;
       this->publish_state(ACP_STATE_DISARMED);
+#ifdef USE_BINARY_SENSOR
+      this->bypassed_sensor_indicies_.clear();
+#endif
     } else if (call.get_state() == ACP_STATE_TRIGGERED) {
       this->publish_state(ACP_STATE_TRIGGERED);
     } else if (call.get_state() == ACP_STATE_PENDING) {

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -22,6 +22,7 @@ enum BinarySensorFlags : uint16_t {
   BINARY_SENSOR_MODE_BYPASS_ARMED_HOME = 1 << 1,
   BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT = 1 << 2,
   BINARY_SENSOR_MODE_CHIME = 1 << 3,
+  BINARY_SENSOR_MODE_BYPASS_AUTO = 1 << 4,
 };
 
 enum AlarmSensorType : uint16_t {
@@ -121,7 +122,8 @@ class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel,
 #ifdef USE_BINARY_SENSOR
   // This maps a binary sensor to its type and attribute bits
   std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
-
+  // a list of automatically bypassed sensors
+  std::vector<uint8_t> bypassed_sensor_indicies_;
 #endif
   TemplateAlarmControlPanelRestoreMode restore_mode_{};
 

esphome/components/template/cover/template_cover.cpp

@@ -16,7 +16,7 @@ TemplateCover::TemplateCover()
       position_trigger_(new Trigger<float>()),
       tilt_trigger_(new Trigger<float>()) {}
 void TemplateCover::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up template cover '%s'...", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
   switch (this->restore_mode_) {
     case COVER_NO_RESTORE:
       break;

esphome/components/template/select/template_select.cpp

@@ -11,7 +11,7 @@ void TemplateSelect::setup() {
     return;
 
   std::string value;
-  ESP_LOGD(TAG, "Setting up Template Select");
+  ESP_LOGD(TAG, "Setting up");
   if (!this->restore_value_) {
     value = this->initial_option_;
     ESP_LOGD(TAG, "State from initial: %s", value.c_str());
@@ -66,9 +66,11 @@ void TemplateSelect::dump_config() {
   LOG_UPDATE_INTERVAL(this);
   if (this->f_.has_value())
     return;
-  ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
-  ESP_LOGCONFIG(TAG, "  Initial Option: %s", this->initial_option_.c_str());
-  ESP_LOGCONFIG(TAG, "  Restore Value: %s", YESNO(this->restore_value_));
+  ESP_LOGCONFIG(TAG,
+                "  Optimistic: %s\n"
+                "  Initial Option: %s\n"
+                "  Restore Value: %s",
+                YESNO(this->optimistic_), this->initial_option_.c_str(), YESNO(this->restore_value_));
 }
 
 }  // namespace template_

esphome/components/template/text/template_text.cpp

@@ -12,9 +12,8 @@ void TemplateText::setup() {
       return;
   }
 
-  std::string value;
-  ESP_LOGD(TAG, "Setting up Template Text Input");
-  value = this->initial_value_;
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
+  std::string value = this->initial_value_;
   if (!this->pref_) {
     ESP_LOGD(TAG, "State from initial: %s", value.c_str());
   } else {