homeassistant 2025.7.4__py3-none-any.whl → 2025.8.0b0__py3-none-any.whl

homeassistant/helpers/entity_platform.py

@@ -44,6 +44,7 @@ from . import (
     service,
     translation,
 )
+from .deprecation import deprecated_function
 from .entity_registry import EntityRegistry, RegistryEntryDisabler, RegistryEntryHider
 from .event import async_call_later
 from .issue_registry import IssueSeverity, async_create_issue
@@ -126,6 +127,77 @@ class EntityPlatformModule(Protocol):
         """Set up an integration platform from a config entry."""
 
 
+class PlatformData:
+    """Information about a platform, used by entities."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        *,
+        domain: str,
+        platform_name: str,
+    ) -> None:
+        """Initialize the base entity platform."""
+        self.hass = hass
+        self.domain = domain
+        self.platform_name = platform_name
+        self.component_translations: dict[str, str] = {}
+        self.platform_translations: dict[str, str] = {}
+        self.object_id_component_translations: dict[str, str] = {}
+        self.object_id_platform_translations: dict[str, str] = {}
+        self.default_language_platform_translations: dict[str, str] = {}
+
+    async def _async_get_translations(
+        self, language: str, category: str, integration: str
+    ) -> dict[str, str]:
+        """Get translations for a language, category, and integration."""
+        try:
+            return await translation.async_get_translations(
+                self.hass, language, category, {integration}
+            )
+        except Exception as err:  # noqa: BLE001
+            _LOGGER.debug(
+                "Could not load translations for %s",
+                integration,
+                exc_info=err,
+            )
+        return {}
+
+    async def async_load_translations(self) -> None:
+        """Load translations."""
+        hass = self.hass
+        object_id_language = (
+            hass.config.language
+            if hass.config.language in languages.NATIVE_ENTITY_IDS
+            else languages.DEFAULT_LANGUAGE
+        )
+        config_language = hass.config.language
+        self.component_translations = await self._async_get_translations(
+            config_language, "entity_component", self.domain
+        )
+        self.platform_translations = await self._async_get_translations(
+            config_language, "entity", self.platform_name
+        )
+        if object_id_language == config_language:
+            self.object_id_component_translations = self.component_translations
+            self.object_id_platform_translations = self.platform_translations
+        else:
+            self.object_id_component_translations = await self._async_get_translations(
+                object_id_language, "entity_component", self.domain
+            )
+            self.object_id_platform_translations = await self._async_get_translations(
+                object_id_language, "entity", self.platform_name
+            )
+        if config_language == languages.DEFAULT_LANGUAGE:
+            self.default_language_platform_translations = self.platform_translations
+        else:
+            self.default_language_platform_translations = (
+                await self._async_get_translations(
+                    languages.DEFAULT_LANGUAGE, "entity", self.platform_name
+                )
+            )
+
+
 class EntityPlatform:
     """Manage the entities for a single platform.
 
@@ -147,8 +219,6 @@ class EntityPlatform:
         """Initialize the entity platform."""
         self.hass = hass
         self.logger = logger
-        self.domain = domain
-        self.platform_name = platform_name
         self.platform = platform
         self.scan_interval = scan_interval
         self.scan_interval_seconds = scan_interval.total_seconds()
@@ -157,11 +227,6 @@ class EntityPlatform:
         # Storage for entities for this specific platform only
         # which are indexed by entity_id
         self.entities: dict[str, Entity] = {}
-        self.component_translations: dict[str, str] = {}
-        self.platform_translations: dict[str, str] = {}
-        self.object_id_component_translations: dict[str, str] = {}
-        self.object_id_platform_translations: dict[str, str] = {}
-        self.default_language_platform_translations: dict[str, str] = {}
         self._tasks: list[asyncio.Task[None]] = []
         # Stop tracking tasks after setup is completed
         self._setup_complete = False
@@ -195,6 +260,10 @@ class EntityPlatform:
             DATA_DOMAIN_PLATFORM_ENTITIES, {}
         ).setdefault(key, {})
 
