esphome 2025.7.4__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/core/component_iterator.cpp

@@ -16,373 +16,173 @@ void ComponentIterator::begin(bool include_internal) {
   this->at_ = 0;
   this->include_internal_ = include_internal;
 }
+
+void ComponentIterator::advance_platform_() {
+  this->state_ = static_cast<IteratorState>(static_cast<uint32_t>(this->state_) + 1);
+  this->at_ = 0;
+}
+
 void ComponentIterator::advance() {
-  bool advance_platform = false;
-  bool success = true;
   switch (this->state_) {
     case IteratorState::NONE:
       // not started
       return;
     case IteratorState::BEGIN:
       if (this->on_begin()) {
-        advance_platform = true;
-      } else {
-        return;
+        advance_platform_();
       }
       break;
+
 #ifdef USE_BINARY_SENSOR
     case IteratorState::BINARY_SENSOR:
-      if (this->at_ >= App.get_binary_sensors().size()) {
-        advance_platform = true;
-      } else {
-        auto *binary_sensor = App.get_binary_sensors()[this->at_];
-        if (binary_sensor->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_binary_sensor(binary_sensor);
-        }
-      }
+      this->process_platform_item_(App.get_binary_sensors(), &ComponentIterator::on_binary_sensor);
       break;
 #endif
+
 #ifdef USE_COVER
     case IteratorState::COVER:
-      if (this->at_ >= App.get_covers().size()) {
-        advance_platform = true;
-      } else {
-        auto *cover = App.get_covers()[this->at_];
-        if (cover->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_cover(cover);
-        }
-      }
+      this->process_platform_item_(App.get_covers(), &ComponentIterator::on_cover);
       break;
 #endif
+
 #ifdef USE_FAN
     case IteratorState::FAN:
-      if (this->at_ >= App.get_fans().size()) {
-        advance_platform = true;
-      } else {
-        auto *fan = App.get_fans()[this->at_];
-        if (fan->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_fan(fan);
-        }
-      }
+      this->process_platform_item_(App.get_fans(), &ComponentIterator::on_fan);
       break;
 #endif
+
 #ifdef USE_LIGHT
     case IteratorState::LIGHT:
-      if (this->at_ >= App.get_lights().size()) {
-        advance_platform = true;
-      } else {
-        auto *light = App.get_lights()[this->at_];
-        if (light->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_light(light);
-        }
-      }
+      this->process_platform_item_(App.get_lights(), &ComponentIterator::on_light);
       break;
 #endif
+
 #ifdef USE_SENSOR
     case IteratorState::SENSOR:
-      if (this->at_ >= App.get_sensors().size()) {
-        advance_platform = true;
-      } else {
-        auto *sensor = App.get_sensors()[this->at_];
-        if (sensor->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_sensor(sensor);
-        }
-      }
+      this->process_platform_item_(App.get_sensors(), &ComponentIterator::on_sensor);
       break;
 #endif
+
 #ifdef USE_SWITCH
     case IteratorState::SWITCH:
-      if (this->at_ >= App.get_switches().size()) {
-        advance_platform = true;
-      } else {
-        auto *a_switch = App.get_switches()[this->at_];
-        if (a_switch->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_switch(a_switch);
-        }
-      }
+      this->process_platform_item_(App.get_switches(), &ComponentIterator::on_switch);
       break;
 #endif
+
 #ifdef USE_BUTTON
     case IteratorState::BUTTON:
-      if (this->at_ >= App.get_buttons().size()) {
-        advance_platform = true;
-      } else {
-        auto *button = App.get_buttons()[this->at_];
-        if (button->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_button(button);
-        }
-      }
+      this->process_platform_item_(App.get_buttons(), &ComponentIterator::on_button);
       break;
 #endif
+
 #ifdef USE_TEXT_SENSOR
     case IteratorState::TEXT_SENSOR:
-      if (this->at_ >= App.get_text_sensors().size()) {
-        advance_platform = true;
-      } else {
-        auto *text_sensor = App.get_text_sensors()[this->at_];
-        if (text_sensor->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_text_sensor(text_sensor);
-        }
-      }
+      this->process_platform_item_(App.get_text_sensors(), &ComponentIterator::on_text_sensor);
       break;
 #endif
+
 #ifdef USE_API_SERVICES
-    case IteratorState ::SERVICE:
-      if (this->at_ >= api::global_api_server->get_user_services().size()) {
-        advance_platform = true;
-      } else {
-        auto *service = api::global_api_server->get_user_services()[this->at_];
-        success = this->on_service(service);
-      }
+    case IteratorState::SERVICE:
+      this->process_platform_item_(api::global_api_server->get_user_services(), &ComponentIterator::on_service);
       break;
 #endif
+
 #ifdef USE_CAMERA
-    case IteratorState::CAMERA:
-      if (camera::Camera::instance() == nullptr) {
-        advance_platform = true;
-      } else {
-        if (camera::Camera::instance()->is_internal() && !this->include_internal_) {
-          advance_platform = success = true;
-          break;
-        } else {
-          advance_platform = success = this->on_camera(camera::Camera::instance());
-        }
+    case IteratorState::CAMERA: {
+      camera::Camera *camera_instance = camera::Camera::instance();
+      if (camera_instance != nullptr && (!camera_instance->is_internal() || this->include_internal_)) {
+        this->on_camera(camera_instance);
       }
-      break;
+      advance_platform_();
+    } break;
 #endif
+
 #ifdef USE_CLIMATE
     case IteratorState::CLIMATE:
-      if (this->at_ >= App.get_climates().size()) {
-        advance_platform = true;
-      } else {
-        auto *climate = App.get_climates()[this->at_];
-        if (climate->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_climate(climate);
-        }
-      }
+      this->process_platform_item_(App.get_climates(), &ComponentIterator::on_climate);
       break;
 #endif
+
 #ifdef USE_NUMBER
     case IteratorState::NUMBER:
-      if (this->at_ >= App.get_numbers().size()) {
-        advance_platform = true;
-      } else {
-        auto *number = App.get_numbers()[this->at_];
-        if (number->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_number(number);
-        }
-      }
+      this->process_platform_item_(App.get_numbers(), &ComponentIterator::on_number);
       break;
 #endif
+
 #ifdef USE_DATETIME_DATE
     case IteratorState::DATETIME_DATE:
-      if (this->at_ >= App.get_dates().size()) {
-        advance_platform = true;
-      } else {
-        auto *date = App.get_dates()[this->at_];
-        if (date->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_date(date);
-        }
-      }
+      this->process_platform_item_(App.get_dates(), &ComponentIterator::on_date);
       break;
 #endif
+
 #ifdef USE_DATETIME_TIME
     case IteratorState::DATETIME_TIME:
-      if (this->at_ >= App.get_times().size()) {
-        advance_platform = true;
-      } else {
-        auto *time = App.get_times()[this->at_];
-        if (time->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_time(time);
-        }
-      }
+      this->process_platform_item_(App.get_times(), &ComponentIterator::on_time);
       break;
 #endif
+
 #ifdef USE_DATETIME_DATETIME
     case IteratorState::DATETIME_DATETIME:
-      if (this->at_ >= App.get_datetimes().size()) {
-        advance_platform = true;
-      } else {
-        auto *datetime = App.get_datetimes()[this->at_];
-        if (datetime->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_datetime(datetime);
-        }
-      }
+      this->process_platform_item_(App.get_datetimes(), &ComponentIterator::on_datetime);
       break;
 #endif
+
 #ifdef USE_TEXT
     case IteratorState::TEXT:
-      if (this->at_ >= App.get_texts().size()) {
-        advance_platform = true;
-      } else {
-        auto *text = App.get_texts()[this->at_];
-        if (text->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_text(text);
-        }
-      }
+      this->process_platform_item_(App.get_texts(), &ComponentIterator::on_text);
       break;
 #endif
+
 #ifdef USE_SELECT
     case IteratorState::SELECT:
-      if (this->at_ >= App.get_selects().size()) {
-        advance_platform = true;
-      } else {
-        auto *select = App.get_selects()[this->at_];
-        if (select->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_select(select);
-        }
-      }
+      this->process_platform_item_(App.get_selects(), &ComponentIterator::on_select);
       break;
 #endif
+
 #ifdef USE_LOCK
     case IteratorState::LOCK:
-      if (this->at_ >= App.get_locks().size()) {
-        advance_platform = true;
-      } else {
-        auto *a_lock = App.get_locks()[this->at_];
-        if (a_lock->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_lock(a_lock);
-        }
-      }
+      this->process_platform_item_(App.get_locks(), &ComponentIterator::on_lock);
       break;
 #endif
+
 #ifdef USE_VALVE
     case IteratorState::VALVE:
-      if (this->at_ >= App.get_valves().size()) {
-        advance_platform = true;
-      } else {
-        auto *valve = App.get_valves()[this->at_];
-        if (valve->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_valve(valve);
-        }
-      }
+      this->process_platform_item_(App.get_valves(), &ComponentIterator::on_valve);
       break;
 #endif
+
 #ifdef USE_MEDIA_PLAYER
     case IteratorState::MEDIA_PLAYER:
-      if (this->at_ >= App.get_media_players().size()) {
-        advance_platform = true;
-      } else {
-        auto *media_player = App.get_media_players()[this->at_];
-        if (media_player->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_media_player(media_player);
-        }
-      }
+      this->process_platform_item_(App.get_media_players(), &ComponentIterator::on_media_player);
       break;
 #endif
+
 #ifdef USE_ALARM_CONTROL_PANEL
     case IteratorState::ALARM_CONTROL_PANEL:
-      if (this->at_ >= App.get_alarm_control_panels().size()) {
-        advance_platform = true;
-      } else {
-        auto *a_alarm_control_panel = App.get_alarm_control_panels()[this->at_];
-        if (a_alarm_control_panel->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_alarm_control_panel(a_alarm_control_panel);
-        }
-      }
+      this->process_platform_item_(App.get_alarm_control_panels(), &ComponentIterator::on_alarm_control_panel);
       break;
 #endif
+
 #ifdef USE_EVENT
     case IteratorState::EVENT:
-      if (this->at_ >= App.get_events().size()) {
-        advance_platform = true;
-      } else {
-        auto *event = App.get_events()[this->at_];
-        if (event->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_event(event);
-        }
-      }
+      this->process_platform_item_(App.get_events(), &ComponentIterator::on_event);
       break;
 #endif
+
 #ifdef USE_UPDATE
     case IteratorState::UPDATE:
-      if (this->at_ >= App.get_updates().size()) {
-        advance_platform = true;
-      } else {
-        auto *update = App.get_updates()[this->at_];
-        if (update->is_internal() && !this->include_internal_) {
-          success = true;
-          break;
-        } else {
-          success = this->on_update(update);
-        }
-      }
+      this->process_platform_item_(App.get_updates(), &ComponentIterator::on_update);
       break;
 #endif
+
     case IteratorState::MAX:
       if (this->on_end()) {
         this->state_ = IteratorState::NONE;
       }
       return;
   }
-
-  if (advance_platform) {
-    this->state_ = static_cast<IteratorState>(static_cast<uint8_t>(this->state_) + 1);
-    this->at_ = 0;
-  } else if (success) {
-    this->at_++;
-  }
 }
+
 bool ComponentIterator::on_end() { return true; }
 bool ComponentIterator::on_begin() { return true; }
 #ifdef USE_API_SERVICES

esphome/core/component_iterator.h

@@ -171,6 +171,21 @@ class ComponentIterator {
   } state_{IteratorState::NONE};
   uint16_t at_{0};  // Supports up to 65,535 entities per type
   bool include_internal_{false};
+
+  template<typename Container>
+  void process_platform_item_(const Container &items,
+                              bool (ComponentIterator::*on_item)(typename Container::value_type)) {
+    if (this->at_ >= items.size()) {
+      this->advance_platform_();
+    } else {
+      typename Container::value_type item = items[this->at_];
+      if ((item->is_internal() && !this->include_internal_) || (this->*on_item)(item)) {
+        this->at_++;
+      }
+    }
+  }
+
+  void advance_platform_();
 };
 
 }  // namespace esphome

