esphome 2025.8.4__py3-none-any.whl → 2025.9.0__py3-none-any.whl

esphome/components/mapping/mapping.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include <map>
+#include <string>
+
+namespace esphome::mapping {
+
+using alloc_string_t = std::basic_string<char, std::char_traits<char>, RAMAllocator<char>>;
+
+/**
+ *
+ * Mapping class with custom allocator.
+ * Additionally, when std::string is used as key or value, it will be replaced with a custom string type
+ * that uses RAMAllocator.
+ * @tparam K The type of the key in the mapping.
+ * @tparam V The type of the value in the mapping. Should be a basic type or pointer.
+ */
+
+static const char *const TAG = "mapping";
+
+template<typename K, typename V> class Mapping {
+ public:
+  // Constructor
+  Mapping() = default;
+
+  using key_t = const std::conditional_t<std::is_same_v<K, std::string>,
+                                         alloc_string_t,  // if K is std::string, custom string type
+                                         K>;
+  using value_t = std::conditional_t<std::is_same_v<V, std::string>,
+                                     alloc_string_t,  // if V is std::string, custom string type
+                                     V>;
+
+  void set(const K &key, const V &value) { this->map_[key_t{key}] = value; }
+
+  V get(const K &key) const {
+    auto it = this->map_.find(key_t{key});
+    if (it != this->map_.end()) {
+      return V{it->second};
+    }
+    if constexpr (std::is_pointer_v<K>) {
+      esph_log_e(TAG, "Key '%p' not found in mapping", key);
+    } else if constexpr (std::is_same_v<K, std::string>) {
+      esph_log_e(TAG, "Key '%s' not found in mapping", key.c_str());
+    } else {
+      esph_log_e(TAG, "Key '%s' not found in mapping", to_string(key).c_str());
+    }
+    return {};
+  }
+
+  // index map overload
+  V operator[](K key) { return this->get(key); }
+
+  // convenience function for strings to get a C-style string
+  template<typename T = V, std::enable_if_t<std::is_same_v<T, std::string>, int> = 0>
+  const char *operator[](K key) const {
+    auto it = this->map_.find(key_t{key});
+    if (it != this->map_.end()) {
+      return it->second.c_str();  // safe since value remains in map
+    }
+    return "";
+  }
+
+ protected:
+  std::map<key_t, value_t, std::less<key_t>, RAMAllocator<std::pair<key_t, value_t>>> map_;
+};
+
+}  // namespace esphome::mapping

esphome/components/max17043/max17043.cpp

