esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

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,11 +143,36 @@ MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
 )
 
 
-MEDIA_PLAYER_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.use_id(MediaPlayer),
-        cv.Optional(CONF_ANNOUNCEMENT, default=False): cv.templatable(cv.boolean),
-    }
+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(
+        {
+            cv.GenerateID(): cv.use_id(MediaPlayer),
+            cv.Optional(CONF_ANNOUNCEMENT, default=False): cv.templatable(cv.boolean),
+        }
+    )
 )
 
 MEDIA_PLAYER_CONDITION_SCHEMA = automation.maybe_simple_id(

esphome/components/micro_wake_word/__init__.py

@@ -12,6 +12,7 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_FILE,
     CONF_ID,
+    CONF_INTERNAL,
     CONF_MICROPHONE,
     CONF_MODEL,
     CONF_PASSWORD,
@@ -40,6 +41,7 @@ CONF_ON_WAKE_WORD_DETECTED = "on_wake_word_detected"
 CONF_PROBABILITY_CUTOFF = "probability_cutoff"
 CONF_SLIDING_WINDOW_AVERAGE_SIZE = "sliding_window_average_size"
 CONF_SLIDING_WINDOW_SIZE = "sliding_window_size"
+CONF_STOP_AFTER_DETECTION = "stop_after_detection"
 CONF_TENSOR_ARENA_SIZE = "tensor_arena_size"
 CONF_VAD = "vad"
 
@@ -49,13 +51,20 @@ micro_wake_word_ns = cg.esphome_ns.namespace("micro_wake_word")
 
 MicroWakeWord = micro_wake_word_ns.class_("MicroWakeWord", cg.Component)
 
+DisableModelAction = micro_wake_word_ns.class_("DisableModelAction", automation.Action)
+EnableModelAction = micro_wake_word_ns.class_("EnableModelAction", automation.Action)
 StartAction = micro_wake_word_ns.class_("StartAction", automation.Action)
 StopAction = micro_wake_word_ns.class_("StopAction", automation.Action)
 
+ModelIsEnabledCondition = micro_wake_word_ns.class_(
+    "ModelIsEnabledCondition", automation.Condition
+)
 IsRunningCondition = micro_wake_word_ns.class_(
     "IsRunningCondition", automation.Condition
 )
 
+WakeWordModel = micro_wake_word_ns.class_("WakeWordModel")
+
 
 def _validate_json_filename(value):
     value = cv.string(value)
@@ -169,9 +178,10 @@ def _convert_manifest_v1_to_v2(v1_manifest):
 
     # Original Inception-based V1 manifest models require a minimum of 45672 bytes
     v2_manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE] = 45672
-
     # Original Inception-based V1 manifest models use a 20 ms feature step size
     v2_manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE] = 20
+    # Original Inception-based V1 manifest models were trained only on TTS English samples
+    v2_manifest[KEY_TRAINED_LANGUAGES] = ["en"]
 
     return v2_manifest
 
