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

esphome/core/__init__.py

@@ -1,8 +1,9 @@
+from collections import defaultdict
 import logging
 import math
 import os
 import re
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from esphome.const import (
     CONF_COMMENT,
@@ -326,7 +327,7 @@ class ID:
         else:
             self.is_manual = is_manual
         self.is_declaration = is_declaration
-        self.type: Optional[MockObjClass] = type
+        self.type: MockObjClass | None = type
 
     def resolve(self, registered_ids):
         from esphome.config_validation import RESERVED_IDS
@@ -476,20 +477,20 @@ class EsphomeCore:
         # True if command is run from vscode api
         self.vscode = False
         # The name of the node
-        self.name: Optional[str] = None
+        self.name: str | None = None
         # The friendly name of the node
-        self.friendly_name: Optional[str] = None
+        self.friendly_name: str | None = None
         # The area / zone of the node
-        self.area: Optional[str] = None
+        self.area: str | None = None
         # Additional data components can store temporary data in
         # The first key to this dict should always be the integration name
         self.data = {}
         # The relative path to the configuration YAML
-        self.config_path: Optional[str] = None
+        self.config_path: str | None = None
         # The relative path to where all build files are stored
-        self.build_path: Optional[str] = None
+        self.build_path: str | None = None
         # The validated configuration, this is None until the config has been validated
-        self.config: Optional[ConfigType] = None
+        self.config: ConfigType | None = None
         # The pending tasks in the task queue (mostly for C++ generation)
         # This is a priority queue (with heapq)
         # Each item is a tuple of form: (-priority, unique number, task)
@@ -509,11 +510,16 @@ class EsphomeCore:
         # A set of defines to set for the compile process in esphome/core/defines.h
         self.defines: set[Define] = set()
         # A map of all platformio options to apply
-        self.platformio_options: dict[str, Union[str, list[str]]] = {}
+        self.platformio_options: dict[str, str | list[str]] = {}
         # A set of strings of names of loaded integrations, used to find namespace ID conflicts
         self.loaded_integrations = set()
+        # A set of strings for platform/integration combos
+        self.loaded_platforms: set[str] = set()
         # A set of component IDs to track what Component subclasses are declared
         self.component_ids = set()
+        # Dict to track platform entity counts for pre-allocation
+        # Key: platform name (e.g. "sensor", "binary_sensor"), Value: count
+        self.platform_counts: defaultdict[str, int] = defaultdict(int)
         # Whether ESPHome was started in verbose mode
         self.verbose = False
         # Whether ESPHome was started in quiet mode
@@ -543,10 +549,11 @@ class EsphomeCore:
         self.platformio_options = {}
         self.loaded_integrations = set()
         self.component_ids = set()
+        self.platform_counts = defaultdict(int)
         PIN_SCHEMA_REGISTRY.reset()
 
     @property
-    def address(self) -> Optional[str]:
+    def address(self) -> str | None:
         if self.config is None:
             raise ValueError("Config has not been loaded yet")
 
@@ -559,7 +566,7 @@ class EsphomeCore:
         return None
 
     @property
-    def web_port(self) -> Optional[int]:
+    def web_port(self) -> int | None:
         if self.config is None:
             raise ValueError("Config has not been loaded yet")
 
@@ -572,7 +579,7 @@ class EsphomeCore:
         return None
 
     @property
-    def comment(self) -> Optional[str]:
+    def comment(self) -> str | None:
         if self.config is None:
             raise ValueError("Config has not been loaded yet")
 
@@ -667,16 +674,17 @@ class EsphomeCore:
     def using_esp_idf(self):
         return self.target_framework == "esp-idf"
 
-    def add_job(self, func, *args, **kwargs):
+    def add_job(self, func, *args, **kwargs) -> None:
         self.event_loop.add_job(func, *args, **kwargs)
 
-    def flush_tasks(self):
+    def flush_tasks(self) -> None:
         try:
             self.event_loop.flush_tasks()
         except RuntimeError as e:
             raise EsphomeError(str(e)) from e
 
-    def add(self, expression):
+    def add(self, expression, prepend=False) -> "Statement":
+        """Add an expression or statement to the main setup() block."""
         from esphome.cpp_generator import Expression, Statement, statement
 
         if isinstance(expression, Expression):
@@ -686,11 +694,14 @@ class EsphomeCore:
                 f"Add '{expression}' must be expression or statement, not {type(expression)}"
             )
 
