esphome 2025.4.2__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/nextion/nextion.h

@@ -35,8 +35,54 @@ using nextion_writer_t = std::function<void(Nextion &)>;
 
 static const std::string COMMAND_DELIMITER{static_cast<char>(255), static_cast<char>(255), static_cast<char>(255)};
 
+#ifdef USE_NEXTION_COMMAND_SPACING
+class NextionCommandPacer {
+ public:
+  /**
+   * @brief Creates command pacer with initial spacing
+   * @param initial_spacing Initial time between commands in milliseconds
+   */
+  explicit NextionCommandPacer(uint8_t initial_spacing = 0) : spacing_ms_(initial_spacing) {}
+
+  /**
+   * @brief Set the minimum time between commands
+   * @param spacing_ms Spacing in milliseconds
+   */
+  void set_spacing(uint8_t spacing_ms) { spacing_ms_ = spacing_ms; }
+
+  /**
+   * @brief Get current command spacing
+   * @return Current spacing in milliseconds
+   */
+  uint8_t get_spacing() const { return spacing_ms_; }
+
+  /**
+   * @brief Check if enough time has passed to send next command
+   * @return true if enough time has passed since last command
+   */
+  bool can_send() const { return (millis() - last_command_time_) >= spacing_ms_; }
+
+  /**
+   * @brief Mark a command as sent, updating the timing
+   */
+  void mark_sent() { last_command_time_ = millis(); }
+
+ private:
+  uint8_t spacing_ms_;
+  uint32_t last_command_time_{0};
+};
+#endif  // USE_NEXTION_COMMAND_SPACING
+
 class Nextion : public NextionBase, public PollingComponent, public uart::UARTDevice {
  public:
+#ifdef USE_NEXTION_COMMAND_SPACING
+  /**
+   * @brief Set the command spacing for the display
+   * @param spacing_ms Time in milliseconds between commands
+   */
+  void set_command_spacing(uint32_t spacing_ms) { this->command_pacer_.set_spacing(spacing_ms); }
+#endif  // USE_NEXTION_COMMAND_SPACING
+
   /**
    * Set the text of a component to a static string.
    * @param component The component name.
@@ -1227,6 +1273,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   bool is_connected() { return this->is_connected_; }
 
  protected:
+#ifdef USE_NEXTION_COMMAND_SPACING
+  NextionCommandPacer command_pacer_{0};
+#endif  // USE_NEXTION_COMMAND_SPACING
   std::deque<NextionQueue *> nextion_queue_;
   std::deque<NextionQueue *> waveform_queue_;
   uint16_t recv_ret_string_(std::string &response, uint32_t timeout, bool recv_flag);
@@ -1360,5 +1409,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   uint32_t started_ms_ = 0;
   bool sent_setup_commands_ = false;
 };
+
 }  // namespace nextion
 }  // namespace esphome

esphome/components/noblex/climate.py

@@ -1,20 +1,13 @@
 import esphome.codegen as cg
 from esphome.components import climate_ir
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
 
 AUTO_LOAD = ["climate_ir"]
 
 noblex_ns = cg.esphome_ns.namespace("noblex")
 NoblexClimate = noblex_ns.class_("NoblexClimate", climate_ir.ClimateIR)
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(NoblexClimate),
-    }
-)
+CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(NoblexClimate)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await climate_ir.register_climate_ir(var, config)
+    await climate_ir.new_climate_ir(config)

esphome/components/number/__init__.py

@@ -170,7 +170,7 @@ NUMBER_OPERATION_OPTIONS = {
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 validate_unit_of_measurement = cv.string_strict
 
-NUMBER_SCHEMA = (
+_NUMBER_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -196,16 +196,14 @@ NUMBER_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def number_schema(
     class_: MockObjClass,
     *,
-    icon: str = _UNDEF,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
-    unit_of_measurement: str = _UNDEF,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
+    unit_of_measurement: str = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {cv.GenerateID(): cv.declare_id(class_)}
 
@@ -215,10 +213,15 @@ def number_schema(
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
         (CONF_UNIT_OF_MEASUREMENT, unit_of_measurement, validate_unit_of_measurement),
     ]:
-        if default is not _UNDEF:
+        if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
 
-    return NUMBER_SCHEMA.extend(schema)
+    return _NUMBER_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+NUMBER_SCHEMA = number_schema(Number)
+NUMBER_SCHEMA.add_extra(cv.deprecated_schema_constant("number"))
 
 
 async def setup_number_core_(

esphome/components/one_wire/one_wire_bus.cpp

@@ -17,8 +17,15 @@ const uint8_t ONE_WIRE_ROM_SEARCH = 0xF0;
 
 const std::vector<uint64_t> &OneWireBus::get_devices() { return this->devices_; }
 
+bool OneWireBus::reset_() {
+  int res = this->reset_int();
+  if (res == -1)
+    ESP_LOGE(TAG, "1-wire bus is held low");
+  return res == 1;
+}
+
 bool IRAM_ATTR OneWireBus::select(uint64_t address) {
-  if (!this->reset())
+  if (!this->reset_())
     return false;
   this->write8(ONE_WIRE_ROM_SELECT);
   this->write64(address);
@@ -31,16 +38,13 @@ void OneWireBus::search() {
   this->reset_search();
   uint64_t address;
   while (true) {
-    {
-      InterruptLock lock;
-      if (!this->reset()) {
-        // Reset failed or no devices present
-        return;
-      }
-
-      this->write8(ONE_WIRE_ROM_SEARCH);
-      address = this->search_int();
+    if (!this->reset_()) {
+      // Reset failed or no devices present
+      return;
     }
+
+    this->write8(ONE_WIRE_ROM_SEARCH);
+    address = this->search_int();
     if (address == 0)
       break;
     auto *address8 = reinterpret_cast<uint8_t *>(&address);

esphome/components/one_wire/one_wire_bus.h

@@ -9,14 +9,6 @@ namespace one_wire {
 
 class OneWireBus {
  public:
-  /** Reset the bus, should be done before all write operations.
-   *
-   * Takes approximately 1ms.
-   *
-   * @return Whether the operation was successful.
-   */
-  virtual bool reset() = 0;
-
   /// Write a word to the bus. LSB first.
   virtual void write8(uint8_t val) = 0;
 
@@ -50,6 +42,20 @@ class OneWireBus {
   /// log the found devices
   void dump_devices_(const char *tag);
 
+  /** Reset the bus, should be done before all write operations.
+   *
+   * Takes approximately 1ms.
+   *
+   * @return Whether the operation was successful.
+   */
+  bool reset_();
+
+  /**
+   * Bus Reset
+   * @return -1: signal fail, 0: no device detected, 1: device detected
+   */
+  virtual int reset_int() = 0;
+
   /// Reset the device search.
   virtual void reset_search() = 0;
 

esphome/components/online_image/bmp_image.cpp

@@ -62,6 +62,13 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
       case 1:
         this->width_bytes_ = (this->width_ % 8 == 0) ? (this->width_ / 8) : (this->width_ / 8 + 1);
         break;
+      case 24:
+        this->width_bytes_ = this->width_ * 3;
+        if (this->width_bytes_ % 4 != 0) {
+          this->padding_bytes_ = 4 - (this->width_bytes_ % 4);
+          this->width_bytes_ += this->padding_bytes_;
+        }
+        break;
       default:
         ESP_LOGE(TAG, "Unsupported bits per pixel: %d", this->bits_per_pixel_);
         return DECODE_ERROR_UNSUPPORTED_FORMAT;
@@ -78,18 +85,48 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
     this->current_index_ = this->data_offset_;
     index = this->data_offset_;
   }
-  while (index < size) {
-    size_t paint_index = this->current_index_ - this->data_offset_;
-
-    uint8_t current_byte = buffer[index];
-    for (uint8_t i = 0; i < 8; i++) {
-      size_t x = (paint_index * 8) % this->width_ + i;
-      size_t y = (this->height_ - 1) - (paint_index / this->width_bytes_);
-      Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
-      this->draw(x, y, 1, 1, c);
+  switch (this->bits_per_pixel_) {
+    case 1: {
+      while (index < size) {
+        uint8_t current_byte = buffer[index];
+        for (uint8_t i = 0; i < 8; i++) {
+          size_t x = (this->paint_index_ % this->width_) + i;
+          size_t y = (this->height_ - 1) - (this->paint_index_ / this->width_);
+          Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
+          this->draw(x, y, 1, 1, c);
+        }
+        this->paint_index_ += 8;
+        this->current_index_++;
+        index++;
+      }
+      break;
     }
-    this->current_index_++;
-    index++;
+    case 24: {
+      while (index < size) {
+        if (index + 2 >= size) {
+          this->decoded_bytes_ += index;
+          return index;
+        }
+        uint8_t b = buffer[index];
+        uint8_t g = buffer[index + 1];
+        uint8_t r = buffer[index + 2];
+        size_t x = this->paint_index_ % this->width_;
+        size_t y = (this->height_ - 1) - (this->paint_index_ / this->width_);
+        Color c = Color(r, g, b);
+        this->draw(x, y, 1, 1, c);
+        this->paint_index_++;
+        this->current_index_ += 3;
+        index += 3;
+        if (x == this->width_ - 1 && this->padding_bytes_ > 0) {
+          index += this->padding_bytes_;
+          this->current_index_ += this->padding_bytes_;
+        }
+      }
+      break;
+    }
+    default:
+      ESP_LOGE(TAG, "Unsupported bits per pixel: %d", this->bits_per_pixel_);
+      return DECODE_ERROR_UNSUPPORTED_FORMAT;
   }
   this->decoded_bytes_ += size;
   return size;

esphome/components/online_image/bmp_image.h

@@ -24,6 +24,7 @@ class BmpDecoder : public ImageDecoder {
 
  protected:
   size_t current_index_{0};
+  size_t paint_index_{0};
   ssize_t width_{0};
   ssize_t height_{0};
   uint16_t bits_per_pixel_{0};
@@ -32,6 +33,7 @@ class BmpDecoder : public ImageDecoder {
   uint32_t color_table_entries_{0};
   size_t width_bytes_{0};
   size_t data_offset_{0};
+  uint8_t padding_bytes_{0};
 };
 
 }  // namespace online_image

esphome/components/opentherm/binary_sensor/__init__.py

@@ -11,10 +11,8 @@ COMPONENT_TYPE = const.BINARY_SENSOR
 
 def get_entity_validation_schema(entity: schema.BinarySensorSchema) -> cv.Schema:
     return binary_sensor.binary_sensor_schema(
-        device_class=(
-            entity.device_class or binary_sensor._UNDEF  # pylint: disable=protected-access
-        ),
-        icon=(entity.icon or binary_sensor._UNDEF),  # pylint: disable=protected-access
+        device_class=(entity.device_class or cv.UNDEFINED),
+        icon=(entity.icon or cv.UNDEFINED),
     )
 
 

esphome/components/opentherm/number/__init__.py

@@ -3,13 +3,7 @@ from typing import Any
 import esphome.codegen as cg
 from esphome.components import number
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    CONF_INITIAL_VALUE,
-    CONF_RESTORE_VALUE,
-    CONF_STEP,
-    CONF_UNIT_OF_MEASUREMENT,
-)
+from esphome.const import CONF_INITIAL_VALUE, CONF_RESTORE_VALUE, CONF_STEP
 
 from .. import const, generate, input, schema, validate
 
@@ -22,33 +16,30 @@ OpenthermNumber = generate.opentherm_ns.class_(
 
 
 async def new_openthermnumber(config: dict[str, Any]) -> cg.Pvariable:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await number.register_number(
-        var,
+    var = await number.new_number(
         config,
         min_value=config[input.CONF_min_value],
         max_value=config[input.CONF_max_value],
         step=config[input.CONF_step],
     )
+    await cg.register_component(var, config)
     input.generate_setters(var, config)
 
-    if CONF_INITIAL_VALUE in config:
-        cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
-    if CONF_RESTORE_VALUE in config:
-        cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
+    if (initial_value := config.get(CONF_INITIAL_VALUE, None)) is not None:
+        cg.add(var.set_initial_value(initial_value))
+    if (restore_value := config.get(CONF_RESTORE_VALUE, None)) is not None:
+        cg.add(var.set_restore_value(restore_value))
 
     return var
 
 
 def get_entity_validation_schema(entity: schema.InputSchema) -> cv.Schema:
     return (
-        number.NUMBER_SCHEMA.extend(
+        number.number_schema(
+            OpenthermNumber, unit_of_measurement=entity.unit_of_measurement
+        )
+        .extend(
             {
-                cv.GenerateID(): cv.declare_id(OpenthermNumber),
-                cv.Optional(
-                    CONF_UNIT_OF_MEASUREMENT, entity.unit_of_measurement
-                ): cv.string_strict,
                 cv.Optional(CONF_STEP, entity.step): cv.float_,
                 cv.Optional(CONF_INITIAL_VALUE): cv.float_,
                 cv.Optional(CONF_RESTORE_VALUE): cv.boolean,

esphome/components/opentherm/sensor/__init__.py

@@ -23,10 +23,10 @@ MSG_DATA_TYPES = {
 
 def get_entity_validation_schema(entity: schema.SensorSchema) -> cv.Schema:
     return sensor.sensor_schema(
-        unit_of_measurement=entity.unit_of_measurement or sensor._UNDEF,  # pylint: disable=protected-access
+        unit_of_measurement=entity.unit_of_measurement or cv.UNDEFINED,  # pylint: disable=protected-access
         accuracy_decimals=entity.accuracy_decimals,
-        device_class=entity.device_class or sensor._UNDEF,  # pylint: disable=protected-access
-        icon=entity.icon or sensor._UNDEF,  # pylint: disable=protected-access
+        device_class=entity.device_class or cv.UNDEFINED,  # pylint: disable=protected-access
+        icon=entity.icon or cv.UNDEFINED,  # pylint: disable=protected-access
         state_class=entity.state_class,
     ).extend(
         {

esphome/components/opentherm/switch/__init__.py

@@ -3,7 +3,6 @@ from typing import Any
 import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
-from esphome.const import CONF_ID
 
 from .. import const, generate, schema, validate
 
@@ -16,15 +15,14 @@ OpenthermSwitch = generate.opentherm_ns.class_(
 
 
 async def new_openthermswitch(config: dict[str, Any]) -> cg.Pvariable:
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await switch.new_switch(config)
     await cg.register_component(var, config)
-    await switch.register_switch(var, config)
     return var
 
 
 def get_entity_validation_schema(entity: schema.SwitchSchema) -> cv.Schema:
-    return switch.SWITCH_SCHEMA.extend(
-        {cv.GenerateID(): cv.declare_id(OpenthermSwitch)}
+    return switch.switch_schema(
+        OpenthermSwitch, default_restore_mode=entity.default_mode
     ).extend(cv.COMPONENT_SCHEMA)
 
 

esphome/components/output/lock/__init__.py

@@ -1,24 +1,26 @@
 import esphome.codegen as cg
 from esphome.components import lock, output
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_OUTPUT
+from esphome.const import CONF_OUTPUT
 
 from .. import output_ns
 
 OutputLock = output_ns.class_("OutputLock", lock.Lock, cg.Component)
 
-CONFIG_SCHEMA = lock.LOCK_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(OutputLock),
-        cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    lock.lock_schema(OutputLock)
+    .extend(
+        {
+            cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await lock.new_lock(config)
     await cg.register_component(var, config)
-    await lock.register_lock(var, config)
 
     output_ = await cg.get_variable(config[CONF_OUTPUT])
     cg.add(var.set_output(output_))

esphome/components/packages/__init__.py

@@ -24,22 +24,13 @@ DOMAIN = CONF_PACKAGES
 
 
 def validate_git_package(config: dict):
+    if CONF_URL not in config:
+        return config
+    config = BASE_SCHEMA(config)
     new_config = config
-    for key, conf in config.items():
-        if CONF_URL in conf:
-            try:
-                conf = BASE_SCHEMA(conf)
-                if CONF_FILE in conf:
-                    new_config[key][CONF_FILES] = [conf[CONF_FILE]]
-                    del new_config[key][CONF_FILE]
-            except cv.MultipleInvalid as e:
-                with cv.prepend_path([key]):
-                    raise e
-            except cv.Invalid as e:
-                raise cv.Invalid(
-                    "Extra keys not allowed in git based package",
-                    path=[key] + e.path,
-                ) from e
+    if CONF_FILE in config:
+        new_config[CONF_FILES] = [config[CONF_FILE]]
+        del new_config[CONF_FILE]
     return new_config
 
 
@@ -74,8 +65,8 @@ BASE_SCHEMA = cv.All(
             cv.Required(CONF_URL): cv.url,
             cv.Optional(CONF_USERNAME): cv.string,
             cv.Optional(CONF_PASSWORD): cv.string,
-            cv.Exclusive(CONF_FILE, "files"): validate_yaml_filename,
-            cv.Exclusive(CONF_FILES, "files"): cv.All(
+            cv.Exclusive(CONF_FILE, CONF_FILES): validate_yaml_filename,
+            cv.Exclusive(CONF_FILES, CONF_FILES): cv.All(
                 cv.ensure_list(
                     cv.Any(
                         validate_yaml_filename,
@@ -100,14 +91,17 @@ BASE_SCHEMA = cv.All(
     cv.has_at_least_one_key(CONF_FILE, CONF_FILES),
 )
 
+PACKAGE_SCHEMA = cv.All(
+    cv.Any(validate_source_shorthand, BASE_SCHEMA, dict), validate_git_package
+)
 
-CONFIG_SCHEMA = cv.All(
+CONFIG_SCHEMA = cv.Any(
     cv.Schema(
         {
-            str: cv.Any(validate_source_shorthand, BASE_SCHEMA, dict),
+            str: PACKAGE_SCHEMA,
         }
     ),
-    validate_git_package,
+    cv.ensure_list(PACKAGE_SCHEMA),
 )
 
 
@@ -183,25 +177,33 @@ def _process_base_package(config: dict) -> dict:
     return {"packages": packages}
 
 
+def _process_package(package_config, config):
+    recursive_package = package_config
+    if CONF_URL in package_config:
+        package_config = _process_base_package(package_config)
+    if isinstance(package_config, dict):
+        recursive_package = do_packages_pass(package_config)
+    config = merge_config(recursive_package, config)
+    return config
+
+
 def do_packages_pass(config: dict):
     if CONF_PACKAGES not in config:
         return config
     packages = config[CONF_PACKAGES]
     with cv.prepend_path(CONF_PACKAGES):
         packages = CONFIG_SCHEMA(packages)
-        if not isinstance(packages, dict):
+        if isinstance(packages, dict):
+            for package_name, package_config in reversed(packages.items()):
+                with cv.prepend_path(package_name):
+                    config = _process_package(package_config, config)
+        elif isinstance(packages, list):
+            for package_config in reversed(packages):
+                config = _process_package(package_config, config)
+        else:
             raise cv.Invalid(
-                f"Packages must be a key to value mapping, got {type(packages)} instead"
+                f"Packages must be a key to value mapping or list, got {type(packages)} instead"
             )
 
-        for package_name, package_config in reversed(packages.items()):
-            with cv.prepend_path(package_name):
-                recursive_package = package_config
-                if CONF_URL in package_config:
-                    package_config = _process_base_package(package_config)
-                if isinstance(package_config, dict):
-                    recursive_package = do_packages_pass(package_config)
-                config = merge_config(recursive_package, config)
-
         del config[CONF_PACKAGES]
     return config