Merge branch 'webserver_flash' into integration

preen

docker/build.py

@@ -90,7 +90,7 @@ def main():
     def run_command(*cmd, ignore_error: bool = False):
         print(f"$ {shlex.join(list(cmd))}")
         if not args.dry_run:
-            rc = subprocess.call(list(cmd))
+            rc = subprocess.call(list(cmd), close_fds=False)
             if rc != 0 and not ignore_error:
                 print("Command failed")
                 sys.exit(1)

esphome/__main__.py

@@ -524,6 +524,13 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
+    # Set memory analysis options in config
+    if args.analyze_memory:
+        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
+
+    if args.memory_report:
+        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
+
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -934,6 +941,17 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
+    parser_compile.add_argument(
+        "--analyze-memory",
+        help="Analyze and display memory usage by component after compilation.",
+        action="store_true",
+    )
+    parser_compile.add_argument(
+        "--memory-report",
+        help="Save memory analysis report to a file (supports .json or .txt).",
+        type=str,
+        metavar="FILE",
+    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/components/api/__init__.py

@@ -122,6 +122,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_CUSTOM_SERVICES, default=False): cv.boolean,
             cv.Optional(CONF_HOMEASSISTANT_SERVICES, default=False): cv.boolean,
             cv.Optional(CONF_HOMEASSISTANT_STATES, default=False): cv.boolean,
+            cv.Optional(CONF_HOMEASSISTANT_SERVICES, default=False): cv.boolean,
+            cv.Optional(CONF_HOMEASSISTANT_STATES, default=False): cv.boolean,
             cv.Optional(CONF_ON_CLIENT_CONNECTED): automation.validate_automation(
                 single=True
             ),

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -370,7 +370,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->conn_id_ != param->search_res.conn_id)
         return false;
       this->service_count_++;
-      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
+      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE ||
+          this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // V3 clients don't need services initialized since
         // as they use the ESP APIs to get services.
         break;

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -101,38 +101,6 @@ void ESP32BLETracker::loop() {
       this->start_scan();
     }
   }
