homeassistant 2025.8.2__py3-none-any.whl → 2025.9.0__py3-none-any.whl

homeassistant/helpers/condition.py

@@ -58,9 +58,9 @@ from homeassistant.util import dt as dt_util
 from homeassistant.util.async_ import run_callback_threadsafe
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.yaml import load_yaml_dict
-from homeassistant.util.yaml.loader import JSON_TYPE
 
 from . import config_validation as cv, entity_registry as er
+from .automation import get_absolute_description_key, get_relative_description_key
 from .integration_platform import async_process_integration_platforms
 from .template import Template, render_complex
 from .trace import (
@@ -132,7 +132,7 @@ def starts_with_dot(key: str) -> str:
 _CONDITIONS_SCHEMA = vol.Schema(
     {
         vol.Remove(vol.All(str, starts_with_dot)): object,
-        cv.slug: vol.Any(None, _CONDITION_SCHEMA),
+        cv.underscore_slug: vol.Any(None, _CONDITION_SCHEMA),
     }
 )
 
@@ -171,6 +171,9 @@ async def _register_condition_platform(
 
     if hasattr(platform, "async_get_conditions"):
         for condition_key in await platform.async_get_conditions(hass):
+            condition_key = get_absolute_description_key(
+                integration_domain, condition_key
+            )
             hass.data[CONDITIONS][condition_key] = integration_domain
             new_conditions.add(condition_key)
     else:
@@ -199,14 +202,14 @@ class Condition(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    async def async_validate_condition_config(
+    async def async_validate_config(
         cls, hass: HomeAssistant, config: ConfigType
     ) -> ConfigType:
         """Validate config."""
 
     @abc.abstractmethod
-    async def async_condition_from_config(self) -> ConditionCheckerType:
-        """Evaluate state based on configuration."""
+    async def async_get_checker(self) -> ConditionCheckerType:
+        """Get the condition checker."""
 
 
 class ConditionProtocol(Protocol):
@@ -288,22 +291,21 @@ def trace_condition_function(condition: ConditionCheckerType) -> ConditionChecke
 
 
 async def _async_get_condition_platform(
-    hass: HomeAssistant, config: ConfigType
-) -> ConditionProtocol | None:
-    condition_key: str = config[CONF_CONDITION]
-    platform_and_sub_type = condition_key.partition(".")
+    hass: HomeAssistant, condition_key: str
+) -> tuple[str, ConditionProtocol | None]:
+    platform_and_sub_type = condition_key.split(".")
     platform: str | None = platform_and_sub_type[0]
     platform = _PLATFORM_ALIASES.get(platform, platform)
     if platform is None:
-        return None
+        return "", None
     try:
         integration = await async_get_integration(hass, platform)
     except IntegrationNotFound:
         raise HomeAssistantError(
-            f'Invalid condition "{condition_key}" specified {config}'
+            f'Invalid condition "{condition_key}" specified'
         ) from None
     try:
-        return await integration.async_get_platform("condition")
+        return platform, await integration.async_get_platform("condition")
     except ImportError:
         raise HomeAssistantError(
             f"Integration '{platform}' does not provide condition support"
@@ -339,17 +341,20 @@ async def async_from_config(
 
             return disabled_condition
 
-    condition: str = config[CONF_CONDITION]
+    condition_key: str = config[CONF_CONDITION]
     factory: Any = None
-    platform = await _async_get_condition_platform(hass, config)
+    platform_domain, platform = await _async_get_condition_platform(hass, condition_key)
 
     if platform is not None:
         condition_descriptors = await platform.async_get_conditions(hass)
-        condition_instance = condition_descriptors[condition](hass, config)
-        return await condition_instance.async_condition_from_config()
+        relative_condition_key = get_relative_description_key(
+            platform_domain, condition_key
+        )
+        condition_instance = condition_descriptors[relative_condition_key](hass, config)
+        return await condition_instance.async_get_checker()
 
     for fmt in (ASYNC_FROM_CONFIG_FORMAT, FROM_CONFIG_FORMAT):
-        factory = getattr(sys.modules[__name__], fmt.format(condition), None)
+        factory = getattr(sys.modules[__name__], fmt.format(condition_key), None)
 
         if factory:
             break
@@ -960,8 +965,9 @@ async def async_validate_condition_config(
     hass: HomeAssistant, config: ConfigType
 ) -> ConfigType:
     """Validate config."""
-    condition: str = config[CONF_CONDITION]
-    if condition in ("and", "not", "or"):
+    condition_key: str = config[CONF_CONDITION]
+
+    if condition_key in ("and", "not", "or"):
         conditions = []
         for sub_cond in config["conditions"]:
             sub_cond = await async_validate_condition_config(hass, sub_cond)
@@ -969,16 +975,23 @@ async def async_validate_condition_config(
         config["conditions"] = conditions
         return config
 
-    platform = await _async_get_condition_platform(hass, config)
+    platform_domain, platform = await _async_get_condition_platform(hass, condition_key)
+
     if platform is not None:
         condition_descriptors = await platform.async_get_conditions(hass)
-        if not (condition_class := condition_descriptors.get(condition)):
-            raise vol.Invalid(f"Invalid condition '{condition}' specified")
-        return await condition_class.async_validate_condition_config(hass, config)
-    if platform is None and condition in ("numeric_state", "state"):
+        relative_condition_key = get_relative_description_key(
+            platform_domain, condition_key
+        )
+        if not (condition_class := condition_descriptors.get(relative_condition_key)):
+            raise vol.Invalid(f"Invalid condition '{condition_key}' specified")
+        return await condition_class.async_validate_config(hass, config)
+
+    if platform is None and condition_key in ("numeric_state", "state"):
         validator = cast(
             Callable[[HomeAssistant, ConfigType], ConfigType],
-            getattr(sys.modules[__name__], VALIDATE_CONFIG_FORMAT.format(condition)),
+            getattr(
+                sys.modules[__name__], VALIDATE_CONFIG_FORMAT.format(condition_key)
+            ),
         )
         return validator(hass, config)
 
@@ -1088,11 +1101,11 @@ def async_extract_devices(config: ConfigType | Template) -> set[str]:
     return referenced
 
 
-def _load_conditions_file(hass: HomeAssistant, integration: Integration) -> JSON_TYPE:
+def _load_conditions_file(integration: Integration) -> dict[str, Any]:
     """Load conditions file for an integration."""
     try:
         return cast(
-            JSON_TYPE,
+            dict[str, Any],
             _CONDITIONS_SCHEMA(
                 load_yaml_dict(str(integration.file_path / "conditions.yaml"))
             ),
@@ -1112,11 +1125,14 @@ def _load_conditions_file(hass: HomeAssistant, integration: Integration) -> JSON
 
 
 def _load_conditions_files(
-    hass: HomeAssistant, integrations: Iterable[Integration]
-) -> dict[str, JSON_TYPE]:
+    integrations: Iterable[Integration],
+) -> dict[str, dict[str, Any]]:
     """Load condition files for multiple integrations."""
     return {
-        integration.domain: _load_conditions_file(hass, integration)
+        integration.domain: {
+            get_absolute_description_key(integration.domain, key): value
+            for key, value in _load_conditions_file(integration).items()
+        }
         for integration in integrations
     }
 
@@ -1137,7 +1153,7 @@ async def async_get_all_descriptions(
         return descriptions_cache
 
     # Files we loaded for missing descriptions
-    new_conditions_descriptions: dict[str, JSON_TYPE] = {}
+    new_conditions_descriptions: dict[str, dict[str, Any]] = {}
     # We try to avoid making a copy in the event the cache is good,
     # but now we must make a copy in case new conditions get added
     # while we are loading the missing ones so we do not
@@ -1166,7 +1182,7 @@ async def async_get_all_descriptions(
 
         if integrations:
             new_conditions_descriptions = await hass.async_add_executor_job(
-                _load_conditions_files, hass, integrations
+                _load_conditions_files, integrations
             )
 
     # Make a copy of the old cache and add missing descriptions to it
@@ -1175,7 +1191,7 @@ async def async_get_all_descriptions(
         domain = conditions[missing_condition]
 
         if (
-            yaml_description := new_conditions_descriptions.get(domain, {}).get(  # type: ignore[union-attr]
+            yaml_description := new_conditions_descriptions.get(domain, {}).get(
                 missing_condition
             )
         ) is None:

homeassistant/helpers/config_entry_oauth2_flow.py

@@ -155,7 +155,7 @@ class LocalOAuth2Implementation(AbstractOAuth2Implementation):
     @property
     def name(self) -> str:
         """Name of the implementation."""
-        return "Configuration.yaml"
+        return "Local application credentials"
 
     @property
     def domain(self) -> str:

homeassistant/helpers/config_validation.py

@@ -373,6 +373,17 @@ def entity_id(value: Any) -> str:
     raise vol.Invalid(f"Entity ID {value} is an invalid entity ID")
 
 
+def strict_entity_id(value: Any) -> str:
+    """Validate Entity ID, strictly."""
+    if not isinstance(value, str):
+        raise vol.Invalid(f"Entity ID {value} is not a string")
+
+    if valid_entity_id(value):
+        return value
+
+    raise vol.Invalid(f"Entity ID {value} is not a valid entity ID")
+
+
 def entity_id_or_uuid(value: Any) -> str:
     """Validate Entity specified by entity_id or uuid."""
     with contextlib.suppress(vol.Invalid):
@@ -644,6 +655,13 @@ def slug(value: Any) -> str:
     raise vol.Invalid(f"invalid slug {value} (try {slg})")
 
 
+def underscore_slug(value: Any) -> str:
+    """Validate value is a valid slug, possibly starting with an underscore."""
+    if value.startswith("_"):
+        return f"_{slug(value[1:])}"
+    return slug(value)
+
+
 def schema_with_slug_keys(
     value_schema: dict | Callable, *, slug_validator: Callable[[Any], str] = slug
 ) -> Callable:
@@ -1285,6 +1303,15 @@ PLATFORM_SCHEMA = vol.Schema(
 
 PLATFORM_SCHEMA_BASE = PLATFORM_SCHEMA.extend({}, extra=vol.ALLOW_EXTRA)
 
+
+TARGET_FIELDS: VolDictType = {
+    vol.Optional(ATTR_ENTITY_ID): vol.All(ensure_list, [strict_entity_id]),
+    vol.Optional(ATTR_DEVICE_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_AREA_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_FLOOR_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_LABEL_ID): vol.All(ensure_list, [str]),
+}
+
 ENTITY_SERVICE_FIELDS: VolDictType = {
     # Either accept static entity IDs, a single dynamic template or a mixed list
     # of static and dynamic templates. While this could be solved with a single

homeassistant/helpers/data_entry_flow.py

@@ -31,27 +31,27 @@ class _BaseFlowManagerView(HomeAssistantView, Generic[_FlowManagerT]):
 
     def _prepare_result_json(
         self, result: data_entry_flow.FlowResult
-    ) -> data_entry_flow.FlowResult:
-        """Convert result to JSON."""
+    ) -> dict[str, Any]:
+        """Convert result to JSON serializable dict."""
         if result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY:
-            data = result.copy()
-            data.pop("result")
-            data.pop("data")
-            data.pop("context")
-            return data
+            assert "result" not in result
+            return {
+                key: val
+                for key, val in result.items()
+                if key not in ("data", "context")
+            }
 
-        if "data_schema" not in result:
-            return result
+        data = dict(result)
 
-        data = result.copy()
+        if "data_schema" not in result:
+            return data
 
-        if (schema := data["data_schema"]) is None:
-            data["data_schema"] = []  # type: ignore[typeddict-item]  # json result type
+        if (schema := result["data_schema"]) is None:
+            data["data_schema"] = []
         else:
             data["data_schema"] = voluptuous_serialize.convert(
                 schema, custom_serializer=cv.custom_serializer
             )
-
         return data
 
 

homeassistant/helpers/device_registry.py

@@ -57,7 +57,7 @@ EVENT_DEVICE_REGISTRY_UPDATED: EventType[EventDeviceRegistryUpdatedData] = Event
 )
 STORAGE_KEY = "core.device_registry"
 STORAGE_VERSION_MAJOR = 1
-STORAGE_VERSION_MINOR = 11
+STORAGE_VERSION_MINOR = 12
 
 CLEANUP_DELAY = 10
 
@@ -465,7 +465,7 @@ class DeletedDeviceEntry:
         validator=_normalize_connections_validator
     )
     created_at: datetime = attr.ib()
-    disabled_by: DeviceEntryDisabler | None = attr.ib()
+    disabled_by: DeviceEntryDisabler | UndefinedType | None = attr.ib()
     id: str = attr.ib()
     identifiers: set[tuple[str, str]] = attr.ib()
     labels: set[str] = attr.ib()
@@ -476,20 +476,31 @@ class DeletedDeviceEntry:
 
     def to_device_entry(
         self,
-        config_entry_id: str,
+        config_entry: ConfigEntry,
         config_subentry_id: str | None,
         connections: set[tuple[str, str]],
         identifiers: set[tuple[str, str]],
+        disabled_by: DeviceEntryDisabler | UndefinedType | None,
     ) -> DeviceEntry:
         """Create DeviceEntry from DeletedDeviceEntry."""
+        # Adjust disabled_by based on config entry state
+        if self.disabled_by is not UNDEFINED:
+            disabled_by = self.disabled_by
+            if config_entry.disabled_by:
+                if disabled_by is None:
+                    disabled_by = DeviceEntryDisabler.CONFIG_ENTRY
+            elif disabled_by == DeviceEntryDisabler.CONFIG_ENTRY:
+                disabled_by = None
+        else:
+            disabled_by = disabled_by if disabled_by is not UNDEFINED else None
         return DeviceEntry(
             area_id=self.area_id,
             # type ignores: likely https://github.com/python/mypy/issues/8625
-            config_entries={config_entry_id},  # type: ignore[arg-type]
-            config_entries_subentries={config_entry_id: {config_subentry_id}},
+            config_entries={config_entry.entry_id},  # type: ignore[arg-type]
+            config_entries_subentries={config_entry.entry_id: {config_subentry_id}},
             connections=self.connections & connections,  # type: ignore[arg-type]
             created_at=self.created_at,
-            disabled_by=self.disabled_by,
+            disabled_by=disabled_by,
             identifiers=self.identifiers & identifiers,  # type: ignore[arg-type]
             id=self.id,
             is_new=True,
@@ -513,7 +524,10 @@ class DeletedDeviceEntry:
                     },
                     "connections": list(self.connections),
                     "created_at": self.created_at,
-                    "disabled_by": self.disabled_by,
+                    "disabled_by": self.disabled_by
+                    if self.disabled_by is not UNDEFINED
+                    else None,
+                    "disabled_by_undefined": self.disabled_by is UNDEFINED,
                     "identifiers": list(self.identifiers),
                     "id": self.id,
                     "labels": list(self.labels),
@@ -614,6 +628,11 @@ class DeviceRegistryStore(storage.Store[dict[str, list[dict[str, Any]]]]):
                     device["connections"] = _normalize_connections(
                         device["connections"]
                     )
+            if old_minor_version < 12:
+                # Version 1.12 adds undefined flags to deleted devices, this is a bugfix
+                # of version 1.10
+                for device in old_data["deleted_devices"]:
+                    device["disabled_by_undefined"] = old_minor_version < 10
 
         if old_major_version > 2:
             raise NotImplementedError
@@ -922,12 +941,15 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
             else:
                 self.deleted_devices.pop(deleted_device.id)
                 device = deleted_device.to_device_entry(
-                    config_entry_id,
+                    config_entry,
                     # Interpret not specifying a subentry as None
                     config_subentry_id if config_subentry_id is not UNDEFINED else None,
                     connections,
                     identifiers,
+                    disabled_by,
                 )
+                disabled_by = UNDEFINED
+
             self.devices[device.id] = device
             # If creating a new device, default to the config entry name
             if device_info_type == "primary" and (not name or name is UNDEFINED):
@@ -978,7 +1000,7 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
             via_device_id=via_device_id,
         )
 
-        # This is safe because _async_update_device will always return a device
+        # This is safe because async_update_device will always return a device
         # in this use case.
         assert device
         return device
@@ -1108,6 +1130,16 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
                 config_entries_subentries = old.config_entries_subentries | {
                     add_config_entry_id: {add_config_subentry_id}
                 }
+                # Enable the device if it was disabled by config entry and we're adding
+                # a non disabled config entry
+                if (
+                    # mypy says add_config_entry can be None. That's impossible, because we
+                    # raise above if that happens
+                    not add_config_entry.disabled_by  # type: ignore[union-attr]
+                    and old.disabled_by is DeviceEntryDisabler.CONFIG_ENTRY
+                ):
+                    new_values["disabled_by"] = None
+                    old_values["disabled_by"] = old.disabled_by
             elif (
                 add_config_subentry_id
                 not in old.config_entries_subentries[add_config_entry_id]
@@ -1150,6 +1182,22 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
 
                 config_entries = config_entries - {remove_config_entry_id}
 
+                # Disable the device if it is enabled and all remaining config entries
+                # are disabled
+                has_enabled_config_entries = any(
+                    config_entry.disabled_by is None
+                    for config_entry_id in config_entries
+                    if (
+                        config_entry := self.hass.config_entries.async_get_entry(
+                            config_entry_id
+                        )
+                    )
+                    is not None
+                )
+                if not has_enabled_config_entries and old.disabled_by is None:
+                    new_values["disabled_by"] = DeviceEntryDisabler.CONFIG_ENTRY
+                    old_values["disabled_by"] = old.disabled_by
+
         if config_entries != old.config_entries:
             new_values["config_entries"] = config_entries
             old_values["config_entries"] = old.config_entries
@@ -1409,7 +1457,21 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
                     sw_version=device["sw_version"],
                     via_device_id=device["via_device_id"],
                 )
+
             # Introduced in 0.111
+            def get_optional_enum[_EnumT: StrEnum](
+                cls: type[_EnumT], value: str | None, undefined: bool
+            ) -> _EnumT | UndefinedType | None:
+                """Convert string to the passed enum, UNDEFINED or None."""
+                if undefined:
+                    return UNDEFINED
+                if value is None:
+                    return None
+                try:
+                    return cls(value)
+                except ValueError:
+                    return None
+
             for device in data["deleted_devices"]:
                 deleted_devices[device["id"]] = DeletedDeviceEntry(
                     area_id=device["area_id"],
@@ -1422,10 +1484,10 @@ class DeviceRegistry(BaseRegistry[dict[str, list[dict[str, Any]]]]):
                     },
                     connections={tuple(conn) for conn in device["connections"]},
                     created_at=datetime.fromisoformat(device["created_at"]),
-                    disabled_by=(
-                        DeviceEntryDisabler(device["disabled_by"])
-                        if device["disabled_by"]
-                        else None
+                    disabled_by=get_optional_enum(
+                        DeviceEntryDisabler,
+                        device["disabled_by"],
+                        device["disabled_by_undefined"],
                     ),
                     identifiers={tuple(iden) for iden in device["identifiers"]},
                     id=device["id"],