[pull] dev from home-assistant:dev

homeassistant/components/lookin/__init__.py

@@ -200,7 +200,7 @@ async def async_remove_config_entry_device(
     hass: HomeAssistant, entry: LookinConfigEntry, device_entry: dr.DeviceEntry
 ) -> bool:
     """Remove lookin config entry from a device."""
-    data: LookinData = hass.data[DOMAIN][entry.entry_id]
+    data = entry.runtime_data
     all_identifiers: set[tuple[str, str]] = {
         (DOMAIN, data.lookin_device.id),
         *((DOMAIN, remote["UUID"]) for remote in data.devices),

homeassistant/components/medcom_ble/__init__.py

@@ -2,34 +2,23 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
-import logging
-
-from bleak import BleakError
-from medcom_ble import MedcomBleDeviceData
-
 from homeassistant.components import bluetooth
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.util.unit_system import METRIC_SYSTEM
 
-from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+from .const import DOMAIN
+from .coordinator import MedcomBleUpdateCoordinator
 
 # Supported platforms
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Medcom BLE radiation monitor from a config entry."""
 
     address = entry.unique_id
-    elevation = hass.config.elevation
-    is_metric = hass.config.units is METRIC_SYSTEM
     assert address is not None
 
     ble_device = bluetooth.async_ble_device_from_address(hass, address)
@@ -38,26 +27,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             f"Could not find Medcom BLE device with address {address}"
         )
 
-    async def _async_update_method():
-        """Get data from Medcom BLE radiation monitor."""
-        ble_device = bluetooth.async_ble_device_from_address(hass, address)
-        inspector = MedcomBleDeviceData(_LOGGER, elevation, is_metric)
-
-        try:
-            data = await inspector.update_device(ble_device)
-        except BleakError as err:
-            raise UpdateFailed(f"Unable to fetch data: {err}") from err
-
-        return data
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        name=DOMAIN,
-        update_method=_async_update_method,
-        update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
-    )
+    coordinator = MedcomBleUpdateCoordinator(hass, entry, address)
 
     await coordinator.async_config_entry_first_refresh()
 

homeassistant/components/medcom_ble/coordinator.py

@@ -0,0 +1,50 @@
+"""The Medcom BLE integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from bleak import BleakError
+from medcom_ble import MedcomBleDevice, MedcomBleDeviceData
+
+from homeassistant.components import bluetooth
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util.unit_system import METRIC_SYSTEM
+
+from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MedcomBleUpdateCoordinator(DataUpdateCoordinator[MedcomBleDevice]):
+    """Coordinator for Medcom BLE radiation monitor data."""
+
+    config_entry: ConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: ConfigEntry, address: str) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name=DOMAIN,
+            update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
+        )
+        self._address = address
+        self._elevation = hass.config.elevation
+        self._is_metric = hass.config.units is METRIC_SYSTEM
+
+    async def _async_update_data(self) -> MedcomBleDevice:
+        """Get data from Medcom BLE radiation monitor."""
+        ble_device = bluetooth.async_ble_device_from_address(self.hass, self._address)
+        inspector = MedcomBleDeviceData(_LOGGER, self._elevation, self._is_metric)
+
+        try:
+            data = await inspector.update_device(ble_device)
+        except BleakError as err:
+            raise UpdateFailed(f"Unable to fetch data: {err}") from err
+
+        return data

homeassistant/components/medcom_ble/sensor.py

@@ -4,8 +4,6 @@
 
 import logging
 
-from medcom_ble import MedcomBleDevice
-
 from homeassistant import config_entries
 from homeassistant.components.sensor import (
     SensorEntity,
@@ -15,12 +13,10 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import (
-    CoordinatorEntity,
-    DataUpdateCoordinator,
-)
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN, UNIT_CPM
+from .coordinator import MedcomBleUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,9 +37,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up Medcom BLE radiation monitor sensors."""
 
-    coordinator: DataUpdateCoordinator[MedcomBleDevice] = hass.data[DOMAIN][
-        entry.entry_id
-    ]
+    coordinator: MedcomBleUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
 
     entities = []
     _LOGGER.debug("got sensors: %s", coordinator.data.sensors)
@@ -62,16 +56,14 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class MedcomSensor(
-    CoordinatorEntity[DataUpdateCoordinator[MedcomBleDevice]], SensorEntity
-):
+class MedcomSensor(CoordinatorEntity[MedcomBleUpdateCoordinator], SensorEntity):
     """Medcom BLE radiation monitor sensors for the device."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: DataUpdateCoordinator[MedcomBleDevice],
+        coordinator: MedcomBleUpdateCoordinator,
         entity_description: SensorEntityDescription,
     ) -> None:
         """Populate the medcom entity with relevant data."""

