homeassistant 2025.6.2__py3-none-any.whl → 2025.7.0b0__py3-none-any.whl

homeassistant/helpers/entity_registry.py

@@ -79,7 +79,7 @@ EVENT_ENTITY_REGISTRY_UPDATED: EventType[EventEntityRegistryUpdatedData] = Event
 _LOGGER = logging.getLogger(__name__)
 
 STORAGE_VERSION_MAJOR = 1
-STORAGE_VERSION_MINOR = 17
+STORAGE_VERSION_MINOR = 18
 STORAGE_KEY = "core.entity_registry"
 
 CLEANUP_INTERVAL = 3600 * 24
@@ -406,12 +406,23 @@ class DeletedRegistryEntry:
     entity_id: str = attr.ib()
     unique_id: str = attr.ib()
     platform: str = attr.ib()
+
+    aliases: set[str] = attr.ib()
+    area_id: str | None = attr.ib()
+    categories: dict[str, str] = attr.ib()
     config_entry_id: str | None = attr.ib()
     config_subentry_id: str | None = attr.ib()
     created_at: datetime = attr.ib()
+    device_class: str | None = attr.ib()
+    disabled_by: RegistryEntryDisabler | None = attr.ib()
     domain: str = attr.ib(init=False, repr=False)
+    hidden_by: RegistryEntryHider | None = attr.ib()
+    icon: str | None = attr.ib()
     id: str = attr.ib()
+    labels: set[str] = attr.ib()
     modified_at: datetime = attr.ib()
+    name: str | None = attr.ib()
+    options: ReadOnlyEntityOptionsType = attr.ib(converter=_protect_entity_options)
     orphaned_timestamp: float | None = attr.ib()
 
     _cache: dict[str, Any] = attr.ib(factory=dict, eq=False, init=False)