+        self.platform_data = PlatformData(
+            hass, domain=domain, platform_name=platform_name
+        )
+
     def __repr__(self) -> str:
         """Represent an EntityPlatform."""
         return (
@@ -362,7 +431,7 @@ class EntityPlatform:
         hass = self.hass
         full_name = f"{self.platform_name}.{self.domain}"
 
-        await self.async_load_translations()
+        await self.platform_data.async_load_translations()
 
         logger.info("Setting up %s", full_name)
         warn_task = hass.loop.call_at(
@@ -457,56 +526,6 @@ class EntityPlatform:
         finally:
             warn_task.cancel()
 
-    async def _async_get_translations(
-        self, language: str, category: str, integration: str
-    ) -> dict[str, str]:
-        """Get translations for a language, category, and integration."""
-        try:
-            return await translation.async_get_translations(
-                self.hass, language, category, {integration}
-            )
-        except Exception as err:  # noqa: BLE001
-            _LOGGER.debug(
-                "Could not load translations for %s",
-                integration,
-                exc_info=err,
-            )
-        return {}
-
-    async def async_load_translations(self) -> None:
-        """Load translations."""
-        hass = self.hass
-        object_id_language = (
-            hass.config.language
-            if hass.config.language in languages.NATIVE_ENTITY_IDS
-            else languages.DEFAULT_LANGUAGE
-        )
-        config_language = hass.config.language
-        self.component_translations = await self._async_get_translations(
-            config_language, "entity_component", self.domain
-        )
-        self.platform_translations = await self._async_get_translations(
-            config_language, "entity", self.platform_name
-        )
-        if object_id_language == config_language:
-            self.object_id_component_translations = self.component_translations
-            self.object_id_platform_translations = self.platform_translations
-        else:
-            self.object_id_component_translations = await self._async_get_translations(
-                object_id_language, "entity_component", self.domain
-            )
-            self.object_id_platform_translations = await self._async_get_translations(
-                object_id_language, "entity", self.platform_name
-            )
-        if config_language == languages.DEFAULT_LANGUAGE:
-            self.default_language_platform_translations = self.platform_translations
-        else:
-            self.default_language_platform_translations = (
-                await self._async_get_translations(
-                    languages.DEFAULT_LANGUAGE, "entity", self.platform_name
-                )
-            )
-
     def _schedule_add_entities(
         self, new_entities: Iterable[Entity], update_before_add: bool = False
     ) -> None:
@@ -825,21 +844,25 @@ class EntityPlatform:
                     entity.add_to_platform_abort()
                     return
 
-            if self.config_entry and (device_info := entity.device_info):
-                try:
-                    device = dev_reg.async_get(self.hass).async_get_or_create(
-                        config_entry_id=self.config_entry.entry_id,
-                        config_subentry_id=config_subentry_id,
-                        **device_info,
-                    )
-                except dev_reg.DeviceInfoError as exc:
-                    self.logger.error(
-                        "%s: Not adding entity with invalid device info: %s",
-                        self.platform_name,
-                        str(exc),
-                    )
-                    entity.add_to_platform_abort()
-                    return
+            device: dev_reg.DeviceEntry | None
+            if self.config_entry:
+                if device_info := entity.device_info:
+                    try:
+                        device = dev_reg.async_get(self.hass).async_get_or_create(
+                            config_entry_id=self.config_entry.entry_id,
+                            config_subentry_id=config_subentry_id,
+                            **device_info,
+                        )
+                    except dev_reg.DeviceInfoError as exc:
+                        self.logger.error(
+                            "%s: Not adding entity with invalid device info: %s",
+                            self.platform_name,
+                            str(exc),
+                        )
+                        entity.add_to_platform_abort()
+                        return
+                else:
+                    device = entity.device_entry
             else:
                 device = None
 
@@ -1116,6 +1139,87 @@ class EntityPlatform:
             ]:
                 await asyncio.gather(*tasks)
 
+    @property
+    def domain(self) -> str:
+        """Return the domain (e.g. light)."""
+        return self.platform_data.domain
+
+    @property
+    def platform_name(self) -> str:
+        """Return the platform name (e.g hue)."""
+        return self.platform_data.platform_name
+
+    @property
+    @deprecated_function(
+        "platform_data.component_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    def component_translations(self) -> dict[str, str]:
+        """Return the component translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return self.platform_data.component_translations
+
+    @property
+    @deprecated_function(
+        "platform_data.platform_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    def platform_translations(self) -> dict[str, str]:
+        """Return the platform translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return self.platform_data.platform_translations
+
+    @property
+    @deprecated_function(
+        "platform_data.object_id_component_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    def object_id_component_translations(self) -> dict[str, str]:
+        """Return the object ID component translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return self.platform_data.object_id_component_translations
+
+    @property
+    @deprecated_function(
+        "platform_data.object_id_platform_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    def object_id_platform_translations(self) -> dict[str, str]:
+        """Return the object ID platform translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return self.platform_data.object_id_platform_translations
+
+    @property
+    @deprecated_function(
+        "platform_data.default_language_platform_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    def default_language_platform_translations(self) -> dict[str, str]:
+        """Return the default language platform translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return self.platform_data.default_language_platform_translations
+
+    @deprecated_function(
+        "platform_data.async_load_translations",
+        breaks_in_ha_version="2026.8",
+    )
+    async def async_load_translations(self) -> None:
+        """Load translations.
+
+        Will be removed in Home Assistant Core 2026.8.
+        """
+        return await self.platform_data.async_load_translations()
+
 
 @callback
 def async_calculate_suggested_object_id(

homeassistant/helpers/entity_registry.py

@@ -1103,8 +1103,20 @@ class EntityRegistry(BaseRegistry):
             entities = async_entries_for_device(
                 self, event.data["device_id"], include_disabled_entities=True
             )
+            removed_device = event.data["device"]
             for entity in entities:
-                self.async_remove(entity.entity_id)
+                config_entry_id = entity.config_entry_id
+                if (
+                    config_entry_id in removed_device.config_entries
+                    and entity.config_subentry_id
+                    in removed_device.config_entries_subentries[config_entry_id]
+                ):
+                    self.async_remove(entity.entity_id)
+                else:
+                    if entity.entity_id not in self.entities:
+                        # Entity has been removed already, skip it
+                        continue
+                    self.async_update_entity(entity.entity_id, device_id=None)
             return
 
         if event.data["action"] != "update":
@@ -1121,29 +1133,38 @@ class EntityRegistry(BaseRegistry):
 
         # Remove entities which belong to config entries no longer associated with the
         # device
-        entities = async_entries_for_device(
-            self, event.data["device_id"], include_disabled_entities=True
-        )
-        for entity in entities:
-            if (
-                entity.config_entry_id is not None
-                and entity.config_entry_id not in device.config_entries
-            ):
-                self.async_remove(entity.entity_id)
+        if old_config_entries := event.data["changes"].get("config_entries"):
+            entities = async_entries_for_device(
+                self, event.data["device_id"], include_disabled_entities=True
+            )
+            for entity in entities:
+                config_entry_id = entity.config_entry_id
+                if (
+                    entity.config_entry_id in old_config_entries
+                    and entity.config_entry_id not in device.config_entries
+                ):
+                    self.async_remove(entity.entity_id)
 
         # Remove entities which belong to config subentries no longer associated with the
         # device
-        entities = async_entries_for_device(
-            self, event.data["device_id"], include_disabled_entities=True
-        )
-        for entity in entities:
-            if (
-                (config_entry_id := entity.config_entry_id) is not None
-                and config_entry_id in device.config_entries
-                and entity.config_subentry_id
-                not in device.config_entries_subentries[config_entry_id]
-            ):
-                self.async_remove(entity.entity_id)
+        if old_config_entries_subentries := event.data["changes"].get(
+            "config_entries_subentries"
+        ):
+            entities = async_entries_for_device(
+                self, event.data["device_id"], include_disabled_entities=True
+            )
+            for entity in entities:
+                config_entry_id = entity.config_entry_id
+                config_subentry_id = entity.config_subentry_id
+                if (
+                    config_entry_id in device.config_entries
+                    and config_entry_id in old_config_entries_subentries
+                    and config_subentry_id
+                    in old_config_entries_subentries[config_entry_id]
+                    and config_subentry_id
+                    not in device.config_entries_subentries[config_entry_id]
+                ):
+                    self.async_remove(entity.entity_id)
 
         # Re-enable disabled entities if the device is no longer disabled
         if not device.disabled:

homeassistant/helpers/event.py

@@ -316,6 +316,10 @@ def async_track_state_change_event(
     Unlike async_track_state_change, async_track_state_change_event
     passes the full event to the callback.
 
+    The action will not be called immediately, but will be scheduled to run
+    in the next event loop iteration, even if the action is decorated with
+    @callback.
+
     In order to avoid having to iterate a long list
     of EVENT_STATE_CHANGED and fire and create a job
     for each one, we keep a dict of entity ids that
@@ -398,7 +402,7 @@ def _async_track_state_change_event(
 _KEYED_TRACK_STATE_REPORT = _KeyedEventTracker(
     key=_TRACK_STATE_REPORT_DATA,
     event_type=EVENT_STATE_REPORTED,
-    dispatcher_callable=_async_dispatch_entity_id_event,
+    dispatcher_callable=_async_dispatch_entity_id_event_soon,
     filter_callable=_async_state_filter,
 )
 
@@ -866,19 +870,21 @@ def async_track_state_change_filtered(
 ) -> _TrackStateChangeFiltered:
     """Track state changes with a TrackStates filter that can be updated.
 
-    Parameters
-    ----------
-    hass
-        Home assistant object.
-    track_states
-        A TrackStates data class.
-    action
-        Callable to call with results.
+    The action will not be called immediately, but will be scheduled to run
+    in the next event loop iteration, even if the action is decorated with
+    @callback.
 
-    Returns
-    -------
-    Object used to update the listeners (async_update_listeners) with a new
-    TrackStates or cancel the tracking (async_remove).
+    Args:
+        hass:
+            Home assistant object.
+        track_states:
+            A TrackStates data class.
+        action:
+            Callable to call with results.
+
+    Returns:
+        Object used to update the listeners (async_update_listeners) with a new
+        TrackStates or cancel the tracking (async_remove).
 
     """
     tracker = _TrackStateChangeFiltered(hass, track_states, action)
@@ -907,29 +913,26 @@ def async_track_template(
     exception, the listener will still be registered but will only
     fire if the template result becomes true without an exception.
 
-    Action arguments
-    ----------------
-    entity_id
-        ID of the entity that triggered the state change.
-    old_state
-        The old state of the entity that changed.
-    new_state
-        New state of the entity that changed.
-
-    Parameters
-    ----------
-    hass
-        Home assistant object.
-    template
-        The template to calculate.
-    action
-        Callable to call with results. See above for arguments.
-    variables
-        Variables to pass to the template.
-
-    Returns
-    -------
-    Callable to unregister the listener.
+    Action args:
+        entity_id:
+            ID of the entity that triggered the state change.
+        old_state:
+            The old state of the entity that changed.
+        new_state:
+            New state of the entity that changed.
+
+    Args:
+        hass:
+            Home assistant object.
+        template:
+            The template to calculate.
+        action:
+            Callable to call with results. See above for arguments.
+        variables:
+            Variables to pass to the template.
+
+    Returns:
+        Callable to unregister the listener.
 
     """
     job = HassJob(action, f"track template {template}")
@@ -1353,34 +1356,36 @@ def async_track_template_result(
     then whenever the output from the template changes. The template will
     be reevaluated if any states referenced in the last run of the
     template change, or if manually triggered. If the result of the
-    evaluation is different from the previous run, the listener is passed
+    evaluation is different from the previous run, the action is passed
     the result.
 
+    The action will not be called immediately, but will be scheduled to run
+    in the next event loop iteration, even if the action is decorated with
+    @callback.
+
     If the template results in an TemplateError, this will be returned to
     the listener the first time this happens but not for subsequent errors.
     Once the template returns to a non-error condition the result is sent
     to the action as usual.
 
-    Parameters
-    ----------
-    hass
-        Home assistant object.
-    track_templates
-        An iterable of TrackTemplate.
-    action
-        Callable to call with results.
-    strict
-        When set to True, raise on undefined variables.
-    log_fn
-        If not None, template error messages will logging by calling log_fn
-        instead of the normal logging facility.
-    has_super_template
-        When set to True, the first template will block rendering of other
-        templates if it doesn't render as True.
-
-    Returns
-    -------
-    Info object used to unregister the listener, and refresh the template.
+    Args:
+        hass:
+            Home assistant object.
+        track_templates:
+            An iterable of TrackTemplate.
+        action:
+            Callable to call with results.
+        strict:
+            When set to True, raise on undefined variables.
+        log_fn:
+            If not None, template error messages will logging by calling log_fn
+            instead of the normal logging facility.
+        has_super_template:
+            When set to True, the first template will block rendering of other
+            templates if it doesn't render as True.
+
+    Returns:
+        Info object used to unregister the listener, and refresh the template.
 
     """
     tracker = TrackTemplateResultInfo(hass, track_templates, action, has_super_template)

homeassistant/helpers/frame.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable
 from dataclasses import dataclass
 import enum
 import functools
+import inspect
 import linecache
 import logging
 import sys
@@ -185,6 +185,21 @@ def report_usage(
     """
     if (hass := _hass.hass) is None:
         raise RuntimeError("Frame helper not set up")
+    integration_frame: IntegrationFrame | None = None
+    integration_frame_err: MissingIntegrationFrame | None = None
+    if not integration_domain:
+        try:
+            integration_frame = get_integration_frame(
+                exclude_integrations=exclude_integrations
+            )
+        except MissingIntegrationFrame as err:
+            # We need to be careful with assigning the error here as it affects the
+            # cleanup of objects referenced from the stack trace as seen in
+            # https://github.com/home-assistant/core/pull/148021#discussion_r2182379834
+            # When core_behavior is ReportBehavior.ERROR, we will re-raise the error,
+            # so we can safely assign it to integration_frame_err.
+            if core_behavior is ReportBehavior.ERROR:
+                integration_frame_err = err
     _report_usage_partial = functools.partial(
         _report_usage,
         hass,
@@ -193,8 +208,9 @@ def report_usage(
         core_behavior=core_behavior,
         core_integration_behavior=core_integration_behavior,
         custom_integration_behavior=custom_integration_behavior,
-        exclude_integrations=exclude_integrations,
         integration_domain=integration_domain,
+        integration_frame=integration_frame,
+        integration_frame_err=integration_frame_err,
         level=level,
     )
     if hass.loop_thread_id != threading.get_ident():
@@ -212,8 +228,9 @@ def _report_usage(
     core_behavior: ReportBehavior,
     core_integration_behavior: ReportBehavior,
     custom_integration_behavior: ReportBehavior,
-    exclude_integrations: set[str] | None,
     integration_domain: str | None,
+    integration_frame: IntegrationFrame | None,
+    integration_frame_err: MissingIntegrationFrame | None,
     level: int,
 ) -> None:
     """Report incorrect code usage.
@@ -235,12 +252,10 @@ def _report_usage(
         _report_usage_no_integration(what, core_behavior, breaks_in_ha_version, None)
         return
 
-    try:
-        integration_frame = get_integration_frame(
-            exclude_integrations=exclude_integrations
+    if not integration_frame:
+        _report_usage_no_integration(
+            what, core_behavior, breaks_in_ha_version, integration_frame_err
         )
-    except MissingIntegrationFrame as err:
-        _report_usage_no_integration(what, core_behavior, breaks_in_ha_version, err)
         return
 
     integration_behavior = core_integration_behavior
@@ -382,7 +397,7 @@ def _report_usage_no_integration(
 
 def warn_use[_CallableT: Callable](func: _CallableT, what: str) -> _CallableT:
     """Mock a function to warn when it was about to be used."""
-    if asyncio.iscoroutinefunction(func):
+    if inspect.iscoroutinefunction(func):
 
         @functools.wraps(func)
         async def report_use(*args: Any, **kwargs: Any) -> None: