esphome 2025.5.1__py3-none-any.whl → 2025.6.0__py3-none-any.whl

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) {

esphome/components/ttp229_bsf/ttp229_bsf.cpp

@@ -7,7 +7,7 @@ namespace ttp229_bsf {
 static const char *const TAG = "ttp229_bsf";
 
 void TTP229BSFComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ttp229_bsf... ");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->sdo_pin_->setup();
   this->scl_pin_->setup();
   this->scl_pin_->digital_write(true);

esphome/components/ttp229_lsf/ttp229_lsf.cpp

@@ -7,7 +7,7 @@ namespace ttp229_lsf {
 static const char *const TAG = "ttp229_lsf";
 
 void TTP229LSFComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ttp229...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t data[2];
   if (this->read(data, 2) != i2c::ERROR_OK) {
     this->error_code_ = COMMUNICATION_FAILED;
@@ -20,7 +20,7 @@ void TTP229LSFComponent::dump_config() {
   LOG_I2C_DEVICE(this);
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, "Communication with TTP229 failed!");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       break;
     case NONE:
     default:

esphome/components/tuya/select/tuya_select.cpp

@@ -44,9 +44,11 @@ void TuyaSelect::control(const std::string &value) {
 
 void TuyaSelect::dump_config() {
   LOG_SELECT("", "Tuya Select", this);
-  ESP_LOGCONFIG(TAG, "  Select has datapoint ID %u", this->select_id_);
-  ESP_LOGCONFIG(TAG, "  Data type: %s", this->is_int_ ? "int" : "enum");
-  ESP_LOGCONFIG(TAG, "  Options are:");
+  ESP_LOGCONFIG(TAG,
+                "  Select has datapoint ID %u\n"
+                "  Data type: %s\n"
+                "  Options are:",
+                this->select_id_, this->is_int_ ? "int" : "enum");
   auto options = this->traits.get_options();
   for (auto i = 0; i < this->mappings_.size(); i++) {
     ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i).c_str());

esphome/components/tx20/tx20.cpp

@@ -1,6 +1,6 @@
 #include "tx20.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <vector>
 
@@ -15,7 +15,7 @@ static const char *const DIRECTIONS[] = {"N", "NNE", "NE", "ENE", "E", "ESE", "S
                                          "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"};
 
 void Tx20Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Tx20");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->setup();
 
   this->store_.buffer = new uint16_t[MAX_BUFFER_SIZE];
@@ -44,7 +44,7 @@ float Tx20Component::get_setup_priority() const { return setup_priority::DATA; }
 std::string Tx20Component::get_wind_cardinal_direction() const { return this->wind_cardinal_direction_; }
 
 void Tx20Component::decode_and_publish_() {
-  ESP_LOGVV(TAG, "Decode Tx20...");
+  ESP_LOGVV(TAG, "Decode Tx20");
 
   std::string string_buffer;
   std::string string_buffer_2;

esphome/components/uart/__init__.py

@@ -1,5 +1,4 @@
 import re
-from typing import Optional
 
 from esphome import automation, pins
 import esphome.codegen as cg
@@ -322,12 +321,12 @@ def final_validate_device_schema(
     name: str,
     *,
     uart_bus: str = CONF_UART_ID,
-    baud_rate: Optional[int] = None,
+    baud_rate: int | None = None,
     require_tx: bool = False,
     require_rx: bool = False,
-    data_bits: Optional[int] = None,
-    parity: Optional[str] = None,
-    stop_bits: Optional[int] = None,
+    data_bits: int | None = None,
+    parity: str | None = None,
+    stop_bits: int | None = None,
 ):
     def validate_baud_rate(value):
         if value != baud_rate:

esphome/components/uart/button/uart_button.cpp

@@ -7,7 +7,7 @@ namespace uart {
 static const char *const TAG = "uart.button";
 
 void UARTButton::press_action() {
-  ESP_LOGD(TAG, "'%s': Sending data...", this->get_name().c_str());
+  ESP_LOGD(TAG, "'%s': Sending data", this->get_name().c_str());
   this->write_array(this->data_.data(), this->data_.size());
 }
 

esphome/components/uart/switch/uart_switch.cpp

@@ -19,11 +19,11 @@ void UARTSwitch::loop() {
 
 void UARTSwitch::write_command_(bool state) {
   if (state && !this->data_on_.empty()) {
-    ESP_LOGD(TAG, "'%s': Sending on data...", this->get_name().c_str());
+    ESP_LOGD(TAG, "'%s': Sending on data", this->get_name().c_str());
     this->write_array(this->data_on_.data(), this->data_on_.size());
   }
   if (!state && !this->data_off_.empty()) {
-    ESP_LOGD(TAG, "'%s': Sending off data...", this->get_name().c_str());
+    ESP_LOGD(TAG, "'%s': Sending off data", this->get_name().c_str());
     this->write_array(this->data_off_.data(), this->data_off_.size());
   }
 }

esphome/components/uart/uart.cpp

@@ -1,8 +1,8 @@
 #include "uart.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <cinttypes>
 
 namespace esphome {

esphome/components/uart/uart_component_esp32_arduino.cpp

@@ -74,7 +74,7 @@ uint32_t ESP32ArduinoUARTComponent::get_config() {
 }
 
 void ESP32ArduinoUARTComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up UART...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Use Arduino HardwareSerial UARTs if all used pins match the ones
   // preconfigured by the platform. For example if RX disabled but TX pin
   // is 1 we still want to use Serial.
@@ -154,10 +154,12 @@ void ESP32ArduinoUARTComponent::dump_config() {
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);
   }
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %u baud", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
-  ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
+  ESP_LOGCONFIG(TAG,
+                "  Baud Rate: %u baud\n"
+                "  Data Bits: %u\n"
+                "  Parity: %s\n"
+                "  Stop bits: %u",
+                this->baud_rate_, this->data_bits_, LOG_STR_ARG(parity_to_str(this->parity_)), this->stop_bits_);
   this->check_logger_conflict();
 }
 
@@ -191,7 +193,7 @@ bool ESP32ArduinoUARTComponent::read_array(uint8_t *data, size_t len) {
 
 int ESP32ArduinoUARTComponent::available() { return this->hw_serial_->available(); }
 void ESP32ArduinoUARTComponent::flush() {
-  ESP_LOGVV(TAG, "    Flushing...");
+  ESP_LOGVV(TAG, "    Flushing");
   this->hw_serial_->flush();
 }
 

esphome/components/uart/uart_component_esp8266.cpp

@@ -56,7 +56,7 @@ uint32_t ESP8266UartComponent::get_config() {
 }
 
 void ESP8266UartComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up UART bus...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Use Arduino HardwareSerial UARTs if all used pins match the ones
   // preconfigured by the platform. For example if RX disabled but TX pin
   // is 1 we still want to use Serial.
@@ -99,7 +99,7 @@ void ESP8266UartComponent::setup() {
 }
 
 void ESP8266UartComponent::load_settings(bool dump_config) {
-  ESP_LOGCONFIG(TAG, "Loading UART bus settings...");
+  ESP_LOGCONFIG(TAG, "Loading UART bus settings");
   if (this->hw_serial_ != nullptr) {
     SerialConfig config = static_cast<SerialConfig>(get_config());
     this->hw_serial_->begin(this->baud_rate_, config);
@@ -121,10 +121,12 @@ void ESP8266UartComponent::dump_config() {
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);  // NOLINT
   }
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %u baud", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
-  ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
+  ESP_LOGCONFIG(TAG,
+                "  Baud Rate: %u baud\n"
+                "  Data Bits: %u\n"
+                "  Parity: %s\n"
+                "  Stop bits: %u",
+                this->baud_rate_, this->data_bits_, LOG_STR_ARG(parity_to_str(this->parity_)), this->stop_bits_);
   if (this->hw_serial_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Using hardware serial interface.");
   } else {
@@ -193,7 +195,7 @@ int ESP8266UartComponent::available() {
   }
 }
 void ESP8266UartComponent::flush() {
-  ESP_LOGVV(TAG, "    Flushing...");
+  ESP_LOGVV(TAG, "    Flushing");
   if (this->hw_serial_ != nullptr) {
     this->hw_serial_->flush();
   } else {

esphome/components/uart/uart_component_esp_idf.cpp

@@ -85,12 +85,12 @@ void IDFUARTComponent::setup() {
 #endif  // USE_LOGGER
 
   if (next_uart_num >= SOC_UART_NUM) {
-    ESP_LOGW(TAG, "Maximum number of UART components created already.");
+    ESP_LOGW(TAG, "Maximum number of UART components created already");
     this->mark_failed();
     return;
   }
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
-  ESP_LOGCONFIG(TAG, "Setting up UART %u...", this->uart_num_);
+  ESP_LOGCONFIG(TAG, "Running setup for UART %u", this->uart_num_);
 
   this->lock_ = xSemaphoreCreateMutex();
 
@@ -162,10 +162,12 @@ void IDFUARTComponent::dump_config() {
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);
   }
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %" PRIu32 " baud", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
-  ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
+  ESP_LOGCONFIG(TAG,
+                "  Baud Rate: %" PRIu32 " baud\n"
+                "  Data Bits: %u\n"
+                "  Parity: %s\n"
+                "  Stop bits: %u",
+                this->baud_rate_, this->data_bits_, LOG_STR_ARG(parity_to_str(this->parity_)), this->stop_bits_);
   this->check_logger_conflict();
 }
 
@@ -234,7 +236,7 @@ int IDFUARTComponent::available() {
 }
 
 void IDFUARTComponent::flush() {
-  ESP_LOGVV(TAG, "    Flushing...");
+  ESP_LOGVV(TAG, "    Flushing");
   xSemaphoreTake(this->lock_, portMAX_DELAY);
   uart_wait_tx_done(this->uart_num_, portMAX_DELAY);
   xSemaphoreGive(this->lock_);

esphome/components/uart/uart_component_host.cpp

@@ -109,7 +109,7 @@ HostUartComponent::~HostUartComponent() {
 }
 
 void HostUartComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Opening UART port...");
+  ESP_LOGCONFIG(TAG, "Opening UART port");
   speed_t baud = get_baud(this->baud_rate_);
   if (baud == B0) {
     ESP_LOGE(TAG, "Unsupported baud rate: %d", this->baud_rate_);
@@ -188,14 +188,17 @@ void HostUartComponent::dump_config() {
     }
     return;
   }
-  ESP_LOGCONFIG(TAG, "  Port status: opened");
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %d", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %d", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s",
+  ESP_LOGCONFIG(TAG,
+                "  Port status: opened\n"
+                "  Baud Rate: %d\n"
+                "  Data Bits: %d\n"
+                "  Parity: %s\n"
+                "  Stop Bits: %d",
+                this->baud_rate_, this->data_bits_,
                 this->parity_ == UART_CONFIG_PARITY_NONE   ? "None"
                 : this->parity_ == UART_CONFIG_PARITY_EVEN ? "Even"
-                                                           : "Odd");
-  ESP_LOGCONFIG(TAG, "  Stop Bits: %d", this->stop_bits_);
+                                                           : "Odd",
+                this->stop_bits_);
   this->check_logger_conflict();
 }
 
@@ -283,7 +286,7 @@ void HostUartComponent::flush() {
     return;
   }
   tcflush(this->file_descriptor_, TCIOFLUSH);
-  ESP_LOGV(TAG, "    Flushing...");
+  ESP_LOGV(TAG, "    Flushing");
 }
 
 void HostUartComponent::update_error_(const std::string &error) {

esphome/components/uart/uart_component_libretiny.cpp

@@ -46,7 +46,7 @@ uint16_t LibreTinyUARTComponent::get_config() {
 }
 
 void LibreTinyUARTComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up UART...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   int8_t tx_pin = tx_pin_ == nullptr ? -1 : tx_pin_->get_pin();
   int8_t rx_pin = rx_pin_ == nullptr ? -1 : rx_pin_->get_pin();
@@ -108,10 +108,12 @@ void LibreTinyUARTComponent::dump_config() {
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);
   }
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %u baud", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
-  ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
+  ESP_LOGCONFIG(TAG,
+                "  Baud Rate: %u baud\n"
+                "  Data Bits: %u\n"
+                "  Parity: %s\n"
+                "  Stop bits: %u",
+                this->baud_rate_, this->data_bits_, LOG_STR_ARG(parity_to_str(this->parity_)), this->stop_bits_);
   this->check_logger_conflict();
 }
 
@@ -145,7 +147,7 @@ bool LibreTinyUARTComponent::read_array(uint8_t *data, size_t len) {
 
 int LibreTinyUARTComponent::available() { return this->serial_->available(); }
 void LibreTinyUARTComponent::flush() {
-  ESP_LOGVV(TAG, "    Flushing...");
+  ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();
 }
 

esphome/components/uart/uart_component_rp2040.cpp

@@ -52,7 +52,7 @@ uint16_t RP2040UartComponent::get_config() {
 }
 
 void RP2040UartComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up UART bus...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint16_t config = get_config();
 
@@ -136,10 +136,12 @@ void RP2040UartComponent::dump_config() {
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);
   }
-  ESP_LOGCONFIG(TAG, "  Baud Rate: %u baud", this->baud_rate_);
-  ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
-  ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
+  ESP_LOGCONFIG(TAG,
+                "  Baud Rate: %u baud\n"
+                "  Data Bits: %u\n"
+                "  Parity: %s\n"
+                "  Stop bits: %u",
+                this->baud_rate_, this->data_bits_, LOG_STR_ARG(parity_to_str(this->parity_)), this->stop_bits_);
   if (this->hw_serial_) {
     ESP_LOGCONFIG(TAG, "  Using hardware serial");
   } else {
@@ -174,7 +176,7 @@ bool RP2040UartComponent::read_array(uint8_t *data, size_t len) {
 }
 int RP2040UartComponent::available() { return this->serial_->available(); }
 void RP2040UartComponent::flush() {
-  ESP_LOGVV(TAG, "    Flushing...");
+  ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();
 }
 

esphome/components/udp/udp_component.cpp

@@ -122,16 +122,20 @@ void UDPComponent::loop() {
 }
 
 void UDPComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "UDP:");
-  ESP_LOGCONFIG(TAG, "  Listen Port: %u", this->listen_port_);
-  ESP_LOGCONFIG(TAG, "  Broadcast Port: %u", this->broadcast_port_);
+  ESP_LOGCONFIG(TAG,
+                "UDP:\n"
+                "  Listen Port: %u\n"
+                "  Broadcast Port: %u",
+                this->listen_port_, this->broadcast_port_);
   for (const auto &address : this->addresses_)
     ESP_LOGCONFIG(TAG, "  Address: %s", address.c_str());
   if (this->listen_address_.has_value()) {
     ESP_LOGCONFIG(TAG, "  Listen address: %s", this->listen_address_.value().str().c_str());
   }
-  ESP_LOGCONFIG(TAG, "  Broadcasting: %s", YESNO(this->should_broadcast_));
-  ESP_LOGCONFIG(TAG, "  Listening: %s", YESNO(this->should_listen_));
+  ESP_LOGCONFIG(TAG,
+                "  Broadcasting: %s\n"
+                "  Listening: %s",
+                YESNO(this->should_broadcast_), YESNO(this->should_listen_));
 }
 
 void UDPComponent::send_packet(const uint8_t *data, size_t size) {

esphome/components/ufire_ec/ufire_ec.cpp

@@ -7,7 +7,7 @@ namespace ufire_ec {
 static const char *const TAG = "ufire_ec";
 
 void UFireECComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up uFire_ec...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint8_t version;
   if (!this->read_byte(REGISTER_VERSION, &version) && version != 0xFF) {
@@ -110,8 +110,10 @@ void UFireECComponent::dump_config() {
   LOG_SENSOR("  ", "EC Sensor", this->ec_sensor_)
   LOG_SENSOR("  ", "Temperature Sensor", this->temperature_sensor_)
   LOG_SENSOR("  ", "Temperature Sensor external", this->temperature_sensor_external_)
-  ESP_LOGCONFIG(TAG, "  Temperature Compensation: %f", this->temperature_compensation_);
-  ESP_LOGCONFIG(TAG, "  Temperature Coefficient: %f", this->temperature_coefficient_);
+  ESP_LOGCONFIG(TAG,
+                "  Temperature Compensation: %f\n"
+                "  Temperature Coefficient: %f",
+                this->temperature_compensation_, this->temperature_coefficient_);
 }
 
 }  // namespace ufire_ec

esphome/components/ufire_ise/ufire_ise.cpp

@@ -9,7 +9,7 @@ namespace ufire_ise {
 static const char *const TAG = "ufire_ise";
 
 void UFireISEComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up uFire_ise...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint8_t version;
   if (!this->read_byte(REGISTER_VERSION, &version) && version != 0xFF) {

esphome/components/ultrasonic/ultrasonic_sensor.cpp

@@ -8,7 +8,7 @@ namespace ultrasonic {
 static const char *const TAG = "ultrasonic.sensor";
 
 void UltrasonicSensorComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Ultrasonic Sensor...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->trigger_pin_->setup();
   this->trigger_pin_->digital_write(false);
   this->echo_pin_->setup();
@@ -45,8 +45,10 @@ void UltrasonicSensorComponent::dump_config() {
   LOG_SENSOR("", "Ultrasonic Sensor", this);
   LOG_PIN("  Echo Pin: ", this->echo_pin_);
   LOG_PIN("  Trigger Pin: ", this->trigger_pin_);
-  ESP_LOGCONFIG(TAG, "  Pulse time: %" PRIu32 " µs", this->pulse_time_us_);
-  ESP_LOGCONFIG(TAG, "  Timeout: %" PRIu32 " µs", this->timeout_us_);
+  ESP_LOGCONFIG(TAG,
+                "  Pulse time: %" PRIu32 " µs\n"
+                "  Timeout: %" PRIu32 " µs",
+                this->pulse_time_us_, this->timeout_us_);
   LOG_UPDATE_INTERVAL(this);
 }
 float UltrasonicSensorComponent::us_to_m(uint32_t us) {

esphome/components/update/__init__.py

@@ -111,6 +111,7 @@ async def register_update(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_update(var))
+    CORE.register_platform_component("update", var)
     await setup_update_core_(var, config)
 
 

esphome/components/update/update_entity.cpp

@@ -30,7 +30,7 @@ void UpdateEntity::publish_state() {
     ESP_LOGD(TAG, "  Progress: %.0f%%", this->update_info_.progress);
   }
 
-  this->has_state_ = true;
+  this->set_has_state(true);
   this->state_callback_.call();
 }