@@ -22,7 +22,7 @@ void MAX17043Component::update() {
 
   if (this->voltage_sensor_ != nullptr) {
     if (!this->read_byte_16(MAX17043_VCELL, &raw_voltage)) {
-      this->status_set_warning("Unable to read MAX17043_VCELL");
+      this->status_set_warning(LOG_STR("Unable to read MAX17043_VCELL"));
     } else {
       float voltage = (1.25 * (float) (raw_voltage >> 4)) / 1000.0;
       this->voltage_sensor_->publish_state(voltage);
@@ -31,7 +31,7 @@ void MAX17043Component::update() {
   }
   if (this->battery_remaining_sensor_ != nullptr) {
     if (!this->read_byte_16(MAX17043_SOC, &raw_percent)) {
-      this->status_set_warning("Unable to read MAX17043_SOC");
+      this->status_set_warning(LOG_STR("Unable to read MAX17043_SOC"));
     } else {
       float percent = (float) ((raw_percent >> 8) + 0.003906f * (raw_percent & 0x00ff));
       this->battery_remaining_sensor_->publish_state(percent);

esphome/components/mcp23016/__init__.py

@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_OUTPUT,
 )
 
+AUTO_LOAD = ["gpio_expander"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 

esphome/components/mcp23016/mcp23016.cpp

@@ -22,14 +22,29 @@ void MCP23016::setup() {
   this->write_reg_(MCP23016_IODIR0, 0xFF);
   this->write_reg_(MCP23016_IODIR1, 0xFF);
 }
-bool MCP23016::digital_read(uint8_t pin) {
-  uint8_t bit = pin % 8;
+
+void MCP23016::loop() {
+  // Invalidate cache at the start of each loop
+  this->reset_pin_cache_();
+}
+bool MCP23016::digital_read_hw(uint8_t pin) {
   uint8_t reg_addr = pin < 8 ? MCP23016_GP0 : MCP23016_GP1;
   uint8_t value = 0;
-  this->read_reg_(reg_addr, &value);
-  return value & (1 << bit);
+  if (!this->read_reg_(reg_addr, &value)) {
+    return false;
+  }
+
+  // Update the appropriate part of input_mask_
+  if (pin < 8) {
+    this->input_mask_ = (this->input_mask_ & 0xFF00) | value;
+  } else {
+    this->input_mask_ = (this->input_mask_ & 0x00FF) | (uint16_t(value) << 8);
+  }
+  return true;
 }
-void MCP23016::digital_write(uint8_t pin, bool value) {
+
+bool MCP23016::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+void MCP23016::digital_write_hw(uint8_t pin, bool value) {
   uint8_t reg_addr = pin < 8 ? MCP23016_OLAT0 : MCP23016_OLAT1;
   this->update_reg_(pin, value, reg_addr);
 }

esphome/components/mcp23016/mcp23016.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/gpio_expander/cached_gpio.h"
 
 namespace esphome {
 namespace mcp23016 {
@@ -24,19 +25,22 @@ enum MCP23016GPIORegisters {
   MCP23016_IOCON1 = 0x0B,
 };
 
-class MCP23016 : public Component, public i2c::I2CDevice {
+class MCP23016 : public Component, public i2c::I2CDevice, public gpio_expander::CachedGpioExpander<uint8_t, 16> {
  public:
   MCP23016() = default;
 
   void setup() override;
-
-  bool digital_read(uint8_t pin);
-  void digital_write(uint8_t pin, bool value);
+  void loop() override;
   void pin_mode(uint8_t pin, gpio::Flags flags);
 
   float get_setup_priority() const override;
 
  protected:
+  // Virtual methods from CachedGpioExpander
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
   // read a given register
   bool read_reg_(uint8_t reg, uint8_t *value);
   // write a value to a given register
@@ -46,6 +50,8 @@ class MCP23016 : public Component, public i2c::I2CDevice {
 
   uint8_t olat_0_{0x00};
   uint8_t olat_1_{0x00};
+  // Cache for input values (16-bit combined for both banks)
+  uint16_t input_mask_{0x00};
 };
 
 class MCP23016GPIOPin : public GPIOPin {

esphome/components/mcp23x08_base/mcp23x08_base.cpp

@@ -8,7 +8,7 @@ static const char *const TAG = "mcp23x08_base";
 
 bool MCP23X08Base::digital_read_hw(uint8_t pin) {
   if (!this->read_reg(mcp23x08_base::MCP23X08_GPIO, &this->input_mask_)) {
-    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
     return false;
   }
   return true;

esphome/components/mcp23x17_base/mcp23x17_base.cpp

@@ -11,13 +11,13 @@ bool MCP23X17Base::digital_read_hw(uint8_t pin) {
   uint8_t data;
   if (pin < 8) {
     if (!this->read_reg(mcp23x17_base::MCP23X17_GPIOA, &data)) {
-      this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+      this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
       return false;
     }
     this->input_mask_ = encode_uint16(this->input_mask_ >> 8, data);
   } else {
     if (!this->read_reg(mcp23x17_base::MCP23X17_GPIOB, &data)) {
-      this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+      this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
       return false;
     }
     this->input_mask_ = encode_uint16(data, this->input_mask_ & 0xFF);

esphome/components/md5/md5.cpp

@@ -1,4 +1,3 @@
-#include <cstdio>
 #include <cstring>
 #include "md5.h"
 #ifdef USE_MD5
@@ -44,7 +43,9 @@ void MD5Digest::get_bytes(uint8_t *output) { memcpy(output, this->digest_, 16);
 
 void MD5Digest::get_hex(char *output) {
   for (size_t i = 0; i < 16; i++) {
-    sprintf(output + i * 2, "%02x", this->digest_[i]);
+    uint8_t byte = this->digest_[i];
+    output[i * 2] = format_hex_char(byte >> 4);
+    output[i * 2 + 1] = format_hex_char(byte & 0x0F);
   }
 }
 

esphome/components/mdns/__init__.py

@@ -11,7 +11,7 @@ from esphome.const import (
     CONF_SERVICES,
     PlatformFramework,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network"]
@@ -72,7 +72,7 @@ def mdns_service(
     )
 
 
-@coroutine_with_priority(55.0)
+@coroutine_with_priority(CoroPriority.COMMUNICATION)
 async def to_code(config):
     if config[CONF_DISABLED] is True:
         return

esphome/components/mdns/mdns_component.cpp

@@ -5,6 +5,30 @@
 #include "esphome/core/version.h"
 #include "mdns_component.h"
 
+#ifdef USE_ESP8266
+#include <pgmspace.h>
+// Macro to define strings in PROGMEM on ESP8266, regular memory on other platforms
+#define MDNS_STATIC_CONST_CHAR(name, value) static const char name[] PROGMEM = value
+// Helper to get string from PROGMEM - returns a temporary std::string
+// Only define this function if we have services that will use it
+#if defined(USE_API) || defined(USE_PROMETHEUS) || defined(USE_WEBSERVER) || defined(USE_MDNS_EXTRA_SERVICES)
+static std::string mdns_string_p(const char *src) {
+  char buf[64];
+  strncpy_P(buf, src, sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  return std::string(buf);
+}
+#define MDNS_STR(name) mdns_string_p(name)
+#else
+// If no services are configured, we still need the fallback service but it uses string literals
+#define MDNS_STR(name) std::string(name)
+#endif
+#else
+// On non-ESP8266 platforms, use regular const char*
+#define MDNS_STATIC_CONST_CHAR(name, value) static constexpr const char *name = value
+#define MDNS_STR(name) name
+#endif
+
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
 #endif
@@ -21,103 +45,168 @@ static const char *const TAG = "mdns";
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
+// Define all constant strings using the macro
+MDNS_STATIC_CONST_CHAR(SERVICE_ESPHOMELIB, "_esphomelib");
+MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
+MDNS_STATIC_CONST_CHAR(SERVICE_PROMETHEUS, "_prometheus-http");
+MDNS_STATIC_CONST_CHAR(SERVICE_HTTP, "_http");
+
+MDNS_STATIC_CONST_CHAR(TXT_FRIENDLY_NAME, "friendly_name");
+MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
+MDNS_STATIC_CONST_CHAR(TXT_MAC, "mac");
+MDNS_STATIC_CONST_CHAR(TXT_PLATFORM, "platform");
+MDNS_STATIC_CONST_CHAR(TXT_BOARD, "board");
+MDNS_STATIC_CONST_CHAR(TXT_NETWORK, "network");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION, "api_encryption");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION_SUPPORTED, "api_encryption_supported");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_NAME, "project_name");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_VERSION, "project_version");
+MDNS_STATIC_CONST_CHAR(TXT_PACKAGE_IMPORT_URL, "package_import_url");
+
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP8266, "ESP8266");
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP32, "ESP32");
+MDNS_STATIC_CONST_CHAR(PLATFORM_RP2040, "RP2040");
+
+MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
+MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
+MDNS_STATIC_CONST_CHAR(NETWORK_THREAD, "thread");
+
 void MDNSComponent::compile_records_() {
   this->hostname_ = App.get_name();
 
-  this->services_.clear();
+  // Calculate exact capacity needed for services vector
+  size_t services_count = 0;
+#ifdef USE_API
+  if (api::global_api_server != nullptr) {
+    services_count++;
+  }
+#endif
+#ifdef USE_PROMETHEUS
+  services_count++;
+#endif
+#ifdef USE_WEBSERVER
+  services_count++;
+#endif
+#ifdef USE_MDNS_EXTRA_SERVICES
+  services_count += this->services_extra_.size();
+#endif
+  // Reserve for fallback service if needed
+  if (services_count == 0) {
+    services_count = 1;
+  }
+  this->services_.reserve(services_count);
+
 #ifdef USE_API
   if (api::global_api_server != nullptr) {
-    MDNSService service{};
-    service.service_type = "_esphomelib";
-    service.proto = "_tcp";
+    this->services_.emplace_back();
+    auto &service = this->services_.back();
+    service.service_type = MDNS_STR(SERVICE_ESPHOMELIB);
+    service.proto = MDNS_STR(SERVICE_TCP);
     service.port = api::global_api_server->get_port();
-    if (!App.get_friendly_name().empty()) {
-      service.txt_records.push_back({"friendly_name", App.get_friendly_name()});
+
+    const std::string &friendly_name = App.get_friendly_name();
+    bool friendly_name_empty = friendly_name.empty();
+
+    // Calculate exact capacity for txt_records
+    size_t txt_count = 3;  // version, mac, board (always present)
+    if (!friendly_name_empty) {
+      txt_count++;  // friendly_name
     }
-    service.txt_records.push_back({"version", ESPHOME_VERSION});
-    service.txt_records.push_back({"mac", get_mac_address()});
-    const char *platform = nullptr;
-#ifdef USE_ESP8266
-    platform = "ESP8266";
+#if defined(USE_ESP8266) || defined(USE_ESP32) || defined(USE_RP2040) || defined(USE_LIBRETINY)
+    txt_count++;  // platform
 #endif
-#ifdef USE_ESP32
-    platform = "ESP32";
+#if defined(USE_WIFI) || defined(USE_ETHERNET) || defined(USE_OPENTHREAD)
+    txt_count++;  // network
 #endif
-#ifdef USE_RP2040
-    platform = "RP2040";
+#ifdef USE_API_NOISE
+    txt_count++;  // api_encryption or api_encryption_supported
 #endif
-#ifdef USE_LIBRETINY
-    platform = lt_cpu_get_model_name();
+#ifdef ESPHOME_PROJECT_NAME
+    txt_count += 2;  // project_name and project_version
 #endif
-    if (platform != nullptr) {
-      service.txt_records.push_back({"platform", platform});
+#ifdef USE_DASHBOARD_IMPORT
+    txt_count++;  // package_import_url
+#endif
+
+    auto &txt_records = service.txt_records;
+    txt_records.reserve(txt_count);
+
+    if (!friendly_name_empty) {
+      txt_records.push_back({MDNS_STR(TXT_FRIENDLY_NAME), friendly_name});
     }
+    txt_records.push_back({MDNS_STR(TXT_VERSION), ESPHOME_VERSION});
+    txt_records.push_back({MDNS_STR(TXT_MAC), get_mac_address()});
 
-    service.txt_records.push_back({"board", ESPHOME_BOARD});
+#ifdef USE_ESP8266
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP8266)});
+#elif defined(USE_ESP32)
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP32)});
+#elif defined(USE_RP2040)
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_RP2040)});
+#elif defined(USE_LIBRETINY)
+    txt_records.emplace_back(MDNSTXTRecord{"platform", lt_cpu_get_model_name()});
+#endif
+
+    txt_records.push_back({MDNS_STR(TXT_BOARD), ESPHOME_BOARD});
 
 #if defined(USE_WIFI)
-    service.txt_records.push_back({"network", "wifi"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)
-    service.txt_records.push_back({"network", "ethernet"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_ETHERNET)});
 #elif defined(USE_OPENTHREAD)
-    service.txt_records.push_back({"network", "thread"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_THREAD)});
 #endif
 
 #ifdef USE_API_NOISE
+    MDNS_STATIC_CONST_CHAR(NOISE_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"});
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION), MDNS_STR(NOISE_ENCRYPTION)});
     } else {
-      service.txt_records.push_back({"api_encryption_supported", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION_SUPPORTED), MDNS_STR(NOISE_ENCRYPTION)});
     }
 #endif
 
 #ifdef ESPHOME_PROJECT_NAME
-    service.txt_records.push_back({"project_name", ESPHOME_PROJECT_NAME});
-    service.txt_records.push_back({"project_version", ESPHOME_PROJECT_VERSION});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_NAME), ESPHOME_PROJECT_NAME});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_VERSION), ESPHOME_PROJECT_VERSION});
 #endif  // ESPHOME_PROJECT_NAME
 
 #ifdef USE_DASHBOARD_IMPORT
