Move dormakaba_dkey coordinator to separate module (#136437)

homeassistant/components/dormakaba_dkey/__init__.py

@@ -2,11 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
-import logging
-
 from py_dormakaba_dkey import DKEYLock
-from py_dormakaba_dkey.errors import DKEY_EXCEPTIONS, NotAssociated
 from py_dormakaba_dkey.models import AssociationData
 
 from homeassistant.components import bluetooth
@@ -14,16 +10,13 @@ from homeassistant.components.bluetooth.match import ADDRESS, BluetoothCallbackM
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ADDRESS, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_ASSOCIATION_DATA, DOMAIN, UPDATE_SECONDS
+from .const import CONF_ASSOCIATION_DATA, DOMAIN
-from .models import DormakabaDkeyData
+from .coordinator import DormakabaDkeyCoordinator
 
 PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.LOCK, Platform.SENSOR]
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Dormakaba dKey from a config entry."""
@@ -56,29 +49,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         )
     )
 
-    async def _async_update() -> None:
+    coordinator = DormakabaDkeyCoordinator(hass, entry, lock)
-        """Update the device state."""
-        try:
-            await lock.update()
-            await lock.disconnect()
-        except NotAssociated as ex:
-            raise ConfigEntryAuthFailed("Not associated") from ex
-        except DKEY_EXCEPTIONS as ex:
-            raise UpdateFailed(str(ex)) from ex
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        name=lock.name,
-        update_method=_async_update,
-        update_interval=timedelta(seconds=UPDATE_SECONDS),
-    )
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = DormakabaDkeyData(
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
-        lock, coordinator
-    )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -95,7 +69,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        data: DormakabaDkeyData = hass.data[DOMAIN].pop(entry.entry_id)
+        coordinator: DormakabaDkeyCoordinator = hass.data[DOMAIN].pop(entry.entry_id)
-        await data.lock.disconnect()
+        await coordinator.lock.disconnect()
 
     return unload_ok

homeassistant/components/dormakaba_dkey/binary_sensor.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections.abc import Callable
 from dataclasses import dataclass
 
-from py_dormakaba_dkey import DKEYLock
 from py_dormakaba_dkey.commands import DoorPosition, Notifications, UnlockStatus
 
 from homeassistant.components.binary_sensor import (
@@ -16,11 +15,10 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN
+from .coordinator import DormakabaDkeyCoordinator
 from .entity import DormakabaDkeyEntity
-from .models import DormakabaDkeyData
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -52,9 +50,9 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the binary sensor platform for Dormakaba dKey."""
-    data: DormakabaDkeyData = hass.data[DOMAIN][entry.entry_id]
+    coordinator: DormakabaDkeyCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities(
-        DormakabaDkeyBinarySensor(data.coordinator, data.lock, description)
+        DormakabaDkeyBinarySensor(coordinator, description)
         for description in BINARY_SENSOR_DESCRIPTIONS
     )
 
@@ -67,16 +65,15 @@ class DormakabaDkeyBinarySensor(DormakabaDkeyEntity, BinarySensorEntity):
 
     def __init__(
         self,
-        coordinator: DataUpdateCoordinator[None],
+        coordinator: DormakabaDkeyCoordinator,
-        lock: DKEYLock,
         description: DormakabaDkeyBinarySensorDescription,
     ) -> None:
         """Initialize a Dormakaba dKey binary sensor."""
         self.entity_description = description
-        self._attr_unique_id = f"{lock.address}_{description.key}"
+        self._attr_unique_id = f"{coordinator.lock.address}_{description.key}"
-        super().__init__(coordinator, lock)
+        super().__init__(coordinator)
 
     @callback
     def _async_update_attrs(self) -> None:
         """Handle updating _attr values."""
-        self._attr_is_on = self.entity_description.is_on(self._lock.state)
+        self._attr_is_on = self.entity_description.is_on(self.coordinator.lock.state)

homeassistant/components/dormakaba_dkey/coordinator.py

@@ -0,0 +1,48 @@
+"""Coordinator for the Dormakaba dKey integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from py_dormakaba_dkey import DKEYLock
+from py_dormakaba_dkey.errors import DKEY_EXCEPTIONS, NotAssociated
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import UPDATE_SECONDS
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DormakabaDkeyCoordinator(DataUpdateCoordinator[None]):
+    """DormakabaDkey coordinator."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: ConfigEntry,
+        lock: DKEYLock,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name=lock.name,
+            update_interval=timedelta(seconds=UPDATE_SECONDS),
+        )
+        self.lock = lock
+
+    async def _async_update_data(self) -> None:
+        """Update the device state."""
+        try:
+            await self.lock.update()
+            await self.lock.disconnect()
+        except NotAssociated as ex:
+            raise ConfigEntryAuthFailed("Not associated") from ex
+        except DKEY_EXCEPTIONS as ex:
+            raise UpdateFailed(str(ex)) from ex

homeassistant/components/dormakaba_dkey/entity.py

@@ -4,29 +4,25 @@ from __future__ import annotations
 
 import abc
 
-from py_dormakaba_dkey import DKEYLock
 from py_dormakaba_dkey.commands import Notifications
 
 from homeassistant.core import callback
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import (
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
-    CoordinatorEntity,
+
-    DataUpdateCoordinator,
+from .coordinator import DormakabaDkeyCoordinator
-)
 
 
-class DormakabaDkeyEntity(CoordinatorEntity[DataUpdateCoordinator[None]]):
+class DormakabaDkeyEntity(CoordinatorEntity[DormakabaDkeyCoordinator]):
     """Dormakaba dKey base entity."""
 
     _attr_has_entity_name = True
 
