esphome 2025.7.4__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/components/zephyr/preferences.cpp

@@ -0,0 +1,156 @@
+#ifdef USE_ZEPHYR
+
+#include <zephyr/kernel.h>
+#include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
+#include <zephyr/settings/settings.h>
+
+namespace esphome {
+namespace zephyr {
+
+static const char *const TAG = "zephyr.preferences";
+
+#define ESPHOME_SETTINGS_KEY "esphome"
+
+class ZephyrPreferenceBackend : public ESPPreferenceBackend {
+ public:
+  ZephyrPreferenceBackend(uint32_t type) { this->type_ = type; }
+  ZephyrPreferenceBackend(uint32_t type, std::vector<uint8_t> &&data) : data(std::move(data)) { this->type_ = type; }
+
+  bool save(const uint8_t *data, size_t len) override {
+    this->data.resize(len);
+    std::memcpy(this->data.data(), data, len);
+    ESP_LOGVV(TAG, "save key: %u, len: %d", this->type_, len);
+    return true;
+  }
+
+  bool load(uint8_t *data, size_t len) override {
+    if (len != this->data.size()) {
+      ESP_LOGE(TAG, "size of setting key %s changed, from: %u, to: %u", get_key().c_str(), this->data.size(), len);
+      return false;
+    }
+    std::memcpy(data, this->data.data(), len);
+    ESP_LOGVV(TAG, "load key: %u, len: %d", this->type_, len);
+    return true;
+  }
+
+  uint32_t get_type() const { return this->type_; }
+  std::string get_key() const { return str_sprintf(ESPHOME_SETTINGS_KEY "/%" PRIx32, this->type_); }
+
+  std::vector<uint8_t> data;
+
+ protected:
+  uint32_t type_ = 0;
+};
+
+class ZephyrPreferences : public ESPPreferences {
+ public:
+  void open() {
+    int err = settings_subsys_init();
+    if (err) {
+      ESP_LOGE(TAG, "Failed to initialize settings subsystem, err: %d", err);
+      return;
+    }
+
+    static struct settings_handler settings_cb = {
+        .name = ESPHOME_SETTINGS_KEY,
+        .h_set = load_setting,
+        .h_export = export_settings,
+    };
+
+    err = settings_register(&settings_cb);
+    if (err) {
+      ESP_LOGE(TAG, "setting_register failed, err, %d", err);
+      return;
+    }
+
+    err = settings_load_subtree(ESPHOME_SETTINGS_KEY);
+    if (err) {
+      ESP_LOGE(TAG, "Cannot load settings, err: %d", err);
+      return;
+    }
+    ESP_LOGD(TAG, "Loaded %u settings.", this->backends_.size());
+  }
+
+  ESPPreferenceObject make_preference(size_t length, uint32_t type, bool in_flash) override {
+    return make_preference(length, type);
+  }
+
+  ESPPreferenceObject make_preference(size_t length, uint32_t type) override {
+    for (auto *backend : this->backends_) {
+      if (backend->get_type() == type) {
+        return ESPPreferenceObject(backend);
+      }
+    }
+    printf("type %u size %u\n", type, this->backends_.size());
+    auto *pref = new ZephyrPreferenceBackend(type);  // NOLINT(cppcoreguidelines-owning-memory)
+    ESP_LOGD(TAG, "Add new setting %s.", pref->get_key().c_str());
+    this->backends_.push_back(pref);
+    return ESPPreferenceObject(pref);
+  }
+
+  bool sync() override {
+    ESP_LOGD(TAG, "Save settings");
+    int err = settings_save();
+    if (err) {
+      ESP_LOGE(TAG, "Cannot save settings, err: %d", err);
+      return false;
+    }
+    return true;
+  }
+
+  bool reset() override {
+    ESP_LOGD(TAG, "Reset settings");
+    for (auto *backend : this->backends_) {
+      // save empty delete data
+      backend->data.clear();
+    }
+    sync();
+    return true;
+  }
+
+ protected:
+  std::vector<ZephyrPreferenceBackend *> backends_;
+
+  static int load_setting(const char *name, size_t len, settings_read_cb read_cb, void *cb_arg) {
+    auto type = parse_hex<uint32_t>(name);
+    if (!type.has_value()) {
+      std::string full_name(ESPHOME_SETTINGS_KEY);
+      full_name += "/";
+      full_name += name;
+      // Delete unusable keys. Otherwise it will stay in flash forever.
+      settings_delete(full_name.c_str());
+      return 1;
+    }
+    std::vector<uint8_t> data(len);
+    int err = read_cb(cb_arg, data.data(), len);
+
+    ESP_LOGD(TAG, "load setting, name: %s(%u), len %u, err %u", name, *type, len, err);
+    auto *pref = new ZephyrPreferenceBackend(*type, std::move(data));  // NOLINT(cppcoreguidelines-owning-memory)
+    static_cast<ZephyrPreferences *>(global_preferences)->backends_.push_back(pref);
+    return 0;
+  }
+
+  static int export_settings(int (*cb)(const char *name, const void *value, size_t val_len)) {
+    for (auto *backend : static_cast<ZephyrPreferences *>(global_preferences)->backends_) {
+      auto name = backend->get_key();
+      int err = cb(name.c_str(), backend->data.data(), backend->data.size());
+      ESP_LOGD(TAG, "save in flash, name %s, len %u, err %d", name.c_str(), backend->data.size(), err);
+    }
+    return 0;
+  }
+};
+
+void setup_preferences() {
+  auto *prefs = new ZephyrPreferences();  // NOLINT(cppcoreguidelines-owning-memory)
+  global_preferences = prefs;
+  prefs->open();
+}
+
+}  // namespace zephyr
+
+ESPPreferences *global_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome
+
+#endif

esphome/components/zephyr/preferences.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef USE_ZEPHYR
+
+namespace esphome {
+namespace zephyr {
+
+void setup_preferences();
+
+}  // namespace zephyr
+}  // namespace esphome
+
+#endif

esphome/config.py

@@ -198,10 +198,7 @@ class Config(OrderedDict, fv.FinalValidateConfig):
         self.output_paths.remove((path, domain))
 
     def is_in_error_path(self, path: ConfigPath) -> bool:
-        for err in self.errors:
-            if _path_begins_with(err.path, path):
-                return True
-        return False
+        return any(_path_begins_with(err.path, path) for err in self.errors)
 
     def set_by_path(self, path, value):
         conf = self
@@ -224,7 +221,7 @@ class Config(OrderedDict, fv.FinalValidateConfig):
         for index, path_item in enumerate(path):
             try:
                 if path_item in data:
-                    key_data = [x for x in data.keys() if x == path_item][0]
+                    key_data = [x for x in data if x == path_item][0]
                     if isinstance(key_data, ESPHomeDataBase):
                         doc_range = key_data.esp_range
                         if get_key and index == len(path) - 1:
@@ -332,6 +329,28 @@ class ConfigValidationStep(abc.ABC):
     def run(self, result: Config) -> None: ...  # noqa: E704
 
 
+class LoadTargetPlatformValidationStep(ConfigValidationStep):
+    """Load target platform step."""
+
+    def __init__(self, domain: str, conf: ConfigType):
+        self.domain = domain
+        self.conf = conf
+
+    def run(self, result: Config) -> None:
+        if self.conf is None:
+            result[self.domain] = self.conf = {}
+        result.add_output_path([self.domain], self.domain)
+        component = get_component(self.domain)
+
+        result[self.domain] = self.conf
+        path = [self.domain]
+        CORE.loaded_integrations.add(self.domain)
+
+        result.add_validation_step(
+            SchemaValidationStep(self.domain, path, self.conf, component)
+        )
+
+
 class LoadValidationStep(ConfigValidationStep):
     """Load step, this step is called once for each domain config fragment.
 
@@ -585,16 +604,18 @@ class MetadataValidationStep(ConfigValidationStep):
                 )
                 return
             for i, part_conf in enumerate(self.conf):
+                path = self.path + [i]
                 result.add_validation_step(
-                    SchemaValidationStep(
-                        self.domain, self.path + [i], part_conf, self.comp
-                    )
+                    SchemaValidationStep(self.domain, path, part_conf, self.comp)
                 )
+                result.add_validation_step(FinalValidateValidationStep(path, self.comp))
+
             return
 
         result.add_validation_step(
             SchemaValidationStep(self.domain, self.path, self.conf, self.comp)
         )
+        result.add_validation_step(FinalValidateValidationStep(self.path, self.comp))
 
 
 class SchemaValidationStep(ConfigValidationStep):
@@ -606,13 +627,15 @@ class SchemaValidationStep(ConfigValidationStep):
     def __init__(
         self, domain: str, path: ConfigPath, conf: ConfigType, comp: ComponentManifest
     ):
+        self.domain = domain
         self.path = path
         self.conf = conf
         self.comp = comp
 
     def run(self, result: Config) -> None:
         token = path_context.set(self.path)
-        with result.catch_error(self.path):
+        # The domain already contains the full component path (e.g., "sensor.template", "sensor.uptime")
+        with CORE.component_context(self.domain), result.catch_error(self.path):
             if self.comp.is_platform:
                 # Remove 'platform' key for validation
                 input_conf = OrderedDict(self.conf)
@@ -631,7 +654,6 @@ class SchemaValidationStep(ConfigValidationStep):
                 result.set_by_path(self.path, validated)
 
         path_context.reset(token)
-        result.add_validation_step(FinalValidateValidationStep(self.path, self.comp))
 
 
 class IDPassValidationStep(ConfigValidationStep):
@@ -912,7 +934,7 @@ def validate_config(
 
     # First run platform validation steps
     result.add_validation_step(
-        LoadValidationStep(target_platform, config[target_platform])
+        LoadTargetPlatformValidationStep(target_platform, config[target_platform])
     )
     result.run_validation_steps()
 
@@ -920,6 +942,9 @@ def validate_config(
         # do not try to validate further as we don't know what the target is
         return result
 
+    # Reset the pin registry so that any target platforms with pin validations do not get the duplicate pin warning.
+    pins.PIN_SCHEMA_REGISTRY.reset()
+
     for domain, conf in config.items():
         result.add_validation_step(LoadValidationStep(domain, conf))
     result.add_validation_step(IDPassValidationStep())
@@ -1081,7 +1106,7 @@ def dump_dict(
             ret += "{}"
             multiline = False
 
-        for k in conf.keys():
+        for k in conf:
             path_ = path + [k]
             error = config.get_error_for_path(path_)
             if error is not None:
@@ -1097,10 +1122,7 @@ def dump_dict(
                 msg = f"\n{indent(msg)}"
 
             if inf is not None:
-                if m:
-                    msg = f" {inf}{msg}"
-                else:
-                    msg = f"{msg} {inf}"
+                msg = f" {inf}{msg}" if m else f"{msg} {inf}"
             ret += f"{st + msg}\n"
     elif isinstance(conf, str):
         if is_secret(conf):

esphome/config_helpers.py

@@ -111,8 +111,7 @@ def merge_config(full_old, full_new):
                     else:
                         ids[new_id] = len(res)
                 res.append(v)
-            res = [v for i, v in enumerate(res) if i not in ids_to_delete]
-            return res
+            return [v for i, v in enumerate(res) if i not in ids_to_delete]
         if new is None:
             return old
 

esphome/config_validation.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from contextlib import contextmanager
+from contextlib import contextmanager, suppress
 from dataclasses import dataclass
 from datetime import datetime
 from ipaddress import (
@@ -87,7 +87,7 @@ from esphome.core import (
     TimePeriodNanoseconds,
     TimePeriodSeconds,
 )
-from esphome.helpers import add_class_to_obj, list_starts_with
+from esphome.helpers import add_class_to_obj, docs_url, list_starts_with
 from esphome.schema_extractors import (
     SCHEMA_EXTRACT,
     schema_extractor,
@@ -291,6 +291,8 @@ class Version:
     extra: str = ""
 
     def __str__(self):
+        if self.extra:
+            return f"{self.major}.{self.minor}.{self.patch}-{self.extra}"
         return f"{self.major}.{self.minor}.{self.patch}"
 
     @classmethod
@@ -391,10 +393,13 @@ def icon(value):
     )
 
 
-def sub_device_id(value: str | None) -> core.ID:
+def sub_device_id(value: str | None) -> core.ID | None:
     # Lazy import to avoid circular imports
     from esphome.core.config import Device
 
+    if not value:
+        return None
+
     return use_id(Device)(value)
 
 
@@ -664,14 +669,6 @@ def only_with_framework(
     if suggestions is None:
         suggestions = {}
 
-    version = Version.parse(ESPHOME_VERSION)
-    if version.is_beta:
-        docs_format = "https://beta.esphome.io/components/{path}"
-    elif version.is_dev:
-        docs_format = "https://next.esphome.io/components/{path}"
-    else:
-        docs_format = "https://esphome.io/components/{path}"
-
     def validator_(obj):
         if CORE.target_framework not in frameworks:
             err_str = f"This feature is only available with framework(s) {', '.join([framework.value for framework in frameworks])}"
@@ -679,7 +676,7 @@ def only_with_framework(
                 (component, docs_path) = suggestion
                 err_str += f"\nPlease use '{component}'"
                 if docs_path:
-                    err_str += f": {docs_format.format(path=docs_path)}"
+                    err_str += f": {docs_url(path=f'components/{docs_path}')}"
             raise Invalid(err_str)
         return obj
 
@@ -1107,6 +1104,7 @@ def float_with_unit(quantity, regex_suffix, optional_unit=False):
     return validator
 
 
+bps = float_with_unit("bits per second", "(bps|bits/s|bit/s)?")
 frequency = float_with_unit("frequency", "(Hz|HZ|hz)?")
 resistance = float_with_unit("resistance", "(Ω|Ω|ohm|Ohm|OHM)?")
 current = float_with_unit("current", "(a|A|amp|Amp|amps|Amps|ampere|Ampere)?")
@@ -1865,7 +1863,7 @@ def validate_registry_entry(name, registry):
 
 def none(value):
     if value in ("none", "None"):
-        return None
+        return
     raise Invalid("Must be none")
 
 
@@ -2112,10 +2110,8 @@ def require_esphome_version(year, month, patch):
 
 @contextmanager
 def suppress_invalid():
-    try:
+    with suppress(vol.Invalid):
         yield
-    except vol.Invalid:
-        pass
 
 
 GIT_SCHEMA = Schema(

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2025.7.4"
+__version__ = "2025.8.0"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -21,6 +21,7 @@ class Platform(StrEnum):
     HOST = "host"
     LIBRETINY_OLDSTYLE = "libretiny"
     LN882X = "ln882x"
+    NRF52 = "nrf52"
     RP2040 = "rp2040"
     RTL87XX = "rtl87xx"
 
@@ -31,6 +32,15 @@ class Framework(StrEnum):
     ARDUINO = "arduino"
     ESP_IDF = "esp-idf"
     NATIVE = "host"
+    ZEPHYR = "zephyr"
+
+
+class ThreadModel(StrEnum):
+    """Threading model identifiers for ESPHome scheduler."""
+
+    SINGLE = "ESPHOME_THREAD_SINGLE"
+    MULTI_NO_ATOMICS = "ESPHOME_THREAD_MULTI_NO_ATOMICS"
+    MULTI_ATOMICS = "ESPHOME_THREAD_MULTI_ATOMICS"
 
 
 class PlatformFramework(Enum):
@@ -47,6 +57,9 @@ class PlatformFramework(Enum):
     RTL87XX_ARDUINO = (Platform.RTL87XX, Framework.ARDUINO)
     LN882X_ARDUINO = (Platform.LN882X, Framework.ARDUINO)
 
+    # Zephyr framework platforms
+    NRF52_ZEPHYR = (Platform.NRF52, Framework.ZEPHYR)
+
     # Host platform (native)
     HOST_NATIVE = (Platform.HOST, Framework.NATIVE)
 
@@ -58,6 +71,7 @@ PLATFORM_ESP8266 = Platform.ESP8266
 PLATFORM_HOST = Platform.HOST
 PLATFORM_LIBRETINY_OLDSTYLE = Platform.LIBRETINY_OLDSTYLE
 PLATFORM_LN882X = Platform.LN882X
+PLATFORM_NRF52 = Platform.NRF52
 PLATFORM_RP2040 = Platform.RP2040
 PLATFORM_RTL87XX = Platform.RTL87XX
 
@@ -90,6 +104,7 @@ CONF_ALL = "all"
 CONF_ALLOW_OTHER_USES = "allow_other_uses"
 CONF_ALPHA = "alpha"
 CONF_ALTITUDE = "altitude"
+CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
 CONF_AMBIENT_LIGHT = "ambient_light"
 CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
 CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
@@ -368,6 +383,8 @@ CONF_FINGER_ID = "finger_id"
 CONF_FINGERPRINT_COUNT = "fingerprint_count"
 CONF_FLASH_LENGTH = "flash_length"
 CONF_FLASH_TRANSITION_LENGTH = "flash_transition_length"
+CONF_FLIP_X = "flip_x"
+CONF_FLIP_Y = "flip_y"
 CONF_FLOW = "flow"
 CONF_FLOW_CONTROL_PIN = "flow_control_pin"
 CONF_FONT = "font"
@@ -506,6 +523,7 @@ CONF_LOADED_INTEGRATIONS = "loaded_integrations"
 CONF_LOCAL = "local"
 CONF_LOCK_ACTION = "lock_action"
 CONF_LOG = "log"
+CONF_LOG_LEVEL = "log_level"
 CONF_LOG_TOPIC = "log_topic"
 CONF_LOGGER = "logger"
 CONF_LOGS = "logs"
@@ -743,6 +761,7 @@ CONF_POSITION_COMMAND_TOPIC = "position_command_topic"
 CONF_POSITION_STATE_TOPIC = "position_state_topic"
 CONF_POWER = "power"
 CONF_POWER_FACTOR = "power_factor"
+CONF_POWER_MODE = "power_mode"
 CONF_POWER_ON_VALUE = "power_on_value"
 CONF_POWER_SAVE_MODE = "power_save_mode"
 CONF_POWER_SUPPLY = "power_supply"
@@ -915,6 +934,7 @@ CONF_SWING_MODE_COMMAND_TOPIC = "swing_mode_command_topic"
 CONF_SWING_MODE_STATE_TOPIC = "swing_mode_state_topic"
 CONF_SWING_OFF_ACTION = "swing_off_action"
 CONF_SWING_VERTICAL_ACTION = "swing_vertical_action"
+CONF_SWITCH = "switch"
 CONF_SWITCH_DATAPOINT = "switch_datapoint"
 CONF_SWITCHES = "switches"
 CONF_SYNC = "sync"
@@ -1187,6 +1207,7 @@ UNIT_WATT = "W"
 UNIT_WATT_HOURS = "Wh"
 
 # device classes
+DEVICE_CLASS_ABSOLUTE_HUMIDITY = "absolute_humidity"
 DEVICE_CLASS_APPARENT_POWER = "apparent_power"
 DEVICE_CLASS_AQI = "aqi"
 DEVICE_CLASS_AREA = "area"
@@ -1311,3 +1332,7 @@ ENTITY_CATEGORY_CONFIG = "config"
 
 # The entity category for read only diagnostic values, for example RSSI, uptime or MAC Address
 ENTITY_CATEGORY_DIAGNOSTIC = "diagnostic"
+
+# The corresponding constant exists in c++
+# when update_interval is set to never, it becomes SCHEDULER_DONT_RUN milliseconds
+SCHEDULER_DONT_RUN = 4294967295