esphome/core/config.py

@@ -317,7 +317,7 @@ def preload_core_config(config, result) -> str:
 
     target_platforms = []
 
-    for domain, _ in config.items():
+    for domain in config:
         if domain.startswith("."):
             continue
         if _is_target_platform(domain):
@@ -419,10 +419,27 @@ async def _add_automations(config):
         await automation.build_automation(trigger, [], conf)
 
 
+# Datetime component has special subtypes that need additional defines
+DATETIME_SUBTYPES = {"date", "time", "datetime"}
+
+
 @coroutine_with_priority(-100.0)
-async def _add_platform_reserves() -> None:
+async def _add_platform_defines() -> None:
+    # Generate compile-time defines for platforms that have actual entities
+    # Only add USE_* and count defines when there are entities
     for platform_name, count in sorted(CORE.platform_counts.items()):
-        cg.add(cg.RawStatement(f"App.reserve_{platform_name}({count});"), prepend=True)
+        if count <= 0:
+            continue
+
+        define_name = f"ESPHOME_ENTITY_{platform_name.upper()}_COUNT"
+        cg.add_define(define_name, count)
+
+        # Datetime subtypes only use USE_DATETIME_* defines
+        if platform_name in DATETIME_SUBTYPES:
+            cg.add_define(f"USE_DATETIME_{platform_name.upper()}")
+        else:
+            # Regular platforms use USE_* defines
+            cg.add_define(f"USE_{platform_name.upper()}")
 
 
 @coroutine_with_priority(100.0)
