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

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();
 }
 

esphome/components/update/update_entity.h

@@ -28,8 +28,6 @@ enum UpdateState : uint8_t {
 
 class UpdateEntity : public EntityBase, public EntityBase_DeviceClass {
  public:
-  bool has_state() const { return this->has_state_; }
-
   void publish_state();
 
   void perform() { this->perform(false); }
@@ -44,7 +42,6 @@ class UpdateEntity : public EntityBase, public EntityBase_DeviceClass {
  protected:
   UpdateState state_{UPDATE_STATE_UNKNOWN};
   UpdateInfo update_info_;
-  bool has_state_{false};
 
   CallbackManager<void()> state_callback_{};
 };

esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp

@@ -1,7 +1,7 @@
 #include "uponor_smatrix_climate.h"
+#include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
 namespace esphome {
 namespace uponor_smatrix {

esphome/components/uponor_smatrix/sensor/uponor_smatrix_sensor.cpp

@@ -7,8 +7,10 @@ namespace uponor_smatrix {
 static const char *const TAG = "uponor_smatrix.sensor";
 
 void UponorSmatrixSensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "Uponor Smatrix Sensor");
-  ESP_LOGCONFIG(TAG, "  Device address: 0x%04X", this->address_);
+  ESP_LOGCONFIG(TAG,
+                "Uponor Smatrix Sensor\n"
+                "  Device address: 0x%04X",
+                this->address_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "External Temperature", this->external_temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/uponor_smatrix/uponor_smatrix.cpp

@@ -1,6 +1,7 @@
 #include "uponor_smatrix.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace uponor_smatrix {

esphome/components/uptime/sensor/uptime_timestamp_sensor.cpp

@@ -13,7 +13,7 @@ static const char *const TAG = "uptime.sensor";
 
 void UptimeTimestampSensor::setup() {
   this->time_->add_on_time_sync_callback([this]() {
-    if (this->has_state_)
+    if (this->has_state())
       return;  // No need to update the timestamp if it's already set
 
     auto now = this->time_->now();

esphome/components/usb_host/__init__.py

@@ -0,0 +1,64 @@
+import esphome.codegen as cg
+from esphome.components.esp32 import (
+    VARIANT_ESP32S2,
+    VARIANT_ESP32S3,
+    add_idf_sdkconfig_option,
+    only_on_variant,
+)
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_types import Component
+
+AUTO_LOAD = ["bytebuffer"]
+CODEOWNERS = ["@clydebarrow"]
+DEPENDENCIES = ["esp32"]
+usb_host_ns = cg.esphome_ns.namespace("usb_host")
+USBHost = usb_host_ns.class_("USBHost", Component)
+USBClient = usb_host_ns.class_("USBClient", Component)
+
+CONF_DEVICES = "devices"
+CONF_VID = "vid"
+CONF_PID = "pid"
+
+
+def usb_device_schema(cls=USBClient, vid: int = None, pid: [int] = None) -> cv.Schema:
+    schema = cv.COMPONENT_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(cls),
+        }
+    )
+    if vid:
+        schema = schema.extend({cv.Optional(CONF_VID, default=vid): cv.hex_uint16_t})
+    else:
+        schema = schema.extend({cv.Required(CONF_VID): cv.hex_uint16_t})
+    if pid:
+        schema = schema.extend({cv.Optional(CONF_PID, default=pid): cv.hex_uint16_t})
+    else:
+        schema = schema.extend({cv.Required(CONF_PID): cv.hex_uint16_t})
+    return schema
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.COMPONENT_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(USBHost),
+            cv.Optional(CONF_DEVICES): cv.ensure_list(usb_device_schema()),
+        }
+    ),
+    cv.only_with_esp_idf,
+    only_on_variant(supported=[VARIANT_ESP32S2, VARIANT_ESP32S3]),
+)
+
+
+async def register_usb_client(config):
+    var = cg.new_Pvariable(config[CONF_ID], config[CONF_VID], config[CONF_PID])
+    await cg.register_component(var, config)
+    return var
+
+
+async def to_code(config):
+    add_idf_sdkconfig_option("CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE", 1024)
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    for device in config.get(CONF_DEVICES) or ():
+        await register_usb_client(device)