Use runtime_data in Huawei LTE (home-assistant#168876)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: epenet

homeassistant/components/huawei_lte/__init__.py

@@ -1,5 +1,4 @@
 """Support for Huawei LTE routers."""
-# pylint: disable=hass-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
 
 from __future__ import annotations
 
@@ -9,7 +8,7 @@
 from dataclasses import dataclass, field
 from datetime import timedelta
 import logging
-from typing import Any, NamedTuple, cast
+from typing import Any, cast
 from xml.parsers.expat import ExpatError
 
 from huawei_lte_api.Client import Client
@@ -64,6 +63,7 @@
     DEFAULT_MANUFACTURER,
     DEFAULT_NOTIFY_SERVICE_NAME,
     DOMAIN,
+    HUAWEI_LTE_CONFIG,
     KEY_DEVICE_BASIC_INFORMATION,
     KEY_DEVICE_INFORMATION,
     KEY_DEVICE_SIGNAL,
@@ -108,7 +108,7 @@ class Router:
     """Class for router state."""
 
     hass: HomeAssistant
-    config_entry: ConfigEntry
+    config_entry: HuaweiLteConfigEntry
     connection: Connection
     url: str
 
@@ -278,14 +278,10 @@ def cleanup(self, *_: Any) -> None:
         self.connection.requests_session.close()
 
 
-class HuaweiLteData(NamedTuple):
-    """Shared state."""
+type HuaweiLteConfigEntry = ConfigEntry[Router]
 
-    hass_config: ConfigType
-    routers: dict[str, Router]
 
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: HuaweiLteConfigEntry) -> bool:
     """Set up Huawei LTE component from config entry."""
     url = entry.data[CONF_URL]
 
@@ -352,7 +348,7 @@ def _connect() -> Connection:
             return False
 
     # Store reference to router
-    hass.data[DOMAIN].routers[entry.entry_id] = router
+    entry.runtime_data = router
 
     # Clear all subscriptions, enabled entities will push back theirs
     router.subscriptions.clear()
@@ -417,7 +413,7 @@ def _connect() -> Connection:
             CONF_NAME: entry.options.get(CONF_NAME, DEFAULT_NOTIFY_SERVICE_NAME),
             CONF_RECIPIENT: entry.options.get(CONF_RECIPIENT),
         },
-        hass.data[DOMAIN].hass_config,
+        hass.data[HUAWEI_LTE_CONFIG],
     )
 
     def _update_router(*_: Any) -> None:
@@ -440,46 +436,47 @@ def _update_router(*_: Any) -> None:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, config_entry: HuaweiLteConfigEntry
+) -> bool:
     """Unload config entry."""
 
     # Forward config entry unload to platforms
     await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
 
-    # Forget about the router and invoke its cleanup
-    router = hass.data[DOMAIN].routers.pop(config_entry.entry_id)
-    await hass.async_add_executor_job(router.cleanup)
+    # Invoke router cleanup
+    await hass.async_add_executor_job(config_entry.runtime_data.cleanup)
 
     return True
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Huawei LTE component."""
 
-    if DOMAIN not in hass.data:
-        hass.data[DOMAIN] = HuaweiLteData(hass_config=config, routers={})
+    hass.data[HUAWEI_LTE_CONFIG] = config
 
     def service_handler(service: ServiceCall) -> None:
         """Apply a service.
 
         We key this using the router URL instead of its unique id / serial number,
         because the latter is not available anywhere in the UI.
         """
-        routers = hass.data[DOMAIN].routers
+        routers = [
+            entry.runtime_data
+            for entry in hass.config_entries.async_loaded_entries(DOMAIN)
+        ]
         if url := service.data.get(CONF_URL):
-            router = next(
-                (router for router in routers.values() if router.url == url), None
-            )
+            router = next((router for router in routers if router.url == url), None)
         elif not routers:
             _LOGGER.error("%s: no routers configured", service.service)
             return
         elif len(routers) == 1:
-            router = next(iter(routers.values()))
+            router = routers[0]
         else:
             _LOGGER.error(
                 "%s: more than one router configured, must specify one of URLs %s",
                 service.service,
-                sorted(router.url for router in routers.values()),
+                sorted(router.url for router in routers),
             )
             return
         if not router:
@@ -509,7 +506,9 @@ def service_handler(service: ServiceCall) -> None:
     return True
 
 
-async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: HuaweiLteConfigEntry
+) -> bool:
     """Migrate config entry to new version."""
     if config_entry.version == 1:
         options = dict(config_entry.options)

homeassistant/components/huawei_lte/binary_sensor.py

@@ -12,13 +12,12 @@
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from . import HuaweiLteConfigEntry
 from .const import (
-    DOMAIN,
     KEY_MONITORING_CHECK_NOTIFICATIONS,
     KEY_MONITORING_STATUS,
     KEY_WLAN_WIFI_FEATURE_SWITCH,
@@ -30,13 +29,11 @@
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: HuaweiLteConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up from config entry."""
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    router = hass.data[DOMAIN].routers[config_entry.entry_id]
+    router = config_entry.runtime_data
     entities: list[Entity] = []
 
     if router.data.get(KEY_MONITORING_STATUS):

homeassistant/components/huawei_lte/button.py

@@ -11,26 +11,23 @@
     ButtonEntity,
     ButtonEntityDescription,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_platform
 