@@ -296,14 +306,16 @@ MODEL_SOURCE_SCHEMA = cv.Any(
 
 MODEL_SCHEMA = cv.Schema(
     {
+        cv.GenerateID(CONF_ID): cv.declare_id(WakeWordModel),
         cv.Optional(CONF_MODEL): MODEL_SOURCE_SCHEMA,
         cv.Optional(CONF_PROBABILITY_CUTOFF): cv.percentage,
         cv.Optional(CONF_SLIDING_WINDOW_SIZE): cv.positive_int,
+        cv.Optional(CONF_INTERNAL, default=False): cv.boolean,
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
     }
 )
 
-# Provide a default VAD model that could be overridden
+# Provides a default VAD model that could be overridden
 VAD_MODEL_SCHEMA = MODEL_SCHEMA.extend(
     cv.Schema(
         {
@@ -328,7 +340,14 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(MicroWakeWord),
-            cv.GenerateID(CONF_MICROPHONE): cv.use_id(microphone.Microphone),
+            cv.Optional(
+                CONF_MICROPHONE, default={}
+            ): microphone.microphone_source_schema(
+                min_bits_per_sample=16,
+                max_bits_per_sample=16,
+                min_channels=1,
+                max_channels=1,
+            ),
             cv.Required(CONF_MODELS): cv.ensure_list(
                 cv.maybe_simple_value(MODEL_SCHEMA, key=CONF_MODEL)
             ),
@@ -336,6 +355,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_VAD): _maybe_empty_vad_schema,
+            cv.Optional(CONF_STOP_AFTER_DETECTION, default=True): cv.boolean,
             cv.Optional(CONF_MODEL): cv.invalid(
                 f"The {CONF_MODEL} parameter has moved to be a list element under the {CONF_MODELS} parameter."
             ),
@@ -404,39 +424,42 @@ def _feature_step_size_validate(config):
             raise cv.Invalid("Cannot load models with different features step sizes.")
 
 
-FINAL_VALIDATE_SCHEMA = _feature_step_size_validate
+FINAL_VALIDATE_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(
+                CONF_MICROPHONE
+            ): microphone.final_validate_microphone_source_schema(
+                "micro_wake_word", sample_rate=16000
+            ),
+        },
+        extra=cv.ALLOW_EXTRA,
+    ),
+    _feature_step_size_validate,
+)
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    mic = await cg.get_variable(config[CONF_MICROPHONE])
-    cg.add(var.set_microphone(mic))
+    mic_source = await microphone.microphone_source_to_code(config[CONF_MICROPHONE])
+    cg.add(var.set_microphone_source(mic_source))
+
+    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.1",
-    )
-    # add esp-nn dependency for tflite-micro to work around https://github.com/espressif/esp-nn/issues/17
-    # ...remove after switching to IDF 5.1.4+
-    esp32.add_idf_component(
-        name="esp-nn",
-        repo="https://github.com/espressif/esp-nn",
-        ref="v1.1.0",
+        ref="v1.3.3.1",
     )
 
     cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
     cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")
     cg.add_build_flag("-DESP_NN")
 
-    if on_wake_word_detection_config := config.get(CONF_ON_WAKE_WORD_DETECTED):
-        await automation.build_automation(
-            var.get_wake_word_detected_trigger(),
-            [(cg.std_string, "wake_word")],
-            on_wake_word_detection_config,
-        )
+    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.1.0")
 
     if vad_model := config.get(CONF_VAD):
         cg.add_define("USE_MICRO_WAKE_WORD_VAD")
@@ -444,7 +467,7 @@ async def to_code(config):
         # Use the general model loading code for the VAD codegen
         config[CONF_MODELS].append(vad_model)
 
-    for model_parameters in config[CONF_MODELS]:
+    for i, model_parameters in enumerate(config[CONF_MODELS]):
         model_config = model_parameters.get(CONF_MODEL)
         data = []
         manifest, data = _model_config_to_manifest_data(model_config)
@@ -455,6 +478,8 @@ async def to_code(config):
         probability_cutoff = model_parameters.get(
             CONF_PROBABILITY_CUTOFF, manifest[KEY_MICRO][CONF_PROBABILITY_CUTOFF]
         )
+        quantized_probability_cutoff = int(probability_cutoff * 255)
+
         sliding_window_size = model_parameters.get(
             CONF_SLIDING_WINDOW_SIZE,
             manifest[KEY_MICRO][CONF_SLIDING_WINDOW_SIZE],
@@ -464,24 +489,40 @@ async def to_code(config):
             cg.add(
                 var.add_vad_model(
                     prog_arr,
-                    probability_cutoff,
+                    quantized_probability_cutoff,
                     sliding_window_size,
                     manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE],
                 )
             )
         else:
