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

esphome/components/thermostat/thermostat_climate.cpp

@@ -537,7 +537,7 @@ void ThermostatClimate::switch_to_supplemental_action_(climate::ClimateAction ac
     default:
       return;
   }
-  ESP_LOGVV(TAG, "Updating supplemental action...");
+  ESP_LOGVV(TAG, "Updating supplemental action");
   this->supplemental_action_ = action;
   this->trigger_supplemental_action_();
 }
@@ -1300,37 +1300,48 @@ void ThermostatClimate::dump_config() {
   }
   ESP_LOGCONFIG(TAG, "  Start-up Delay Enabled: %s", YESNO(this->use_startup_delay_));
   if (this->supports_cool_) {
-    ESP_LOGCONFIG(TAG, "  Cooling Parameters:");
-    ESP_LOGCONFIG(TAG, "    Deadband: %.1f°C", this->cooling_deadband_);
-    ESP_LOGCONFIG(TAG, "    Overrun: %.1f°C", this->cooling_overrun_);
+    ESP_LOGCONFIG(TAG,
+                  "  Cooling Parameters:\n"
+                  "    Deadband: %.1f°C\n"
+                  "    Overrun: %.1f°C",
+                  this->cooling_deadband_, this->cooling_overrun_);
     if ((this->supplemental_cool_delta_ > 0) || (this->timer_duration_(thermostat::TIMER_COOLING_MAX_RUN_TIME) > 0)) {
-      ESP_LOGCONFIG(TAG, "    Supplemental Delta: %.1f°C", this->supplemental_cool_delta_);
-      ESP_LOGCONFIG(TAG, "    Maximum Run Time: %" PRIu32 "s",
+      ESP_LOGCONFIG(TAG,
+                    "    Supplemental Delta: %.1f°C\n"
+                    "    Maximum Run Time: %" PRIu32 "s",
+                    this->supplemental_cool_delta_,
                     this->timer_duration_(thermostat::TIMER_COOLING_MAX_RUN_TIME) / 1000);
     }
-    ESP_LOGCONFIG(TAG, "    Minimum Off Time: %" PRIu32 "s",
-                  this->timer_duration_(thermostat::TIMER_COOLING_OFF) / 1000);
-    ESP_LOGCONFIG(TAG, "    Minimum Run Time: %" PRIu32 "s",
+    ESP_LOGCONFIG(TAG,
+                  "    Minimum Off Time: %" PRIu32 "s\n"
+                  "    Minimum Run Time: %" PRIu32 "s",
+                  this->timer_duration_(thermostat::TIMER_COOLING_OFF) / 1000,
                   this->timer_duration_(thermostat::TIMER_COOLING_ON) / 1000);
   }
   if (this->supports_heat_) {
-    ESP_LOGCONFIG(TAG, "  Heating Parameters:");
-    ESP_LOGCONFIG(TAG, "    Deadband: %.1f°C", this->heating_deadband_);
-    ESP_LOGCONFIG(TAG, "    Overrun: %.1f°C", this->heating_overrun_);
+    ESP_LOGCONFIG(TAG,
+                  "  Heating Parameters:\n"
+                  "    Deadband: %.1f°C\n"
+                  "    Overrun: %.1f°C",
+                  this->heating_deadband_, this->heating_overrun_);
     if ((this->supplemental_heat_delta_ > 0) || (this->timer_duration_(thermostat::TIMER_HEATING_MAX_RUN_TIME) > 0)) {
-      ESP_LOGCONFIG(TAG, "    Supplemental Delta: %.1f°C", this->supplemental_heat_delta_);
-      ESP_LOGCONFIG(TAG, "    Maximum Run Time: %" PRIu32 "s",
+      ESP_LOGCONFIG(TAG,
+                    "    Supplemental Delta: %.1f°C\n"
+                    "    Maximum Run Time: %" PRIu32 "s",
+                    this->supplemental_heat_delta_,
                     this->timer_duration_(thermostat::TIMER_HEATING_MAX_RUN_TIME) / 1000);
     }
-    ESP_LOGCONFIG(TAG, "    Minimum Off Time: %" PRIu32 "s",
-                  this->timer_duration_(thermostat::TIMER_HEATING_OFF) / 1000);
-    ESP_LOGCONFIG(TAG, "    Minimum Run Time: %" PRIu32 "s",
+    ESP_LOGCONFIG(TAG,
+                  "    Minimum Off Time: %" PRIu32 "s\n"
+                  "    Minimum Run Time: %" PRIu32 "s",
+                  this->timer_duration_(thermostat::TIMER_HEATING_OFF) / 1000,
                   this->timer_duration_(thermostat::TIMER_HEATING_ON) / 1000);
   }
   if (this->supports_fan_only_) {
-    ESP_LOGCONFIG(TAG, "  Fanning Minimum Off Time: %" PRIu32 "s",
-                  this->timer_duration_(thermostat::TIMER_FANNING_OFF) / 1000);
-    ESP_LOGCONFIG(TAG, "  Fanning Minimum Run Time: %" PRIu32 "s",
+    ESP_LOGCONFIG(TAG,
+                  "  Fanning Minimum Off Time: %" PRIu32 "s\n"
+                  "  Fanning Minimum Run Time: %" PRIu32 "s",
+                  this->timer_duration_(thermostat::TIMER_FANNING_OFF) / 1000,
                   this->timer_duration_(thermostat::TIMER_FANNING_ON) / 1000);
   }
   if (this->supports_fan_mode_on_ || this->supports_fan_mode_off_ || this->supports_fan_mode_auto_ ||
@@ -1341,14 +1352,17 @@ void ThermostatClimate::dump_config() {
                   this->timer_duration_(thermostat::TIMER_FAN_MODE) / 1000);
   }
   ESP_LOGCONFIG(TAG, "  Minimum Idle Time: %" PRIu32 "s", this->timer_[thermostat::TIMER_IDLE_ON].time / 1000);
-  ESP_LOGCONFIG(TAG, "  Supports AUTO: %s", YESNO(this->supports_auto_));
-  ESP_LOGCONFIG(TAG, "  Supports HEAT/COOL: %s", YESNO(this->supports_heat_cool_));
-  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
-  ESP_LOGCONFIG(TAG, "  Supports DRY: %s", YESNO(this->supports_dry_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN_ONLY: %s", YESNO(this->supports_fan_only_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN_ONLY_ACTION_USES_FAN_MODE_TIMER: %s",
-                YESNO(this->supports_fan_only_action_uses_fan_mode_timer_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN_ONLY_COOLING: %s", YESNO(this->supports_fan_only_cooling_));
+  ESP_LOGCONFIG(TAG,
+                "  Supports AUTO: %s\n"
+                "  Supports HEAT/COOL: %s\n"
+                "  Supports COOL: %s\n"
+                "  Supports DRY: %s\n"
+                "  Supports FAN_ONLY: %s\n"
+                "  Supports FAN_ONLY_ACTION_USES_FAN_MODE_TIMER: %s\n"
+                "  Supports FAN_ONLY_COOLING: %s",
+                YESNO(this->supports_auto_), YESNO(this->supports_heat_cool_), YESNO(this->supports_cool_),
+                YESNO(this->supports_dry_), YESNO(this->supports_fan_only_),
+                YESNO(this->supports_fan_only_action_uses_fan_mode_timer_), YESNO(this->supports_fan_only_cooling_));
   if (this->supports_cool_) {
     ESP_LOGCONFIG(TAG, "  Supports FAN_WITH_COOLING: %s", YESNO(this->supports_fan_with_cooling_));
   }
@@ -1356,21 +1370,31 @@ void ThermostatClimate::dump_config() {
     ESP_LOGCONFIG(TAG, "  Supports FAN_WITH_HEATING: %s", YESNO(this->supports_fan_with_heating_));
   }
   ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE ON: %s", YESNO(this->supports_fan_mode_on_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE OFF: %s", YESNO(this->supports_fan_mode_off_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE AUTO: %s", YESNO(this->supports_fan_mode_auto_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE LOW: %s", YESNO(this->supports_fan_mode_low_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE MEDIUM: %s", YESNO(this->supports_fan_mode_medium_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE HIGH: %s", YESNO(this->supports_fan_mode_high_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE MIDDLE: %s", YESNO(this->supports_fan_mode_middle_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE FOCUS: %s", YESNO(this->supports_fan_mode_focus_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE DIFFUSE: %s", YESNO(this->supports_fan_mode_diffuse_));
-  ESP_LOGCONFIG(TAG, "  Supports FAN MODE QUIET: %s", YESNO(this->supports_fan_mode_quiet_));
-  ESP_LOGCONFIG(TAG, "  Supports SWING MODE BOTH: %s", YESNO(this->supports_swing_mode_both_));
-  ESP_LOGCONFIG(TAG, "  Supports SWING MODE OFF: %s", YESNO(this->supports_swing_mode_off_));
-  ESP_LOGCONFIG(TAG, "  Supports SWING MODE HORIZONTAL: %s", YESNO(this->supports_swing_mode_horizontal_));
-  ESP_LOGCONFIG(TAG, "  Supports SWING MODE VERTICAL: %s", YESNO(this->supports_swing_mode_vertical_));
-  ESP_LOGCONFIG(TAG, "  Supports TWO SET POINTS: %s", YESNO(this->supports_two_points_));
+  ESP_LOGCONFIG(TAG,
+                "  Supports FAN MODE ON: %s\n"
+                "  Supports FAN MODE OFF: %s\n"
+                "  Supports FAN MODE AUTO: %s\n"
+                "  Supports FAN MODE LOW: %s\n"
+                "  Supports FAN MODE MEDIUM: %s\n"
+                "  Supports FAN MODE HIGH: %s\n"
+                "  Supports FAN MODE MIDDLE: %s\n"
+                "  Supports FAN MODE FOCUS: %s\n"
+                "  Supports FAN MODE DIFFUSE: %s\n"
+                "  Supports FAN MODE QUIET: %s",
+                YESNO(this->supports_fan_mode_on_), YESNO(this->supports_fan_mode_off_),
+                YESNO(this->supports_fan_mode_auto_), YESNO(this->supports_fan_mode_low_),
+                YESNO(this->supports_fan_mode_medium_), YESNO(this->supports_fan_mode_high_),
+                YESNO(this->supports_fan_mode_middle_), YESNO(this->supports_fan_mode_focus_),
+                YESNO(this->supports_fan_mode_diffuse_), YESNO(this->supports_fan_mode_quiet_));
+  ESP_LOGCONFIG(TAG,
+                "  Supports SWING MODE BOTH: %s\n"
+                "  Supports SWING MODE OFF: %s\n"
+                "  Supports SWING MODE HORIZONTAL: %s\n"
+                "  Supports SWING MODE VERTICAL: %s\n"
+                "  Supports TWO SET POINTS: %s",
+                YESNO(this->supports_swing_mode_both_), YESNO(this->supports_swing_mode_off_),
+                YESNO(this->supports_swing_mode_horizontal_), YESNO(this->supports_swing_mode_vertical_),
+                YESNO(this->supports_two_points_));
 
   ESP_LOGCONFIG(TAG, "  Supported PRESETS: ");
   for (auto &it : this->preset_config_) {

esphome/components/time/__init__.py

@@ -1,6 +1,5 @@
 from importlib import resources
 import logging
-from typing import Optional
 
 import tzlocal
 
@@ -40,7 +39,7 @@ SyncTrigger = time_ns.class_("SyncTrigger", automation.Trigger.template(), cg.Co
 TimeHasTimeCondition = time_ns.class_("TimeHasTimeCondition", Condition)
 
 
-def _load_tzdata(iana_key: str) -> Optional[bytes]:
+def _load_tzdata(iana_key: str) -> bytes | None:
     # From https://tzdata.readthedocs.io/en/latest/#examples
     try:
         package_loc, resource = iana_key.rsplit("/", 1)

esphome/components/time_based/time_based_cover.cpp

@@ -12,8 +12,10 @@ using namespace esphome::cover;
 
 void TimeBasedCover::dump_config() {
   LOG_COVER("", "Time Based Cover", this);
-  ESP_LOGCONFIG(TAG, "  Open Duration: %.1fs", this->open_duration_ / 1e3f);
-  ESP_LOGCONFIG(TAG, "  Close Duration: %.1fs", this->close_duration_ / 1e3f);
+  ESP_LOGCONFIG(TAG,
+                "  Open Duration: %.1fs\n"
+                "  Close Duration: %.1fs",
+                this->open_duration_ / 1e3f, this->close_duration_ / 1e3f);
 }
 void TimeBasedCover::setup() {
   auto restore = this->restore_state_();

esphome/components/tlc59208f/tlc59208f_output.cpp

@@ -1,7 +1,7 @@
 #include "tlc59208f_output.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 tlc59208f {
@@ -71,9 +71,9 @@ static const uint8_t LDR_PWM = 0x02;
 static const uint8_t LDR_GRPPWM = 0x03;
 
 void TLC59208FOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TLC59208FOutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
-  ESP_LOGV(TAG, "  Resetting all devices on the bus...");
+  ESP_LOGV(TAG, "  Resetting all devices on the bus");
 
   // Reset all devices on the bus
   if (this->bus_->write(TLC59208F_SWRST_ADDR >> 1, TLC59208F_SWRST_SEQ, 2) != i2c::ERROR_OK) {
@@ -111,8 +111,10 @@ void TLC59208FOutput::setup() {
 }
 
 void TLC59208FOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "TLC59208F:");
-  ESP_LOGCONFIG(TAG, "  Mode: 0x%02X", this->mode_);
+  ESP_LOGCONFIG(TAG,
+                "TLC59208F:\n"
+                "  Mode: 0x%02X",
+                this->mode_);
 
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Setting up TLC59208F failed!");

esphome/components/tm1621/tm1621.cpp

@@ -1,7 +1,7 @@
 #include "tm1621.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 tm1621 {
@@ -29,7 +29,7 @@ const uint8_t TM1621_DIGIT_ROW[2][12] = {{0x5F, 0x50, 0x3D, 0x79, 0x72, 0x6B, 0x
                                          {0xF5, 0x05, 0xB6, 0x97, 0x47, 0xD3, 0xF3, 0x85, 0xF7, 0xD7, 0x02, 0x00}};
 
 void TM1621Display::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TM1621...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->cs_pin_->setup();  // OUTPUT
   this->cs_pin_->digital_write(true);

esphome/components/tm1637/tm1637.cpp

@@ -1,7 +1,7 @@
 #include "tm1637.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 tm1637 {
@@ -125,7 +125,7 @@ const uint8_t TM1637_ASCII_TO_RAW[] PROGMEM = {
     0b01100011,           // '~', ord 0x7E (degree symbol)
 };
 void TM1637Display::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TM1637...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->clk_pin_->setup();               // OUTPUT
   this->clk_pin_->digital_write(false);  // LOW
@@ -135,10 +135,12 @@ void TM1637Display::setup() {
   this->display();
 }
 void TM1637Display::dump_config() {
-  ESP_LOGCONFIG(TAG, "TM1637:");
-  ESP_LOGCONFIG(TAG, "  Intensity: %d", this->intensity_);
-  ESP_LOGCONFIG(TAG, "  Inverted: %d", this->inverted_);
-  ESP_LOGCONFIG(TAG, "  Length: %d", this->length_);
+  ESP_LOGCONFIG(TAG,
+                "TM1637:\n"
+                "  Intensity: %d\n"
+                "  Inverted: %d\n"
+                "  Length: %d",
+                this->intensity_, this->inverted_, this->length_);
   LOG_PIN("  CLK Pin: ", this->clk_pin_);
   LOG_PIN("  DIO Pin: ", this->dio_pin_);
   LOG_UPDATE_INTERVAL(this);

esphome/components/tm1638/tm1638.cpp

@@ -1,8 +1,8 @@
 #include "tm1638.h"
 #include "sevenseg.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 tm1638 {
@@ -20,7 +20,7 @@ static const uint8_t TM1638_UNKNOWN_CHAR = 0b11111111;
 static const uint8_t TM1638_SHIFT_DELAY = 4;  // clock pause between commands, default 4ms
 
 void TM1638Component::setup() {
-  ESP_LOGD(TAG, "Setting up TM1638...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->clk_pin_->setup();  // OUTPUT
   this->dio_pin_->setup();  // OUTPUT
@@ -43,8 +43,10 @@ void TM1638Component::setup() {
 }
 
 void TM1638Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "TM1638:");
-  ESP_LOGCONFIG(TAG, "  Intensity: %u", this->intensity_);
+  ESP_LOGCONFIG(TAG,
+                "TM1638:\n"
+                "  Intensity: %u",
+                this->intensity_);
   LOG_PIN("  CLK Pin: ", this->clk_pin_);
   LOG_PIN("  DIO Pin: ", this->dio_pin_);
   LOG_PIN("  STB Pin: ", this->stb_pin_);

esphome/components/tm1651/tm1651.cpp

@@ -1,8 +1,8 @@
 #ifdef USE_ARDUINO
 
 #include "tm1651.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace tm1651 {
@@ -17,7 +17,7 @@ static const uint8_t TM1651_BRIGHTNESS_MEDIUM_HW = 2;
 static const uint8_t TM1651_BRIGHTNESS_HIGH_HW = 7;
 
 void TM1651Display::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TM1651...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint8_t clk = clk_pin_->get_pin();
   uint8_t dio = dio_pin_->get_pin();

esphome/components/tmp102/tmp102.cpp

@@ -15,13 +15,11 @@ static const uint8_t TMP102_REGISTER_HIGH_LIMIT = 0x03;
 
 static const float TMP102_CONVERSION_FACTOR = 0.0625;
 
-void TMP102Component::setup() { ESP_LOGCONFIG(TAG, "Setting up TMP102..."); }
-
 void TMP102Component::dump_config() {
   ESP_LOGCONFIG(TAG, "TMP102:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TMP102 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Temperature", this);

esphome/components/tmp102/tmp102.h

@@ -9,10 +9,7 @@ namespace tmp102 {
 
 class TMP102Component : public PollingComponent, public i2c::I2CDevice, public sensor::Sensor {
  public:
-  /// Setup (reset) the sensor and check connection.
-  void setup() override;
   void dump_config() override;
-  /// Update the sensor values (temperature)
   void update() override;
 
   float get_setup_priority() const override;

esphome/components/tmp1075/tmp1075.cpp

@@ -44,17 +44,20 @@ void TMP1075Sensor::update() {
 void TMP1075Sensor::dump_config() {
   LOG_SENSOR("", "TMP1075 Sensor", this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "  Communication with TMP1075 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     return;
   }
-  ESP_LOGCONFIG(TAG, "  limit low  : %.4f °C", alert_limit_low_);
-  ESP_LOGCONFIG(TAG, "  limit high : %.4f °C", alert_limit_high_);
-  ESP_LOGCONFIG(TAG, "  oneshot    : %d", config_.fields.oneshot);
-  ESP_LOGCONFIG(TAG, "  rate       : %d", config_.fields.rate);
-  ESP_LOGCONFIG(TAG, "  fault_count: %d", config_.fields.faults);
-  ESP_LOGCONFIG(TAG, "  polarity   : %d", config_.fields.polarity);
-  ESP_LOGCONFIG(TAG, "  alert_mode : %d", config_.fields.alert_mode);
-  ESP_LOGCONFIG(TAG, "  shutdown   : %d", config_.fields.shutdown);
+  ESP_LOGCONFIG(TAG,
+                "  limit low  : %.4f °C\n"
+                "  limit high : %.4f °C\n"
+                "  oneshot    : %d\n"
+                "  rate       : %d\n"
+                "  fault_count: %d\n"
+                "  polarity   : %d\n"
+                "  alert_mode : %d\n"
+                "  shutdown   : %d",
+                alert_limit_low_, alert_limit_high_, config_.fields.oneshot, config_.fields.rate, config_.fields.faults,
+                config_.fields.polarity, config_.fields.alert_mode, config_.fields.shutdown);
 }
 
 void TMP1075Sensor::set_fault_count(const int faults) {

esphome/components/tmp117/tmp117.cpp

@@ -26,7 +26,7 @@ void TMP117Component::update() {
   }
 }
 void TMP117Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TMP117...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   if (!this->write_config_(this->config_)) {
     this->mark_failed();
@@ -43,7 +43,7 @@ void TMP117Component::dump_config() {
   ESP_LOGD(TAG, "TMP117:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TMP117 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_SENSOR("  ", "Temperature", this);
 }

esphome/components/tof10120/tof10120_sensor.cpp

@@ -27,7 +27,7 @@ void TOF10120Sensor::setup() {}
 
 void TOF10120Sensor::update() {
   if (!this->write_bytes(TOF10120_DISTANCE_REGISTER, TOF10120_READ_DISTANCE_CMD, sizeof(TOF10120_READ_DISTANCE_CMD))) {
-    ESP_LOGE(TAG, "Communication with TOF10120 failed on write");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->status_set_warning();
     return;
   }
@@ -39,7 +39,7 @@ void TOF10120Sensor::update() {
   }
   delay(TOF10120_DEFAULT_DELAY);
   if (this->read(data, 2) != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, "Communication with TOF10120 failed on read");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->status_set_warning();
     return;
   }

esphome/components/tormatic/tormatic_cover.cpp

@@ -34,8 +34,10 @@ void Tormatic::dump_config() {
   LOG_COVER("", "Tormatic Cover", this);
   this->check_uart_settings(9600, 1, uart::UART_CONFIG_PARITY_NONE, 8);
 
-  ESP_LOGCONFIG(TAG, "  Open Duration: %.1fs", this->open_duration_ / 1e3f);
-  ESP_LOGCONFIG(TAG, "  Close Duration: %.1fs", this->close_duration_ / 1e3f);
+  ESP_LOGCONFIG(TAG,
+                "  Open Duration: %.1fs\n"
+                "  Close Duration: %.1fs",
+                this->open_duration_ / 1e3f, this->close_duration_ / 1e3f);
 
   auto restore = this->restore_state_();
   if (restore.has_value()) {

esphome/components/tsl2561/tsl2561.cpp

@@ -15,7 +15,7 @@ static const uint8_t TSL2561_REGISTER_DATA_0 = 0x0C;
 static const uint8_t TSL2561_REGISTER_DATA_1 = 0x0E;
 
 void TSL2561Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TSL2561...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t id;
   if (!this->tsl2561_read_byte(TSL2561_REGISTER_ID, &id)) {
     this->mark_failed();
@@ -41,12 +41,14 @@ void TSL2561Sensor::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TSL2561 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 
   int gain = this->gain_ == TSL2561_GAIN_1X ? 1 : 16;
-  ESP_LOGCONFIG(TAG, "  Gain: %dx", gain);
-  ESP_LOGCONFIG(TAG, "  Integration Time: %.1f ms", this->get_integration_time_ms_());
+  ESP_LOGCONFIG(TAG,
+                "  Gain: %dx\n"
+                "  Integration Time: %.1f ms",
+                gain, this->get_integration_time_ms_());
 
   LOG_UPDATE_INTERVAL(this);
 }
@@ -65,7 +67,7 @@ void TSL2561Sensor::update() {
 
 float TSL2561Sensor::calculate_lx_(uint16_t ch0, uint16_t ch1) {
   if ((ch0 == 0xFFFF) || (ch1 == 0xFFFF)) {
-    ESP_LOGW(TAG, "TSL2561 sensor is saturated.");
+    ESP_LOGW(TAG, "Sensor is saturated");
     return NAN;
   }
 

esphome/components/tsl2591/tsl2591.cpp

@@ -26,13 +26,13 @@ static const char *const TAG = "tsl2591.sensor";
 void TSL2591Component::enable() {
   // Enable the device by setting the control bit to 0x01. Also turn on ADCs.
   if (!this->write_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_ENABLE, TSL2591_ENABLE_POWERON | TSL2591_ENABLE_AEN)) {
-    ESP_LOGE(TAG, "Failed I2C write during enable()");
+    ESP_LOGE(TAG, "I2C write failed");
   }
 }
 
 void TSL2591Component::disable() {
   if (!this->write_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_ENABLE, TSL2591_ENABLE_POWEROFF)) {
-    ESP_LOGE(TAG, "Failed I2C write during disable()");
+    ESP_LOGE(TAG, "I2C write failed");
   }
 }
 
@@ -43,6 +43,7 @@ void TSL2591Component::disable_if_power_saving_() {
 }
 
 void TSL2591Component::setup() {
+  ESP_LOGCONFIG(TAG, "Running setup for address 0x%02X", this->address_);
   switch (this->component_gain_) {
     case TSL2591_CGAIN_LOW:
       this->gain_ = TSL2591_GAIN_LOW;
@@ -61,21 +62,15 @@ void TSL2591Component::setup() {
       break;
   }
 
-  uint8_t address = this->address_;
-  ESP_LOGI(TAG, "Setting up TSL2591 sensor at I2C address 0x%02X", address);
-
   uint8_t id;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_DEVICE_ID, &id)) {
-    ESP_LOGE(TAG, "Failed I2C read during setup()");
+    ESP_LOGE(TAG, "I2C read failed");
     this->mark_failed();
     return;
   }
 
   if (id != 0x50) {
-    ESP_LOGE(TAG,
-             "Could not find the TSL2591 sensor. The ID register of the device at address 0x%02X reported 0x%02X "
-             "instead of 0x50.",
-             address, id);
+    ESP_LOGE(TAG, "Unknown chip ID");
     this->mark_failed();
     return;
   }
@@ -89,7 +84,7 @@ void TSL2591Component::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with TSL2591 failed earlier, during setup");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     return;
   }
 
@@ -119,13 +114,16 @@ void TSL2591Component::dump_config() {
       gain_word = "auto";
       break;
   }
-  ESP_LOGCONFIG(TAG, "  Gain: %dx (%s)", gain, gain_word.c_str());
   TSL2591IntegrationTime raw_timing = this->integration_time_;
   int timing_ms = (1 + raw_timing) * 100;
-  ESP_LOGCONFIG(TAG, "  Integration Time: %d ms", timing_ms);
-  ESP_LOGCONFIG(TAG, "  Power save mode enabled: %s", ONOFF(this->power_save_mode_enabled_));
-  ESP_LOGCONFIG(TAG, "  Device factor: %f", this->device_factor_);
-  ESP_LOGCONFIG(TAG, "  Glass attenuation factor: %f", this->glass_attenuation_factor_);
+  ESP_LOGCONFIG(TAG,
+                "  Gain: %dx (%s)"
+                "  Integration Time: %d ms\n"
+                "  Power save mode enabled: %s\n"
+                "  Device factor: %f\n"
+                "  Glass attenuation factor: %f",
+                gain, gain_word.c_str(), timing_ms, ONOFF(this->power_save_mode_enabled_), this->device_factor_,
+                this->glass_attenuation_factor_);
   LOG_SENSOR("  ", "Full spectrum:", this->full_spectrum_sensor_);
   LOG_SENSOR("  ", "Infrared:", this->infrared_sensor_);
   LOG_SENSOR("  ", "Visible:", this->visible_sensor_);
@@ -174,7 +172,7 @@ void TSL2591Component::interval_function_for_update_() {
     uint64_t now = millis();
     ESP_LOGD(TAG, "Elapsed %3llu ms; still waiting for valid ADC", (now - this->interval_start_));
     if (now > this->interval_timeout_) {
-      ESP_LOGW(TAG, "Interval timeout for TSL2591 '%s' expired before ADCs became valid.", this->name_);
+      ESP_LOGW(TAG, "Interval timeout for '%s' expired before ADCs became valid", this->name_);
       this->cancel_interval(interval_name);
     }
     return;
@@ -235,7 +233,7 @@ void TSL2591Component::set_integration_time_and_gain(TSL2591IntegrationTime inte
   this->gain_ = gain;
   if (!this->write_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CONTROL,
                         this->integration_time_ | this->gain_)) {  // NOLINT
-    ESP_LOGE(TAG, "Failed I2C write during set_integration_time_and_gain()");
+    ESP_LOGE(TAG, "I2C write failed");
   }
   // The ADC values can be confused if gain or integration time are changed in the middle of a cycle.
   // So, we unconditionally disable the device to turn the ADCs off. When re-enabling, the ADCs
@@ -255,7 +253,7 @@ float TSL2591Component::get_setup_priority() const { return setup_priority::DATA
 bool TSL2591Component::is_adc_valid() {
   uint8_t status;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_STATUS, &status)) {
-    ESP_LOGE(TAG, "Failed I2C read during is_adc_valid()");
+    ESP_LOGE(TAG, "I2C read failed");
     return false;
   }
   return status & 0x01;
@@ -281,7 +279,7 @@ uint32_t TSL2591Component::get_combined_illuminance() {
   if (!avalid) {
     // still not valid after a sutiable delay
     // we don't mark the device as failed since it might come around in the future (probably not :-()
-    ESP_LOGE(TAG, "tsl2591 device '%s' did not return valid readings.", this->name_);
+    ESP_LOGE(TAG, "Device '%s' returned invalid readings", this->name_);
     this->disable_if_power_saving_();
     return 0;
   }
@@ -295,20 +293,20 @@ uint32_t TSL2591Component::get_combined_illuminance() {
   uint16_t ch0_16;
   uint16_t ch1_16;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN0_LOW, &ch0low)) {
-    ESP_LOGE(TAG, "Failed I2C read during get_combined_illuminance()");
+    ESP_LOGE(TAG, "I2C read failed");
     return 0;
   }
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN0_HIGH, &ch0high)) {
-    ESP_LOGE(TAG, "Failed I2C read during get_combined_illuminance()");
+    ESP_LOGE(TAG, "I2C read failed");
     return 0;
   }
   ch0_16 = (ch0high << 8) | ch0low;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN1_LOW, &ch1low)) {
-    ESP_LOGE(TAG, "Failed I2C read during get_combined_illuminance()");
+    ESP_LOGE(TAG, "I2C read failed");
     return 0;
   }
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CHAN1_HIGH, &ch1high)) {
-    ESP_LOGE(TAG, "Failed I2C read during get_combined_illuminance()");
+    ESP_LOGE(TAG, "I2C read failed");
     return 0;
   }
   ch1_16 = (ch1high << 8) | ch1low;
@@ -335,7 +333,7 @@ uint16_t TSL2591Component::get_illuminance(TSL2591SensorChannel channel, uint32_
     return ((combined_illuminance & 0xFFFF) - (combined_illuminance >> 16));
   }
   // unknown channel!
-  ESP_LOGE(TAG, "TSL2591Component::get_illuminance() caller requested an unknown channel: %d", channel);
+  ESP_LOGE(TAG, "get_illuminance() caller requested an unknown channel: %d", channel);
   return 0;
 }
 
@@ -358,13 +356,13 @@ float TSL2591Component::get_calculated_lux(uint16_t full_spectrum, uint16_t infr
   uint16_t max_count = (this->integration_time_ == TSL2591_INTEGRATION_TIME_100MS ? 36863 : 65535);
   if ((full_spectrum == max_count) || (infrared == max_count)) {
     // Signal an overflow
-    ESP_LOGW(TAG, "Apparent saturation on TSL2591 (%s). You could reduce the gain or integration time.", this->name_);
+    ESP_LOGW(TAG, "Apparent saturation on '%s'; try reducing the gain or integration time", this->name_);
     return NAN;
   }
 
   if ((full_spectrum == 0) && (infrared == 0)) {
     // trivial conversion; avoids divide by 0
-    ESP_LOGW(TAG, "Zero reading on both TSL2591 (%s) sensors. Is the device having a problem?", this->name_);
+    ESP_LOGW(TAG, "Zero reading on both '%s' sensors", this->name_);
     return 0.0F;
   }
 

esphome/components/tt21100/touchscreen/tt21100.cpp

@@ -47,7 +47,7 @@ struct TT21100TouchReport {
 float TT21100Touchscreen::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
 
 void TT21100Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up TT21100 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Register interrupt pin
   if (this->interrupt_pin_ != nullptr) {