-        self.main_statements.append(expression)
+        if prepend:
+            self.main_statements.insert(0, expression)
+        else:
+            self.main_statements.append(expression)
         _LOGGER.debug("Adding: %s", expression)
         return expression
 
-    def add_global(self, expression, prepend=False):
+    def add_global(self, expression, prepend=False) -> "Statement":
         from esphome.cpp_generator import Expression, Statement, statement
 
         if isinstance(expression, Expression):
@@ -773,7 +784,7 @@ class EsphomeCore:
         _LOGGER.debug("Adding define: %s", define)
         return define
 
-    def add_platformio_option(self, key: str, value: Union[str, list[str]]) -> None:
+    def add_platformio_option(self, key: str, value: str | list[str]) -> None:
         new_val = value
         old_val = self.platformio_options.get(key)
         if isinstance(old_val, list):
@@ -820,6 +831,14 @@ class EsphomeCore:
     def has_id(self, id):
         return id in self.variables
 
+    def register_platform_component(self, platform_name: str, var) -> None:
+        """Register a component for a platform and track its count.
+
+        :param platform_name: The name of the platform (e.g., 'sensor', 'binary_sensor')
+        :param var: The variable (component) being registered (currently unused but kept for future use)
+        """
+        self.platform_counts[platform_name] += 1
+
     @property
     def cpp_main_section(self):
         from esphome.cpp_generator import statement

esphome/core/application.cpp

@@ -2,11 +2,30 @@
 #include "esphome/core/log.h"
 #include "esphome/core/version.h"
 #include "esphome/core/hal.h"
