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

esphome/components/mapping/__init__.py

@@ -0,0 +1,134 @@
+import difflib
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_FROM, CONF_ID, CONF_TO
+from esphome.core import CORE
+from esphome.cpp_generator import MockObj, VariableDeclarationExpression, add_global
+from esphome.loader import get_component
+
+CODEOWNERS = ["@clydebarrow"]
+MULTI_CONF = True
+
+map_ = cg.std_ns.class_("map")
+
+CONF_ENTRIES = "entries"
+CONF_CLASS = "class"
+
+
+class IndexType:
+    """
+    Represents a type of index in a map.
+    """
+
+    def __init__(self, validator, data_type, conversion):
+        self.validator = validator
+        self.data_type = data_type
+        self.conversion = conversion
+
+
+INDEX_TYPES = {
+    "int": IndexType(cv.int_, cg.int_, int),
+    "string": IndexType(cv.string, cg.std_string, str),
+}
+
+
+def to_schema(value):
+    """
+    Generate a schema for the 'to' field of a map. This can be either one of the index types or a class name.
+    :param value:
+    :return:
+    """
+    return cv.Any(
+        cv.one_of(*INDEX_TYPES, lower=True),
+        cv.one_of(*CORE.id_classes.keys()),
+    )(value)
+
+
+BASE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(map_),
+        cv.Required(CONF_FROM): cv.one_of(*INDEX_TYPES, lower=True),
+        cv.Required(CONF_TO): cv.string,
+    },
+    extra=cv.ALLOW_EXTRA,
+)
+
+
+def get_object_type(to_):
+    """
+    Get the object type from a string. Possible formats:
+       xxx The name of a component which defines INSTANCE_TYPE
+       esphome::xxx::yyy A C++ class name defined in a component
+       xxx::yyy A C++ class name defined in a component
+       yyy A C++ class name defined in the core
+    """
+
+    if cls := CORE.id_classes.get(to_):
+        return cls
+    if cls := CORE.id_classes.get(to_.removeprefix("esphome::")):
+        return cls
+    # get_component will throw a wobbly if we don't check this first.
+    if "." in to_:
+        return None
+    if component := get_component(to_):
+        return component.instance_type
+    return None
+
+
+def map_schema(config):
+    config = BASE_SCHEMA(config)
+    if CONF_ENTRIES not in config or not isinstance(config[CONF_ENTRIES], dict):
+        raise cv.Invalid("an entries list is required for a map")
+    entries = config[CONF_ENTRIES]
+    if len(entries) == 0:
+        raise cv.Invalid("Map must have at least one entry")
+    to_ = config[CONF_TO]
+    if to_ in INDEX_TYPES:
+        value_type = INDEX_TYPES[to_].validator
+    else:
+        value_type = get_object_type(to_)
+        if value_type is None:
+            matches = difflib.get_close_matches(to_, CORE.id_classes)
+            raise cv.Invalid(
+                f"No known mappable class name matches '{to_}'; did you mean one of {', '.join(matches)}?"
+            )
+        value_type = cv.use_id(value_type)
+    config[CONF_ENTRIES] = {k: value_type(v) for k, v in entries.items()}
+    return config
+
+
+CONFIG_SCHEMA = map_schema
+
+
+async def to_code(config):
+    entries = config[CONF_ENTRIES]
+    from_ = config[CONF_FROM]
+    to_ = config[CONF_TO]
+    index_conversion = INDEX_TYPES[from_].conversion
+    index_type = INDEX_TYPES[from_].data_type
+    if to_ in INDEX_TYPES:
+        value_conversion = INDEX_TYPES[to_].conversion
+        value_type = INDEX_TYPES[to_].data_type
+        entries = {
+            index_conversion(key): value_conversion(value)
+            for key, value in entries.items()
+        }
+    else:
+        entries = {
+            index_conversion(key): await cg.get_variable(value)
+            for key, value in entries.items()
+        }
+        value_type = get_object_type(to_)
+        if list(entries.values())[0].op != ".":
+            value_type = value_type.operator("ptr")
+    varid = config[CONF_ID]
+    varid.type = map_.template(index_type, value_type)
+    var = MockObj(varid, ".")
+    decl = VariableDeclarationExpression(varid.type, "", varid)
+    add_global(decl)
+    CORE.register_variable(varid, var)
+
+    for key, value in entries.items():
+        cg.add(var.insert((key, value)))
+    return var

esphome/components/matrix_keypad/matrix_keypad.cpp

@@ -1,5 +1,6 @@
 #include "matrix_keypad.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace matrix_keypad {