-            cg.add(
-                var.add_wake_word_model(
-                    prog_arr,
-                    probability_cutoff,
-                    sliding_window_size,
-                    manifest[KEY_WAKE_WORD],
-                    manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE],
-                )
+            # Only enable the first wake word by default. After first boot, the enable state is saved/loaded to the flash
+            default_enabled = i == 0
+            wake_word_model = cg.new_Pvariable(
+                model_parameters[CONF_ID],
+                str(model_parameters[CONF_ID]),
+                prog_arr,
+                quantized_probability_cutoff,
+                sliding_window_size,
+                manifest[KEY_WAKE_WORD],
+                manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE],
+                default_enabled,
+                model_parameters[CONF_INTERNAL],
             )
 
+            for lang in manifest[KEY_TRAINED_LANGUAGES]:
+                cg.add(wake_word_model.add_trained_language(lang))
+
+            cg.add(var.add_wake_word_model(wake_word_model))
+
     cg.add(var.set_features_step_size(manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE]))
-    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.1.0")
+    cg.add(var.set_stop_after_detection(config[CONF_STOP_AFTER_DETECTION]))
+
+    if on_wake_word_detection_config := config.get(CONF_ON_WAKE_WORD_DETECTED):
+        await automation.build_automation(
+            var.get_wake_word_detected_trigger(),
+            [(cg.std_string, "wake_word")],
+            on_wake_word_detection_config,
+        )
 
 
 MICRO_WAKE_WORD_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(MicroWakeWord)})
@@ -496,3 +537,30 @@ async def micro_wake_word_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var
+
+
+MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA = automation.maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(WakeWordModel),
+    }
+)
+
+
+@register_action(
+    "micro_wake_word.enable_model",
+    EnableModelAction,
+    MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA,
+)
+@register_action(
+    "micro_wake_word.disable_model",
+    DisableModelAction,
+    MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA,
+)
+@register_condition(
+    "micro_wake_word.model_is_enabled",
+    ModelIsEnabledCondition,
+    MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA,
+)
+async def model_action(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, parent)

esphome/components/micro_wake_word/automation.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "micro_wake_word.h"
+#include "streaming_model.h"
+
+#ifdef USE_ESP_IDF
+namespace esphome {
+namespace micro_wake_word {
+
+template<typename... Ts> class StartAction : public Action<Ts...>, public Parented<MicroWakeWord> {
+ public:
+  void play(Ts... x) override { this->parent_->start(); }
+};
+
+template<typename... Ts> class StopAction : public Action<Ts...>, public Parented<MicroWakeWord> {
+ public:
+  void play(Ts... x) override { this->parent_->stop(); }
+};
+
+template<typename... Ts> class IsRunningCondition : public Condition<Ts...>, public Parented<MicroWakeWord> {
+ public:
+  bool check(Ts... x) override { return this->parent_->is_running(); }
+};
+
+template<typename... Ts> class EnableModelAction : public Action<Ts...> {
+ public:
+  explicit EnableModelAction(WakeWordModel *wake_word_model) : wake_word_model_(wake_word_model) {}
+  void play(Ts... x) override { this->wake_word_model_->enable(); }
+
+ protected:
+  WakeWordModel *wake_word_model_;
+};
+
+template<typename... Ts> class DisableModelAction : public Action<Ts...> {
+ public:
+  explicit DisableModelAction(WakeWordModel *wake_word_model) : wake_word_model_(wake_word_model) {}
+  void play(Ts... x) override { this->wake_word_model_->disable(); }
+
+ protected:
+  WakeWordModel *wake_word_model_;
+};
+
+template<typename... Ts> class ModelIsEnabledCondition : public Condition<Ts...> {
+ public:
+  explicit ModelIsEnabledCondition(WakeWordModel *wake_word_model) : wake_word_model_(wake_word_model) {}
+  bool check(Ts... x) override { return this->wake_word_model_->is_enabled(); }
+
+ protected:
+  WakeWordModel *wake_word_model_;
+};
+
+}  // namespace micro_wake_word
+}  // namespace esphome
+#endif