-    service.txt_records.push_back({"package_import_url", dashboard_import::get_package_import_url()});
+    txt_records.push_back({MDNS_STR(TXT_PACKAGE_IMPORT_URL), dashboard_import::get_package_import_url()});
 #endif
-
-    this->services_.push_back(service);
   }
 #endif  // USE_API
 
 #ifdef USE_PROMETHEUS
-  {
-    MDNSService service{};
-    service.service_type = "_prometheus-http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    this->services_.push_back(service);
-  }
+  this->services_.emplace_back();
+  auto &prom_service = this->services_.back();
+  prom_service.service_type = MDNS_STR(SERVICE_PROMETHEUS);
+  prom_service.proto = MDNS_STR(SERVICE_TCP);
+  prom_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_WEBSERVER
-  {
-    MDNSService service{};
-    service.service_type = "_http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    this->services_.push_back(service);
-  }
+  this->services_.emplace_back();
+  auto &web_service = this->services_.back();
+  web_service.service_type = MDNS_STR(SERVICE_HTTP);
+  web_service.proto = MDNS_STR(SERVICE_TCP);
+  web_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_MDNS_EXTRA_SERVICES
   this->services_.insert(this->services_.end(), this->services_extra_.begin(), this->services_extra_.end());
 #endif
 
-  if (this->services_.empty()) {
-    // Publish "http" service if not using native API
-    // This is just to have *some* mDNS service so that .local resolution works
-    MDNSService service{};
-    service.service_type = "_http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    service.txt_records.push_back({"version", ESPHOME_VERSION});
-    this->services_.push_back(service);
-  }
+#if !defined(USE_API) && !defined(USE_PROMETHEUS) && !defined(USE_WEBSERVER) && !defined(USE_MDNS_EXTRA_SERVICES)
+  // Publish "http" service if not using native API or any other services
+  // This is just to have *some* mDNS service so that .local resolution works
+  this->services_.emplace_back();
+  auto &fallback_service = this->services_.back();
+  fallback_service.service_type = "_http";
+  fallback_service.proto = "_tcp";
+  fallback_service.port = USE_WEBSERVER_PORT;
+  fallback_service.txt_records.emplace_back(MDNSTXTRecord{"version", ESPHOME_VERSION});
+#endif
 }
 
 void MDNSComponent::dump_config() {
@@ -125,6 +214,7 @@ void MDNSComponent::dump_config() {
                 "mDNS:\n"
                 "  Hostname: %s",
                 this->hostname_.c_str());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   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(),
@@ -134,6 +224,7 @@ void MDNSComponent::dump_config() {
                const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
+#endif
 }
 
 std::vector<MDNSService> MDNSComponent::get_services() { return this->services_; }

esphome/components/media_player/__init__.py

@@ -14,7 +14,7 @@ from esphome.const import (
 )
 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.coroutine import CoroPriority, coroutine_with_priority
 from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@jesserockz"]
@@ -303,7 +303,7 @@ async def media_player_volume_set_action(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(media_player_ns.using)
     cg.add_define("USE_MEDIA_PLAYER")

esphome/components/micro_wake_word/__init__.py

@@ -201,7 +201,7 @@ def _validate_manifest_version(manifest_data):
         else:
             raise cv.Invalid("Invalid manifest version")
     else:
-        raise cv.Invalid("Invalid manifest file, missing 'version' key.")
+        raise cv.Invalid("Invalid manifest file, missing 'version' key")
 
 
 def _process_http_source(config):
@@ -421,7 +421,7 @@ def _feature_step_size_validate(config):
         if features_step_size is None:
             features_step_size = model_step_size
         elif features_step_size != model_step_size:
-            raise cv.Invalid("Cannot load models with different features step sizes.")
+            raise cv.Invalid("Cannot load models with different features step sizes")
 
 
 FINAL_VALIDATE_SCHEMA = cv.All(

esphome/components/microphone/__init__.py

@@ -12,7 +12,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
 )
 from esphome.core import CORE
-from esphome.coroutine import coroutine_with_priority
+from esphome.coroutine import CoroPriority, coroutine_with_priority
 
 AUTO_LOAD = ["audio"]
 CODEOWNERS = ["@jesserockz", "@kahrendt"]
@@ -213,7 +213,7 @@ automation.register_condition(
 )(microphone_action)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(microphone_ns.using)
     cg.add_define("USE_MICROPHONE")