esphome 2025.7.0b1__py3-none-any.whl → 2025.7.0b3__py3-none-any.whl

esphome/components/lvgl/widgets/meter.py

@@ -29,9 +29,9 @@ from ..defines import (
 )
 from ..helpers import add_lv_use, lvgl_components_required
 from ..lv_validation import (
-    angle,
     get_end_value,
     get_start_value,
+    lv_angle,
     lv_bool,
     lv_color,
     lv_float,
@@ -162,7 +162,7 @@ SCALE_SCHEMA = cv.Schema(
         cv.Optional(CONF_RANGE_FROM, default=0.0): cv.float_,
         cv.Optional(CONF_RANGE_TO, default=100.0): cv.float_,
         cv.Optional(CONF_ANGLE_RANGE, default=270): cv.int_range(0, 360),
-        cv.Optional(CONF_ROTATION): angle,
+        cv.Optional(CONF_ROTATION): lv_angle,
         cv.Optional(CONF_INDICATORS): cv.ensure_list(INDICATOR_SCHEMA),
     }
 )
@@ -187,7 +187,7 @@ class MeterType(WidgetType):
         for scale_conf in config.get(CONF_SCALES, ()):
             rotation = 90 + (360 - scale_conf[CONF_ANGLE_RANGE]) / 2
             if CONF_ROTATION in scale_conf:
-                rotation = scale_conf[CONF_ROTATION] // 10
+                rotation = await lv_angle.process(scale_conf[CONF_ROTATION])
             with LocalVariable(
                 "meter_var", "lv_meter_scale_t", lv_expr.meter_add_scale(var)
             ) as meter_var:
@@ -205,21 +205,20 @@ class MeterType(WidgetType):
                         var,
                         meter_var,
                         ticks[CONF_COUNT],
-                        ticks[CONF_WIDTH],
-                        ticks[CONF_LENGTH],
+                        await size.process(ticks[CONF_WIDTH]),
+                        await size.process(ticks[CONF_LENGTH]),
                         color,
                     )
                     if CONF_MAJOR in ticks:
                         major = ticks[CONF_MAJOR]
-                        color = await lv_color.process(major[CONF_COLOR])
                         lv.meter_set_scale_major_ticks(
                             var,
                             meter_var,
                             major[CONF_STRIDE],
-                            major[CONF_WIDTH],
-                            major[CONF_LENGTH],
-                            color,
-                            major[CONF_LABEL_GAP],
+                            await size.process(major[CONF_WIDTH]),
+                            await size.process(major[CONF_LENGTH]),
+                            await lv_color.process(major[CONF_COLOR]),
+                            await size.process(major[CONF_LABEL_GAP]),
                         )
                 for indicator in scale_conf.get(CONF_INDICATORS, ()):
                     (t, v) = next(iter(indicator.items()))
@@ -233,7 +232,11 @@ class MeterType(WidgetType):
                         lv_assign(
                             ivar,
                             lv_expr.meter_add_needle_line(
-                                var, meter_var, v[CONF_WIDTH], color, v[CONF_R_MOD]
+                                var,
+                                meter_var,
+                                await size.process(v[CONF_WIDTH]),
+                                color,
+                                await size.process(v[CONF_R_MOD]),
                             ),
                         )
                     if t == CONF_ARC:
@@ -241,7 +244,11 @@ class MeterType(WidgetType):
                         lv_assign(
                             ivar,
                             lv_expr.meter_add_arc(
-                                var, meter_var, v[CONF_WIDTH], color, v[CONF_R_MOD]
+                                var,
+                                meter_var,
+                                await size.process(v[CONF_WIDTH]),
+                                color,
+                                await size.process(v[CONF_R_MOD]),
                             ),
                         )
                     if t == CONF_TICK_STYLE:
@@ -257,7 +264,7 @@ class MeterType(WidgetType):
                                 color_start,
                                 color_end,
                                 v[CONF_LOCAL],
-                                v[CONF_WIDTH],
+                                size.process(v[CONF_WIDTH]),
                             ),
                         )
                     if t == CONF_IMAGE:

esphome/components/mqtt/mqtt_backend_esp32.cpp