-    def __init__(
+    def __init__(self, coordinator: DormakabaDkeyCoordinator) -> None:
-        self, coordinator: DataUpdateCoordinator[None], lock: DKEYLock
-    ) -> None:
         """Initialize a Dormakaba dKey entity."""
         super().__init__(coordinator)
-        self._lock = lock
+        lock = coordinator.lock
         self._attr_device_info = DeviceInfo(
             name=lock.device_info.device_name or lock.device_info.device_id,
             model="MTL 9291",
@@ -53,5 +49,7 @@ class DormakabaDkeyEntity(CoordinatorEntity[DataUpdateCoordinator[None]]):
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
-        self.async_on_remove(self._lock.register_callback(self._handle_state_update))
+        self.async_on_remove(
+            self.coordinator.lock.register_callback(self._handle_state_update)
+        )
         return await super().async_added_to_hass()

homeassistant/components/dormakaba_dkey/lock.py

@@ -4,18 +4,16 @@ from __future__ import annotations
 
 from typing import Any
 
-from py_dormakaba_dkey import DKEYLock
 from py_dormakaba_dkey.commands import UnlockStatus
 
 from homeassistant.components.lock import LockEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN
+from .coordinator import DormakabaDkeyCoordinator
 from .entity import DormakabaDkeyEntity
-from .models import DormakabaDkeyData
 
 
 async def async_setup_entry(
@@ -24,8 +22,8 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the lock platform for Dormakaba dKey."""
-    data: DormakabaDkeyData = hass.data[DOMAIN][entry.entry_id]
+    coordinator: DormakabaDkeyCoordinator = hass.data[DOMAIN][entry.entry_id]
-    async_add_entities([DormakabaDkeyLock(data.coordinator, data.lock)])
+    async_add_entities([DormakabaDkeyLock(coordinator)])
 
 
 class DormakabaDkeyLock(DormakabaDkeyEntity, LockEntity):
@@ -33,25 +31,23 @@ class DormakabaDkeyLock(DormakabaDkeyEntity, LockEntity):
 
     _attr_has_entity_name = True
 
-    def __init__(
+    def __init__(self, coordinator: DormakabaDkeyCoordinator) -> None:
-        self, coordinator: DataUpdateCoordinator[None], lock: DKEYLock
-    ) -> None:
         """Initialize a Dormakaba dKey lock."""
-        self._attr_unique_id = lock.address
+        self._attr_unique_id = coordinator.lock.address
-        super().__init__(coordinator, lock)
+        super().__init__(coordinator)
 
     @callback
     def _async_update_attrs(self) -> None:
         """Handle updating _attr values."""
-        self._attr_is_locked = self._lock.state.unlock_status in (
+        self._attr_is_locked = self.coordinator.lock.state.unlock_status in (
             UnlockStatus.LOCKED,
             UnlockStatus.SECURITY_LOCKED,
         )
 
     async def async_lock(self, **kwargs: Any) -> None:
         """Lock the lock."""
-        await self._lock.lock()
+        await self.coordinator.lock.lock()
 
     async def async_unlock(self, **kwargs: Any) -> None:
         """Unlock the lock."""
-        await self._lock.unlock()
+        await self.coordinator.lock.unlock()

homeassistant/components/dormakaba_dkey/models.py

@@ -1,17 +0,0 @@
-"""The Dormakaba dKey integration models."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from py_dormakaba_dkey import DKEYLock
-
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-
-
-@dataclass
-class DormakabaDkeyData:
-    """Data for the Dormakaba dKey integration."""
-
-    lock: DKEYLock
-    coordinator: DataUpdateCoordinator[None]

homeassistant/components/dormakaba_dkey/sensor.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from py_dormakaba_dkey import DKEYLock
-
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -14,11 +12,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import PERCENTAGE
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN
+from .coordinator import DormakabaDkeyCoordinator
 from .entity import DormakabaDkeyEntity
-from .models import DormakabaDkeyData
 
 BINARY_SENSOR_DESCRIPTIONS = (
     SensorEntityDescription(
@@ -36,9 +33,9 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the lock platform for Dormakaba dKey."""
-    data: DormakabaDkeyData = hass.data[DOMAIN][entry.entry_id]
+    coordinator: DormakabaDkeyCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities(
-        DormakabaDkeySensor(data.coordinator, data.lock, description)
+        DormakabaDkeySensor(coordinator, description)
         for description in BINARY_SENSOR_DESCRIPTIONS
     )
 
@@ -50,16 +47,17 @@ class DormakabaDkeySensor(DormakabaDkeyEntity, SensorEntity):
 
     def __init__(
         self,
-        coordinator: DataUpdateCoordinator[None],
+        coordinator: DormakabaDkeyCoordinator,
-        lock: DKEYLock,
         description: SensorEntityDescription,
     ) -> None:
         """Initialize a Dormakaba dKey binary sensor."""
         self.entity_description = description
-        self._attr_unique_id = f"{lock.address}_{description.key}"
+        self._attr_unique_id = f"{coordinator.lock.address}_{description.key}"
-        super().__init__(coordinator, lock)
+        super().__init__(coordinator)
 
     @callback
     def _async_update_attrs(self) -> None:
         """Handle updating _attr values."""
-        self._attr_native_value = getattr(self._lock, self.entity_description.key)
+        self._attr_native_value = getattr(
+            self.coordinator.lock, self.entity_description.key
+        )