esphome 2025.6.3__py3-none-any.whl → 2025.7.0b2__py3-none-any.whl

esphome/components/veml3235/veml3235.h

@@ -65,7 +65,6 @@ class VEML3235Sensor : public sensor::Sensor, public PollingComponent, public i2
   void setup() override;
   void dump_config() override;
   void update() override { this->publish_state(this->read_lx_()); }
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   // Used by ESPHome framework. Does NOT actually set the value on the device.
   void set_auto_gain(bool auto_gain) { this->auto_gain_ = auto_gain; }

esphome/components/veml7700/veml7700.h

@@ -102,7 +102,6 @@ class VEML7700Component : public PollingComponent, public i2c::I2CDevice {
   //
   // EspHome framework functions
   //
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/vl53l0x/vl53l0x_sensor.h

@@ -30,7 +30,6 @@ class VL53L0XSensor : public sensor::Sensor, public PollingComponent, public i2c
   void setup() override;
 
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void update() override;
 
   void loop() override;

esphome/components/voice_assistant/voice_assistant.cpp

@@ -85,7 +85,7 @@ bool VoiceAssistant::start_udp_socket_() {
 bool VoiceAssistant::allocate_buffers_() {
 #ifdef USE_SPEAKER
   if ((this->speaker_ != nullptr) && (this->speaker_buffer_ == nullptr)) {
-    ExternalRAMAllocator<uint8_t> speaker_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    RAMAllocator<uint8_t> speaker_allocator;
     this->speaker_buffer_ = speaker_allocator.allocate(SPEAKER_BUFFER_SIZE);
     if (this->speaker_buffer_ == nullptr) {
       ESP_LOGW(TAG, "Could not allocate speaker buffer");
@@ -103,7 +103,7 @@ bool VoiceAssistant::allocate_buffers_() {
   }
 
   if (this->send_buffer_ == nullptr) {
-    ExternalRAMAllocator<uint8_t> send_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    RAMAllocator<uint8_t> send_allocator;
     this->send_buffer_ = send_allocator.allocate(SEND_BUFFER_SIZE);
     if (send_buffer_ == nullptr) {
       ESP_LOGW(TAG, "Could not allocate send buffer");
@@ -136,7 +136,7 @@ void VoiceAssistant::clear_buffers_() {
 
 void VoiceAssistant::deallocate_buffers_() {
   if (this->send_buffer_ != nullptr) {
-    ExternalRAMAllocator<uint8_t> send_deallocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    RAMAllocator<uint8_t> send_deallocator;
     send_deallocator.deallocate(this->send_buffer_, SEND_BUFFER_SIZE);
     this->send_buffer_ = nullptr;
   }
@@ -147,7 +147,7 @@ void VoiceAssistant::deallocate_buffers_() {
 
 #ifdef USE_SPEAKER
   if ((this->speaker_ != nullptr) && (this->speaker_buffer_ != nullptr)) {
-    ExternalRAMAllocator<uint8_t> speaker_deallocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+    RAMAllocator<uint8_t> speaker_deallocator;
     speaker_deallocator.deallocate(this->speaker_buffer_, SPEAKER_BUFFER_SIZE);
     this->speaker_buffer_ = nullptr;
   }

esphome/components/watchdog/watchdog.cpp

@@ -38,16 +38,12 @@ WatchdogManager::~WatchdogManager() {
 void WatchdogManager::set_timeout_(uint32_t timeout_ms) {
   ESP_LOGV(TAG, "Adjusting WDT to %" PRIu32 "ms", timeout_ms);
 #ifdef USE_ESP32
-#if ESP_IDF_VERSION_MAJOR >= 5
   esp_task_wdt_config_t wdt_config = {
       .timeout_ms = timeout_ms,
       .idle_core_mask = (1 << SOC_CPU_CORES_NUM) - 1,
       .trigger_panic = true,
   };
   esp_task_wdt_reconfigure(&wdt_config);
-#else
-  esp_task_wdt_init(timeout_ms / 1000, true);
-#endif  // ESP_IDF_VERSION_MAJOR
 #endif  // USE_ESP32
 
 #ifdef USE_RP2040

esphome/components/waveshare_epaper/waveshare_epaper.cpp

@@ -1,9 +1,9 @@
 #include "waveshare_epaper.h"
+#include <bitset>
+#include <cinttypes>
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <cinttypes>
-#include <bitset>
 
 namespace esphome {
 namespace waveshare_epaper {
@@ -185,7 +185,7 @@ void WaveshareEPaper7C::setup() {
   this->initialize();
 }
 void WaveshareEPaper7C::init_internal_7c_(uint32_t buffer_length) {
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   uint32_t small_buffer_length = buffer_length / NUM_BUFFERS;
 
   for (int i = 0; i < NUM_BUFFERS; i++) {
@@ -2054,7 +2054,7 @@ void GDEW029T5::initialize() {
     this->deep_sleep_between_updates_ = true;
 
   // old buffer for partial update
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   this->old_buffer_ = allocator.allocate(this->get_buffer_length_());
   if (this->old_buffer_ == nullptr) {
     ESP_LOGE(TAG, "Could not allocate old buffer for display!");
@@ -2199,7 +2199,7 @@ void GDEW029T5::dump_config() {
 
 void GDEW0154M09::initialize() {
   this->init_internal_();
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   this->lastbuff_ = allocator.allocate(this->get_buffer_length_());
   if (this->lastbuff_ != nullptr) {
     memset(this->lastbuff_, 0xff, sizeof(uint8_t) * this->get_buffer_length_());
@@ -3132,7 +3132,7 @@ void HOT GDEY0583T81::display() {
   } else {
     // Partial out (PTOUT), makes the display exit partial mode
     this->command(0x92);
-    ESP_LOGD(TAG, "Partial update done, next full update after %d cycles",
+    ESP_LOGD(TAG, "Partial update done, next full update after %" PRIu32 " cycles",
              this->full_update_every_ - this->at_update_ - 1);
   }
 

esphome/components/web_server/__init__.py

@@ -28,10 +28,12 @@ from esphome.const import (
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
+    PLATFORM_LN882X,
     PLATFORM_RTL87XX,
 )
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
+from esphome.types import ConfigType
 
 AUTO_LOAD = ["json", "web_server_base"]
 
@@ -39,13 +41,14 @@ CONF_SORTING_GROUP_ID = "sorting_group_id"
 CONF_SORTING_GROUPS = "sorting_groups"
 CONF_SORTING_WEIGHT = "sorting_weight"
 
+
 web_server_ns = cg.esphome_ns.namespace("web_server")
 WebServer = web_server_ns.class_("WebServer", cg.Component, cg.Controller)
 
 sorting_groups = {}
 
 
-def default_url(config):
+def default_url(config: ConfigType) -> ConfigType:
     config = config.copy()
     if config[CONF_VERSION] == 1:
         if CONF_CSS_URL not in config:
@@ -65,19 +68,27 @@ def default_url(config):
     return config
 
 
-def validate_local(config):
+def validate_local(config: ConfigType) -> ConfigType:
     if CONF_LOCAL in config and config[CONF_VERSION] == 1:
         raise cv.Invalid("'local' is not supported in version 1")
     return config
 
 
-def validate_ota(config):
-    if CORE.using_esp_idf and config[CONF_OTA]:
-        raise cv.Invalid("Enabling 'ota' is not supported for IDF framework yet")
+def validate_ota_removed(config: ConfigType) -> ConfigType:
+    # Only raise error if OTA is explicitly enabled (True)
+    # If it's False or not specified, we can safely ignore it
+    if config.get(CONF_OTA):
+        raise cv.Invalid(
+            f"The '{CONF_OTA}' option has been removed from 'web_server'. "
+            f"Please use the new OTA platform structure instead:\n\n"
+            f"ota:\n"
+            f"  - platform: web_server\n\n"
+            f"See https://esphome.io/components/ota for more information."
+        )
     return config
 
 
-def validate_sorting_groups(config):
+def validate_sorting_groups(config: ConfigType) -> ConfigType:
     if CONF_SORTING_GROUPS in config and config[CONF_VERSION] != 3:
         raise cv.Invalid(
             f"'{CONF_SORTING_GROUPS}' is only supported in 'web_server' version 3"
@@ -88,7 +99,7 @@ def validate_sorting_groups(config):
 def _validate_no_sorting_component(
     sorting_component: str,
     webserver_version: int,
-    config: dict,
+    config: ConfigType,
     path: list[str] | None = None,
 ) -> None:
     if path is None:
@@ -111,7 +122,7 @@ def _validate_no_sorting_component(
                     )
 
 
-def _final_validate_sorting(config):
+def _final_validate_sorting(config: ConfigType) -> ConfigType:
     if (webserver_version := config.get(CONF_VERSION)) != 3:
         _validate_no_sorting_component(
             CONF_SORTING_WEIGHT, webserver_version, fv.full_config.get()
@@ -174,24 +185,25 @@ CONFIG_SCHEMA = cv.All(
                 web_server_base.WebServerBase
             ),
             cv.Optional(CONF_INCLUDE_INTERNAL, default=False): cv.boolean,
-            cv.SplitDefault(
-                CONF_OTA,
-                esp8266=True,
-                esp32_arduino=True,
-                esp32_idf=False,
-                bk72xx=True,
-                rtl87xx=True,
-            ): cv.boolean,
+            cv.Optional(CONF_OTA, default=False): cv.boolean,
             cv.Optional(CONF_LOG, default=True): cv.boolean,
             cv.Optional(CONF_LOCAL): cv.boolean,
             cv.Optional(CONF_SORTING_GROUPS): cv.ensure_list(sorting_group),
         }
     ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX, PLATFORM_RTL87XX]),
+    cv.only_on(
+        [
+            PLATFORM_ESP32,
+            PLATFORM_ESP8266,
+            PLATFORM_BK72XX,
+            PLATFORM_LN882X,
+            PLATFORM_RTL87XX,
+        ]
+    ),
     default_url,
     validate_local,
-    validate_ota,
     validate_sorting_groups,
+    validate_ota_removed,
 )
 
 
@@ -211,6 +223,7 @@ async def add_entity_config(entity, config):
     sorting_weight = config.get(CONF_SORTING_WEIGHT, 50)
     sorting_group_hash = hash(config.get(CONF_SORTING_GROUP_ID))
 
+    cg.add_define("USE_WEBSERVER_SORTING")
     cg.add(
         web_server.add_entity_config(
             entity,
@@ -274,7 +287,8 @@ async def to_code(config):
     else:
         cg.add(var.set_css_url(config[CONF_CSS_URL]))
         cg.add(var.set_js_url(config[CONF_JS_URL]))
-    cg.add(var.set_allow_ota(config[CONF_OTA]))
+    # OTA is now handled by the web_server OTA platform
+    # The CONF_OTA option is kept only for backwards compatibility validation
     cg.add(var.set_expose_log(config[CONF_LOG]))
     if config[CONF_ENABLE_PRIVATE_NETWORK_ACCESS]:
         cg.add_define("USE_WEBSERVER_PRIVATE_NETWORK_ACCESS")
@@ -296,4 +310,5 @@ async def to_code(config):
         cg.add_define("USE_WEBSERVER_LOCAL")
 
     if (sorting_group_config := config.get(CONF_SORTING_GROUPS)) is not None:
+        cg.add_define("USE_WEBSERVER_SORTING")
         add_sorting_groups(var, sorting_group_config)

esphome/components/web_server/ota/__init__.py

@@ -0,0 +1,32 @@
+import esphome.codegen as cg
+from esphome.components.esp32 import add_idf_component
+from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.core import CORE, coroutine_with_priority
+
+CODEOWNERS = ["@esphome/core"]
+DEPENDENCIES = ["network", "web_server_base"]
+
+web_server_ns = cg.esphome_ns.namespace("web_server")
+WebServerOTAComponent = web_server_ns.class_("WebServerOTAComponent", OTAComponent)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(WebServerOTAComponent),
+        }
+    )
+    .extend(BASE_OTA_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+@coroutine_with_priority(52.0)
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await ota_to_code(var, config)
+    await cg.register_component(var, config)
+    cg.add_define("USE_WEBSERVER_OTA")
+    if CORE.using_esp_idf:
+        add_idf_component(name="zorxx/multipart-parser", ref="1.0.1")

esphome/components/web_server/ota/ota_web_server.cpp

@@ -0,0 +1,210 @@
+#include "ota_web_server.h"
+#ifdef USE_WEBSERVER_OTA
+
+#include "esphome/components/ota/ota_backend.h"
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ARDUINO
+#ifdef USE_ESP8266
+#include <Updater.h>
+#elif defined(USE_ESP32) || defined(USE_LIBRETINY)
+#include <Update.h>
+#endif
+#endif  // USE_ARDUINO
+
+namespace esphome {
+namespace web_server {
+
+static const char *const TAG = "web_server.ota";
+
+class OTARequestHandler : public AsyncWebHandler {
+ public:
+  OTARequestHandler(WebServerOTAComponent *parent) : parent_(parent) {}
+  void handleRequest(AsyncWebServerRequest *request) override;
+  void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len,
+                    bool final) override;
+  bool canHandle(AsyncWebServerRequest *request) const override {
+    return request->url() == "/update" && request->method() == HTTP_POST;
+  }
+
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  bool isRequestHandlerTrivial() const override { return false; }
+
+ protected:
+  void report_ota_progress_(AsyncWebServerRequest *request);
+  void schedule_ota_reboot_();
+  void ota_init_(const char *filename);
+
+  uint32_t last_ota_progress_{0};
+  uint32_t ota_read_length_{0};
+  WebServerOTAComponent *parent_;
+  bool ota_success_{false};
+
+ private:
+  std::unique_ptr<ota::OTABackend> ota_backend_{nullptr};
+};
+
+void OTARequestHandler::report_ota_progress_(AsyncWebServerRequest *request) {
+  const uint32_t now = millis();
+  if (now - this->last_ota_progress_ > 1000) {
+    float percentage = 0.0f;
+    if (request->contentLength() != 0) {
+      // Note: Using contentLength() for progress calculation is technically wrong as it includes
+      // multipart headers/boundaries, but it's only off by a small amount and we don't have
+      // access to the actual firmware size until the upload is complete. This is intentional
+      // as it still gives the user a reasonable progress indication.
+      percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
+      ESP_LOGD(TAG, "OTA in progress: %0.1f%%", percentage);
+    } else {
+      ESP_LOGD(TAG, "OTA in progress: %u bytes read", this->ota_read_length_);
+    }
+#ifdef USE_OTA_STATE_CALLBACK
+    // Report progress - use call_deferred since we're in web server task
+    this->parent_->state_callback_.call_deferred(ota::OTA_IN_PROGRESS, percentage, 0);
+#endif
+    this->last_ota_progress_ = now;
+  }
+}
+
+void OTARequestHandler::schedule_ota_reboot_() {
+  ESP_LOGI(TAG, "OTA update successful!");
+  this->parent_->set_timeout(100, []() {
+    ESP_LOGI(TAG, "Performing OTA reboot now");
+    App.safe_reboot();
+  });
+}
+
+void OTARequestHandler::ota_init_(const char *filename) {
+  ESP_LOGI(TAG, "OTA Update Start: %s", filename);
+  this->ota_read_length_ = 0;
+  this->ota_success_ = false;
+}
+
+void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index,
+                                     uint8_t *data, size_t len, bool final) {
+  ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_OK;
+
+  if (index == 0 && !this->ota_backend_) {
+    // Initialize OTA on first call
+    this->ota_init_(filename.c_str());
+
+#ifdef USE_OTA_STATE_CALLBACK
+    // Notify OTA started - use call_deferred since we're in web server task
+    this->parent_->state_callback_.call_deferred(ota::OTA_STARTED, 0.0f, 0);
+#endif
+
+    // Platform-specific pre-initialization
+#ifdef USE_ARDUINO
+#ifdef USE_ESP8266
+    Update.runAsync(true);
+#endif
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+    if (Update.isRunning()) {
+      Update.abort();
+    }
+#endif
+#endif  // USE_ARDUINO
+
+    this->ota_backend_ = ota::make_ota_backend();
+    if (!this->ota_backend_) {
+      ESP_LOGE(TAG, "Failed to create OTA backend");
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota::OTA_ERROR, 0.0f,
+                                                   static_cast<uint8_t>(ota::OTA_RESPONSE_ERROR_UNKNOWN));
+#endif
+      return;
+    }
+
+    // Web server OTA uses multipart uploads where the actual firmware size
+    // is unknown (contentLength includes multipart overhead)
+    // Pass 0 to indicate unknown size
+    error_code = this->ota_backend_->begin(0);
+    if (error_code != ota::OTA_RESPONSE_OK) {
+      ESP_LOGE(TAG, "OTA begin failed: %d", error_code);
+      this->ota_backend_.reset();
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
+      return;
+    }
+  }
+
+  if (!this->ota_backend_) {
+    return;
+  }
+
+  // Process data
+  if (len > 0) {
+    error_code = this->ota_backend_->write(data, len);
+    if (error_code != ota::OTA_RESPONSE_OK) {
+      ESP_LOGE(TAG, "OTA write failed: %d", error_code);
+      this->ota_backend_->abort();
+      this->ota_backend_.reset();
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
+      return;
+    }
+    this->ota_read_length_ += len;
+    this->report_ota_progress_(request);
+  }
+
+  // Finalize
+  if (final) {
+    ESP_LOGD(TAG, "OTA final chunk: index=%u, len=%u, total_read=%u, contentLength=%u", index, len,
+             this->ota_read_length_, request->contentLength());
+
+    // For Arduino framework, the Update library tracks expected size from firmware header
+    // If we haven't received enough data, calling end() will fail
+    // This can happen if the upload is interrupted or the client disconnects
+    error_code = this->ota_backend_->end();
+    if (error_code == ota::OTA_RESPONSE_OK) {
+      this->ota_success_ = true;
+#ifdef USE_OTA_STATE_CALLBACK
+      // Report completion before reboot - use call_deferred since we're in web server task
+      this->parent_->state_callback_.call_deferred(ota::OTA_COMPLETED, 100.0f, 0);
+#endif
+      this->schedule_ota_reboot_();
+    } else {
+      ESP_LOGE(TAG, "OTA end failed: %d", error_code);
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
+    }
+    this->ota_backend_.reset();
+  }
+}
+
+void OTARequestHandler::handleRequest(AsyncWebServerRequest *request) {
+  AsyncWebServerResponse *response;
+  // Use the ota_success_ flag to determine the actual result
+  const char *msg = this->ota_success_ ? "Update Successful!" : "Update Failed!";
+  response = request->beginResponse(200, "text/plain", msg);
+  response->addHeader("Connection", "close");
+  request->send(response);
+}
+
+void WebServerOTAComponent::setup() {
+  // Get the global web server base instance and register our handler
+  auto *base = web_server_base::global_web_server_base;
+  if (base == nullptr) {
+    ESP_LOGE(TAG, "WebServerBase not found");
+    this->mark_failed();
+    return;
+  }
+
+  // AsyncWebServer takes ownership of the handler and will delete it when the server is destroyed
+  base->add_handler(new OTARequestHandler(this));  // NOLINT
+#ifdef USE_OTA_STATE_CALLBACK
+  // Register with global OTA callback system
+  ota::register_ota_platform(this);
+#endif
+}
+
+void WebServerOTAComponent::dump_config() { ESP_LOGCONFIG(TAG, "Web Server OTA"); }
+
+}  // namespace web_server
+}  // namespace esphome
+
+#endif  // USE_WEBSERVER_OTA

esphome/components/web_server/ota/ota_web_server.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_WEBSERVER_OTA
+
+#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/web_server_base/web_server_base.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace web_server {
+
+class WebServerOTAComponent : public ota::OTAComponent {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+ protected:
+  friend class OTARequestHandler;
+};
+
+}  // namespace web_server
+}  // namespace esphome
+
+#endif  // USE_WEBSERVER_OTA