@@ -442,12 +459,10 @@ async def to_code(config: ConfigType) -> None:
             config[CONF_NAME_ADD_MAC_SUFFIX],
         )
     )
-    # Reserve space for components to avoid reallocation during registration
-    cg.add(
-        cg.RawStatement(f"App.reserve_components({len(CORE.component_ids)});"),
-    )
+    # Define component count for static allocation
+    cg.add_define("ESPHOME_COMPONENT_COUNT", len(CORE.component_ids))
 
-    CORE.add_job(_add_platform_reserves)
+    CORE.add_job(_add_platform_defines)
 
     CORE.add_job(_add_automations, config)
 
@@ -514,8 +529,8 @@ async def to_code(config: ConfigType) -> None:
     all_areas.extend(config[CONF_AREAS])
 
     if all_areas:
-        cg.add(cg.RawStatement(f"App.reserve_area({len(all_areas)});"))
         cg.add_define("USE_AREAS")
+        cg.add_define("ESPHOME_AREA_COUNT", len(all_areas))
 
         for area_conf in all_areas:
             area_id: core.ID = area_conf[CONF_ID]
@@ -532,9 +547,9 @@ async def to_code(config: ConfigType) -> None:
     if not devices:
         return
 
-    # Reserve space for devices
-    cg.add(cg.RawStatement(f"App.reserve_device({len(devices)});"))
+    # Define device count for static allocation
     cg.add_define("USE_DEVICES")