+#include <algorithm>
 
 #ifdef USE_STATUS_LED
 #include "esphome/components/status_led/status_led.h"
 #endif
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+#include <cerrno>
+
+#ifdef USE_SOCKET_IMPL_LWIP_SOCKETS
+// LWIP sockets implementation
+#include <lwip/sockets.h>
+#elif defined(USE_SOCKET_IMPL_BSD_SOCKETS)
+// BSD sockets implementation
+#ifdef USE_ESP32
+// ESP32 "BSD sockets" are actually LWIP under the hood
+#include <lwip/sockets.h>
+#else
+// True BSD sockets (e.g., host platform)
+#include <sys/select.h>
+#endif
+#endif
+#endif
+
 namespace esphome {
 
 static const char *const TAG = "app";
@@ -26,8 +45,8 @@ void Application::register_component_(Component *comp) {
   this->components_.push_back(comp);
 }
 void Application::setup() {
-  ESP_LOGI(TAG, "Running through setup()...");
-  ESP_LOGV(TAG, "Sorting components by setup priority...");
+  ESP_LOGI(TAG, "Running through setup()");
+  ESP_LOGV(TAG, "Sorting components by setup priority");
   std::stable_sort(this->components_.begin(), this->components_.end(), [](const Component *a, const Component *b) {
     return a->get_actual_setup_priority() > b->get_actual_setup_priority();
   });
@@ -47,7 +66,7 @@ void Application::setup() {
                      [](Component *a, Component *b) { return a->get_loop_priority() > b->get_loop_priority(); });
 
     do {
-      uint32_t new_app_state = STATUS_LED_WARNING;
+      uint8_t new_app_state = STATUS_LED_WARNING;
       this->scheduler.call();
       this->feed_wdt();
       for (uint32_t j = 0; j <= i; j++) {
@@ -68,7 +87,7 @@ void Application::setup() {
   this->calculate_looping_components_();
 }
 void Application::loop() {
-  uint32_t new_app_state = 0;
+  uint8_t new_app_state = 0;
 
   this->scheduler.call();
 
@@ -98,7 +117,9 @@ void Application::loop() {
   // Use the last component's end time instead of calling millis() again
   auto elapsed = last_op_end_time - this->last_loop_;
   if (elapsed >= this->loop_interval_ || HighFrequencyLoopRequester::is_high_frequency()) {
-    yield();
+    // Even if we overran the loop interval, we still need to select()
+    // to know if any sockets have data ready
+    this->yield_with_select_(0);
   } else {
     uint32_t delay_time = this->loop_interval_ - elapsed;
     uint32_t next_schedule = this->scheduler.next_schedule_in().value_or(delay_time);
@@ -106,7 +127,8 @@ void Application::loop() {
     // otherwise interval=0 schedules result in constant looping with almost no sleep
     next_schedule = std::max(next_schedule, delay_time / 2);
     delay_time = std::min(next_schedule, delay_time);
-    delay(delay_time);
+
+    this->yield_with_select_(delay_time);
   }
   this->last_loop_ = last_op_end_time;
 
@@ -139,15 +161,17 @@ void IRAM_ATTR HOT Application::feed_wdt(uint32_t time) {
   }
 }
 void Application::reboot() {
-  ESP_LOGI(TAG, "Forcing a reboot...");
+  ESP_LOGI(TAG, "Forcing a reboot");
   for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
     (*it)->on_shutdown();
   }
   arch_restart();
 }
 void Application::safe_reboot() {
-  ESP_LOGI(TAG, "Rebooting safely...");
+  ESP_LOGI(TAG, "Rebooting safely");
   run_safe_shutdown_hooks();
+  teardown_components(TEARDOWN_TIMEOUT_REBOOT_MS);
+  run_powerdown_hooks();
   arch_restart();
 }
 
@@ -160,6 +184,56 @@ void Application::run_safe_shutdown_hooks() {
   }
 }
 
+void Application::run_powerdown_hooks() {
+  for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
+    (*it)->on_powerdown();
+  }
+}
+
+void Application::teardown_components(uint32_t timeout_ms) {
+  uint32_t start_time = millis();
+
+  // Copy all components in reverse order using reverse iterators
+  // Reverse order matches the behavior of run_safe_shutdown_hooks() above and ensures
+  // components are torn down in the opposite order of their setup_priority (which is
+  // used to sort components during Application::setup())
+  std::vector<Component *> pending_components(this->components_.rbegin(), this->components_.rend());
+
+  uint32_t now = start_time;
+  while (!pending_components.empty() && (now - start_time) < timeout_ms) {
+    // Feed watchdog during teardown to prevent triggering
+    this->feed_wdt(now);
+
+    // Use iterator to safely erase elements
+    for (auto it = pending_components.begin(); it != pending_components.end();) {
+      if ((*it)->teardown()) {
+        // Component finished teardown, erase it
+        it = pending_components.erase(it);
+      } else {
+        // Component still needs time
+        ++it;
+      }
+    }
+
+    // Give some time for I/O operations if components are still pending
+    if (!pending_components.empty()) {
+      this->yield_with_select_(1);
+    }
+
+    // Update time for next iteration
+    now = millis();
+  }
+
+  if (!pending_components.empty()) {
+    // Note: At this point, connections are either disconnected or in a bad state,
+    // so this warning will only appear via serial rather than being transmitted to clients
+    for (auto *component : pending_components) {
+      ESP_LOGW(TAG, "%s did not complete teardown within %" PRIu32 " ms", component->get_component_source(),
+               timeout_ms);
+    }
+  }
+}
+
 void Application::calculate_looping_components_() {
   for (auto *obj : this->components_) {
     if (obj->has_overridden_loop())
@@ -167,6 +241,121 @@ void Application::calculate_looping_components_() {
   }
 }
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+bool Application::register_socket_fd(int fd) {
+  // WARNING: This function is NOT thread-safe and must only be called from the main loop
+  // It modifies socket_fds_ and related variables without locking
+  if (fd < 0)
+    return false;
+
+  if (fd >= FD_SETSIZE) {
+    ESP_LOGE(TAG, "Cannot monitor socket fd %d: exceeds FD_SETSIZE (%d)", fd, FD_SETSIZE);
+    ESP_LOGE(TAG, "Socket will not be monitored for data - may cause performance issues!");
+    return false;
+  }
+
+  this->socket_fds_.push_back(fd);
+  this->socket_fds_changed_ = true;
+
+  if (fd > this->max_fd_) {
+    this->max_fd_ = fd;
+  }
+
+  return true;
+}
+
+void Application::unregister_socket_fd(int fd) {
+  // WARNING: This function is NOT thread-safe and must only be called from the main loop
+  // It modifies socket_fds_ and related variables without locking
+  if (fd < 0)
+    return;
+
+  auto it = std::find(this->socket_fds_.begin(), this->socket_fds_.end(), fd);
+  if (it != this->socket_fds_.end()) {
+    // Swap with last element and pop - O(1) removal since order doesn't matter
+    if (it != this->socket_fds_.end() - 1) {
+      std::swap(*it, this->socket_fds_.back());
+    }
+    this->socket_fds_.pop_back();
+    this->socket_fds_changed_ = true;
+
+    // Only recalculate max_fd if we removed the current max
+    if (fd == this->max_fd_) {
+      if (this->socket_fds_.empty()) {
+        this->max_fd_ = -1;
+      } else {
+        // Find new max using std::max_element
+        this->max_fd_ = *std::max_element(this->socket_fds_.begin(), this->socket_fds_.end());
+      }
+    }
+  }
+}
+
+bool Application::is_socket_ready(int fd) const {
+  // This function is thread-safe for reading the result of select()
+  // However, it should only be called after select() has been executed in the main loop
+  // The read_fds_ is only modified by select() in the main loop
+  if (fd < 0 || fd >= FD_SETSIZE)
+    return false;
+
+  return FD_ISSET(fd, &this->read_fds_);
+}
+#endif
+
+void Application::yield_with_select_(uint32_t delay_ms) {
+  // Delay while monitoring sockets. When delay_ms is 0, always yield() to ensure other tasks run
+  // since select() with 0 timeout only polls without yielding.
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  if (!this->socket_fds_.empty()) {
+    // Update fd_set if socket list has changed
+    if (this->socket_fds_changed_) {
+      FD_ZERO(&this->base_read_fds_);
+      for (int fd : this->socket_fds_) {
+        if (fd >= 0 && fd < FD_SETSIZE) {
+          FD_SET(fd, &this->base_read_fds_);
+        }
+      }
+      this->socket_fds_changed_ = false;
+    }
+
+    // Copy base fd_set before each select
+    this->read_fds_ = this->base_read_fds_;
+
+    // Convert delay_ms to timeval
+    struct timeval tv;
+    tv.tv_sec = delay_ms / 1000;
+    tv.tv_usec = (delay_ms - tv.tv_sec * 1000) * 1000;
+
+    // Call select with timeout
+#if defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || (defined(USE_ESP32) && defined(USE_SOCKET_IMPL_BSD_SOCKETS))
+    int ret = lwip_select(this->max_fd_ + 1, &this->read_fds_, nullptr, nullptr, &tv);
+#else
+    int ret = ::select(this->max_fd_ + 1, &this->read_fds_, nullptr, nullptr, &tv);
+#endif
+
+    // Process select() result:
+    // ret < 0: error (except EINTR which is normal)
+    // ret > 0: socket(s) have data ready - normal and expected
+    // ret == 0: timeout occurred - normal and expected
+    if (ret < 0 && errno != EINTR) {
+      // Actual error - log and fall back to delay
+      ESP_LOGW(TAG, "select() failed with errno %d", errno);
+      delay(delay_ms);
+    }
+    // When delay_ms is 0, we need to yield since select(0) doesn't yield
+    if (delay_ms == 0) {
+      yield();
+    }
+  } else {
+    // No sockets registered, use regular delay
+    delay(delay_ms);
+  }
+#else
+  // No select support, use regular delay
+  delay(delay_ms);
+#endif
+}
+
 Application App;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace esphome

esphome/core/application.h

@@ -9,6 +9,10 @@
 #include "esphome/core/preferences.h"
 #include "esphome/core/scheduler.h"
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+#include <sys/select.h>
+#endif
+
 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
@@ -75,10 +79,16 @@
 
 namespace esphome {
 
+// Teardown timeout constant (in milliseconds)
+// For reboots, it's more important to shut down quickly than disconnect cleanly
+// since we're not entering deep sleep. The only consequence of not shutting down
+// cleanly is a warning in the log.
+static const uint32_t TEARDOWN_TIMEOUT_REBOOT_MS = 1000;  // 1 second for quick reboot
+
 class Application {
  public:
-  void pre_setup(const std::string &name, const std::string &friendly_name, const std::string &area,
-                 const char *comment, const char *compilation_time, bool name_add_mac_suffix) {
+  void pre_setup(const std::string &name, const std::string &friendly_name, const char *area, const char *comment,
+                 const char *compilation_time, bool name_add_mac_suffix) {
     arch_init();
     this->name_add_mac_suffix_ = name_add_mac_suffix;
     if (name_add_mac_suffix) {
@@ -188,6 +198,73 @@ class Application {
   void register_update(update::UpdateEntity *update) { this->updates_.push_back(update); }
 #endif
 
+  /// Reserve space for components to avoid memory fragmentation
+  void reserve_components(size_t count) { this->components_.reserve(count); }
+
+#ifdef USE_BINARY_SENSOR
+  void reserve_binary_sensor(size_t count) { this->binary_sensors_.reserve(count); }
+#endif
+#ifdef USE_SWITCH
+  void reserve_switch(size_t count) { this->switches_.reserve(count); }
+#endif
+#ifdef USE_BUTTON
+  void reserve_button(size_t count) { this->buttons_.reserve(count); }
+#endif
+#ifdef USE_SENSOR
+  void reserve_sensor(size_t count) { this->sensors_.reserve(count); }
+#endif
+#ifdef USE_TEXT_SENSOR
+  void reserve_text_sensor(size_t count) { this->text_sensors_.reserve(count); }
+#endif
+#ifdef USE_FAN
+  void reserve_fan(size_t count) { this->fans_.reserve(count); }
+#endif
+#ifdef USE_COVER
+  void reserve_cover(size_t count) { this->covers_.reserve(count); }
+#endif
+#ifdef USE_CLIMATE
+  void reserve_climate(size_t count) { this->climates_.reserve(count); }
+#endif
+#ifdef USE_LIGHT
+  void reserve_light(size_t count) { this->lights_.reserve(count); }
+#endif
+#ifdef USE_NUMBER
+  void reserve_number(size_t count) { this->numbers_.reserve(count); }
+#endif
+#ifdef USE_DATETIME_DATE
+  void reserve_date(size_t count) { this->dates_.reserve(count); }
+#endif
+#ifdef USE_DATETIME_TIME
+  void reserve_time(size_t count) { this->times_.reserve(count); }
+#endif
+#ifdef USE_DATETIME_DATETIME
+  void reserve_datetime(size_t count) { this->datetimes_.reserve(count); }
+#endif
+#ifdef USE_SELECT
+  void reserve_select(size_t count) { this->selects_.reserve(count); }
+#endif
+#ifdef USE_TEXT
+  void reserve_text(size_t count) { this->texts_.reserve(count); }
+#endif
+#ifdef USE_LOCK
+  void reserve_lock(size_t count) { this->locks_.reserve(count); }
+#endif
+#ifdef USE_VALVE
+  void reserve_valve(size_t count) { this->valves_.reserve(count); }
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void reserve_media_player(size_t count) { this->media_players_.reserve(count); }
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+  void reserve_alarm_control_panel(size_t count) { this->alarm_control_panels_.reserve(count); }
+#endif
+#ifdef USE_EVENT
+  void reserve_event(size_t count) { this->events_.reserve(count); }
+#endif
+#ifdef USE_UPDATE
+  void reserve_update(size_t count) { this->updates_.reserve(count); }
+#endif
+
   /// Register the component in this Application instance.
   template<class C> C *register_component(C *c) {
     static_assert(std::is_base_of<Component, C>::value, "Only Component subclasses can be registered");
@@ -208,7 +285,7 @@ class Application {
   const std::string &get_friendly_name() const { return this->friendly_name_; }
 
   /// Get the area of this Application set by pre_setup().
-  const std::string &get_area() const { return this->area_; }
+  std::string get_area() const { return this->area_ == nullptr ? "" : this->area_; }
 
   /// Get the comment of this Application set by pre_setup().
   std::string get_comment() const { return this->comment_; }
@@ -247,7 +324,15 @@ class Application {
 
   void run_safe_shutdown_hooks();
 
-  uint32_t get_app_state() const { return this->app_state_; }
+  void run_powerdown_hooks();
+
+  /** Teardown all components with a timeout.
+   *
+   * @param timeout_ms Maximum time to wait for teardown in milliseconds
+   */
+  void teardown_components(uint32_t timeout_ms);
+
+  uint8_t get_app_state() const { return this->app_state_; }
 
 #ifdef USE_BINARY_SENSOR
   const std::vector<binary_sensor::BinarySensor *> &get_binary_sensors() { return this->binary_sensors_; }
@@ -467,6 +552,19 @@ class Application {
 
   Scheduler scheduler;
 
+  /// Register/unregister a socket file descriptor to be monitored for read events.
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  /// These functions update the fd_set used by select() in the main loop.
+  /// WARNING: These functions are NOT thread-safe. They must only be called from the main loop.
+  /// NOTE: File descriptors >= FD_SETSIZE (typically 10 on ESP) will be rejected with an error.
+  /// @return true if registration was successful, false if fd exceeds limits
+  bool register_socket_fd(int fd);
+  void unregister_socket_fd(int fd);
+  /// Check if there's data available on a socket without blocking
+  /// This function is thread-safe for reading, but should be called after select() has run
+  bool is_socket_ready(int fd) const;
+#endif
+
  protected:
   friend Component;
 
@@ -476,6 +574,9 @@ class Application {
 
   void feed_wdt_arch_();
 
+  /// Perform a delay while also monitoring socket file descriptors for readiness
+  void yield_with_select_(uint32_t delay_ms);
+
   std::vector<Component *> components_{};
   std::vector<Component *> looping_components_{};
 
@@ -545,16 +646,25 @@ class Application {
 
   std::string name_;
   std::string friendly_name_;
-  std::string area_;
+  const char *area_{nullptr};
   const char *comment_{nullptr};
   const char *compilation_time_{nullptr};
   bool name_add_mac_suffix_;
   uint32_t last_loop_{0};
   uint32_t loop_interval_{16};
   size_t dump_config_at_{SIZE_MAX};
-  uint32_t app_state_{0};
+  uint8_t app_state_{0};
   Component *current_component_{nullptr};
   uint32_t loop_component_start_time_{0};
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  // Socket select management
+  std::vector<int> socket_fds_;     // Vector of all monitored socket file descriptors
+  bool socket_fds_changed_{false};  // Flag to rebuild base_read_fds_ when socket_fds_ changes
+  int max_fd_{-1};                  // Highest file descriptor number for select()
+  fd_set base_read_fds_{};          // Cached fd_set rebuilt only when socket_fds_ changes
+  fd_set read_fds_{};               // Working fd_set for select(), copied from base_read_fds_
+#endif
 };
 
 /// Global storage of Application pointer - only one Application can exist.