@@ -427,12 +438,22 @@ class DeletedRegistryEntry:
         return json_fragment(
             json_bytes(
                 {
+                    "aliases": list(self.aliases),
+                    "area_id": self.area_id,
+                    "categories": self.categories,
                     "config_entry_id": self.config_entry_id,
                     "config_subentry_id": self.config_subentry_id,
                     "created_at": self.created_at,
+                    "device_class": self.device_class,
+                    "disabled_by": self.disabled_by,
                     "entity_id": self.entity_id,
+                    "hidden_by": self.hidden_by,
+                    "icon": self.icon,
                     "id": self.id,
+                    "labels": list(self.labels),
                     "modified_at": self.modified_at,
+                    "name": self.name,
+                    "options": self.options,
                     "orphaned_timestamp": self.orphaned_timestamp,
                     "platform": self.platform,
                     "unique_id": self.unique_id,
@@ -556,6 +577,20 @@ class EntityRegistryStore(storage.Store[dict[str, list[dict[str, Any]]]]):
                 for entity in data["entities"]:
                     entity["suggested_object_id"] = None
 
+            if old_minor_version < 18:
+                # Version 1.18 adds user customizations to deleted entities
+                for entity in data["deleted_entities"]:
+                    entity["aliases"] = []
+                    entity["area_id"] = None
+                    entity["categories"] = {}
+                    entity["device_class"] = None
+                    entity["disabled_by"] = None
+                    entity["hidden_by"] = None
+                    entity["icon"] = None
+                    entity["labels"] = []
+                    entity["name"] = None
+                    entity["options"] = {}
+
         if old_major_version > 1:
             raise NotImplementedError
         return data
@@ -916,15 +951,40 @@ class EntityRegistry(BaseRegistry):
         entity_registry_id: str | None = None
         created_at = utcnow()
         deleted_entity = self.deleted_entities.pop((domain, platform, unique_id), None)
+        options: Mapping[str, Mapping[str, Any]] | None
         if deleted_entity is not None:
-            # Restore id
-            entity_registry_id = deleted_entity.id
+            aliases = deleted_entity.aliases
+            area_id = deleted_entity.area_id
+            categories = deleted_entity.categories
             created_at = deleted_entity.created_at
-
-        entity_id = self.async_generate_entity_id(
-            domain,
-            suggested_object_id or calculated_object_id or f"{platform}_{unique_id}",
-        )
+            device_class = deleted_entity.device_class
+            disabled_by = deleted_entity.disabled_by
+            # Restore entity_id if it's available
+            if self._entity_id_available(deleted_entity.entity_id):
+                entity_id = deleted_entity.entity_id
+            entity_registry_id = deleted_entity.id
+            hidden_by = deleted_entity.hidden_by
+            icon = deleted_entity.icon
+            labels = deleted_entity.labels
+            name = deleted_entity.name
+            options = deleted_entity.options
+        else:
+            aliases = set()
+            area_id = None
+            categories = {}
+            device_class = None
+            icon = None
+            labels = set()
+            name = None
+            options = get_initial_options() if get_initial_options else None
+
+        if not entity_id:
+            entity_id = self.async_generate_entity_id(
+                domain,
+                suggested_object_id
+                or calculated_object_id
+                or f"{platform}_{unique_id}",
+            )
 
         if (
             disabled_by is None
@@ -938,21 +998,26 @@ class EntityRegistry(BaseRegistry):
             """Return None if value is UNDEFINED, otherwise return value."""
             return None if value is UNDEFINED else value
 
-        initial_options = get_initial_options() if get_initial_options else None
-
         entry = RegistryEntry(
+            aliases=aliases,
+            area_id=area_id,
+            categories=categories,
             capabilities=none_if_undefined(capabilities),
             config_entry_id=none_if_undefined(config_entry_id),
             config_subentry_id=none_if_undefined(config_subentry_id),
             created_at=created_at,
+            device_class=device_class,
             device_id=none_if_undefined(device_id),
             disabled_by=disabled_by,
             entity_category=none_if_undefined(entity_category),
             entity_id=entity_id,
             hidden_by=hidden_by,
             has_entity_name=none_if_undefined(has_entity_name) or False,
+            icon=icon,
             id=entity_registry_id,
-            options=initial_options,
+            labels=labels,
+            name=name,
+            options=options,
             original_device_class=none_if_undefined(original_device_class),
             original_icon=none_if_undefined(original_icon),
             original_name=none_if_undefined(original_name),
@@ -994,12 +1059,22 @@ class EntityRegistry(BaseRegistry):
         # If the entity does not belong to a config entry, mark it as orphaned
         orphaned_timestamp = None if config_entry_id else time.time()
         self.deleted_entities[key] = DeletedRegistryEntry(
+            aliases=entity.aliases,
+            area_id=entity.area_id,
+            categories=entity.categories,
             config_entry_id=config_entry_id,
             config_subentry_id=entity.config_subentry_id,
             created_at=entity.created_at,
+            device_class=entity.device_class,
+            disabled_by=entity.disabled_by,
             entity_id=entity_id,
+            hidden_by=entity.hidden_by,
+            icon=entity.icon,
             id=entity.id,
+            labels=entity.labels,
             modified_at=utcnow(),
+            name=entity.name,
+            options=entity.options,
             orphaned_timestamp=orphaned_timestamp,
             platform=entity.platform,
             unique_id=entity.unique_id,
@@ -1428,12 +1503,30 @@ class EntityRegistry(BaseRegistry):
                     entity["unique_id"],
                 )
                 deleted_entities[key] = DeletedRegistryEntry(
+                    aliases=set(entity["aliases"]),
+                    area_id=entity["area_id"],
+                    categories=entity["categories"],
                     config_entry_id=entity["config_entry_id"],
                     config_subentry_id=entity["config_subentry_id"],
                     created_at=datetime.fromisoformat(entity["created_at"]),
+                    device_class=entity["device_class"],
+                    disabled_by=(
+                        RegistryEntryDisabler(entity["disabled_by"])
+                        if entity["disabled_by"]
+                        else None
+                    ),
                     entity_id=entity["entity_id"],
+                    hidden_by=(
+                        RegistryEntryHider(entity["hidden_by"])
+                        if entity["hidden_by"]
+                        else None
+                    ),
+                    icon=entity["icon"],
                     id=entity["id"],
+                    labels=set(entity["labels"]),
                     modified_at=datetime.fromisoformat(entity["modified_at"]),
+                    name=entity["name"],
+                    options=entity["options"],
                     orphaned_timestamp=entity["orphaned_timestamp"],
                     platform=entity["platform"],
                     unique_id=entity["unique_id"],
@@ -1463,12 +1556,29 @@ class EntityRegistry(BaseRegistry):
                 categories = entry.categories.copy()
                 del categories[scope]
                 self.async_update_entity(entity_id, categories=categories)
+        for key, deleted_entity in list(self.deleted_entities.items()):
+            if (
+                existing_category_id := deleted_entity.categories.get(scope)
+            ) and category_id == existing_category_id:
+                categories = deleted_entity.categories.copy()
+                del categories[scope]
+                self.deleted_entities[key] = attr.evolve(
+                    deleted_entity, categories=categories
+                )
+                self.async_schedule_save()
 
     @callback
     def async_clear_label_id(self, label_id: str) -> None:
         """Clear label from registry entries."""
         for entry in self.entities.get_entries_for_label(label_id):
             self.async_update_entity(entry.entity_id, labels=entry.labels - {label_id})
+        for key, deleted_entity in list(self.deleted_entities.items()):
+            if label_id not in deleted_entity.labels:
+                continue
+            self.deleted_entities[key] = attr.evolve(
+                deleted_entity, labels=deleted_entity.labels - {label_id}
+            )
+            self.async_schedule_save()
 
     @callback
     def async_clear_config_entry(self, config_entry_id: str) -> None:
@@ -1533,6 +1643,11 @@ class EntityRegistry(BaseRegistry):
         """Clear area id from registry entries."""
         for entry in self.entities.get_entries_for_area_id(area_id):
             self.async_update_entity(entry.entity_id, area_id=None)
+        for key, deleted_entity in list(self.deleted_entities.items()):
+            if deleted_entity.area_id != area_id:
+                continue
+            self.deleted_entities[key] = attr.evolve(deleted_entity, area_id=None)
+            self.async_schedule_save()
 
 
 @callback
@@ -1630,8 +1745,7 @@ def async_config_entry_disabled_by_changed(
 @callback
 def _async_setup_cleanup(hass: HomeAssistant, registry: EntityRegistry) -> None:
     """Clean up device registry when entities removed."""
-    # pylint: disable-next=import-outside-toplevel
-    from . import category_registry as cr, event, label_registry as lr
+    from . import category_registry as cr, event, label_registry as lr  # noqa: PLC0415
 
     @callback
     def _removed_from_registry_filter(

homeassistant/helpers/json.py

@@ -235,10 +235,7 @@ def find_paths_unserializable_data(
 
     This method is slow! Only use for error handling.
     """
-    from homeassistant.core import (  # pylint: disable=import-outside-toplevel
-        Event,
-        State,
-    )
+    from homeassistant.core import Event, State  # noqa: PLC0415
 
     to_process = deque([(bad_data, "$")])
     invalid = {}

homeassistant/helpers/llm.py

@@ -160,11 +160,19 @@ class LLMContext:
     """Tool input to be processed."""
 
     platform: str
+    """Integration that is handling the LLM request."""
+
     context: Context | None
-    user_prompt: str | None
+    """Context of the LLM request."""
+
     language: str | None
+    """Language of the LLM request."""
+
     assistant: str | None
+    """Assistant domain that is handling the LLM request."""
+
     device_id: str | None
+    """Device that is making the request."""
 
 
 @dataclass(slots=True)
@@ -208,8 +216,7 @@ class APIInstance:
 
     async def async_call_tool(self, tool_input: ToolInput) -> JsonObjectType:
         """Call a LLM tool, validate args and return the response."""
-        # pylint: disable=import-outside-toplevel
-        from homeassistant.components.conversation import (
+        from homeassistant.components.conversation import (  # noqa: PLC0415
             ConversationTraceEventType,
             async_conversation_trace_append,
         )
@@ -302,7 +309,7 @@ class IntentTool(Tool):
             platform=llm_context.platform,
             intent_type=self.name,
             slots=slots,
-            text_input=llm_context.user_prompt,
+            text_input=None,
             context=llm_context.context,
             language=llm_context.language,
             assistant=llm_context.assistant,
@@ -893,6 +900,12 @@ class ActionTool(Tool):
         self._domain = domain
         self._action = action
         self.name = f"{domain}.{action}"
+        # Note: _get_cached_action_parameters only works for services which
+        # add their description directly to the service description cache.
+        # This is not the case for most services, but it is for scripts.
+        # If we want to use `ActionTool` for services other than scripts, we
+        # need to add a coroutine function to fetch the non-cached description
+        # and schema.
         self.description, self.parameters = _get_cached_action_parameters(
             hass, domain, action
         )

homeassistant/helpers/network.py

@@ -186,8 +186,7 @@ def get_url(
         known_hostnames = ["localhost"]
         if is_hassio(hass):
             # Local import to avoid circular dependencies
-            # pylint: disable-next=import-outside-toplevel
-            from homeassistant.components.hassio import get_host_info
+            from homeassistant.components.hassio import get_host_info  # noqa: PLC0415
 
             if host_info := get_host_info(hass):
                 known_hostnames.extend(
@@ -318,8 +317,7 @@ def _get_cloud_url(hass: HomeAssistant, require_current_request: bool = False) -
     """Get external Home Assistant Cloud URL of this instance."""
     if "cloud" in hass.config.components:
         # Local import to avoid circular dependencies
-        # pylint: disable-next=import-outside-toplevel
-        from homeassistant.components.cloud import (
+        from homeassistant.components.cloud import (  # noqa: PLC0415
             CloudNotAvailable,
             async_remote_ui_url,
         )

homeassistant/helpers/recorder.py

@@ -35,8 +35,7 @@ class RecorderData:
 @callback
 def async_migration_in_progress(hass: HomeAssistant) -> bool:
     """Check to see if a recorder migration is in progress."""
-    # pylint: disable-next=import-outside-toplevel
-    from homeassistant.components import recorder
+    from homeassistant.components import recorder  # noqa: PLC0415
 
     return recorder.util.async_migration_in_progress(hass)
 
@@ -44,8 +43,7 @@ def async_migration_in_progress(hass: HomeAssistant) -> bool:
 @callback
 def async_migration_is_live(hass: HomeAssistant) -> bool:
     """Check to see if a recorder migration is live."""
-    # pylint: disable-next=import-outside-toplevel
-    from homeassistant.components import recorder
+    from homeassistant.components import recorder  # noqa: PLC0415
 
     return recorder.util.async_migration_is_live(hass)
 
@@ -58,8 +56,9 @@ def async_initialize_recorder(hass: HomeAssistant) -> None:
     registers the basic recorder websocket API which is used by frontend to determine
     if the recorder is migrating the database.
     """
-    # pylint: disable-next=import-outside-toplevel
-    from homeassistant.components.recorder.basic_websocket_api import async_setup
+    from homeassistant.components.recorder.basic_websocket_api import (  # noqa: PLC0415
+        async_setup,
+    )
 
     hass.data[DATA_RECORDER] = RecorderData()
     async_setup(hass)

homeassistant/helpers/selector.py

@@ -1010,9 +1010,11 @@ class LocationSelector(Selector[LocationSelectorConfig]):
         return location
 
 
-class MediaSelectorConfig(BaseSelectorConfig):
+class MediaSelectorConfig(BaseSelectorConfig, total=False):
     """Class to represent a media selector config."""
 
+    accept: list[str]
+
 
 @SELECTORS.register("media")
 class MediaSelector(Selector[MediaSelectorConfig]):
@@ -1020,11 +1022,15 @@ class MediaSelector(Selector[MediaSelectorConfig]):
 
     selector_type = "media"
 
-    CONFIG_SCHEMA = BASE_SELECTOR_CONFIG_SCHEMA
+    CONFIG_SCHEMA = BASE_SELECTOR_CONFIG_SCHEMA.extend(
+        {
+            vol.Optional("accept"): [str],
+        }
+    )
     DATA_SCHEMA = vol.Schema(
         {
-            # Although marked as optional in frontend, this field is required
-            vol.Required("entity_id"): cv.entity_id_or_uuid,
+            # If accept is set, the entity_id field will not be present
+            vol.Optional("entity_id"): cv.entity_id_or_uuid,
             # Although marked as optional in frontend, this field is required
             vol.Required("media_content_id"): str,
             # Although marked as optional in frontend, this field is required
@@ -1113,9 +1119,23 @@ class NumberSelector(Selector[NumberSelectorConfig]):
         return value
 
 
+class ObjectSelectorField(TypedDict):
+    """Class to represent an object selector fields dict."""
+
+    label: str
+    required: bool
+    selector: dict[str, Any]
+
+
 class ObjectSelectorConfig(BaseSelectorConfig):
     """Class to represent an object selector config."""
 
+    fields: dict[str, ObjectSelectorField]
+    multiple: bool
+    label_field: str
+    description_field: bool
+    translation_key: str
+
 
 @SELECTORS.register("object")
 class ObjectSelector(Selector[ObjectSelectorConfig]):
@@ -1123,7 +1143,21 @@ class ObjectSelector(Selector[ObjectSelectorConfig]):
 
     selector_type = "object"
 
-    CONFIG_SCHEMA = BASE_SELECTOR_CONFIG_SCHEMA
+    CONFIG_SCHEMA = BASE_SELECTOR_CONFIG_SCHEMA.extend(
+        {
+            vol.Optional("fields"): {
+                str: {
+                    vol.Required("selector"): dict,
+                    vol.Optional("required"): bool,
+                    vol.Optional("label"): str,
+                }
+            },
+            vol.Optional("multiple", default=False): bool,
+            vol.Optional("label_field"): str,
+            vol.Optional("description_field"): str,
+            vol.Optional("translation_key"): str,
+        }
+    )
 
     def __init__(self, config: ObjectSelectorConfig | None = None) -> None:
         """Instantiate a selector."""
@@ -1216,6 +1250,39 @@ class SelectSelector(Selector[SelectSelectorConfig]):
         return [parent_schema(vol.Schema(str)(val)) for val in data]
 
 
+class StatisticSelectorConfig(BaseSelectorConfig, total=False):
+    """Class to represent a statistic selector config."""
+
+    multiple: bool
+
+
+@SELECTORS.register("statistic")
+class StatisticSelector(Selector[StatisticSelectorConfig]):
+    """Selector of a single or list of statistics."""
+
+    selector_type = "statistic"
+
+    CONFIG_SCHEMA = BASE_SELECTOR_CONFIG_SCHEMA.extend(
+        {
+            vol.Optional("multiple", default=False): cv.boolean,
+        }
+    )
+
+    def __init__(self, config: StatisticSelectorConfig | None = None) -> None:
+        """Instantiate a selector."""
+        super().__init__(config)
+
+    def __call__(self, data: Any) -> str | list[str]:
+        """Validate the passed selection."""
+
+        if not self.config["multiple"]:
+            stat: str = vol.Schema(str)(data)
+            return stat
+        if not isinstance(data, list):
+            raise vol.Invalid("Value should be a list")
+        return [vol.Schema(str)(val) for val in data]
+
+
 class TargetSelectorConfig(BaseSelectorConfig, total=False):
     """Class to represent a target selector config."""
 

homeassistant/helpers/service.py

@@ -85,8 +85,7 @@ ALL_SERVICE_DESCRIPTIONS_CACHE: HassKey[
 @cache
 def _base_components() -> dict[str, ModuleType]:
     """Return a cached lookup of base components."""
-    # pylint: disable-next=import-outside-toplevel
-    from homeassistant.components import (
+    from homeassistant.components import (  # noqa: PLC0415
         alarm_control_panel,
         assist_satellite,
         calendar,
@@ -718,7 +717,6 @@ async def async_get_all_descriptions(
         for service_name in services_by_domain
     }
     # If we have a complete cache, check if it is still valid
-    all_cache: tuple[set[tuple[str, str]], dict[str, dict[str, Any]]] | None
     if all_cache := hass.data.get(ALL_SERVICE_DESCRIPTIONS_CACHE):
         previous_all_services, previous_descriptions_cache = all_cache
         # If the services are the same, we can return the cache
@@ -744,7 +742,11 @@ async def async_get_all_descriptions(
                 continue
             if TYPE_CHECKING:
                 assert isinstance(int_or_exc, Exception)
-            _LOGGER.error("Failed to load integration: %s", domain, exc_info=int_or_exc)
+            _LOGGER.error(
+                "Failed to load services.yaml for integration: %s",
+                domain,
+                exc_info=int_or_exc,
+            )
 
         if integrations:
             loaded = await hass.async_add_executor_job(
@@ -772,7 +774,7 @@ async def async_get_all_descriptions(
             # Cache missing descriptions
             domain_yaml = loaded.get(domain) or {}
             # The YAML may be empty for dynamically defined
-            # services (ie shell_command) that never call
+            # services (e.g. shell_command) that never call
             # service.async_set_service_schema for the dynamic
             # service
 
@@ -1293,8 +1295,7 @@ def async_register_entity_service(
     if schema is None or isinstance(schema, dict):
         schema = cv.make_entity_service_schema(schema)
     elif not cv.is_entity_service_schema(schema):
-        # pylint: disable-next=import-outside-toplevel
-        from .frame import ReportBehavior, report_usage
+        from .frame import ReportBehavior, report_usage  # noqa: PLC0415
 
         report_usage(
             "registers an entity service with a non entity service schema",

homeassistant/helpers/storage.py

@@ -354,7 +354,7 @@ class Store[_T: Mapping[str, Any] | Sequence[Any]]:
                         corrupt_path,
                         err,
                     )
-                    from .issue_registry import (  # pylint: disable=import-outside-toplevel
+                    from .issue_registry import (  # noqa: PLC0415
                         IssueSeverity,
                         async_create_issue,
                     )

homeassistant/helpers/sun.py

@@ -31,8 +31,8 @@ def get_astral_location(
     hass: HomeAssistant,
 ) -> tuple[astral.location.Location, astral.Elevation]:
     """Get an astral location for the current Home Assistant configuration."""
-    from astral import LocationInfo  # pylint: disable=import-outside-toplevel
-    from astral.location import Location  # pylint: disable=import-outside-toplevel
+    from astral import LocationInfo  # noqa: PLC0415
+    from astral.location import Location  # noqa: PLC0415
 
     latitude = hass.config.latitude
     longitude = hass.config.longitude

homeassistant/helpers/system_info.py

@@ -21,6 +21,7 @@ from .singleton import singleton
 _LOGGER = logging.getLogger(__name__)
 
 _DATA_MAC_VER = "system_info_mac_ver"
+_DATA_CONTAINER_ARCH = "system_info_container_arch"
 
 
 @singleton(_DATA_MAC_VER)
@@ -29,6 +30,22 @@ async def async_get_mac_ver(hass: HomeAssistant) -> str:
     return (await hass.async_add_executor_job(platform.mac_ver))[0]
 
 
+@singleton(_DATA_CONTAINER_ARCH)
+async def async_get_container_arch(hass: HomeAssistant) -> str:
+    """Return the container architecture."""
+
+    def _read_arch_file() -> str:
+        """Read the architecture from /etc/apk/arch."""
+        with open("/etc/apk/arch", encoding="utf-8") as arch_file:
+            return arch_file.read().strip()
+
+    try:
+        raw_arch = await hass.async_add_executor_job(_read_arch_file)
+    except FileNotFoundError:
+        return "unknown"
+    return {"x86": "i386", "x86_64": "amd64"}.get(raw_arch, raw_arch)
+
+
 # Cache the result of getuser() because it can call getpwuid() which
 # can do blocking I/O to look up the username in /etc/passwd.
 cached_get_user = cache(getuser)
@@ -42,8 +59,7 @@ async def async_get_system_info(hass: HomeAssistant) -> dict[str, Any]:
     # may not be loaded yet and we don't want to
     # do blocking I/O in the event loop to import it.
     if TYPE_CHECKING:
-        # pylint: disable-next=import-outside-toplevel
-        from homeassistant.components import hassio
+        from homeassistant.components import hassio  # noqa: PLC0415
     else:
         hassio = await async_import_module(hass, "homeassistant.components.hassio")
 
@@ -80,6 +96,7 @@ async def async_get_system_info(hass: HomeAssistant) -> dict[str, Any]:
     if info_object["docker"]:
         if info_object["user"] == "root" and is_official_image():
             info_object["installation_type"] = "Home Assistant Container"
+            info_object["container_arch"] = await async_get_container_arch(hass)
         else:
             info_object["installation_type"] = "Unsupported Third Party Container"