homeassistant/components/media_source/__init__.py

@@ -30,6 +30,7 @@
     DOMAIN,
     MEDIA_CLASS_MAP,
     MEDIA_MIME_TYPES,
+    MEDIA_SOURCE_DATA,
     URI_SCHEME,
     URI_SCHEME_REGEX,
 )
@@ -78,7 +79,7 @@ def generate_media_source_id(domain: str, identifier: str) -> str:
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the media_source component."""
-    hass.data[DOMAIN] = {}
+    hass.data[MEDIA_SOURCE_DATA] = {}
     websocket_api.async_register_command(hass, websocket_browse_media)
     websocket_api.async_register_command(hass, websocket_resolve_media)
     frontend.async_register_built_in_panel(
@@ -97,7 +98,7 @@ async def _process_media_source_platform(
     platform: MediaSourceProtocol,
 ) -> None:
     """Process a media source platform."""
-    hass.data[DOMAIN][domain] = await platform.async_get_media_source(hass)
+    hass.data[MEDIA_SOURCE_DATA][domain] = await platform.async_get_media_source(hass)
 
 
 @callback
@@ -109,10 +110,10 @@ def _get_media_item(
         item = MediaSourceItem.from_uri(hass, media_content_id, target_media_player)
     else:
         # We default to our own domain if its only one registered
-        domain = None if len(hass.data[DOMAIN]) > 1 else DOMAIN
+        domain = None if len(hass.data[MEDIA_SOURCE_DATA]) > 1 else DOMAIN
         return MediaSourceItem(hass, domain, "", target_media_player)
 
-    if item.domain is not None and item.domain not in hass.data[DOMAIN]:
+    if item.domain is not None and item.domain not in hass.data[MEDIA_SOURCE_DATA]:
         raise UnknownMediaSource(
             translation_domain=DOMAIN,
             translation_key="unknown_media_source",

homeassistant/components/media_source/const.py

@@ -1,10 +1,18 @@
 """Constants for the media_source integration."""
 
+from __future__ import annotations
+
 import re
+from typing import TYPE_CHECKING
 
 from homeassistant.components.media_player import MediaClass
+from homeassistant.util.hass_dict import HassKey
+
+if TYPE_CHECKING:
+    from .models import MediaSource
 
 DOMAIN = "media_source"
+MEDIA_SOURCE_DATA: HassKey[dict[str, MediaSource]] = HassKey(DOMAIN)
 MEDIA_MIME_TYPES = ("audio", "video", "image")
 MEDIA_CLASS_MAP = {
     "audio": MediaClass.MUSIC,

homeassistant/components/media_source/local_source.py

@@ -6,7 +6,7 @@
 import mimetypes
 from pathlib import Path
 import shutil
-from typing import Any
+from typing import Any, cast
 
 from aiohttp import web
 from aiohttp.web_request import FileField
@@ -18,7 +18,7 @@
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.util import raise_if_invalid_filename, raise_if_invalid_path
 
-from .const import DOMAIN, MEDIA_CLASS_MAP, MEDIA_MIME_TYPES
+from .const import DOMAIN, MEDIA_CLASS_MAP, MEDIA_MIME_TYPES, MEDIA_SOURCE_DATA
 from .error import Unresolvable
 from .models import BrowseMediaSource, MediaSource, MediaSourceItem, PlayMedia
 
@@ -30,7 +30,7 @@
 def async_setup(hass: HomeAssistant) -> None:
     """Set up local media source."""
     source = LocalSource(hass)
-    hass.data[DOMAIN][DOMAIN] = source
+    hass.data[MEDIA_SOURCE_DATA][DOMAIN] = source
     hass.http.register_view(LocalMediaView(hass, source))
     hass.http.register_view(UploadMediaView(hass, source))
     websocket_api.async_register_command(hass, websocket_remove_media)
@@ -352,7 +352,7 @@ async def websocket_remove_media(
         connection.send_error(msg["id"], websocket_api.ERR_INVALID_FORMAT, str(err))
         return
 
-    source: LocalSource = hass.data[DOMAIN][DOMAIN]
+    source = cast(LocalSource, hass.data[MEDIA_SOURCE_DATA][DOMAIN])
 
     try:
         source_dir_id, location = source.async_parse_identifier(item)

homeassistant/components/media_source/models.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.media_player import BrowseMedia, MediaClass, MediaType
 from homeassistant.core import HomeAssistant, callback
 
-from .const import DOMAIN, URI_SCHEME, URI_SCHEME_REGEX
+from .const import MEDIA_SOURCE_DATA, URI_SCHEME, URI_SCHEME_REGEX
 
 
 @dataclass(slots=True)
@@ -70,7 +70,7 @@ async def async_browse(self) -> BrowseMediaSource:
                         can_play=False,
                         can_expand=True,
                     )
-                    for source in self.hass.data[DOMAIN].values()
+                    for source in self.hass.data[MEDIA_SOURCE_DATA].values()
                 ),
                 key=lambda item: item.title,
             )
@@ -85,7 +85,9 @@ async def async_resolve(self) -> PlayMedia:
     @callback
     def async_media_source(self) -> MediaSource:
         """Return media source that owns this item."""
-        return cast(MediaSource, self.hass.data[DOMAIN][self.domain])
+        if TYPE_CHECKING:
+            assert self.domain is not None
+        return self.hass.data[MEDIA_SOURCE_DATA][self.domain]
 
     @classmethod
     def from_uri(

homeassistant/components/melcloud/__init__.py

@@ -27,9 +27,11 @@
 
 PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
+type MelCloudConfigEntry = ConfigEntry[dict[str, list[MelCloudDevice]]]
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Establish connection with MELClooud."""
+
+async def async_setup_entry(hass: HomeAssistant, entry: MelCloudConfigEntry) -> bool:
+    """Establish connection with MELCloud."""
     conf = entry.data
     try:
         mel_devices = await mel_devices_setup(hass, conf[CONF_TOKEN])
