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

esphome/components/lps22/sensor.py

@@ -0,0 +1,58 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ID,
+    CONF_TEMPERATURE,
+    CONF_PRESSURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    ICON_THERMOMETER,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+)
+
+CODEOWNERS = ["@nagisa"]
+DEPENDENCIES = ["i2c"]
+
+lps22 = cg.esphome_ns.namespace("lps22")
+
+LPS22Component = lps22.class_("LPS22Component", cg.PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(LPS22Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                icon=ICON_THERMOMETER,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x5D))  # can also be 0x5C
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))

esphome/components/ltr390/ltr390.h

@@ -44,7 +44,6 @@ enum LTR390RESOLUTION {
 
 class LTR390Component : public PollingComponent, public i2c::I2CDevice {
  public:
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/ltr501/ltr501.h

@@ -25,7 +25,6 @@ class LTRAlsPs501Component : 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/ltr_als_ps/ltr_als_ps.h

@@ -25,7 +25,6 @@ class LTRAlsPsComponent : 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/lvgl/__init__.py

@@ -466,7 +466,7 @@ LVGL_SCHEMA = cv.All(
                 ): lvalid.lv_color,
                 cv.Optional(df.CONF_THEME): cv.Schema(
                     {
-                        cv.Optional(name): obj_schema(w)
+                        cv.Optional(name): obj_schema(w).extend(FULL_STYLE_SCHEMA)
                         for name, w in WIDGET_TYPES.items()
                     }
                 ),

esphome/components/lvgl/schemas.py

@@ -21,7 +21,7 @@ from esphome.core.config import StartupTrigger
 from esphome.schema_extractors import SCHEMA_EXTRACT
 
 from . import defines as df, lv_validation as lvalid
-from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR
+from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR, TYPE_GRID
 from .helpers import add_lv_use, requires_component, validate_printf
 from .lv_validation import lv_color, lv_font, lv_gradient, lv_image, opacity
 from .lvcode import LvglComponent, lv_event_t_ptr
@@ -349,7 +349,60 @@ def obj_schema(widget_type: WidgetType):
     )
 
 
+def _validate_grid_layout(config):
+    layout = config[df.CONF_LAYOUT]
+    rows = len(layout[df.CONF_GRID_ROWS])
+    columns = len(layout[df.CONF_GRID_COLUMNS])
+    used_cells = [[None] * columns for _ in range(rows)]
+    for index, widget in enumerate(config[df.CONF_WIDGETS]):
+        _, w = next(iter(widget.items()))
+        if (df.CONF_GRID_CELL_COLUMN_POS in w) != (df.CONF_GRID_CELL_ROW_POS in w):
+            # pylint: disable=raise-missing-from
+            raise cv.Invalid(
+                "Both row and column positions must be specified, or both omitted",
+                [df.CONF_WIDGETS, index],
+            )
+        if df.CONF_GRID_CELL_ROW_POS in w:
+            row = w[df.CONF_GRID_CELL_ROW_POS]
+            column = w[df.CONF_GRID_CELL_COLUMN_POS]
+        else:
+            try:
+                row, column = next(
+                    (r_idx, c_idx)
+                    for r_idx, row in enumerate(used_cells)
+                    for c_idx, value in enumerate(row)
+                    if value is None
+                )
+            except StopIteration:
+                # pylint: disable=raise-missing-from
+                raise cv.Invalid(
+                    "No free cells available in grid layout", [df.CONF_WIDGETS, index]
+                )
+            w[df.CONF_GRID_CELL_ROW_POS] = row
+            w[df.CONF_GRID_CELL_COLUMN_POS] = column
+
+        for i in range(w[df.CONF_GRID_CELL_ROW_SPAN]):
+            for j in range(w[df.CONF_GRID_CELL_COLUMN_SPAN]):
+                if row + i >= rows or column + j >= columns:
+                    # pylint: disable=raise-missing-from
+                    raise cv.Invalid(
+                        f"Cell at {row}/{column} span {w[df.CONF_GRID_CELL_ROW_SPAN]}x{w[df.CONF_GRID_CELL_COLUMN_SPAN]} "
+                        f"exceeds grid size {rows}x{columns}",
+                        [df.CONF_WIDGETS, index],
+                    )
+                if used_cells[row + i][column + j] is not None:
+                    # pylint: disable=raise-missing-from
+                    raise cv.Invalid(
+                        f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
+                        [df.CONF_WIDGETS, index],
+                    )
+                used_cells[row + i][column + j] = index
+
+    return config
+
+
 LAYOUT_SCHEMAS = {}
+LAYOUT_VALIDATORS = {TYPE_GRID: _validate_grid_layout}
 
 ALIGN_TO_SCHEMA = {
     cv.Optional(df.CONF_ALIGN_TO): cv.Schema(
@@ -402,8 +455,8 @@ LAYOUT_SCHEMA = {
 }
 
 GRID_CELL_SCHEMA = {
-    cv.Required(df.CONF_GRID_CELL_ROW_POS): cv.positive_int,
-    cv.Required(df.CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
+    cv.Optional(df.CONF_GRID_CELL_ROW_POS): cv.positive_int,
+    cv.Optional(df.CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_ROW_SPAN, default=1): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_COLUMN_SPAN, default=1): cv.positive_int,
     cv.Optional(df.CONF_GRID_CELL_X_ALIGN): grid_alignments,
@@ -454,9 +507,13 @@ def container_validator(schema, widget_type: WidgetType):
     """
 
     def validator(value):
-        result = schema
         if w_sch := widget_type.schema:
-            result = result.extend(w_sch)
+            if isinstance(w_sch, dict):
+                w_sch = cv.Schema(w_sch)
+            # order is important here to preserve extras
+            result = w_sch.extend(schema)
+        else:
+            result = schema
         ltype = df.TYPE_NONE
         if value and (layout := value.get(df.CONF_LAYOUT)):
             if not isinstance(layout, dict):
@@ -470,7 +527,10 @@ def container_validator(schema, widget_type: WidgetType):
         result = result.extend(
             LAYOUT_SCHEMAS.get(ltype.lower(), LAYOUT_SCHEMAS[df.TYPE_NONE])
         )
-        return result(value)
+        value = result(value)
+        if layout_validator := LAYOUT_VALIDATORS.get(ltype):
+            value = layout_validator(value)
+        return value
 
     return validator
 

esphome/components/lvgl/styles.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.core import ID
-from esphome.cpp_generator import MockObj
 
 from .defines import (
     CONF_STYLE_DEFINITIONS,
@@ -13,12 +12,13 @@ from .defines import (
     literal,
 )
 from .helpers import add_lv_use
-from .lvcode import LambdaContext, LocalVariable, lv, lv_assign, lv_variable
+from .lvcode import LambdaContext, LocalVariable, lv
 from .schemas import ALL_STYLES, FULL_STYLE_SCHEMA, STYLE_REMAP
-from .types import ObjUpdateAction, lv_lambda_t, lv_obj_t, lv_obj_t_ptr, lv_style_t
+from .types import ObjUpdateAction, lv_obj_t, lv_style_t
 from .widgets import (
     Widget,
     add_widgets,
+    collect_parts,
     set_obj_properties,
     theme_widget_map,
     wait_for_widgets,
@@ -37,12 +37,18 @@ async def style_set(svar, style):
             lv.call(f"style_set_{remapped_prop}", svar, literal(value))
 
 
+async def create_style(style, id_name):
+    style_id = ID(id_name, True, lv_style_t)
+    svar = cg.new_Pvariable(style_id)
+    lv.style_init(svar)
+    await style_set(svar, style)
+    return svar
+
+
 async def styles_to_code(config):
     """Convert styles to C__ code."""
     for style in config.get(CONF_STYLE_DEFINITIONS, ()):
-        svar = cg.new_Pvariable(style[CONF_ID])
-        lv.style_init(svar)
-        await style_set(svar, style)
+        await create_style(style, style[CONF_ID].id)
 
 
 @automation.register_action(
@@ -68,16 +74,18 @@ async def theme_to_code(config):
     if theme := config.get(CONF_THEME):
         add_lv_use(CONF_THEME)
         for w_name, style in theme.items():
-            if not isinstance(style, dict):
-                continue
-
-            lname = "lv_theme_apply_" + w_name
-            apply = lv_variable(lv_lambda_t, lname)
-            theme_widget_map[w_name] = apply
-            ow = Widget.create("obj", MockObj(ID("obj")), obj_spec)
-            async with LambdaContext([(lv_obj_t_ptr, "obj")], where=w_name) as context:
-                await set_obj_properties(ow, style)
-            lv_assign(apply, await context.get_lambda())
+            # Work around Python 3.10 bug with nested async comprehensions
+            # With Python 3.11 this could be simplified
+            styles = {}
+            for part, states in collect_parts(style).items():
+                styles[part] = {
+                    state: await create_style(
+                        props,
+                        "_lv_theme_style_" + w_name + "_" + part + "_" + state,
+                    )
+                    for state, props in states.items()
+                }
+            theme_widget_map[w_name] = styles
 
 
 async def add_top_layer(lv_component, config):

esphome/components/lvgl/widgets/__init__.py

@@ -6,7 +6,7 @@ from esphome.config_validation import Invalid
 from esphome.const import CONF_DEFAULT, CONF_GROUP, CONF_ID, CONF_STATE, CONF_TYPE
 from esphome.core import ID, TimePeriod
 from esphome.coroutine import FakeAwaitable
-from esphome.cpp_generator import CallExpression, MockObj
+from esphome.cpp_generator import MockObj
 
 from ..defines import (
     CONF_FLEX_ALIGN_CROSS,
@@ -453,7 +453,17 @@ async def widget_to_code(w_cnfig, w_type: WidgetType, parent):
 
     w = Widget.create(wid, var, spec, w_cnfig)
     if theme := theme_widget_map.get(w_type):
-        lv_add(CallExpression(theme, w.obj))
+        for part, states in theme.items():
+            part = "LV_PART_" + part.upper()
+            for state, style in states.items():
+                state = "LV_STATE_" + state.upper()
+                if state == "LV_STATE_DEFAULT":
+                    lv_state = literal(part)
+                elif part == "LV_PART_MAIN":
+                    lv_state = literal(state)
+                else:
+                    lv_state = join_enums((state, part))
+                lv.obj_add_style(w.obj, style, lv_state)
     await set_obj_properties(w, w_cnfig)
     await add_widgets(w, w_cnfig)
     await spec.to_code(w, w_cnfig)

esphome/components/lvgl/widgets/lv_bar.py

@@ -1,8 +1,15 @@
 import esphome.config_validation as cv
 from esphome.const import CONF_MAX_VALUE, CONF_MIN_VALUE, CONF_MODE, CONF_VALUE
 
-from ..defines import BAR_MODES, CONF_ANIMATED, CONF_INDICATOR, CONF_MAIN, literal
-from ..lv_validation import animated, get_start_value, lv_float
+from ..defines import (
+    BAR_MODES,
+    CONF_ANIMATED,
+    CONF_INDICATOR,
+    CONF_MAIN,
+    CONF_START_VALUE,
+    literal,
+)
+from ..lv_validation import animated, lv_int
 from ..lvcode import lv
 from ..types import LvNumber, NumberType
 from . import Widget
@@ -10,22 +17,30 @@ from . import Widget
 # Note this file cannot be called "bar.py" because that name is disallowed.
 
 CONF_BAR = "bar"
-BAR_MODIFY_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_VALUE): lv_float,
-        cv.Optional(CONF_ANIMATED, default=True): animated,
-    }
-)
+
+
+def validate_bar(config):
+    if config.get(CONF_MODE) != "LV_BAR_MODE_RANGE" and CONF_START_VALUE in config:
+        raise cv.Invalid(
+            f"{CONF_START_VALUE} is only allowed when {CONF_MODE} is set to 'RANGE'"
+        )
+    if (CONF_MIN_VALUE in config) != (CONF_MAX_VALUE in config):
+        raise cv.Invalid(
+            f"If either {CONF_MIN_VALUE} or {CONF_MAX_VALUE} is set, both must be set"
+        )
+    return config
+
 
 BAR_SCHEMA = cv.Schema(
     {
-        cv.Optional(CONF_VALUE): lv_float,
-        cv.Optional(CONF_MIN_VALUE, default=0): cv.int_,
-        cv.Optional(CONF_MAX_VALUE, default=100): cv.int_,
-        cv.Optional(CONF_MODE, default="NORMAL"): BAR_MODES.one_of,
+        cv.Optional(CONF_VALUE): lv_int,
+        cv.Optional(CONF_START_VALUE): lv_int,
+        cv.Optional(CONF_MIN_VALUE): lv_int,
+        cv.Optional(CONF_MAX_VALUE): lv_int,
+        cv.Optional(CONF_MODE): BAR_MODES.one_of,
         cv.Optional(CONF_ANIMATED, default=True): animated,
     }
-)
+).add_extra(validate_bar)
 
 
 class BarType(NumberType):
@@ -35,17 +50,23 @@ class BarType(NumberType):
             LvNumber("lv_bar_t"),
             parts=(CONF_MAIN, CONF_INDICATOR),
             schema=BAR_SCHEMA,
-            modify_schema=BAR_MODIFY_SCHEMA,
         )
 
     async def to_code(self, w: Widget, config):
         var = w.obj
+        if mode := config.get(CONF_MODE):
+            lv.bar_set_mode(var, literal(mode))
+        is_animated = literal(config[CONF_ANIMATED])
         if CONF_MIN_VALUE in config:
-            lv.bar_set_range(var, config[CONF_MIN_VALUE], config[CONF_MAX_VALUE])
-            lv.bar_set_mode(var, literal(config[CONF_MODE]))
-        value = await get_start_value(config)
-        if value is not None:
-            lv.bar_set_value(var, value, literal(config[CONF_ANIMATED]))
+            lv.bar_set_range(
+                var,
+                await lv_int.process(config[CONF_MIN_VALUE]),
+                await lv_int.process(config[CONF_MAX_VALUE]),
+            )
+        if value := await lv_int.process(config.get(CONF_VALUE)):
+            lv.bar_set_value(var, value, is_animated)
+        if start_value := await lv_int.process(config.get(CONF_START_VALUE)):
+            lv.bar_set_start_value(var, start_value, is_animated)
 
     @property
     def animated(self):

esphome/components/m5stack_8angle/light/m5stack_8angle_light.cpp

@@ -8,7 +8,7 @@ namespace m5stack_8angle {
 static const char *const TAG = "m5stack_8angle.light";
 
 void M5Stack8AngleLightOutput::setup() {
-  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> allocator;
   this->buf_ = allocator.allocate(M5STACK_8ANGLE_NUM_LEDS * M5STACK_8ANGLE_BYTES_PER_LED);
   if (this->buf_ == nullptr) {
     ESP_LOGE(TAG, "Failed to allocate buffer of size %u", M5STACK_8ANGLE_NUM_LEDS * M5STACK_8ANGLE_BYTES_PER_LED);

esphome/components/max9611/max9611.h

@@ -38,7 +38,6 @@ class MAX9611Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void update() override;
   void set_voltage_sensor(sensor::Sensor *vs) { voltage_sensor_ = vs; }
   void set_current_sensor(sensor::Sensor *cs) { current_sensor_ = cs; }

esphome/components/mcp23016/__init__.py

@@ -50,7 +50,7 @@ MCP23016_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=15),
     modes=[CONF_INPUT, CONF_OUTPUT],
     mode_validator=validate_mode,
-    invertable=True,
+    invertible=True,
 ).extend(
     {
         cv.Required(CONF_MCP23016): cv.use_id(MCP23016),

esphome/components/mcp23xxx_base/__init__.py

@@ -60,7 +60,7 @@ MCP23XXX_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=15),
     modes=[CONF_INPUT, CONF_OUTPUT, CONF_PULLUP],
     mode_validator=validate_mode,
-    invertable=True,
+    invertible=True,
 ).extend(
     {
         cv.Required(CONF_MCP23XXX): cv.use_id(MCP23XXXBase),

esphome/components/mcp4461/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import i2c
+import esphome.config_validation as cv
 from esphome.const import CONF_ID
 
 CODEOWNERS = ["@p1ngb4ck"]

esphome/components/mcp4461/output/__init__.py

@@ -1,8 +1,9 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import output
+import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID, CONF_INITIAL_VALUE
-from .. import Mcp4461Component, CONF_MCP4461_ID, mcp4461_ns
+
+from .. import CONF_MCP4461_ID, Mcp4461Component, mcp4461_ns
 
 DEPENDENCIES = ["mcp4461"]
 

esphome/components/mcp9600/mcp9600.h

@@ -24,8 +24,6 @@ class MCP9600Component : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   void update() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void set_hot_junction(sensor::Sensor *hot_junction) { this->hot_junction_sensor_ = hot_junction; }
   void set_cold_junction(sensor::Sensor *cold_junction) { this->cold_junction_sensor_ = cold_junction; }
   void set_thermocouple_type(MCP9600ThermocoupleType thermocouple_type) {

esphome/components/md5/md5.cpp

@@ -7,7 +7,7 @@
 namespace esphome {
 namespace md5 {
 
-#if defined(USE_ARDUINO) && !defined(USE_RP2040)
+#if defined(USE_ARDUINO) && !defined(USE_RP2040) && !defined(USE_ESP32)
 void MD5Digest::init() {
   memset(this->digest_, 0, 16);
   MD5Init(&this->ctx_);
@@ -18,7 +18,7 @@ void MD5Digest::add(const uint8_t *data, size_t len) { MD5Update(&this->ctx_, da
 void MD5Digest::calculate() { MD5Final(this->digest_, &this->ctx_); }
 #endif  // USE_ARDUINO && !USE_RP2040
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 void MD5Digest::init() {
   memset(this->digest_, 0, 16);
   esp_rom_md5_init(&this->ctx_);
@@ -27,7 +27,7 @@ void MD5Digest::init() {
 void MD5Digest::add(const uint8_t *data, size_t len) { esp_rom_md5_update(&this->ctx_, data, len); }
 
 void MD5Digest::calculate() { esp_rom_md5_final(this->digest_, &this->ctx_); }
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32
 
 #ifdef USE_RP2040
 void MD5Digest::init() {

esphome/components/md5/md5.h

@@ -3,16 +3,11 @@
 #include "esphome/core/defines.h"
 #ifdef USE_MD5
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 #include "esp_rom_md5.h"
 #define MD5_CTX_TYPE md5_context_t
 #endif
 
-#if defined(USE_ARDUINO) && defined(USE_ESP32)
-#include "rom/md5_hash.h"
-#define MD5_CTX_TYPE MD5Context
-#endif
-
 #if defined(USE_ARDUINO) && defined(USE_ESP8266)
 #include <md5.h>
 #define MD5_CTX_TYPE md5_context_t

esphome/components/mdns/__init__.py

@@ -1,5 +1,6 @@
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DISABLED,
@@ -8,8 +9,7 @@ from esphome.const import (
     CONF_PROTOCOL,
     CONF_SERVICE,
     CONF_SERVICES,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
+    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 
@@ -85,15 +85,8 @@ async def to_code(config):
         elif CORE.is_rp2040:
             cg.add_library("LEAmDNS", None)
 
-    if CORE.using_esp_idf and CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(
-        5, 0, 0
-    ):
-        add_idf_component(
-            name="mdns",
-            repo="https://github.com/espressif/esp-protocols.git",
-            ref="mdns-v1.8.2",
-            path="components/mdns",
-        )
+    if CORE.using_esp_idf:
+        add_idf_component(name="espressif/mdns", ref="1.8.2")
 
     cg.add_define("USE_MDNS")
 
@@ -117,3 +110,21 @@ async def to_code(config):
         )
 
         cg.add(var.add_extra_service(exp))
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "mdns_esp32.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        "mdns_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "mdns_host.cpp": {PlatformFramework.HOST_NATIVE},
+        "mdns_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
+        "mdns_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+    }
+)

esphome/components/media_player/__init__.py

@@ -11,9 +11,9 @@ from esphome.const import (
     CONF_VOLUME,
 )
 from esphome.core import CORE
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.coroutine import coroutine_with_priority
 from esphome.cpp_generator import MockObjClass
-from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@jesserockz"]
 
@@ -81,7 +81,7 @@ IsAnnouncingCondition = media_player_ns.class_(
 
 
 async def setup_media_player_core_(var, config):
-    await setup_entity(var, config)
+    await setup_entity(var, config, "media_player")
     for conf in config.get(CONF_ON_STATE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
@@ -143,6 +143,8 @@ _MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
     }
 )
 
+_MEDIA_PLAYER_SCHEMA.add_extra(entity_duplicate_validator("media_player"))
+
 
 def media_player_schema(
     class_: MockObjClass,
@@ -166,7 +168,6 @@ def media_player_schema(
 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/micro_wake_word/__init__.py

@@ -449,11 +449,7 @@ async def to_code(config):
     cg.add_define("USE_MICRO_WAKE_WORD")
     cg.add_define("USE_OTA_STATE_CALLBACK")
 
-    esp32.add_idf_component(
-        name="esp-tflite-micro",
-        repo="https://github.com/espressif/esp-tflite-micro",
-        ref="v1.3.3.1",
-    )
+    esp32.add_idf_component(name="espressif/esp-tflite-micro", ref="1.3.3~1")
 
     cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
     cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")

esphome/components/micro_wake_word/streaming_model.cpp

@@ -27,7 +27,7 @@ void VADModel::log_model_config() {
 }
 
 bool StreamingModel::load_model_() {
-  RAMAllocator<uint8_t> arena_allocator(RAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> arena_allocator;
 
   if (this->tensor_arena_ == nullptr) {
     this->tensor_arena_ = arena_allocator.allocate(this->tensor_arena_size_);
@@ -96,7 +96,7 @@ bool StreamingModel::load_model_() {
 void StreamingModel::unload_model() {
   this->interpreter_.reset();
 
-  RAMAllocator<uint8_t> arena_allocator(RAMAllocator<uint8_t>::ALLOW_FAILURE);
+  RAMAllocator<uint8_t> arena_allocator;
 
   if (this->tensor_arena_ != nullptr) {
     arena_allocator.deallocate(this->tensor_arena_, this->tensor_arena_size_);

esphome/components/microphone/microphone.cpp

@@ -5,17 +5,15 @@ namespace microphone {
 
 void Microphone::add_data_callback(std::function<void(const std::vector<uint8_t> &)> &&data_callback) {
   std::function<void(const std::vector<uint8_t> &)> mute_handled_callback =
-      [this, data_callback](const std::vector<uint8_t> &data) { data_callback(this->silence_audio_(data)); };
+      [this, data_callback](const std::vector<uint8_t> &data) {
+        if (this->mute_state_) {
+          data_callback(std::vector<uint8_t>(data.size(), 0));
+        } else {
+          data_callback(data);
+        };
+      };
   this->data_callbacks_.add(std::move(mute_handled_callback));
 }
 
-std::vector<uint8_t> Microphone::silence_audio_(std::vector<uint8_t> data) {
-  if (this->mute_state_) {
-    std::memset((void *) data.data(), 0, data.size());
-  }
-
-  return data;
-}
-
 }  // namespace microphone
 }  // namespace esphome