+    cg.add_define("ESPHOME_DEVICE_COUNT", len(devices))
 
     # Process each device
     for dev_conf in devices:

esphome/core/defines.h

@@ -15,6 +15,9 @@
 #define ESPHOME_VARIANT "ESP32"
 #define ESPHOME_DEBUG_SCHEDULER
 
+// Default threading model for static analysis (ESP32 is multi-threaded with atomics)
+#define ESPHOME_THREAD_MULTI_ATOMICS
+
 // logger
 #define ESPHOME_LOG_LEVEL ESPHOME_LOG_LEVEL_VERY_VERBOSE
 
@@ -106,6 +109,8 @@
 #define USE_API
 #define USE_API_CLIENT_CONNECTED_TRIGGER
 #define USE_API_CLIENT_DISCONNECTED_TRIGGER
+#define USE_API_HOMEASSISTANT_SERVICES
+#define USE_API_HOMEASSISTANT_STATES
 #define USE_API_NOISE
 #define USE_API_PLAINTEXT
 #define USE_API_SERVICES
@@ -142,10 +147,15 @@
 #define USE_ESPHOME_TASK_LOG_BUFFER
 
 #define USE_BLUETOOTH_PROXY
+#define BLUETOOTH_PROXY_MAX_CONNECTIONS 3
+#define BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE 16
 #define USE_CAPTIVE_PORTAL
 #define USE_ESP32_BLE
 #define USE_ESP32_BLE_CLIENT
+#define USE_ESP32_BLE_DEVICE
 #define USE_ESP32_BLE_SERVER
+#define USE_ESP32_BLE_UUID
+#define USE_ESP32_BLE_ADVERTISING
 #define USE_I2C
 #define USE_IMPROV
 #define USE_MICROPHONE
@@ -156,18 +166,18 @@
 #define USE_SPI
 #define USE_VOICE_ASSISTANT
 #define USE_WEBSERVER
+#define USE_WEBSERVER_AUTH
 #define USE_WEBSERVER_OTA
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #define USE_WEBSERVER_SORTING
 #define USE_WIFI_11KV_SUPPORT
 
 #ifdef USE_ARDUINO
-#define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 1, 3)
+#define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 2, 1)
 #define USE_ETHERNET
 #endif
 
 #ifdef USE_ESP_IDF
