esphome 2025.5.1__py3-none-any.whl → 2025.6.0__py3-none-any.whl

esphome/components/number/number.h

@@ -48,9 +48,6 @@ class Number : public EntityBase {
 
   NumberTraits traits;
 
-  /// Return whether this number has gotten a full state yet.
-  bool has_state() const { return has_state_; }
-
  protected:
   friend class NumberCall;
 
@@ -63,7 +60,6 @@ class Number : public EntityBase {
   virtual void control(float value) = 0;
 
   CallbackManager<void(float)> state_callback_;
-  bool has_state_{false};
 };
 
 }  // namespace number

esphome/components/online_image/__init__.py

@@ -2,6 +2,7 @@ import logging
 
 from esphome import automation
 import esphome.codegen as cg
+from esphome.components.const import CONF_REQUEST_HEADERS
 from esphome.components.http_request import CONF_HTTP_REQUEST_ID, HttpRequestComponent
 from esphome.components.image import (
     CONF_INVERT_ALPHA,
@@ -24,6 +25,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_URL,
 )
+from esphome.core import Lambda
 
 AUTO_LOAD = ["image"]
 DEPENDENCIES = ["display", "http_request"]
@@ -124,6 +126,9 @@ ONLINE_IMAGE_SCHEMA = (
             cv.GenerateID(CONF_HTTP_REQUEST_ID): cv.use_id(HttpRequestComponent),
             # Online Image specific options
             cv.Required(CONF_URL): cv.url,
+            cv.Optional(CONF_REQUEST_HEADERS): cv.All(
+                cv.Schema({cv.string: cv.templatable(cv.string)})
+            ),
             cv.Required(CONF_FORMAT): cv.one_of(*IMAGE_FORMATS, upper=True),
             cv.Optional(CONF_PLACEHOLDER): cv.use_id(Image_),
             cv.Optional(CONF_BUFFER_SIZE, default=65536): cv.int_range(256, 65536),
@@ -207,13 +212,20 @@ async def to_code(config):
     await cg.register_component(var, config)
     await cg.register_parented(var, config[CONF_HTTP_REQUEST_ID])
 
+    for key, value in config.get(CONF_REQUEST_HEADERS, {}).items():
+        if isinstance(value, Lambda):
+            template_ = await cg.templatable(value, [], cg.std_string)
+            cg.add(var.add_request_header(key, template_))
+        else:
+            cg.add(var.add_request_header(key, value))
+
     if placeholder_id := config.get(CONF_PLACEHOLDER):
         placeholder = await cg.get_variable(placeholder_id)
         cg.add(var.set_placeholder(placeholder))
 
     for conf in config.get(CONF_ON_DOWNLOAD_FINISHED, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
+        await automation.build_automation(trigger, [(bool, "cached")], conf)
 
     for conf in config.get(CONF_ON_ERROR, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)

esphome/components/online_image/online_image.cpp

@@ -3,6 +3,10 @@
 #include "esphome/core/log.h"
 
 static const char *const TAG = "online_image";
+static const char *const ETAG_HEADER_NAME = "etag";
+static const char *const IF_NONE_MATCH_HEADER_NAME = "if-none-match";
+static const char *const LAST_MODIFIED_HEADER_NAME = "last-modified";
+static const char *const IF_MODIFIED_SINCE_HEADER_NAME = "if-modified-since";
 
 #include "image_decoder.h"
 
@@ -52,7 +56,7 @@ void OnlineImage::draw(int x, int y, display::Display *display, Color color_on,
 
 void OnlineImage::release() {
   if (this->buffer_) {
-    ESP_LOGV(TAG, "Deallocating old buffer...");
+    ESP_LOGV(TAG, "Deallocating old buffer");
     this->allocator_.deallocate(this->buffer_, this->get_buffer_size_());
     this->data_start_ = nullptr;
     this->buffer_ = nullptr;
@@ -60,6 +64,8 @@ void OnlineImage::release() {
     this->height_ = 0;
     this->buffer_width_ = 0;
     this->buffer_height_ = 0;
+    this->last_modified_ = "";
+    this->etag_ = "";
     this->end_connection_();
   }
 }
@@ -127,9 +133,21 @@ void OnlineImage::update() {
   }
   accept_header.value = accept_mime_type + ",*/*;q=0.8";
 
+  if (!this->etag_.empty()) {
+    headers.push_back(http_request::Header{IF_NONE_MATCH_HEADER_NAME, this->etag_});
+  }
+
+  if (!this->last_modified_.empty()) {
+    headers.push_back(http_request::Header{IF_MODIFIED_SINCE_HEADER_NAME, this->last_modified_});
+  }
+
   headers.push_back(accept_header);
 
-  this->downloader_ = this->parent_->get(this->url_, headers);
+  for (auto &header : this->request_headers_) {
+    headers.push_back(http_request::Header{header.first, header.second.value()});
+  }
+
+  this->downloader_ = this->parent_->get(this->url_, headers, {ETAG_HEADER_NAME, LAST_MODIFIED_HEADER_NAME});
 
   if (this->downloader_ == nullptr) {
     ESP_LOGE(TAG, "Download failed.");
@@ -141,7 +159,9 @@ void OnlineImage::update() {
   int http_code = this->downloader_->status_code;
   if (http_code == HTTP_CODE_NOT_MODIFIED) {
     // Image hasn't changed on server. Skip download.
+    ESP_LOGI(TAG, "Server returned HTTP 304 (Not Modified). Download skipped.");
     this->end_connection_();
+    this->download_finished_callback_.call(true);
     return;
   }
   if (http_code != HTTP_CODE_OK) {
@@ -201,8 +221,10 @@ void OnlineImage::loop() {
     ESP_LOGD(TAG, "Image fully downloaded, read %zu bytes, width/height = %d/%d", this->downloader_->get_bytes_read(),
              this->width_, this->height_);
     ESP_LOGD(TAG, "Total time: %lds", ::time(nullptr) - this->start_time_);
+    this->etag_ = this->downloader_->get_response_header(ETAG_HEADER_NAME);
+    this->last_modified_ = this->downloader_->get_response_header(LAST_MODIFIED_HEADER_NAME);
+    this->download_finished_callback_.call(false);
     this->end_connection_();
-    this->download_finished_callback_.call();
     return;
   }
   if (this->downloader_ == nullptr) {
@@ -325,7 +347,7 @@ bool OnlineImage::validate_url_(const std::string &url) {
   return true;
 }
 
-void OnlineImage::add_on_finished_callback(std::function<void()> &&callback) {
+void OnlineImage::add_on_finished_callback(std::function<void(bool)> &&callback) {
   this->download_finished_callback_.add(std::move(callback));
 }
 

esphome/components/online_image/online_image.h

@@ -63,6 +63,13 @@ class OnlineImage : public PollingComponent,
     if (this->validate_url_(url)) {
       this->url_ = url;
     }
+    this->etag_ = "";
+    this->last_modified_ = "";
+  }
+
+  /** Add the request header */
+  template<typename V> void add_request_header(const std::string &header, V value) {
+    this->request_headers_.push_back(std::pair<std::string, TemplatableValue<std::string> >(header, value));
   }
 
   /**
@@ -86,7 +93,7 @@ class OnlineImage : public PollingComponent,
    */
   size_t resize_download_buffer(size_t size) { return this->download_buffer_.resize(size); }
 
-  void add_on_finished_callback(std::function<void()> &&callback);
+  void add_on_finished_callback(std::function<void(bool)> &&callback);
   void add_on_error_callback(std::function<void()> &&callback);
 
  protected:
@@ -131,7 +138,7 @@ class OnlineImage : public PollingComponent,
 
   void end_connection_();
 
-  CallbackManager<void()> download_finished_callback_{};
+  CallbackManager<void(bool)> download_finished_callback_{};
   CallbackManager<void()> download_error_callback_{};
 
   std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
@@ -151,6 +158,8 @@ class OnlineImage : public PollingComponent,
 
   std::string url_{""};
 
+  std::vector<std::pair<std::string, TemplatableValue<std::string> > > request_headers_;
+
   /** width requested on configuration, or 0 if non specified. */
   const int fixed_width_;
   /** height requested on configuration, or 0 if non specified. */
@@ -173,6 +182,14 @@ class OnlineImage : public PollingComponent,
    * decoded images).
    */
   int buffer_height_;
+  /**
+   * The value of the ETag HTTP header provided in the last response.
+   */
+  std::string etag_ = "";
+  /**
+   * The value of the Last-Modified HTTP header provided in the last response.
+   */
+  std::string last_modified_ = "";
 
   time_t start_time_;
 
@@ -202,10 +219,10 @@ template<typename... Ts> class OnlineImageReleaseAction : public Action<Ts...> {
   OnlineImage *parent_;
 };
 
-class DownloadFinishedTrigger : public Trigger<> {
+class DownloadFinishedTrigger : public Trigger<bool> {
  public:
   explicit DownloadFinishedTrigger(OnlineImage *parent) {
-    parent->add_on_finished_callback([this]() { this->trigger(); });
+    parent->add_on_finished_callback([this](bool cached) { this->trigger(cached); });
   }
 };
 

esphome/components/opentherm/generate.py

@@ -1,5 +1,5 @@
-from collections.abc import Awaitable
-from typing import Any, Callable, Optional
+from collections.abc import Awaitable, Callable
+from typing import Any
 
 import esphome.codegen as cg
 from esphome.const import CONF_ID
@@ -103,7 +103,7 @@ def define_setting_readers(component_type: str, keys: list[str]) -> None:
 
 
 def add_messages(hub: cg.MockObj, keys: list[str], schemas: dict[str, TSchema]):
-    messages: dict[str, tuple[bool, Optional[int]]] = {}
+    messages: dict[str, tuple[bool, int | None]] = {}
     for key in keys:
         messages[schemas[key].message] = (
             schemas[key].keep_updated,

esphome/components/opentherm/hub.cpp

@@ -399,13 +399,17 @@ void OpenthermHub::dump_config() {
   ESP_LOGCONFIG(TAG, "OpenTherm:");
   LOG_PIN("  In: ", this->in_pin_);
   LOG_PIN("  Out: ", this->out_pin_);
-  ESP_LOGCONFIG(TAG, "  Sync mode: %s", YESNO(this->sync_mode_));
-  ESP_LOGCONFIG(TAG, "  Sensors: %s", SHOW(OPENTHERM_SENSOR_LIST(ID, )));
-  ESP_LOGCONFIG(TAG, "  Binary sensors: %s", SHOW(OPENTHERM_BINARY_SENSOR_LIST(ID, )));
-  ESP_LOGCONFIG(TAG, "  Switches: %s", SHOW(OPENTHERM_SWITCH_LIST(ID, )));
-  ESP_LOGCONFIG(TAG, "  Input sensors: %s", SHOW(OPENTHERM_INPUT_SENSOR_LIST(ID, )));
-  ESP_LOGCONFIG(TAG, "  Outputs: %s", SHOW(OPENTHERM_OUTPUT_LIST(ID, )));
-  ESP_LOGCONFIG(TAG, "  Numbers: %s", SHOW(OPENTHERM_NUMBER_LIST(ID, )));
+  ESP_LOGCONFIG(TAG,
+                "  Sync mode: %s\n"
+                "  Sensors: %s\n"
+                "  Binary sensors: %s\n"
+                "  Switches: %s\n"
+                "  Input sensors: %s\n"
+                "  Outputs: %s\n"
+                "  Numbers: %s",
+                YESNO(this->sync_mode_), SHOW(OPENTHERM_SENSOR_LIST(ID, )), SHOW(OPENTHERM_BINARY_SENSOR_LIST(ID, )),
+                SHOW(OPENTHERM_SWITCH_LIST(ID, )), SHOW(OPENTHERM_INPUT_SENSOR_LIST(ID, )),
+                SHOW(OPENTHERM_OUTPUT_LIST(ID, )), SHOW(OPENTHERM_NUMBER_LIST(ID, )));
   ESP_LOGCONFIG(TAG, "  Initial requests:");
   for (auto type : initial_messages) {
     ESP_LOGCONFIG(TAG, "  - %d (%s)", type, this->opentherm_->message_id_to_str(type));

esphome/components/opentherm/number/number.cpp

@@ -31,9 +31,11 @@ void OpenthermNumber::setup() {
 
 void OpenthermNumber::dump_config() {
   LOG_NUMBER("", "OpenTherm Number", this);
-  ESP_LOGCONFIG(TAG, "  Restore value: %d", this->restore_value_);
-  ESP_LOGCONFIG(TAG, "  Initial value: %.2f", this->initial_value_);
-  ESP_LOGCONFIG(TAG, "  Current value: %.2f", this->state);
+  ESP_LOGCONFIG(TAG,
+                "  Restore value: %d\n"
+                "  Initial value: %.2f\n"
+                "  Current value: %.2f",
+                this->restore_value_, this->initial_value_, this->state);
 }
 
 }  // namespace opentherm

esphome/components/opentherm/opentherm.h

@@ -9,8 +9,8 @@
 
 #include <string>
 #include "esphome/core/hal.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #if defined(ESP32) || defined(USE_ESP_IDF)
 #include "driver/timer.h"

esphome/components/opentherm/schema.py

@@ -2,7 +2,7 @@
 # inputs of the OpenTherm component.
 
 from dataclasses import dataclass
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 import esphome.config_validation as cv
 from esphome.const import (
@@ -61,11 +61,11 @@ TSchema = TypeVar("TSchema", bound=EntitySchema)
 class SensorSchema(EntitySchema):
     accuracy_decimals: int
     state_class: str
-    unit_of_measurement: Optional[str] = None
-    icon: Optional[str] = None
-    device_class: Optional[str] = None
+    unit_of_measurement: str | None = None
+    icon: str | None = None
+    device_class: str | None = None
     disabled_by_default: bool = False
-    order: Optional[int] = None
+    order: int | None = None
 
 
 SENSORS: dict[str, SensorSchema] = {
@@ -461,9 +461,9 @@ SENSORS: dict[str, SensorSchema] = {
 
 @dataclass
 class BinarySensorSchema(EntitySchema):
-    icon: Optional[str] = None
-    device_class: Optional[str] = None
-    order: Optional[int] = None
+    icon: str | None = None
+    device_class: str | None = None
+    order: int | None = None
 
 
 BINARY_SENSORS: dict[str, BinarySensorSchema] = {
@@ -654,7 +654,7 @@ BINARY_SENSORS: dict[str, BinarySensorSchema] = {
 
 @dataclass
 class SwitchSchema(EntitySchema):
-    default_mode: Optional[str] = None
+    default_mode: str | None = None
 
 
 SWITCHES: dict[str, SwitchSchema] = {
@@ -721,9 +721,9 @@ class InputSchema(EntitySchema):
     unit_of_measurement: str
     step: float
     range: tuple[int, int]
-    icon: Optional[str] = None
-    auto_max_value: Optional[AutoConfigure] = None
-    auto_min_value: Optional[AutoConfigure] = None
+    icon: str | None = None
+    auto_max_value: AutoConfigure | None = None
+    auto_min_value: AutoConfigure | None = None
 
 
 INPUTS: dict[str, InputSchema] = {
@@ -834,7 +834,7 @@ class SettingSchema(EntitySchema):
     backing_type: str
     validation_schema: cv.Schema
     default_value: Any
-    order: Optional[int] = None
+    order: int | None = None
 
 
 SETTINGS: dict[str, SettingSchema] = {

esphome/components/opentherm/validate.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
 
 from voluptuous import Schema
 

esphome/components/openthread/__init__.py

@@ -0,0 +1,146 @@
+import esphome.codegen as cg
+from esphome.components.esp32 import (
+    VARIANT_ESP32C6,
+    VARIANT_ESP32H2,
+    add_idf_sdkconfig_option,
+    only_on_variant,
+)
+from esphome.components.mdns import MDNSComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ENABLE_IPV6, CONF_ID
+import esphome.final_validate as fv
+
+from .const import (
+    CONF_EXT_PAN_ID,
+    CONF_FORCE_DATASET,
+    CONF_MDNS_ID,
+    CONF_MESH_LOCAL_PREFIX,
+    CONF_NETWORK_KEY,
+    CONF_NETWORK_NAME,
+    CONF_PAN_ID,
+    CONF_PSKC,
+    CONF_SRP_ID,
+    CONF_TLV,
+)
+from .tlv import parse_tlv
+
+CODEOWNERS = ["@mrene"]
+
+AUTO_LOAD = ["network"]
+
+# Wi-fi / Bluetooth / Thread coexistence isn't implemented at this time
+# TODO: Doesn't conflict with wifi if you're using another ESP as an RCP (radio coprocessor), but this isn't implemented yet
+CONFLICTS_WITH = ["wifi"]
+DEPENDENCIES = ["esp32"]
+
+
+def set_sdkconfig_options(config):
+    # and expose options for using SPI/UART RCPs
+    add_idf_sdkconfig_option("CONFIG_IEEE802154_ENABLED", True)
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_RADIO_NATIVE", True)
+
+    # There is a conflict if the logger's uart also uses the default UART, which is seen as a watchdog failure on "ot_cli"
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_CLI", False)
+
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_ENABLED", True)
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_PANID", config[CONF_PAN_ID])
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_CHANNEL", config[CONF_CHANNEL])
+    add_idf_sdkconfig_option(
+        "CONFIG_OPENTHREAD_NETWORK_MASTERKEY", f"{config[CONF_NETWORK_KEY]:X}"
+    )
+
+    if network_name := config.get(CONF_NETWORK_NAME):
+        add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_NAME", network_name)
+
+    if (ext_pan_id := config.get(CONF_EXT_PAN_ID)) is not None:
+        add_idf_sdkconfig_option(
+            "CONFIG_OPENTHREAD_NETWORK_EXTPANID", f"{ext_pan_id:X}"
+        )
+    if (mesh_local_prefix := config.get(CONF_MESH_LOCAL_PREFIX)) is not None:
+        add_idf_sdkconfig_option(
+            "CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX", f"{mesh_local_prefix:X}"
+        )
+    if (pskc := config.get(CONF_PSKC)) is not None:
+        add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_PSKC", f"{pskc:X}")
+
+    if CONF_FORCE_DATASET in config:
+        if config[CONF_FORCE_DATASET]:
+            cg.add_define("CONFIG_OPENTHREAD_FORCE_DATASET")
+
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_DNS64_CLIENT", True)
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_SRP_CLIENT", True)
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_SRP_CLIENT_MAX_SERVICES", 5)
+
+    # TODO: Add suport for sleepy end devices
+    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_FTD", True)  # Full Thread Device
+
+
+openthread_ns = cg.esphome_ns.namespace("openthread")
+OpenThreadComponent = openthread_ns.class_("OpenThreadComponent", cg.Component)
+OpenThreadSrpComponent = openthread_ns.class_("OpenThreadSrpComponent", cg.Component)
+
+
+def _convert_tlv(config):
+    if tlv := config.get(CONF_TLV):
+        config = config.copy()
+        parsed_tlv = parse_tlv(tlv)
+        validated = _CONNECTION_SCHEMA(parsed_tlv)
+        config.update(validated)
+        del config[CONF_TLV]
+    return config
+
+
+_CONNECTION_SCHEMA = cv.Schema(
+    {
+        cv.Inclusive(CONF_PAN_ID, "manual"): cv.hex_int,
+        cv.Inclusive(CONF_CHANNEL, "manual"): cv.int_,
+        cv.Inclusive(CONF_NETWORK_KEY, "manual"): cv.hex_int,
+        cv.Optional(CONF_EXT_PAN_ID): cv.hex_int,
+        cv.Optional(CONF_NETWORK_NAME): cv.string_strict,
+        cv.Optional(CONF_PSKC): cv.hex_int,
+        cv.Optional(CONF_MESH_LOCAL_PREFIX): cv.hex_int,
+    }
+)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(OpenThreadComponent),
+            cv.GenerateID(CONF_SRP_ID): cv.declare_id(OpenThreadSrpComponent),
+            cv.GenerateID(CONF_MDNS_ID): cv.use_id(MDNSComponent),
+            cv.Optional(CONF_FORCE_DATASET): cv.boolean,
+            cv.Optional(CONF_TLV): cv.string_strict,
+        }
+    ).extend(_CONNECTION_SCHEMA),
+    cv.has_exactly_one_key(CONF_PAN_ID, CONF_TLV),
+    _convert_tlv,
+    cv.only_with_esp_idf,
+    only_on_variant(supported=[VARIANT_ESP32C6, VARIANT_ESP32H2]),
+)
+
+
+def _final_validate(_):
+    full_config = fv.full_config.get()
+    network_config = full_config.get("network", {})
+    if not network_config.get(CONF_ENABLE_IPV6, False):
+        raise cv.Invalid(
+            "OpenThread requires IPv6 to be enabled in the network component. "
+            "Please set `enable_ipv6: true` in the `network` configuration."
+        )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    cg.add_define("USE_OPENTHREAD")
+
+    ot = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(ot, config)
+
+    srp = cg.new_Pvariable(config[CONF_SRP_ID])
+    mdns_component = await cg.get_variable(config[CONF_MDNS_ID])
+    cg.add(srp.set_mdns(mdns_component))
+    await cg.register_component(srp, config)
+
+    set_sdkconfig_options(config)

esphome/components/openthread/const.py

@@ -0,0 +1,10 @@
+CONF_EXT_PAN_ID = "ext_pan_id"
+CONF_FORCE_DATASET = "force_dataset"
+CONF_MDNS_ID = "mdns_id"
+CONF_MESH_LOCAL_PREFIX = "mesh_local_prefix"
+CONF_NETWORK_NAME = "network_name"
+CONF_NETWORK_KEY = "network_key"
+CONF_PAN_ID = "pan_id"
+CONF_PSKC = "pskc"
+CONF_SRP_ID = "srp_id"
+CONF_TLV = "tlv"