-from .const import DOMAIN
+from . import HuaweiLteConfigEntry
 from .entity import HuaweiLteBaseEntityWithDevice
 
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: HuaweiLteConfigEntry,
     async_add_entities: entity_platform.AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Huawei LTE buttons."""
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    router = hass.data[DOMAIN].routers[config_entry.entry_id]
+    router = config_entry.runtime_data
     buttons = [
         ClearTrafficStatisticsButton(router),
         RestartButton(router),

homeassistant/components/huawei_lte/config_flow.py

@@ -21,12 +21,7 @@
 from url_normalize import url_normalize
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    OptionsFlow,
-)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
 from homeassistant.const import (
     CONF_MAC,
     CONF_NAME,
@@ -47,6 +42,7 @@
     SsdpServiceInfo,
 )
 
+from . import HuaweiLteConfigEntry
 from .const import (
     CONF_MANUFACTURER,
     CONF_TRACK_WIRED_CLIENTS,
@@ -76,7 +72,7 @@ class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
     @staticmethod
     @callback
     def async_get_options_flow(
-        config_entry: ConfigEntry,
+        config_entry: HuaweiLteConfigEntry,
     ) -> HuaweiLteOptionsFlow:
         """Get options flow."""
         return HuaweiLteOptionsFlow()

homeassistant/components/huawei_lte/const.py

@@ -1,7 +1,12 @@
 """Huawei LTE constants."""
 
+from homeassistant.helpers.typing import ConfigType
+from homeassistant.util.hass_dict import HassKey
+
 DOMAIN = "huawei_lte"
 
+HUAWEI_LTE_CONFIG: HassKey[ConfigType] = HassKey(DOMAIN)
+
 CONF_MANUFACTURER = "manufacturer"
 CONF_TRACK_WIRED_CLIENTS = "track_wired_clients"
 CONF_UNAUTHENTICATED_MODE = "unauthenticated_mode"

homeassistant/components/huawei_lte/device_tracker.py

@@ -9,19 +9,17 @@
     DOMAIN as DEVICE_TRACKER_DOMAIN,
     ScannerEntity,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import snakecase
 
-from . import Router
+from . import HuaweiLteConfigEntry, Router
 from .const import (
     CONF_TRACK_WIRED_CLIENTS,
     DEFAULT_TRACK_WIRED_CLIENTS,
-    DOMAIN,
     KEY_LAN_HOST_INFO,
     KEY_WLAN_HOST_LIST,
     UPDATE_SIGNAL,
@@ -50,17 +48,15 @@ def _get_hosts(
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: HuaweiLteConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up from config entry."""
 
     # Grab hosts list once to examine whether the initial fetch has got some data for
     # us, i.e. if wlan host list is supported. Only set up a subscription and proceed
     # with adding and tracking entities if it is.
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    router = hass.data[DOMAIN].routers[config_entry.entry_id]
+    router = config_entry.runtime_data
     if (hosts := _get_hosts(router, True)) is None:
         return
 

homeassistant/components/huawei_lte/diagnostics.py

@@ -5,10 +5,9 @@
 from typing import Any
 
 from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
+from . import HuaweiLteConfigEntry
 
 ENTRY_FIELDS_DATA_TO_REDACT = {
     "mac",
@@ -74,13 +73,13 @@
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: ConfigEntry
+    hass: HomeAssistant, entry: HuaweiLteConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
     return async_redact_data(
         {
             "entry": entry.data,
-            "router": hass.data[DOMAIN].routers[entry.entry_id].data,
+            "router": entry.runtime_data.data,
         },
         TO_REDACT,
     )

homeassistant/components/huawei_lte/notify.py

@@ -12,8 +12,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from . import Router
-from .const import DOMAIN
+from . import HuaweiLteConfigEntry, Router
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,9 +26,11 @@ async def async_get_service(
     if discovery_info is None:
         return None
 
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    router = hass.data[DOMAIN].routers[discovery_info[ATTR_CONFIG_ENTRY_ID]]
+    entry: HuaweiLteConfigEntry | None = hass.config_entries.async_get_entry(
+        discovery_info[ATTR_CONFIG_ENTRY_ID]
+    )
+    assert entry is not None
+    router = entry.runtime_data
     default_targets = discovery_info[CONF_RECIPIENT] or []
 
     return HuaweiLteSmsNotificationService(router, default_targets)

homeassistant/components/huawei_lte/quality_scale.yaml

@@ -22,7 +22,7 @@ rules:
   entity-event-setup: done
   entity-unique-id: done
   has-entity-name: done
-  runtime-data: todo
+  runtime-data: done
   test-before-configure: done
   test-before-setup: done
   unique-config-entry: done

homeassistant/components/huawei_lte/select.py

@@ -6,6 +6,7 @@
 from dataclasses import dataclass
 from functools import partial
 import logging
+from typing import Any
 
 from huawei_lte_api.enums.net import LTEBandEnum, NetworkBandEnum, NetworkModeEnum
 
@@ -14,14 +15,13 @@
     SelectEntity,
     SelectEntityDescription,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import Router
-from .const import DOMAIN, KEY_NET_NET_MODE
+from . import HuaweiLteConfigEntry, Router
+from .const import KEY_NET_NET_MODE
 from .entity import HuaweiLteBaseEntityWithDevice
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,18 +31,16 @@
 class HuaweiSelectEntityDescription(SelectEntityDescription):
     """Class describing Huawei LTE select entities."""
 
-    setter_fn: Callable[[str], None]
+    setter_fn: Callable[[str], Any]
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: HuaweiLteConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up from config entry."""
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    router = hass.data[DOMAIN].routers[config_entry.entry_id]
+    router = config_entry.runtime_data
     selects: list[Entity] = []
 
     desc = HuaweiSelectEntityDescription(