-
-  // Check for scan timeout - moved here from scheduler to avoid false reboots
-  // when the loop is blocked
-  if (this->scanner_state_ == ScannerState::RUNNING) {
-    switch (this->scan_timeout_state_) {
-      case ScanTimeoutState::MONITORING: {
-        uint32_t now = App.get_loop_component_start_time();
-        uint32_t timeout_ms = this->scan_duration_ * 2000;
-        // Robust time comparison that handles rollover correctly
-        // This works because unsigned arithmetic wraps around predictably
-        if ((now - this->scan_start_time_) > timeout_ms) {
-          // First time we've seen the timeout exceeded - wait one more loop iteration
-          // This ensures all components have had a chance to process pending events
-          // This is because esp32_ble may not have run yet and called
-          // gap_scan_event_handler yet when the loop unblocks
-          ESP_LOGW(TAG, "Scan timeout exceeded");
-          this->scan_timeout_state_ = ScanTimeoutState::EXCEEDED_WAIT;
-        }
-        break;
-      }
-      case ScanTimeoutState::EXCEEDED_WAIT:
-        // We've waited at least one full loop iteration, and scan is still running
-        ESP_LOGE(TAG, "Scan never terminated, rebooting");
-        App.reboot();
-        break;
-
-      case ScanTimeoutState::INACTIVE:
-        // This case should be unreachable - scanner and timeout states are always synchronized
-        break;
-    }
-  }
-
   ClientStateCounts counts = this->count_client_states_();
   if (counts != this->client_state_counts_) {
     this->client_state_counts_ = counts;
@@ -196,8 +164,7 @@ void ESP32BLETracker::stop_scan_() {
     ESP_LOGE(TAG, "Cannot stop scan: %s", this->scanner_state_to_string_(this->scanner_state_));
     return;
   }
-  // Reset timeout state machine when stopping scan
-  this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
+  this->cancel_timeout("scan");
   this->set_scanner_state_(ScannerState::STOPPING);
   esp_err_t err = esp_ble_gap_stop_scanning();
   if (err != ESP_OK) {
@@ -230,10 +197,11 @@ void ESP32BLETracker::start_scan_(bool first) {
   this->scan_params_.scan_interval = this->scan_interval_;
   this->scan_params_.scan_window = this->scan_window_;
 
-  // Start timeout monitoring in loop() instead of using scheduler
-  // This prevents false reboots when the loop is blocked
-  this->scan_start_time_ = App.get_loop_component_start_time();
-  this->scan_timeout_state_ = ScanTimeoutState::MONITORING;
+  // Start timeout before scan is started. Otherwise scan never starts if any error.
+  this->set_timeout("scan", this->scan_duration_ * 2000, []() {
+    ESP_LOGE(TAG, "Scan never terminated, rebooting to restore stack (IDF)");
+    App.reboot();
+  });
 
   esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
   if (err != ESP_OK) {
@@ -784,8 +752,7 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
 #ifdef USE_ESP32_BLE_DEVICE
   this->already_discovered_.clear();
 #endif
-  // Reset timeout state machine instead of cancelling scheduler timeout
-  this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
+  this->cancel_timeout("scan");
 
   for (auto *listener : this->listeners_)
     listener->on_scan_end();

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -367,14 +367,6 @@ class ESP32BLETracker : public Component,
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
   bool coex_prefer_ble_{false};
 #endif
-  // Scan timeout state machine
-  enum class ScanTimeoutState : uint8_t {
-    INACTIVE,       // No timeout monitoring
-    MONITORING,     // Actively monitoring for timeout
-    EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
-  };
-  uint32_t scan_start_time_{0};
-  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };
 
 // NOLINTNEXTLINE

esphome/components/esphome/ota/ota_esphome.cpp

@@ -20,6 +20,7 @@ namespace esphome {
 
 static const char *const TAG = "esphome.ota";
 static constexpr u_int16_t OTA_BLOCK_SIZE = 8192;
+static constexpr uint16_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 1000;  // milliseconds for initial handshake
 
 void ESPHomeOTAComponent::setup() {
 #ifdef USE_OTA_STATE_CALLBACK
@@ -28,19 +29,19 @@ void ESPHomeOTAComponent::setup() {
 
   this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
   if (this->server_ == nullptr) {
-    ESP_LOGW(TAG, "Could not create socket");
+    this->log_socket_error_("creation");
     this->mark_failed();
     return;
   }
   int enable = 1;
   int err = this->server_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
   if (err != 0) {
-    ESP_LOGW(TAG, "Socket unable to set reuseaddr: errno %d", err);
+    this->log_socket_error_("reuseaddr");
     // we can still continue
   }
   err = this->server_->setblocking(false);
   if (err != 0) {
-    ESP_LOGW(TAG, "Socket unable to set nonblocking mode: errno %d", err);
+    this->log_socket_error_("non-blocking");
     this->mark_failed();
     return;
   }
@@ -49,21 +50,21 @@ void ESPHomeOTAComponent::setup() {
 
   socklen_t sl = socket::set_sockaddr_any((struct sockaddr *) &server, sizeof(server), this->port_);
   if (sl == 0) {
-    ESP_LOGW(TAG, "Socket unable to set sockaddr: errno %d", errno);
+    this->log_socket_error_("set sockaddr");
     this->mark_failed();
     return;
   }
 
   err = this->server_->bind((struct sockaddr *) &server, sizeof(server));
   if (err != 0) {
-    ESP_LOGW(TAG, "Socket unable to bind: errno %d", errno);
+    this->log_socket_error_("bind");
     this->mark_failed();
     return;
   }
 
   err = this->server_->listen(4);
   if (err != 0) {
-    ESP_LOGW(TAG, "Socket unable to listen: errno %d", errno);
+    this->log_socket_error_("listen");
     this->mark_failed();
     return;
   }
@@ -120,26 +121,26 @@ void ESPHomeOTAComponent::handle_() {
   int enable = 1;
   int err = this->client_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(int));
   if (err != 0) {
-    ESP_LOGW(TAG, "Socket could not enable TCP nodelay, errno %d", errno);
-    this->client_->close();
-    this->client_ = nullptr;
+    this->log_socket_error_("nodelay");
+    this->cleanup_connection_();
+    return;
+  }
+  err = this->client_->setblocking(false);
+  if (err != 0) {
+    this->log_socket_error_("non-blocking");
+    this->cleanup_connection_();
     return;
   }
 
-  ESP_LOGD(TAG, "Starting update from %s", this->client_->getpeername().c_str());
-  this->status_set_warning();
-#ifdef USE_OTA_STATE_CALLBACK
-  this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
-#endif
+  this->log_start_("handshake");
 
-  if (!this->readall_(buf, 5)) {
-    ESP_LOGW(TAG, "Reading magic bytes failed");
+  if (!this->readall_(buf, 5, OTA_SOCKET_TIMEOUT_HANDSHAKE)) {
+    ESP_LOGW(TAG, "Read magic bytes failed");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   // 0x6C, 0x26, 0xF7, 0x5C, 0x45
   if (buf[0] != 0x6C || buf[1] != 0x26 || buf[2] != 0xF7 || buf[3] != 0x5C || buf[4] != 0x45) {
-    ESP_LOGW(TAG, "Magic bytes do not match! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", buf[0], buf[1], buf[2], buf[3],
-             buf[4]);
+    ESP_LOGW(TAG, "Magic bytes mismatch! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", buf[0], buf[1], buf[2], buf[3], buf[4]);
     error_code = ota::OTA_RESPONSE_ERROR_MAGIC;
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
@@ -153,7 +154,7 @@ void ESPHomeOTAComponent::handle_() {
 
   // Read features - 1 byte
   if (!this->readall_(buf, 1)) {
-    ESP_LOGW(TAG, "Reading features failed");
+    ESP_LOGW(TAG, "Read features failed");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_features = buf[0];  // NOLINT
@@ -232,7 +233,7 @@ void ESPHomeOTAComponent::handle_() {
 
   // Read size, 4 bytes MSB first
   if (!this->readall_(buf, 4)) {
-    ESP_LOGW(TAG, "Reading size failed");
+    ESP_LOGW(TAG, "Read size failed");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_size = 0;
@@ -242,6 +243,17 @@ void ESPHomeOTAComponent::handle_() {
   }
   ESP_LOGV(TAG, "Size is %u bytes", ota_size);
 
+  // Now that we've passed authentication and are actually
+  // starting the update, set the warning status and notify
+  // listeners. This ensures that port scanners do not
+  // accidentally trigger the update process.
+  this->log_start_("update");
+  this->status_set_warning();
+#ifdef USE_OTA_STATE_CALLBACK
+  this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
+#endif
+
+  // This will block for a few seconds as it locks flash
   error_code = backend->begin(ota_size);
   if (error_code != ota::OTA_RESPONSE_OK)
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
@@ -253,7 +265,7 @@ void ESPHomeOTAComponent::handle_() {
 
   // Read binary MD5, 32 bytes
   if (!this->readall_(buf, 32)) {
-    ESP_LOGW(TAG, "Reading binary MD5 checksum failed");
+    ESP_LOGW(TAG, "Read MD5 checksum failed");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   sbuf[32] = '\0';
@@ -274,19 +286,19 @@ void ESPHomeOTAComponent::handle_() {
         delay(1);
         continue;
       }
-      ESP_LOGW(TAG, "Error receiving data for update, errno %d", errno);
+      ESP_LOGW(TAG, "Read error, errno %d", errno);
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     } else if (read == 0) {
       // $ man recv
       // "When  a  stream socket peer has performed an orderly shutdown, the return value will
       // be 0 (the traditional "end-of-file" return)."
-      ESP_LOGW(TAG, "Remote end closed connection");
+      ESP_LOGW(TAG, "Remote closed connection");
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
     error_code = backend->write(buf, read);
     if (error_code != ota::OTA_RESPONSE_OK) {
-      ESP_LOGW(TAG, "Error writing binary data to flash!, error_code: %d", error_code);
+      ESP_LOGW(TAG, "Flash write error, code: %d", error_code);
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
     total += read;
@@ -318,7 +330,7 @@ void ESPHomeOTAComponent::handle_() {
 
   error_code = backend->end();
   if (error_code != ota::OTA_RESPONSE_OK) {
-    ESP_LOGW(TAG, "Error ending update! error_code: %d", error_code);
+    ESP_LOGW(TAG, "Error ending update! code: %d", error_code);
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
 
@@ -328,12 +340,11 @@ void ESPHomeOTAComponent::handle_() {
 
   // Read ACK
   if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
-    ESP_LOGW(TAG, "Reading back acknowledgement failed");
+    ESP_LOGW(TAG, "Read ack failed");
     // do not go to error, this is not fatal
   }
 
-  this->client_->close();
-  this->client_ = nullptr;
+  this->cleanup_connection_();
   delay(10);
   ESP_LOGI(TAG, "Update complete");
   this->status_clear_warning();
@@ -346,8 +357,7 @@ void ESPHomeOTAComponent::handle_() {
 error:
   buf[0] = static_cast<uint8_t>(error_code);
   this->writeall_(buf, 1);
-  this->client_->close();
-  this->client_ = nullptr;
+  this->cleanup_connection_();
 
   if (backend != nullptr && update_started) {
     backend->abort();
@@ -359,13 +369,13 @@ error:
 #endif
 }
 
-bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
+bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len, uint16_t timeout) {
   uint32_t start = millis();
   uint32_t at = 0;
   while (len - at > 0) {
     uint32_t now = millis();
-    if (now - start > 1000) {
-      ESP_LOGW(TAG, "Timed out reading %d bytes of data", len);
+    if (now - start > timeout) {
+      ESP_LOGW(TAG, "Timeout reading %d bytes", len);
       return false;
     }
 
@@ -376,7 +386,7 @@ bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
         delay(1);
         continue;
       }
-      ESP_LOGW(TAG, "Failed to read %d bytes of data, errno %d", len, errno);
+      ESP_LOGW(TAG, "Error reading %d bytes, errno %d", len, errno);
       return false;
     } else if (read == 0) {
       ESP_LOGW(TAG, "Remote closed connection");
@@ -390,13 +400,13 @@ bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
 
   return true;
 }
-bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len) {
+bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len, uint16_t timeout) {
   uint32_t start = millis();
   uint32_t at = 0;
   while (len - at > 0) {
     uint32_t now = millis();
-    if (now - start > 1000) {
-      ESP_LOGW(TAG, "Timed out writing %d bytes of data", len);
+    if (now - start > timeout) {
+      ESP_LOGW(TAG, "Timeout writing %d bytes", len);
       return false;
     }
 
@@ -407,7 +417,7 @@ bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len) {
         delay(1);
         continue;
       }
-      ESP_LOGW(TAG, "Failed to write %d bytes of data, errno %d", len, errno);
+      ESP_LOGW(TAG, "Error writing %d bytes, errno %d", len, errno);
       return false;
     } else {
       at += written;
@@ -421,5 +431,17 @@ bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len) {
 float ESPHomeOTAComponent::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 uint16_t ESPHomeOTAComponent::get_port() const { return this->port_; }
 void ESPHomeOTAComponent::set_port(uint16_t port) { this->port_ = port; }
+
+void ESPHomeOTAComponent::log_socket_error_(const char *msg) { ESP_LOGW(TAG, "Socket %s: errno %d", msg, errno); }
+
+void ESPHomeOTAComponent::log_start_(const char *phase) {
+  ESP_LOGD(TAG, "Starting %s from %s", phase, this->client_->getpeername().c_str());
+}
+
+void ESPHomeOTAComponent::cleanup_connection_() {
+  this->client_->close();
+  this->client_ = nullptr;
+}
+
 }  // namespace esphome
 #endif

esphome/components/esphome/ota/ota_esphome.h

@@ -9,6 +9,8 @@
 
 namespace esphome {
 
+static constexpr uint16_t OTA_SOCKET_TIMEOUT_DATA = 2500;  // milliseconds for data transfer
+
 /// ESPHomeOTAComponent provides a simple way to integrate Over-the-Air updates into your app using ArduinoOTA.
 class ESPHomeOTAComponent : public ota::OTAComponent {
  public:
@@ -28,8 +30,11 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
 
  protected:
   void handle_();
-  bool readall_(uint8_t *buf, size_t len);
-  bool writeall_(const uint8_t *buf, size_t len);
+  bool readall_(uint8_t *buf, size_t len, uint16_t timeout = OTA_SOCKET_TIMEOUT_DATA);
+  bool writeall_(const uint8_t *buf, size_t len, uint16_t timeout = OTA_SOCKET_TIMEOUT_DATA);
+  void log_socket_error_(const char *msg);
+  void log_start_(const char *phase);
+  void cleanup_connection_();
 
 #ifdef USE_OTA_PASSWORD
   std::string password_;

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -159,7 +159,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/sdl/display.py

@@ -36,7 +36,9 @@ def get_sdl_options(value):
     if value != "":
         return value
     try:
-        return subprocess.check_output(["sdl2-config", "--cflags", "--libs"]).decode()
+        return subprocess.check_output(
+            ["sdl2-config", "--cflags", "--libs"], close_fds=False
+        ).decode()
     except Exception as e:
         raise cv.Invalid("Unable to run sdl2-config - have you installed sdl2?") from e
 

esphome/components/switch/__init__.py

@@ -10,7 +10,6 @@ from esphome.const import (
     CONF_ID,
     CONF_INVERTED,
     CONF_MQTT_ID,
-    CONF_ON_STATE,
     CONF_ON_TURN_OFF,
     CONF_ON_TURN_ON,
     CONF_RESTORE_MODE,
@@ -57,9 +56,6 @@ TurnOnAction = switch_ns.class_("TurnOnAction", automation.Action)
 SwitchPublishAction = switch_ns.class_("SwitchPublishAction", automation.Action)
 
 SwitchCondition = switch_ns.class_("SwitchCondition", Condition)
-SwitchStateTrigger = switch_ns.class_(
-    "SwitchStateTrigger", automation.Trigger.template(bool)
-)
 SwitchTurnOnTrigger = switch_ns.class_(
     "SwitchTurnOnTrigger", automation.Trigger.template()
 )
@@ -81,11 +77,6 @@ _SWITCH_SCHEMA = (
             cv.Optional(CONF_RESTORE_MODE, default="ALWAYS_OFF"): cv.enum(
                 RESTORE_MODES, upper=True, space="_"
             ),
-            cv.Optional(CONF_ON_STATE): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SwitchStateTrigger),
-                }
-            ),
             cv.Optional(CONF_ON_TURN_ON): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SwitchTurnOnTrigger),
@@ -149,9 +140,6 @@ async def setup_switch_core_(var, config):
 
     if (inverted := config.get(CONF_INVERTED)) is not None:
         cg.add(var.set_inverted(inverted))
-    for conf in config.get(CONF_ON_STATE, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(bool, "x")], conf)
     for conf in config.get(CONF_ON_TURN_ON, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)

esphome/components/switch/automation.h

@@ -64,13 +64,6 @@ template<typename... Ts> class SwitchCondition : public Condition<Ts...> {
   bool state_;
 };
 
-class SwitchStateTrigger : public Trigger<bool> {
- public:
-  SwitchStateTrigger(Switch *a_switch) {
-    a_switch->add_on_state_callback([this](bool state) { this->trigger(state); });
-  }
-};
-
 class SwitchTurnOnTrigger : public Trigger<> {
  public:
   SwitchTurnOnTrigger(Switch *a_switch) {

esphome/components/web_server/web_server.cpp

@@ -635,15 +635,8 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
     } else if (match.method_equals("turn_on") || match.method_equals("turn_off")) {
       auto call = match.method_equals("turn_on") ? obj->turn_on() : obj->turn_off();
 
-      if (request->hasParam("speed_level")) {
-        auto speed_level = request->getParam("speed_level")->value();
-        auto val = parse_number<int>(speed_level.c_str());
-        if (!val.has_value()) {
-          ESP_LOGW(TAG, "Can't convert '%s' to number!", speed_level.c_str());
-          return;
-        }
-        call.set_speed(*val);
-      }
+      parse_int_param(request, "speed_level", call, &decltype(call)::set_speed);
+
       if (request->hasParam("oscillation")) {
         auto speed = request->getParam("oscillation")->value();
         auto val = parse_on_off(speed.c_str());
@@ -715,69 +708,26 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
       request->send(200);
     } else if (match.method_equals("turn_on")) {
       auto call = obj->turn_on();
-      if (request->hasParam("brightness")) {
-        auto brightness = parse_number<float>(request->getParam("brightness")->value().c_str());
-        if (brightness.has_value()) {
-          call.set_brightness(*brightness / 255.0f);
-        }
-      }
-      if (request->hasParam("r")) {
-        auto r = parse_number<float>(request->getParam("r")->value().c_str());
-        if (r.has_value()) {
-          call.set_red(*r / 255.0f);
-        }
-      }
-      if (request->hasParam("g")) {
-        auto g = parse_number<float>(request->getParam("g")->value().c_str());
-        if (g.has_value()) {
-          call.set_green(*g / 255.0f);
-        }
-      }
-      if (request->hasParam("b")) {
-        auto b = parse_number<float>(request->getParam("b")->value().c_str());
-        if (b.has_value()) {
-          call.set_blue(*b / 255.0f);
-        }
-      }
-      if (request->hasParam("white_value")) {
-        auto white_value = parse_number<float>(request->getParam("white_value")->value().c_str());
-        if (white_value.has_value()) {
-          call.set_white(*white_value / 255.0f);
-        }
-      }
-      if (request->hasParam("color_temp")) {
-        auto color_temp = parse_number<float>(request->getParam("color_temp")->value().c_str());
-        if (color_temp.has_value()) {
-          call.set_color_temperature(*color_temp);
-        }
-      }
-      if (request->hasParam("flash")) {
-        auto flash = parse_number<uint32_t>(request->getParam("flash")->value().c_str());
-        if (flash.has_value()) {
-          call.set_flash_length(*flash * 1000);
-        }
-      }
-      if (request->hasParam("transition")) {
-        auto transition = parse_number<uint32_t>(request->getParam("transition")->value().c_str());
-        if (transition.has_value()) {
-          call.set_transition_length(*transition * 1000);
-        }
-      }
-      if (request->hasParam("effect")) {
-        const char *effect = request->getParam("effect")->value().c_str();
-        call.set_effect(effect);
-      }
+
+      // Parse color parameters
+      parse_light_param(request, "brightness", call, &decltype(call)::set_brightness, 255.0f);
+      parse_light_param(request, "r", call, &decltype(call)::set_red, 255.0f);
+      parse_light_param(request, "g", call, &decltype(call)::set_green, 255.0f);
+      parse_light_param(request, "b", call, &decltype(call)::set_blue, 255.0f);
+      parse_light_param(request, "white_value", call, &decltype(call)::set_white, 255.0f);
+      parse_light_param(request, "color_temp", call, &decltype(call)::set_color_temperature);
+
+      // Parse timing parameters
+      parse_light_param_uint(request, "flash", call, &decltype(call)::set_flash_length, 1000);
+      parse_light_param_uint(request, "transition", call, &decltype(call)::set_transition_length, 1000);
+
+      parse_string_param(request, "effect", call, &decltype(call)::set_effect);
 
       this->defer([call]() mutable { call.perform(); });
       request->send(200);
     } else if (match.method_equals("turn_off")) {
       auto call = obj->turn_off();
-      if (request->hasParam("transition")) {
-        auto transition = parse_number<uint32_t>(request->getParam("transition")->value().c_str());
-        if (transition.has_value()) {
-          call.set_transition_length(*transition * 1000);
-        }
-      }
+      parse_light_param_uint(request, "transition", call, &decltype(call)::set_transition_length, 1000);
       this->defer([call]() mutable { call.perform(); });
       request->send(200);
     } else {
@@ -850,18 +800,8 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
       return;
     }
 
-    if (request->hasParam("position")) {
-      auto position = parse_number<float>(request->getParam("position")->value().c_str());
-      if (position.has_value()) {
-        call.set_position(*position);
-      }
-    }
-    if (request->hasParam("tilt")) {
-      auto tilt = parse_number<float>(request->getParam("tilt")->value().c_str());
-      if (tilt.has_value()) {
-        call.set_tilt(*tilt);
-      }
-    }
+    parse_float_param(request, "position", call, &decltype(call)::set_position);
+    parse_float_param(request, "tilt", call, &decltype(call)::set_tilt);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -915,11 +855,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
     }
 
     auto call = obj->make_call();
-    if (request->hasParam("value")) {
-      auto value = parse_number<float>(request->getParam("value")->value().c_str());
-      if (value.has_value())
-        call.set_value(*value);
-    }
+    parse_float_param(request, "value", call, &decltype(call)::set_value);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -991,10 +927,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
       return;
     }
 
-    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();  // NOLINT
-      call.set_date(value);
-    }
+    parse_string_param(request, "value", call, &decltype(call)::set_date);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1050,10 +983,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
       return;
     }
 
-    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();  // NOLINT
-      call.set_time(value);
-    }
+    parse_string_param(request, "value", call, &decltype(call)::set_time);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1108,10 +1038,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
       return;
     }
 
-    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();  // NOLINT
-      call.set_datetime(value);
-    }
+    parse_string_param(request, "value", call, &decltype(call)::set_datetime);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1162,10 +1089,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
     }
 
     auto call = obj->make_call();
-    if (request->hasParam("value")) {
-      String value = request->getParam("value")->value();
-      call.set_value(value.c_str());  // NOLINT
-    }
+    parse_string_param(request, "value", call, &decltype(call)::set_value);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1224,11 +1148,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
     }
 
     auto call = obj->make_call();
-
-    if (request->hasParam("option")) {
-      auto option = request->getParam("option")->value();
-      call.set_option(option.c_str());  // NOLINT
-    }
+    parse_string_param(request, "option", call, &decltype(call)::set_option);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1284,38 +1204,15 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
 
     auto call = obj->make_call();
 
-    if (request->hasParam("mode")) {
-      auto mode = request->getParam("mode")->value();
-      call.set_mode(mode.c_str());  // NOLINT
-    }
+    // Parse string mode parameters
+    parse_string_param(request, "mode", call, &decltype(call)::set_mode);
+    parse_string_param(request, "fan_mode", call, &decltype(call)::set_fan_mode);
+    parse_string_param(request, "swing_mode", call, &decltype(call)::set_swing_mode);
 
-    if (request->hasParam("fan_mode")) {
-      auto mode = request->getParam("fan_mode")->value();
-      call.set_fan_mode(mode.c_str());  // NOLINT
-    }
-
-    if (request->hasParam("swing_mode")) {
-      auto mode = request->getParam("swing_mode")->value();
-      call.set_swing_mode(mode.c_str());  // NOLINT
-    }
-
-    if (request->hasParam("target_temperature_high")) {
-      auto target_temperature_high = parse_number<float>(request->getParam("target_temperature_high")->value().c_str());
-      if (target_temperature_high.has_value())
-        call.set_target_temperature_high(*target_temperature_high);
-    }
-
-    if (request->hasParam("target_temperature_low")) {
-      auto target_temperature_low = parse_number<float>(request->getParam("target_temperature_low")->value().c_str());
-      if (target_temperature_low.has_value())
-        call.set_target_temperature_low(*target_temperature_low);
-    }
-
-    if (request->hasParam("target_temperature")) {
-      auto target_temperature = parse_number<float>(request->getParam("target_temperature")->value().c_str());
-      if (target_temperature.has_value())
-        call.set_target_temperature(*target_temperature);
-    }
+    // Parse temperature parameters
+    parse_float_param(request, "target_temperature_high", call, &decltype(call)::set_target_temperature_high);
+    parse_float_param(request, "target_temperature_low", call, &decltype(call)::set_target_temperature_low);
+    parse_float_param(request, "target_temperature", call, &decltype(call)::set_target_temperature);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1506,12 +1403,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
       return;
     }
 
-    if (request->hasParam("position")) {
-      auto position = parse_number<float>(request->getParam("position")->value().c_str());
-      if (position.has_value()) {
-        call.set_position(*position);
-      }
-    }
+    parse_float_param(request, "position", call, &decltype(call)::set_position);
 
     this->defer([call]() mutable { call.perform(); });
     request->send(200);
@@ -1559,9 +1451,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
     }
 
     auto call = obj->make_call();
-    if (request->hasParam("code")) {
-      call.set_code(request->getParam("code")->value().c_str());  // NOLINT
-    }
+    parse_string_param(request, "code", call, &decltype(call)::set_code);
 
     if (match.method_equals("disarm")) {
       call.disarm();
@@ -1659,6 +1549,19 @@ std::string WebServer::event_json(event::Event *obj, const std::string &event_ty
 #endif
 
 #ifdef USE_UPDATE
+static const char *update_state_to_string(update::UpdateState state) {
+  switch (state) {
+    case update::UPDATE_STATE_NO_UPDATE:
+      return "NO UPDATE";
+    case update::UPDATE_STATE_AVAILABLE:
+      return "UPDATE AVAILABLE";
+    case update::UPDATE_STATE_INSTALLING:
+      return "INSTALLING";
+    default:
+      return "UNKNOWN";
+  }
+}
+
 void WebServer::on_update(update::UpdateEntity *obj) {
   if (this->events_.empty())
     return;
@@ -1698,20 +1601,7 @@ std::string WebServer::update_json(update::UpdateEntity *obj, JsonDetail start_c
   return json::build_json([this, obj, start_config](JsonObject root) {
     set_json_id(root, obj, "update-" + obj->get_object_id(), start_config);
     root["value"] = obj->update_info.latest_version;
-    switch (obj->state) {
-      case update::UPDATE_STATE_NO_UPDATE:
-        root["state"] = "NO UPDATE";
-        break;
-      case update::UPDATE_STATE_AVAILABLE:
-        root["state"] = "UPDATE AVAILABLE";
-        break;
-      case update::UPDATE_STATE_INSTALLING:
-        root["state"] = "INSTALLING";
-        break;
-      default:
-        root["state"] = "UNKNOWN";
-        break;
-    }
+    root["state"] = update_state_to_string(obj->state);
     if (start_config == DETAIL_ALL) {
       root["current_version"] = obj->update_info.current_version;
       root["title"] = obj->update_info.title;

esphome/components/web_server/web_server.h

@@ -498,6 +498,65 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
 
  protected:
   void add_sorting_info_(JsonObject &root, EntityBase *entity);
+
+#ifdef USE_LIGHT
+  // Helper to parse and apply a float parameter with optional scaling
+  template<typename T, typename Ret>
+  void parse_light_param(AsyncWebServerRequest *request, const char *param_name, T &call, Ret (T::*setter)(float),
+                         float scale = 1.0f) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value / scale);
+      }
+    }
+  }
+
+  // Helper to parse and apply a uint32_t parameter with optional scaling
+  template<typename T, typename Ret>
+  void parse_light_param_uint(AsyncWebServerRequest *request, const char *param_name, T &call,
+                              Ret (T::*setter)(uint32_t), uint32_t scale = 1) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<uint32_t>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value * scale);
+      }
+    }
+  }
+#endif
+
+  // Generic helper to parse and apply a float parameter
+  template<typename T, typename Ret>
+  void parse_float_param(AsyncWebServerRequest *request, const char *param_name, T &call, Ret (T::*setter)(float)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
+    }
+  }
+
+  // Generic helper to parse and apply an int parameter
+  template<typename T, typename Ret>
+  void parse_int_param(AsyncWebServerRequest *request, const char *param_name, T &call, Ret (T::*setter)(int)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<int>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
+    }
+  }
+
+  // Generic helper to parse and apply a string parameter
+  template<typename T, typename Ret>
+  void parse_string_param(AsyncWebServerRequest *request, const char *param_name, T &call,
+                          Ret (T::*setter)(const std::string &)) {
+    if (request->hasParam(param_name)) {
+      std::string value = request->getParam(param_name)->value().c_str();
+      (call.*setter)(value);
+    }
+  }
+
   web_server_base::WebServerBase *base_;
 #ifdef USE_ARDUINO
   DeferredUpdateEventSourceList events_;

esphome/dashboard/web_server.py

@@ -229,6 +229,7 @@ class EsphomeCommandWebSocket(tornado.websocket.WebSocketHandler):
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
+                close_fds=False,
             )
             stdout_thread = threading.Thread(target=self._stdout_thread)
             stdout_thread.daemon = True
@@ -324,14 +325,13 @@ class EsphomePortCommandWebSocket(EsphomeCommandWebSocket):
         configuration = json_message["configuration"]
         config_file = settings.rel_path(configuration)
         port = json_message["port"]
-        addresses: list[str] = [port]
+        addresses: list[str] = []
         if (
             port == "OTA"  # pylint: disable=too-many-boolean-expressions
             and (entry := entries.get(config_file))
             and entry.loaded_integrations
             and "api" in entry.loaded_integrations
         ):
-            addresses = []
             # First priority: entry.address AKA use_address
             if (
                 (use_address := entry.address)
@@ -359,6 +359,13 @@ class EsphomePortCommandWebSocket(EsphomeCommandWebSocket):
                 # since MQTT logging will not work otherwise
                 addresses.extend(sort_ip_addresses(new_addresses))
 
+        if not addresses:
+            # If no address was found, use the port directly
+            # as otherwise they will get the chooser which
+            # does not work with the dashboard as there is no
+            # interactive way to get keyboard input
+            addresses = [port]
+
         device_args: list[str] = [
             arg for address in addresses for arg in ("--device", address)
         ]

esphome/git.py

@@ -17,7 +17,9 @@ _LOGGER = logging.getLogger(__name__)
 def run_git_command(cmd, cwd=None) -> str:
     _LOGGER.debug("Running git command: %s", " ".join(cmd))
     try:
-        ret = subprocess.run(cmd, cwd=cwd, capture_output=True, check=False)
+        ret = subprocess.run(
+            cmd, cwd=cwd, capture_output=True, check=False, close_fds=False
+        )
     except FileNotFoundError as err:
         raise cv.Invalid(
             "git is not installed but required for external_components.\n"

esphome/helpers.py

@@ -114,7 +114,9 @@ def cpp_string_escape(string, encoding="utf-8"):
 def run_system_command(*args):
     import subprocess
 
-    with subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+    with subprocess.Popen(
+        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=False
+    ) as p:
         stdout, stderr = p.communicate()
         rc = p.returncode
         return rc, stdout, stderr

esphome/platformio_api.py

@@ -5,6 +5,7 @@ import os
 from pathlib import Path
 import re
 import subprocess
+from typing import Any
 
 from esphome.const import CONF_COMPILE_PROCESS_LIMIT, CONF_ESPHOME, KEY_CORE
 from esphome.core import CORE, EsphomeError
@@ -107,7 +108,16 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    return run_platformio_cli_run(config, verbose, *args)
+    result = run_platformio_cli_run(config, verbose, *args)
+
+    # Run memory analysis if enabled
+    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
+        try:
+            analyze_memory_usage(config)
+        except Exception as e:
+            _LOGGER.warning("Failed to analyze memory usage: %s", e)
+
+    return result
 
 
 def _run_idedata(config):
@@ -211,7 +221,7 @@ def _decode_pc(config, addr):
         return
     command = [idedata.addr2line_path, "-pfiaC", "-e", idedata.firmware_elf_path, addr]
     try:
-        translation = subprocess.check_output(command).decode().strip()
+        translation = subprocess.check_output(command, close_fds=False).decode().strip()
     except Exception:  # pylint: disable=broad-except
         _LOGGER.debug("Caught exception for command %s", command, exc_info=1)
         return
@@ -336,3 +346,93 @@ class IDEData:
             return f"{self.cc_path[:-7]}addr2line.exe"
 
         return f"{self.cc_path[:-3]}addr2line"
+
+    @property
+    def objdump_path(self) -> str:
+        # replace gcc at end with objdump
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}objdump.exe"
+
+        return f"{self.cc_path[:-3]}objdump"
+
+    @property
+    def readelf_path(self) -> str:
+        # replace gcc at end with readelf
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}readelf.exe"
+
+        return f"{self.cc_path[:-3]}readelf"
+
+
+def analyze_memory_usage(config: dict[str, Any]) -> None:
+    """Analyze memory usage by component after compilation."""
+    # Lazy import to avoid overhead when not needed
+    from esphome.analyze_memory import MemoryAnalyzer
+
+    idedata = get_idedata(config)
+
+    # Get paths to tools
+    elf_path = idedata.firmware_elf_path
+    objdump_path = idedata.objdump_path
+    readelf_path = idedata.readelf_path
+
+    # Debug logging
+    _LOGGER.debug("ELF path from idedata: %s", elf_path)
+
+    # Check if file exists
+    if not Path(elf_path).exists():
+        # Try alternate path
+        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
+        if alt_path.exists():
+            elf_path = str(alt_path)
+            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
+        else:
+            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
+            return
+
+    # Extract external components from config
+    external_components = set()
+
+    # Get the list of built-in ESPHome components
+    from esphome.analyze_memory import get_esphome_components
+
+    builtin_components = get_esphome_components()
+
+    # Special non-component keys that appear in configs
+    NON_COMPONENT_KEYS = {
+        CONF_ESPHOME,
+        "substitutions",
+        "packages",
+        "globals",
+        "<<",
+    }
+
+    # Check all top-level keys in config
+    for key in config:
+        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
+            # This is an external component
+            external_components.add(key)
+
+    _LOGGER.debug("Detected external components: %s", external_components)
+
+    # Create analyzer and run analysis
+    analyzer = MemoryAnalyzer(elf_path, objdump_path, readelf_path, external_components)
+    analyzer.analyze()
+
+    # Generate and print report
+    report = analyzer.generate_report()
+    _LOGGER.info("\n%s", report)
+
+    # Optionally save to file
+    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
+        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
+        if report_file.suffix == ".json":
+            report_file.write_text(analyzer.to_json())
+            _LOGGER.info("Memory report saved to %s", report_file)
+        else:
+            report_file.write_text(report)
+            _LOGGER.info("Memory report saved to %s", report_file)

esphome/util.py

@@ -239,7 +239,12 @@ def run_external_process(*cmd: str, **kwargs: Any) -> int | str:
 
     try:
         proc = subprocess.run(
-            cmd, stdout=sub_stdout, stderr=sub_stderr, encoding="utf-8", check=False
+            cmd,
+            stdout=sub_stdout,
+            stderr=sub_stderr,
+            encoding="utf-8",
+            check=False,
+            close_fds=False,
         )
         return proc.stdout if capture_stdout else proc.returncode
     except KeyboardInterrupt:  # pylint: disable=try-except-raise

script/clang-format

@@ -31,7 +31,11 @@ def run_format(executable, args, queue, lock, failed_files):
         invocation.append(path)
 
         proc = subprocess.run(
-            invocation, capture_output=True, encoding="utf-8", check=False
+            invocation,
+            capture_output=True,
+            encoding="utf-8",
+            check=False,
+            close_fds=False,
         )
         if proc.returncode != 0:
             with lock:

script/clang-tidy

@@ -158,7 +158,11 @@ def run_tidy(executable, args, options, tmpdir, path_queue, lock, failed_files):
         invocation.extend(options)
 
         proc = subprocess.run(
-            invocation, capture_output=True, encoding="utf-8", check=False
+            invocation,
+            capture_output=True,
+            encoding="utf-8",
+            check=False,
+            close_fds=False,
         )
         if proc.returncode != 0:
             with lock:
@@ -320,9 +324,11 @@ def main():
         print("Applying fixes ...")
         try:
             try:
-                subprocess.call(["clang-apply-replacements-18", tmpdir])
+                subprocess.call(
+                    ["clang-apply-replacements-18", tmpdir], close_fds=False
+                )
             except FileNotFoundError:
-                subprocess.call(["clang-apply-replacements", tmpdir])
+                subprocess.call(["clang-apply-replacements", tmpdir], close_fds=False)
         except FileNotFoundError:
             print(
                 "Error please install clang-apply-replacements-18 or clang-apply-replacements.\n",

script/platformio_install_deps.py

@@ -55,4 +55,6 @@ for section in config.sections():
             tools.append("-t")
             tools.append(tool)
 
-subprocess.check_call(["platformio", "pkg", "install", "-g", *libs, *platforms, *tools])
+subprocess.check_call(
+    ["platformio", "pkg", "install", "-g", *libs, *platforms, *tools], close_fds=False
+)

script/run-in-env.py

@@ -13,7 +13,7 @@ def find_and_activate_virtualenv():
     try:
         # Get the top-level directory of the git repository
         my_path = subprocess.check_output(
-            ["git", "rev-parse", "--show-toplevel"], text=True
+            ["git", "rev-parse", "--show-toplevel"], text=True, close_fds=False
         ).strip()
     except subprocess.CalledProcessError:
         print(
@@ -44,7 +44,7 @@ def find_and_activate_virtualenv():
 def run_command():
     # Execute the remaining arguments in the new environment
     if len(sys.argv) > 1:
-        subprocess.run(sys.argv[1:], check=False)
+        subprocess.run(sys.argv[1:], check=False, close_fds=False)
     else:
         print(
             "No command provided to run in the virtual environment.",

tests/components/switch/common.yaml

@@ -9,18 +9,6 @@ switch:
     name: "Template Switch"
     id: the_switch
     optimistic: true
-    on_state:
-      - if:
-          condition:
-            - lambda: return x;
-          then:
-            - logger.log: "Switch turned ON"
-          else:
-            - logger.log: "Switch turned OFF"
-    on_turn_on:
-      - logger.log: "Switch is now ON"
-    on_turn_off:
-      - logger.log: "Switch is now OFF"
 
 esphome:
   on_boot:

tests/integration/conftest.py

@@ -105,6 +105,7 @@ logger:
                     check=True,
                     cwd=init_dir,
                     env=env,
+                    close_fds=False,
                 )
 
         # Lock is held until here, ensuring cache is fully populated before any test proceeds
@@ -245,6 +246,7 @@ async def compile_esphome(
                 # Start in a new process group to isolate signal handling
                 start_new_session=True,
                 env=env,
+                close_fds=False,
             )
             await proc.wait()
 
@@ -477,6 +479,7 @@ async def run_binary_and_wait_for_port(
         # Start in a new process group to isolate signal handling
         start_new_session=True,
         pass_fds=(device_fd,),
+        close_fds=False,
     )
 
     # Close the device end in the parent process