@@ -40,20 +42,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     except (TimeoutError, ClientConnectionError) as ex:
         raise ConfigEntryNotReady from ex
 
-    hass.data.setdefault(DOMAIN, {}).update({entry.entry_id: mel_devices})
+    entry.runtime_data = mel_devices
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(
-        config_entry, PLATFORMS
-    )
-    hass.data[DOMAIN].pop(config_entry.entry_id)
-    if not hass.data[DOMAIN]:
-        hass.data.pop(DOMAIN)
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
 
 
 class MelCloudDevice:

homeassistant/components/melcloud/climate.py

@@ -24,21 +24,19 @@
     HVACAction,
     HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import MelCloudDevice
+from . import MelCloudConfigEntry, MelCloudDevice
 from .const import (
     ATTR_STATUS,
     ATTR_VANE_HORIZONTAL,
     ATTR_VANE_HORIZONTAL_POSITIONS,
     ATTR_VANE_VERTICAL,
     ATTR_VANE_VERTICAL_POSITIONS,
     CONF_POSITION,
-    DOMAIN,
     SERVICE_SET_VANE_HORIZONTAL,
     SERVICE_SET_VANE_VERTICAL,
 )
@@ -77,11 +75,11 @@
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MelCloudConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up MelCloud device climate based on config_entry."""
-    mel_devices = hass.data[DOMAIN][entry.entry_id]
+    mel_devices = entry.runtime_data
     entities: list[AtaDeviceClimate | AtwDeviceZoneClimate] = [
         AtaDeviceClimate(mel_device, mel_device.device)
         for mel_device in mel_devices[DEVICE_TYPE_ATA]