-#define USE_ESP_IDF_VERSION_CODE VERSION_CODE(5, 3, 2)
 #define USE_MICRO_WAKE_WORD
 #define USE_MICRO_WAKE_WORD_VAD
 #if defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
@@ -204,6 +214,7 @@
   {}
 
 #define USE_WEBSERVER
+#define USE_WEBSERVER_AUTH
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
@@ -220,6 +231,7 @@
 #define USE_SOCKET_IMPL_LWIP_SOCKETS
 #define USE_SOCKET_SELECT_SUPPORT
 #define USE_WEBSERVER
+#define USE_WEBSERVER_AUTH
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
@@ -233,3 +245,29 @@
 // #define USE_BSEC2  // Requires a library with proprietary license
 
 #define USE_DASHBOARD_IMPORT
+
+// Default counts for static analysis
+#define ESPHOME_COMPONENT_COUNT 50
+#define ESPHOME_DEVICE_COUNT 10
+#define ESPHOME_AREA_COUNT 10
+#define ESPHOME_ENTITY_ALARM_CONTROL_PANEL_COUNT 1
+#define ESPHOME_ENTITY_BINARY_SENSOR_COUNT 1
+#define ESPHOME_ENTITY_BUTTON_COUNT 1
+#define ESPHOME_ENTITY_CLIMATE_COUNT 1
+#define ESPHOME_ENTITY_COVER_COUNT 1
+#define ESPHOME_ENTITY_DATE_COUNT 1
+#define ESPHOME_ENTITY_DATETIME_COUNT 1
+#define ESPHOME_ENTITY_EVENT_COUNT 1
+#define ESPHOME_ENTITY_FAN_COUNT 1
+#define ESPHOME_ENTITY_LIGHT_COUNT 1
+#define ESPHOME_ENTITY_LOCK_COUNT 1
+#define ESPHOME_ENTITY_MEDIA_PLAYER_COUNT 1
+#define ESPHOME_ENTITY_NUMBER_COUNT 1
+#define ESPHOME_ENTITY_SELECT_COUNT 1
+#define ESPHOME_ENTITY_SENSOR_COUNT 1
+#define ESPHOME_ENTITY_SWITCH_COUNT 1
+#define ESPHOME_ENTITY_TEXT_COUNT 1
+#define ESPHOME_ENTITY_TEXT_SENSOR_COUNT 1
+#define ESPHOME_ENTITY_TIME_COUNT 1
+#define ESPHOME_ENTITY_UPDATE_COUNT 1
+#define ESPHOME_ENTITY_VALVE_COUNT 1

esphome/core/entity_base.h

@@ -54,6 +54,14 @@ class EntityBase {
   // Get/set this entity's icon
   std::string get_icon() const;
   void set_icon(const char *icon);
+  StringRef get_icon_ref() const {
+    static constexpr auto EMPTY_STRING = StringRef::from_lit("");
+#ifdef USE_ENTITY_ICON
+    return this->icon_c_str_ == nullptr ? EMPTY_STRING : StringRef(this->icon_c_str_);
+#else
+    return EMPTY_STRING;
+#endif
+  }
 
 #ifdef USE_DEVICES
   // Get/set this entity's device id
@@ -105,6 +113,11 @@ class EntityBase_DeviceClass {  // NOLINT(readability-identifier-naming)
   std::string get_device_class();
   /// Manually set the device class.
   void set_device_class(const char *device_class);
+  /// Get the device class as StringRef
+  StringRef get_device_class_ref() const {
+    static constexpr auto EMPTY_STRING = StringRef::from_lit("");
+    return this->device_class_ == nullptr ? EMPTY_STRING : StringRef(this->device_class_);
+  }
 
  protected:
   const char *device_class_{nullptr};  ///< Device class override
@@ -116,6 +129,11 @@ class EntityBase_UnitOfMeasurement {  // NOLINT(readability-identifier-naming)
   std::string get_unit_of_measurement();
   /// Manually set the unit of measurement.
   void set_unit_of_measurement(const char *unit_of_measurement);
+  /// Get the unit of measurement as StringRef
+  StringRef get_unit_of_measurement_ref() const {
+    static constexpr auto EMPTY_STRING = StringRef::from_lit("");
+    return this->unit_of_measurement_ == nullptr ? EMPTY_STRING : StringRef(this->unit_of_measurement_);
+  }
 
  protected:
   const char *unit_of_measurement_{nullptr};  ///< Unit of measurement override