@@ -28,7 +29,7 @@ void MatrixKeypad::setup() {
 void MatrixKeypad::loop() {
   static uint32_t active_start = 0;
   static int active_key = -1;
-  uint32_t now = millis();
+  uint32_t now = App.get_loop_component_start_time();
   int key = -1;
   bool error = false;
   int pos = 0, row, col;

esphome/components/max7219digit/max7219digit.cpp

@@ -2,8 +2,11 @@
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/application.h"
 #include "max7219font.h"
 
+#include <algorithm>
+
 namespace esphome {
 namespace max7219digit {
 
@@ -61,45 +64,42 @@ void MAX7219Component::dump_config() {
 }
 
 void MAX7219Component::loop() {
-  uint32_t now = millis();
-
+  const uint32_t now = App.get_loop_component_start_time();
+  const uint32_t millis_since_last_scroll = now - this->last_scroll_;
+  const size_t first_line_size = this->max_displaybuffer_[0].size();
   // check if the buffer has shrunk past the current position since last update
-  if ((this->max_displaybuffer_[0].size() >= this->old_buffer_size_ + 3) ||
-      (this->max_displaybuffer_[0].size() <= this->old_buffer_size_ - 3)) {
+  if ((first_line_size >= this->old_buffer_size_ + 3) || (first_line_size <= this->old_buffer_size_ - 3)) {
+    ESP_LOGV(TAG, "Buffer size changed %d to %d", this->old_buffer_size_, first_line_size);
     this->stepsleft_ = 0;
     this->display();
-    this->old_buffer_size_ = this->max_displaybuffer_[0].size();
+    this->old_buffer_size_ = first_line_size;
   }
 
-  // Reset the counter back to 0 when full string has been displayed.
-  if (this->stepsleft_ > this->max_displaybuffer_[0].size())
-    this->stepsleft_ = 0;
-
-  // Return if there is no need to scroll or scroll is off
-  if (!this->scroll_ || (this->max_displaybuffer_[0].size() <= (size_t) get_width_internal())) {
+  if (!this->scroll_ || (first_line_size <= (size_t) get_width_internal())) {
+    ESP_LOGVV(TAG, "Return if there is no need to scroll or scroll is off.");
     this->display();
     return;
   }
 
-  if ((this->stepsleft_ == 0) && (now - this->last_scroll_ < this->scroll_delay_)) {
+  if ((this->stepsleft_ == 0) && (millis_since_last_scroll < this->scroll_delay_)) {
+    ESP_LOGVV(TAG, "At first step. Waiting for scroll delay");
     this->display();
     return;
   }
 
-  // Dwell time at end of string in case of stop at end
   if (this->scroll_mode_ == ScrollMode::STOP) {
-    if (this->stepsleft_ >= this->max_displaybuffer_[0].size() - (size_t) get_width_internal() + 1) {
-      if (now - this->last_scroll_ >= this->scroll_dwell_) {
-        this->stepsleft_ = 0;
-        this->last_scroll_ = now;
-        this->display();
+    if (this->stepsleft_ + get_width_internal() == first_line_size + 1) {
+      if (millis_since_last_scroll < this->scroll_dwell_) {
+        ESP_LOGVV(TAG, "Dwell time at end of string in case of stop at end. Step %d, since last scroll %d, dwell %d.",
+                  this->stepsleft_, millis_since_last_scroll, this->scroll_dwell_);
+        return;
       }
-      return;
+      ESP_LOGV(TAG, "Dwell time passed. Continue scrolling.");
     }
   }
 
-  // Actual call to scroll left action
-  if (now - this->last_scroll_ >= this->scroll_speed_) {
+  if (millis_since_last_scroll >= this->scroll_speed_) {
+    ESP_LOGVV(TAG, "Call to scroll left action");
     this->last_scroll_ = now;
     this->scroll_left();
     this->display();
@@ -227,19 +227,20 @@ void MAX7219Component::scroll(bool on_off) { this->set_scroll(on_off); }
 
 void MAX7219Component::scroll_left() {
   for (int chip_line = 0; chip_line < this->num_chip_lines_; chip_line++) {
+    auto scroll = [&](std::vector<uint8_t> &line, uint16_t steps) {
+      std::rotate(line.begin(), std::next(line.begin(), steps), line.end());
+    };
     if (this->update_) {
       this->max_displaybuffer_[chip_line].push_back(this->bckgrnd_);
-      for (uint16_t i = 0; i < this->stepsleft_; i++) {
-        this->max_displaybuffer_[chip_line].push_back(this->max_displaybuffer_[chip_line].front());
-        this->max_displaybuffer_[chip_line].erase(this->max_displaybuffer_[chip_line].begin());
-      }
+      scroll(this->max_displaybuffer_[chip_line],
+             (this->stepsleft_ + 1) % (this->max_displaybuffer_[chip_line].size()));
     } else {
-      this->max_displaybuffer_[chip_line].push_back(this->max_displaybuffer_[chip_line].front());
-      this->max_displaybuffer_[chip_line].erase(this->max_displaybuffer_[chip_line].begin());
+      scroll(this->max_displaybuffer_[chip_line], 1);
     }
   }
   this->update_ = false;
   this->stepsleft_++;
+  this->stepsleft_ %= this->max_displaybuffer_[0].size();
 }
 
 void MAX7219Component::send_char(uint8_t chip, uint8_t data) {

esphome/components/mdns/__init__.py

@@ -35,8 +35,8 @@ SERVICE_SCHEMA = cv.Schema(
     {
         cv.Required(CONF_SERVICE): cv.string,
         cv.Required(CONF_PROTOCOL): cv.string,
-        cv.Optional(CONF_PORT, default=0): cv.Any(0, cv.port),
-        cv.Optional(CONF_TXT, default={}): {cv.string: cv.string},
+        cv.Optional(CONF_PORT, default=0): cv.templatable(cv.Any(0, cv.port)),
+        cv.Optional(CONF_TXT, default={}): {cv.string: cv.templatable(cv.string)},
     }
 )
 
@@ -102,12 +102,18 @@ async def to_code(config):
 
     for service in config[CONF_SERVICES]:
         txt = [
-            mdns_txt_record(txt_key, txt_value)
+            cg.StructInitializer(
+                MDNSTXTRecord,
+                ("key", txt_key),
+                ("value", await cg.templatable(txt_value, [], cg.std_string)),
+            )
             for txt_key, txt_value in service[CONF_TXT].items()
         ]
-
         exp = mdns_service(
-            service[CONF_SERVICE], service[CONF_PROTOCOL], service[CONF_PORT], txt
+            service[CONF_SERVICE],
+            service[CONF_PROTOCOL],
+            await cg.templatable(service[CONF_PORT], [], cg.uint16),
+            txt,
         )
 
         cg.add(var.add_extra_service(exp))

esphome/components/mdns/mdns_component.cpp

@@ -1,9 +1,9 @@
 #include "esphome/core/defines.h"
 #ifdef USE_MDNS
-#include "mdns_component.h"
-#include "esphome/core/version.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
+#include "esphome/core/version.h"
+#include "mdns_component.h"
 
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
@@ -62,7 +62,11 @@ void MDNSComponent::compile_records_() {
 #endif
 
 #ifdef USE_API_NOISE
-    service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+    if (api::global_api_server->get_noise_ctx()->has_psk()) {
+      service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+    } else {
+      service.txt_records.push_back({"api_encryption_supported", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+    }
 #endif
 
 #ifdef ESPHOME_PROJECT_NAME
@@ -117,9 +121,11 @@ void MDNSComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "  Hostname: %s", this->hostname_.c_str());
   ESP_LOGV(TAG, "  Services:");
   for (const auto &service : this->services_) {
-    ESP_LOGV(TAG, "  - %s, %s, %d", service.service_type.c_str(), service.proto.c_str(), service.port);
+    ESP_LOGV(TAG, "  - %s, %s, %d", service.service_type.c_str(), service.proto.c_str(),
+             const_cast<TemplatableValue<uint16_t> &>(service.port).value());
     for (const auto &record : service.txt_records) {
-      ESP_LOGV(TAG, "    TXT: %s = %s", record.key.c_str(), record.value.c_str());
+      ESP_LOGV(TAG, "    TXT: %s = %s", record.key.c_str(),
+               const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
 }

esphome/components/mdns/mdns_component.h

@@ -3,6 +3,7 @@
 #ifdef USE_MDNS
 #include <string>
 #include <vector>
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 
 namespace esphome {
@@ -10,7 +11,7 @@ namespace mdns {
 
 struct MDNSTXTRecord {
   std::string key;
-  std::string value;
+  TemplatableValue<std::string> value;
 };
 
 struct MDNSService {
@@ -20,7 +21,7 @@ struct MDNSService {
   // second label indicating protocol _including_ underscore character prefix
   // as defined in RFC6763 Section 7, like "_tcp" or "_udp"
   std::string proto;
-  uint16_t port;
+  TemplatableValue<uint16_t> port;
   std::vector<MDNSTXTRecord> txt_records;
 };
 

esphome/components/mdns/mdns_esp32.cpp

@@ -31,11 +31,12 @@ void MDNSComponent::setup() {
       mdns_txt_item_t it{};
       // dup strings to ensure the pointer is valid even after the record loop
       it.key = strdup(record.key.c_str());
-      it.value = strdup(record.value.c_str());
+      it.value = strdup(const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
       txt_records.push_back(it);
     }
-    err = mdns_service_add(nullptr, service.service_type.c_str(), service.proto.c_str(), service.port,
-                           txt_records.data(), txt_records.size());
+    uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
+    err = mdns_service_add(nullptr, service.service_type.c_str(), service.proto.c_str(), port, txt_records.data(),
+                           txt_records.size());
 
     // free records
     for (const auto &it : txt_records) {

esphome/components/mdns/mdns_esp8266.cpp

@@ -29,9 +29,11 @@ void MDNSComponent::setup() {
     while (*service_type == '_') {
       service_type++;
     }
-    MDNS.addService(service_type, proto, service.port);
+    uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
+    MDNS.addService(service_type, proto, port);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(), record.value.c_str());
+      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
+                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
 }

esphome/components/mdns/mdns_libretiny.cpp

@@ -29,9 +29,11 @@ void MDNSComponent::setup() {
     while (*service_type == '_') {
       service_type++;
     }
-    MDNS.addService(service_type, proto, service.port);
+    uint16_t port_ = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
+    MDNS.addService(service_type, proto, port_);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(), record.value.c_str());
+      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
+                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
 }

esphome/components/mdns/mdns_rp2040.cpp

@@ -29,9 +29,11 @@ void MDNSComponent::setup() {
     while (*service_type == '_') {
       service_type++;
     }
-    MDNS.addService(service_type, proto, service.port);
+    uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
+    MDNS.addService(service_type, proto, port);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(), record.value.c_str());
+      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
+                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
 }

esphome/components/media_player/__init__.py

@@ -2,6 +2,8 @@ from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_ON_IDLE,
     CONF_ON_STATE,
@@ -10,6 +12,7 @@ from esphome.const import (
 )
 from esphome.core import CORE
 from esphome.coroutine import coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@jesserockz"]
@@ -103,7 +106,13 @@ async def register_media_player(var, config):
     await setup_media_player_core_(var, config)
 
 
-MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
+async def new_media_player(config, *args):
+    var = cg.new_Pvariable(config[CONF_ID], *args)
+    await register_media_player(var, config)
+    return var
+
+
+_MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
     {
         cv.Optional(CONF_ON_STATE): automation.validate_automation(
             {
@@ -134,6 +143,29 @@ MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
 )
 
 
+def media_player_schema(
+    class_: MockObjClass,
+    *,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {cv.GenerateID(CONF_ID): cv.declare_id(class_)}
+
+    for key, default, validator in [
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _MEDIA_PLAYER_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+MEDIA_PLAYER_SCHEMA = media_player_schema(MediaPlayer)
+MEDIA_PLAYER_SCHEMA.add_extra(cv.deprecated_schema_constant("media_player"))
+
+
 MEDIA_PLAYER_ACTION_SCHEMA = automation.maybe_simple_id(
     cv.Schema(
         {

esphome/components/mhz19/sensor.py

@@ -32,7 +32,7 @@ CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(MHZ19Component),
-            cv.Required(CONF_CO2): sensor.sensor_schema(
+            cv.Optional(CONF_CO2): sensor.sensor_schema(
                 unit_of_measurement=UNIT_PARTS_PER_MILLION,
                 icon=ICON_MOLECULE_CO2,
                 accuracy_decimals=0,
@@ -61,16 +61,20 @@ async def to_code(config):
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
 
-    if CONF_CO2 in config:
-        sens = await sensor.new_sensor(config[CONF_CO2])
+    if co2 := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2)
         cg.add(var.set_co2_sensor(sens))
 
-    if CONF_TEMPERATURE in config:
-        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
         cg.add(var.set_temperature_sensor(sens))
 
-    if CONF_AUTOMATIC_BASELINE_CALIBRATION in config:
-        cg.add(var.set_abc_enabled(config[CONF_AUTOMATIC_BASELINE_CALIBRATION]))
+    if (
+        automatic_baseline_calibration := config.get(
+            CONF_AUTOMATIC_BASELINE_CALIBRATION
+        )
+    ) is not None:
+        cg.add(var.set_abc_enabled(automatic_baseline_calibration))
 
     cg.add(var.set_warmup_seconds(config[CONF_WARMUP_TIME]))