@@ -153,11 +153,15 @@ void MQTTBackendESP32::mqtt_event_handler_(const Event &event) {
     case MQTT_EVENT_DATA: {
       static std::string topic;
       if (!event.topic.empty()) {
+        // When a single message arrives as multiple chunks, the topic will be empty
+        // on any but the first message, leading to event.topic being an empty string.
+        // To ensure handlers get the correct topic, cache the last seen topic to
+        // simulate always receiving the topic from underlying library
         topic = event.topic;
       }
       ESP_LOGV(TAG, "MQTT_EVENT_DATA %s", topic.c_str());
-      this->on_message_.call(!event.topic.empty() ? topic.c_str() : nullptr, event.data.data(), event.data.size(),
-                             event.current_data_offset, event.total_data_len);
+      this->on_message_.call(topic.c_str(), event.data.data(), event.data.size(), event.current_data_offset,
+                             event.total_data_len);
     } break;
     case MQTT_EVENT_ERROR:
       ESP_LOGE(TAG, "MQTT_EVENT_ERROR");

esphome/components/packet_transport/packet_transport.cpp

@@ -314,6 +314,9 @@ void PacketTransport::send_data_(bool all) {
 }
 
 void PacketTransport::update() {
+  if (!this->ping_pong_enable_) {
+    return;
+  }
   auto now = millis() / 1000;
   if (this->last_key_time_ + this->ping_pong_recyle_time_ < now) {
     this->resend_ping_key_ = this->ping_pong_enable_;

esphome/components/rp2040/__init__.py

@@ -165,6 +165,7 @@ async def to_code(config):
     # Allow LDF to properly discover dependency including those in preprocessor
     # conditionals
     cg.add_platformio_option("lib_ldf_mode", "chain+")
+    cg.add_platformio_option("lib_compat_mode", "strict")
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_build_flag("-DUSE_RP2040")
     cg.set_cpp_standard("gnu++20")

esphome/components/substitutions/__init__.py

@@ -151,8 +151,11 @@ def _substitute_item(substitutions, item, path, jinja, ignore_missing):
             if sub is not None:
                 item[k] = sub
         for old, new in replace_keys:
-            item[new] = merge_config(item.get(old), item.get(new))
-            del item[old]
+            if str(new) == str(old):
+                item[new] = item[old]
+            else:
+                item[new] = merge_config(item.get(old), item.get(new))
+                del item[old]
     elif isinstance(item, str):
         sub = _expand_substitutions(substitutions, item, path, jinja, ignore_missing)
         if isinstance(sub, JinjaStr) or sub != item:

esphome/components/sx126x/__init__.py

@@ -167,8 +167,8 @@ def validate_config(config):
     if config[CONF_MODULATION] == "LORA":
         if config[CONF_BANDWIDTH] not in lora_bws:
             raise cv.Invalid(f"{config[CONF_BANDWIDTH]} is not available with LORA")
-        if config[CONF_PREAMBLE_SIZE] > 0 and config[CONF_PREAMBLE_SIZE] < 6:
-            raise cv.Invalid("Minimum preamble size is 6 with LORA")
+        if config[CONF_PREAMBLE_SIZE] < 6:
+            raise cv.Invalid("Minimum 'preamble_size' is 6 with LORA")
         if config[CONF_SPREADING_FACTOR] == 6 and config[CONF_PAYLOAD_LENGTH] == 0:
             raise cv.Invalid("Payload length must be set when spreading factor is 6")
     else:
@@ -200,7 +200,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_PA_RAMP, default="40us"): cv.enum(RAMP),
             cv.Optional(CONF_PAYLOAD_LENGTH, default=0): cv.int_range(min=0, max=256),
             cv.Optional(CONF_PREAMBLE_DETECT, default=2): cv.int_range(min=0, max=4),
-            cv.Required(CONF_PREAMBLE_SIZE): cv.int_range(min=1, max=65535),
+            cv.Optional(CONF_PREAMBLE_SIZE, default=8): cv.int_range(min=1, max=65535),
             cv.Required(CONF_RST_PIN): pins.internal_gpio_output_pin_schema,
             cv.Optional(CONF_RX_START, default=True): cv.boolean,
             cv.Required(CONF_RF_SWITCH): cv.boolean,

esphome/components/sx127x/__init__.py

@@ -164,8 +164,8 @@ def validate_config(config):
             raise cv.Invalid(f"{config[CONF_BANDWIDTH]} is not available with LORA")
         if CONF_DIO0_PIN not in config:
             raise cv.Invalid("Cannot use LoRa without dio0_pin")
-        if 0 < config[CONF_PREAMBLE_SIZE] < 6:
-            raise cv.Invalid("Minimum preamble size is 6 with LORA")
+        if config[CONF_PREAMBLE_SIZE] < 6:
+            raise cv.Invalid("Minimum 'preamble_size' is 6 with LORA")
         if config[CONF_SPREADING_FACTOR] == 6 and config[CONF_PAYLOAD_LENGTH] == 0:
             raise cv.Invalid("Payload length must be set when spreading factor is 6")
     else:

esphome/components/usb_host/usb_host_client.cpp

@@ -70,7 +70,7 @@ static void usbh_print_cfg_desc(const usb_config_desc_t *cfg_desc) {
   ESP_LOGV(TAG, "bMaxPower %dmA", cfg_desc->bMaxPower * 2);
 }
 
-void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
+static void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
   if (devc_desc == NULL) {
     return;
   }
@@ -92,8 +92,8 @@ void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
   ESP_LOGV(TAG, "bNumConfigurations %d", devc_desc->bNumConfigurations);
 }
 
-void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
-                                        print_class_descriptor_cb class_specific_cb) {
+static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
+                                               print_class_descriptor_cb class_specific_cb) {
   if (cfg_desc == nullptr) {
     return;
   }
@@ -128,9 +128,9 @@ void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
 static std::string get_descriptor_string(const usb_str_desc_t *desc) {
   char buffer[256];
   if (desc == nullptr)
-    return "(unknown)";
+    return "(unspecified)";
   char *p = buffer;
-  for (size_t i = 0; i != desc->bLength / 2; i++) {
+  for (int i = 0; i != desc->bLength / 2; i++) {
     auto c = desc->wData[i];
     if (c < 0x100)
       *p++ = static_cast<char>(c);
@@ -169,7 +169,7 @@ void USBClient::setup() {
     this->mark_failed();
     return;
   }
-  for (auto trq : this->trq_pool_) {
+  for (auto *trq : this->trq_pool_) {
     usb_host_transfer_alloc(64, 0, &trq->transfer);
     trq->client = this;
   }
@@ -197,7 +197,8 @@ void USBClient::loop() {
         ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
         if (desc->idVendor == this->vid_ && desc->idProduct == this->pid_ || this->vid_ == 0 && this->pid_ == 0) {
           usb_device_info_t dev_info;
-          if ((err = usb_host_device_info(this->device_handle_, &dev_info)) != ESP_OK) {
+          err = usb_host_device_info(this->device_handle_, &dev_info);
+          if (err != ESP_OK) {
             ESP_LOGW(TAG, "Device info failed: %s", esp_err_to_name(err));
             this->disconnect();
             break;
@@ -336,7 +337,7 @@ static void transfer_callback(usb_transfer_t *xfer) {
  * @throws None.
  */
 void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
-  auto trq = this->get_trq_();
+  auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
     return;
@@ -349,7 +350,6 @@ void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, u
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "Failed to submit transfer, address=%x, length=%d, err=%x", ep_address, length, err);
     this->release_trq(trq);
-    this->disconnect();
   }
 }
 
@@ -364,7 +364,7 @@ void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, u
  * @throws None.
  */
 void USBClient::transfer_out(uint8_t ep_address, const transfer_cb_t &callback, const uint8_t *data, uint16_t length) {
-  auto trq = this->get_trq_();
+  auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
     return;

esphome/components/usb_uart/cp210x.cpp

@@ -43,7 +43,7 @@ static constexpr uint8_t SET_BAUDRATE = 0x1E;     // Set the baud rate.
 static constexpr uint8_t SET_CHARS = 0x19;        // Set special characters.
 static constexpr uint8_t VENDOR_SPECIFIC = 0xFF;  // Vendor specific command.
 
-std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors_(usb_device_handle_t dev_hdl) {
+std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors(usb_device_handle_t dev_hdl) {
   const usb_config_desc_t *config_desc;
   const usb_device_desc_t *device_desc;
   int conf_offset = 0, ep_offset;

esphome/components/usb_uart/usb_uart.cpp

@@ -18,52 +18,48 @@ namespace usb_uart {
  */
 static optional<CdcEps> get_cdc(const usb_config_desc_t *config_desc, uint8_t intf_idx) {
   int conf_offset, ep_offset;
-  const usb_ep_desc_t *notify_ep{}, *in_ep{}, *out_ep{};
-  uint8_t interface_number = 0;
-  // look for an interface with one interrupt endpoint (notify), and an interface with two bulk endpoints (data in/out)
+  // look for an interface with an interrupt endpoint (notify), and one with two bulk endpoints (data in/out)
+  CdcEps eps{};
+  eps.bulk_interface_number = 0xFF;
   for (;;) {
-    auto intf_desc = usb_parse_interface_descriptor(config_desc, intf_idx++, 0, &conf_offset);
+    const auto *intf_desc = usb_parse_interface_descriptor(config_desc, intf_idx++, 0, &conf_offset);
     if (!intf_desc) {
       ESP_LOGE(TAG, "usb_parse_interface_descriptor failed");
       return nullopt;
     }
-    if (intf_desc->bNumEndpoints == 1) {
+    ESP_LOGD(TAG, "intf_desc: bInterfaceClass=%02X, bInterfaceSubClass=%02X, bInterfaceProtocol=%02X, bNumEndpoints=%d",
+             intf_desc->bInterfaceClass, intf_desc->bInterfaceSubClass, intf_desc->bInterfaceProtocol,
+             intf_desc->bNumEndpoints);
+    for (uint8_t i = 0; i != intf_desc->bNumEndpoints; i++) {
       ep_offset = conf_offset;
-      notify_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
-      if (!notify_ep) {
-        ESP_LOGE(TAG, "notify_ep: usb_parse_endpoint_descriptor_by_index failed");
+      const auto *ep = usb_parse_endpoint_descriptor_by_index(intf_desc, i, config_desc->wTotalLength, &ep_offset);
+      if (!ep) {
+        ESP_LOGE(TAG, "Ran out of interfaces at %d before finding all endpoints", i);
         return nullopt;
       }
-      if (notify_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_INT)
-        notify_ep = nullptr;
-    } else if (USB_CLASS_CDC_DATA && intf_desc->bNumEndpoints == 2) {
-      interface_number = intf_desc->bInterfaceNumber;
-      ep_offset = conf_offset;
-      out_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
-      if (!out_ep) {
-        ESP_LOGE(TAG, "out_ep: usb_parse_endpoint_descriptor_by_index failed");
-        return nullopt;
-      }
-      if (out_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
-        out_ep = nullptr;
-      ep_offset = conf_offset;
-      in_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 1, config_desc->wTotalLength, &ep_offset);
-      if (!in_ep) {
-        ESP_LOGE(TAG, "in_ep: usb_parse_endpoint_descriptor_by_index failed");
-        return nullopt;
+      ESP_LOGD(TAG, "ep: bEndpointAddress=%02X, bmAttributes=%02X", ep->bEndpointAddress, ep->bmAttributes);
+      if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_INT) {
+        eps.notify_ep = ep;
+        eps.interrupt_interface_number = intf_desc->bInterfaceNumber;
+      } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && ep->bEndpointAddress & usb_host::USB_DIR_IN &&
+                 (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
+        eps.in_ep = ep;
+        eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+      } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && !(ep->bEndpointAddress & usb_host::USB_DIR_IN) &&
+                 (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
+        eps.out_ep = ep;
+        eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+      } else {
+        ESP_LOGE(TAG, "Unexpected endpoint attributes: %02X", ep->bmAttributes);
+        continue;
       }
-      if (in_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
-        in_ep = nullptr;
     }
-    if (in_ep != nullptr && out_ep != nullptr && notify_ep != nullptr)
-      break;
+    if (eps.in_ep != nullptr && eps.out_ep != nullptr && eps.notify_ep != nullptr)
+      return eps;
   }
-  if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN)
-    return CdcEps{notify_ep, in_ep, out_ep, interface_number};
-  return CdcEps{notify_ep, out_ep, in_ep, interface_number};
 }
 
-std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors_(usb_device_handle_t dev_hdl) {
+std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors(usb_device_handle_t dev_hdl) {
   const usb_config_desc_t *config_desc;
   const usb_device_desc_t *device_desc;
   int desc_offset = 0;
@@ -78,7 +74,7 @@ std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors_(usb_device_handle_t de
     ESP_LOGE(TAG, "get_active_config_descriptor failed");
     return {};
   }
-  if (device_desc->bDeviceClass == USB_CLASS_COMM) {
+  if (device_desc->bDeviceClass == USB_CLASS_COMM || device_desc->bDeviceClass == USB_CLASS_VENDOR_SPEC) {
     // single CDC-ACM device
     if (auto eps = get_cdc(config_desc, 0)) {
       ESP_LOGV(TAG, "Found CDC-ACM device");
@@ -194,7 +190,7 @@ void USBUartComponent::start_input(USBUartChannel *channel) {
   if (!channel->initialised_ || channel->input_started_ ||
       channel->input_buffer_.get_free_space() < channel->cdc_dev_.in_ep->wMaxPacketSize)
     return;
-  auto ep = channel->cdc_dev_.in_ep;
+  const auto *ep = channel->cdc_dev_.in_ep;
   auto callback = [this, channel](const usb_host::TransferStatus &status) {
     ESP_LOGV(TAG, "Transfer result: length: %u; status %X", status.data_len, status.error_code);
     if (!status.success) {
@@ -227,7 +223,7 @@ void USBUartComponent::start_output(USBUartChannel *channel) {
   if (channel->output_buffer_.is_empty()) {
     return;
   }
-  auto ep = channel->cdc_dev_.out_ep;
+  const auto *ep = channel->cdc_dev_.out_ep;
   auto callback = [this, channel](const usb_host::TransferStatus &status) {
     ESP_LOGV(TAG, "Output Transfer result: length: %u; status %X", status.data_len, status.error_code);
     channel->output_started_ = false;
@@ -259,15 +255,15 @@ static void fix_mps(const usb_ep_desc_t *ep) {
   }
 }
 void USBUartTypeCdcAcm::on_connected() {
-  auto cdc_devs = this->parse_descriptors_(this->device_handle_);
+  auto cdc_devs = this->parse_descriptors(this->device_handle_);
   if (cdc_devs.empty()) {
     this->status_set_error("No CDC-ACM device found");
     this->disconnect();
     return;
   }
   ESP_LOGD(TAG, "Found %zu CDC-ACM devices", cdc_devs.size());
-  auto i = 0;
-  for (auto channel : this->channels_) {
+  size_t i = 0;
+  for (auto *channel : this->channels_) {
     if (i == cdc_devs.size()) {
       ESP_LOGE(TAG, "No configuration found for channel %d", channel->index_);
       this->status_set_warning("No configuration found for channel");
@@ -277,10 +273,11 @@ void USBUartTypeCdcAcm::on_connected() {
     fix_mps(channel->cdc_dev_.in_ep);
     fix_mps(channel->cdc_dev_.out_ep);
     channel->initialised_ = true;
-    auto err = usb_host_interface_claim(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number, 0);
+    auto err =
+        usb_host_interface_claim(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number, 0);
     if (err != ESP_OK) {
       ESP_LOGE(TAG, "usb_host_interface_claim failed: %s, channel=%d, intf=%d", esp_err_to_name(err), channel->index_,
-               channel->cdc_dev_.interface_number);
+               channel->cdc_dev_.bulk_interface_number);
       this->status_set_error("usb_host_interface_claim failed");
       this->disconnect();
       return;
@@ -290,7 +287,7 @@ void USBUartTypeCdcAcm::on_connected() {
 }
 
 void USBUartTypeCdcAcm::on_disconnected() {
-  for (auto channel : this->channels_) {
+  for (auto *channel : this->channels_) {
     if (channel->cdc_dev_.in_ep != nullptr) {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
@@ -303,7 +300,7 @@ void USBUartTypeCdcAcm::on_disconnected() {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
     }
-    usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number);
+    usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number);
     channel->initialised_ = false;
     channel->input_started_ = false;
     channel->output_started_ = false;
@@ -314,7 +311,7 @@ void USBUartTypeCdcAcm::on_disconnected() {
 }
 
 void USBUartTypeCdcAcm::enable_channels() {
-  for (auto channel : this->channels_) {
+  for (auto *channel : this->channels_) {
     if (!channel->initialised_)
       continue;
     channel->input_started_ = false;

esphome/components/usb_uart/usb_uart.h

@@ -25,7 +25,8 @@ struct CdcEps {
   const usb_ep_desc_t *notify_ep;
   const usb_ep_desc_t *in_ep;
   const usb_ep_desc_t *out_ep;
-  uint8_t interface_number;
+  uint8_t bulk_interface_number;
+  uint8_t interrupt_interface_number;
 };
 
 enum UARTParityOptions {
@@ -123,7 +124,7 @@ class USBUartTypeCdcAcm : public USBUartComponent {
   USBUartTypeCdcAcm(uint16_t vid, uint16_t pid) : USBUartComponent(vid, pid) {}
 
  protected:
-  virtual std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl);
+  virtual std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl);
   void on_connected() override;
   virtual void enable_channels();
   void on_disconnected() override;
@@ -134,7 +135,7 @@ class USBUartTypeCP210X : public USBUartTypeCdcAcm {
   USBUartTypeCP210X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {}
 
  protected:
-  std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl) override;
+  std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl) override;
   void enable_channels() override;
 };
 class USBUartTypeCH34X : public USBUartTypeCdcAcm {

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2025.7.0b1"
+__version__ = "2025.7.0b3"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/component.cpp

@@ -138,7 +138,7 @@ void Component::call_dump_config() {
         }
       }
     }
-    ESP_LOGE(TAG, "  Component %s is marked FAILED: %s", this->get_component_source(), error_msg);
+    ESP_LOGE(TAG, "  %s is marked FAILED: %s", this->get_component_source(), error_msg);
   }
 }
 
@@ -191,7 +191,7 @@ bool Component::should_warn_of_blocking(uint32_t blocking_time) {
   return false;
 }
 void Component::mark_failed() {
-  ESP_LOGE(TAG, "Component %s was marked as failed", this->get_component_source());
+  ESP_LOGE(TAG, "%s was marked as failed", this->get_component_source());
   this->component_state_ &= ~COMPONENT_STATE_MASK;
   this->component_state_ |= COMPONENT_STATE_FAILED;
   this->status_set_error();
@@ -229,7 +229,7 @@ void IRAM_ATTR HOT Component::enable_loop_soon_any_context() {
 }
 void Component::reset_to_construction_state() {
   if ((this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_FAILED) {
-    ESP_LOGI(TAG, "Component %s is being reset to construction state", this->get_component_source());
+    ESP_LOGI(TAG, "%s is being reset to construction state", this->get_component_source());
     this->component_state_ &= ~COMPONENT_STATE_MASK;
     this->component_state_ |= COMPONENT_STATE_CONSTRUCTION;
     // Clear error status when resetting
@@ -275,14 +275,14 @@ void Component::status_set_warning(const char *message) {
     return;
   this->component_state_ |= STATUS_LED_WARNING;
   App.app_state_ |= STATUS_LED_WARNING;
-  ESP_LOGW(TAG, "Component %s set Warning flag: %s", this->get_component_source(), message);
+  ESP_LOGW(TAG, "%s set Warning flag: %s", this->get_component_source(), message);
 }
 void Component::status_set_error(const char *message) {
   if ((this->component_state_ & STATUS_LED_ERROR) != 0)
     return;
   this->component_state_ |= STATUS_LED_ERROR;
   App.app_state_ |= STATUS_LED_ERROR;
-  ESP_LOGE(TAG, "Component %s set Error flag: %s", this->get_component_source(), message);
+  ESP_LOGE(TAG, "%s set Error flag: %s", this->get_component_source(), message);
   if (strcmp(message, "unspecified") != 0) {
     // Lazy allocate the error messages vector if needed
     if (!component_error_messages) {
@@ -303,13 +303,13 @@ void Component::status_clear_warning() {
   if ((this->component_state_ & STATUS_LED_WARNING) == 0)
     return;
   this->component_state_ &= ~STATUS_LED_WARNING;
-  ESP_LOGW(TAG, "Component %s cleared Warning flag", this->get_component_source());
+  ESP_LOGW(TAG, "%s cleared Warning flag", this->get_component_source());
 }
 void Component::status_clear_error() {
   if ((this->component_state_ & STATUS_LED_ERROR) == 0)
     return;
   this->component_state_ &= ~STATUS_LED_ERROR;
-  ESP_LOGE(TAG, "Component %s cleared Error flag", this->get_component_source());
+  ESP_LOGE(TAG, "%s cleared Error flag", this->get_component_source());
 }
 void Component::status_momentary_warning(const std::string &name, uint32_t length) {
   this->status_set_warning();
@@ -403,7 +403,7 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   }
   if (should_warn) {
     const char *src = component_ == nullptr ? "<null>" : component_->get_component_source();
-    ESP_LOGW(TAG, "Component %s took a long time for an operation (%" PRIu32 " ms)", src, blocking_time);
+    ESP_LOGW(TAG, "%s took a long time for an operation (%" PRIu32 " ms)", src, blocking_time);
     ESP_LOGW(TAG, "Components should block for at most 30 ms");
   }
 

esphome/core/component_iterator.cpp

@@ -4,6 +4,8 @@
 
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
+#endif
+#ifdef USE_API_SERVICES
 #include "esphome/components/api/user_services.h"
 #endif
 
@@ -148,7 +150,7 @@ void ComponentIterator::advance() {
       }
       break;
 #endif
-#ifdef USE_API
+#ifdef USE_API_SERVICES
     case IteratorState ::SERVICE:
       if (this->at_ >= api::global_api_server->get_user_services().size()) {
         advance_platform = true;
@@ -383,7 +385,7 @@ void ComponentIterator::advance() {
 }
 bool ComponentIterator::on_end() { return true; }
 bool ComponentIterator::on_begin() { return true; }
-#ifdef USE_API
+#ifdef USE_API_SERVICES
 bool ComponentIterator::on_service(api::UserServiceDescriptor *service) { return true; }
 #endif
 #ifdef USE_CAMERA

esphome/core/component_iterator.h

@@ -10,7 +10,7 @@
 
 namespace esphome {
 
-#ifdef USE_API
+#ifdef USE_API_SERVICES
 namespace api {
 class UserServiceDescriptor;
 }  // namespace api
@@ -45,7 +45,7 @@ class ComponentIterator {
 #ifdef USE_TEXT_SENSOR
   virtual bool on_text_sensor(text_sensor::TextSensor *text_sensor) = 0;
 #endif
-#ifdef USE_API
+#ifdef USE_API_SERVICES
   virtual bool on_service(api::UserServiceDescriptor *service);
 #endif
 #ifdef USE_CAMERA
@@ -122,7 +122,7 @@ class ComponentIterator {
 #ifdef USE_TEXT_SENSOR
     TEXT_SENSOR,
 #endif
-#ifdef USE_API
+#ifdef USE_API_SERVICES
     SERVICE,
 #endif
 #ifdef USE_CAMERA

esphome/core/defines.h

@@ -108,7 +108,7 @@
 #define USE_API_CLIENT_DISCONNECTED_TRIGGER
 #define USE_API_NOISE
 #define USE_API_PLAINTEXT
-#define USE_API_YAML_SERVICES
+#define USE_API_SERVICES
 #define USE_MD5
 #define USE_MQTT
 #define USE_NETWORK

esphome/core/entity_helpers.py

@@ -187,6 +187,12 @@ def entity_duplicate_validator(platform: str) -> Callable[[ConfigType], ConfigTy
             # No name to validate
             return config
 
+        # Skip validation for internal entities
+        # Internal entities are not exposed to Home Assistant and don't use the hash-based
+        # entity state tracking system, so name collisions don't matter for them
+        if config.get(CONF_INTERNAL, False):
+            return config
+
         # Get the entity name
         entity_name = config[CONF_NAME]
 

esphome/core/helpers.h

@@ -783,7 +783,7 @@ template<class T> class RAMAllocator {
   T *reallocate(T *p, size_t n) { return this->reallocate(p, n, sizeof(T)); }
 
   T *reallocate(T *p, size_t n, size_t manual_size) {
-    size_t size = n * sizeof(T);
+    size_t size = n * manual_size;
     T *ptr = nullptr;
 #ifdef USE_ESP32
     if (this->flags_ & Flags::ALLOC_EXTERNAL) {