Add typing to deCONZ Lock and Logbook platforms (#59605)

homeassistant/components/deconz/device_trigger.py

@@ -1,4 +1,7 @@
 """Provides device automations for deconz events."""
+
+from __future__ import annotations
+
 import voluptuous as vol
 
 from homeassistant.components.device_automation import DEVICE_TRIGGER_BASE_SCHEMA
@@ -14,10 +17,11 @@ from homeassistant.const import (
     CONF_TYPE,
     CONF_UNIQUE_ID,
 )
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 
 from . import DOMAIN
-from .deconz_event import CONF_DECONZ_EVENT, CONF_GESTURE
+from .deconz_event import CONF_DECONZ_EVENT, CONF_GESTURE, DeconzAlarmEvent, DeconzEvent
 
 CONF_SUBTYPE = "subtype"
 
@@ -613,16 +617,19 @@ TRIGGER_SCHEMA = DEVICE_TRIGGER_BASE_SCHEMA.extend(
 )
 
 
-def _get_deconz_event_from_device_id(hass, device_id):
+def _get_deconz_event_from_device(
-    """Resolve deconz event from device id."""
+    hass: HomeAssistant,
+    device: dr.DeviceEntry,
+) -> DeconzAlarmEvent | DeconzEvent:
+    """Resolve deconz event from device."""
     for gateway in hass.data.get(DOMAIN, {}).values():
-
         for deconz_event in gateway.events:
-
+            if device.id == deconz_event.device_id:
-            if device_id == deconz_event.device_id:
                 return deconz_event
 
-    return None
+    raise InvalidDeviceAutomationConfig(
+        f'No deconz_event tied to device "{device.name}" found'
+    )
 
 
 async def async_validate_trigger_config(hass, config):
@@ -658,11 +665,7 @@ async def async_attach_trigger(hass, config, action, automation_info):
 
     trigger = REMOTES[device.model][trigger]
 
-    deconz_event = _get_deconz_event_from_device_id(hass, device.id)
+    deconz_event = _get_deconz_event_from_device(hass, device)
-    if deconz_event is None:
-        raise InvalidDeviceAutomationConfig(
-            f'No deconz_event tied to device "{device.name}" found'
-        )
 
     event_id = deconz_event.serial
 

homeassistant/components/deconz/lock.py

@@ -1,23 +1,36 @@
 """Support for deCONZ locks."""
 
+from __future__ import annotations
+
+from collections.abc import ValuesView
+from typing import Any
+
 from pydeconz.light import Lock
 from pydeconz.sensor import DoorLock
 
 from homeassistant.components.lock import DOMAIN, LockEntity
-from homeassistant.core import callback
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .deconz_device import DeconzDevice
 from .gateway import get_gateway_from_config_entry
 
 
-async def async_setup_entry(hass, config_entry, async_add_entities):
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
     """Set up locks for deCONZ component."""
     gateway = get_gateway_from_config_entry(hass, config_entry)
     gateway.entities[DOMAIN] = set()
 
     @callback
-    def async_add_lock_from_light(lights=gateway.api.lights.values()):
+    def async_add_lock_from_light(
+        lights: list[Lock] | ValuesView[Lock] = gateway.api.lights.values(),
+    ) -> None:
         """Add lock from deCONZ."""
         entities = []
 
@@ -41,7 +54,9 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     )
 
     @callback
-    def async_add_lock_from_sensor(sensors=gateway.api.sensors.values()):
+    def async_add_lock_from_sensor(
+        sensors: list[DoorLock] | ValuesView[DoorLock] = gateway.api.sensors.values(),
+    ) -> None:
         """Add lock from deCONZ."""
         entities = []
 
@@ -72,16 +87,17 @@ class DeconzLock(DeconzDevice, LockEntity):
     """Representation of a deCONZ lock."""
 
     TYPE = DOMAIN
+    _device: DoorLock | Lock
 
     @property
-    def is_locked(self):
+    def is_locked(self) -> bool:
         """Return true if lock is on."""
-        return self._device.is_locked
+        return self._device.is_locked  # type: ignore[no-any-return]
 
-    async def async_lock(self, **kwargs):
+    async def async_lock(self, **kwargs: Any) -> None:
         """Lock the lock."""
         await self._device.lock()
 
-    async def async_unlock(self, **kwargs):
+    async def async_unlock(self, **kwargs: Any) -> None:
         """Unlock the lock."""
         await self._device.unlock()

homeassistant/components/deconz/logbook.py

@@ -5,15 +5,11 @@ from collections.abc import Callable
 
 from homeassistant.const import ATTR_DEVICE_ID, CONF_EVENT
 from homeassistant.core import HomeAssistant, callback
+import homeassistant.helpers.device_registry as dr
 from homeassistant.helpers.event import Event
 
 from .const import CONF_GESTURE, DOMAIN as DECONZ_DOMAIN
-from .deconz_event import (
+from .deconz_event import CONF_DECONZ_ALARM_EVENT, CONF_DECONZ_EVENT
-    CONF_DECONZ_ALARM_EVENT,
-    CONF_DECONZ_EVENT,
-    DeconzAlarmEvent,
-    DeconzEvent,
-)
 from .device_trigger import (
     CONF_BOTH_BUTTONS,
     CONF_BOTTOM_BUTTONS,
@@ -57,7 +53,7 @@ from .device_trigger import (
     CONF_TURN_OFF,
     CONF_TURN_ON,
     REMOTES,
-    _get_deconz_event_from_device_id,
+    _get_deconz_event_from_device,
 )
 
 ACTIONS = {
@@ -108,9 +104,11 @@ INTERFACES = {
 }
 
 
-def _get_device_event_description(modelid: str, event: str) -> tuple:
+def _get_device_event_description(
+    modelid: str, event: int
+) -> tuple[str | None, str | None]:
     """Get device event description."""
-    device_event_descriptions: dict = REMOTES[modelid]
+    device_event_descriptions = REMOTES[modelid]
 
     for event_type_tuple, event_dict in device_event_descriptions.items():
         if event == event_dict.get(CONF_EVENT):
@@ -124,16 +122,16 @@ def _get_device_event_description(modelid: str, event: str) -> tuple:
 @callback
 def async_describe_events(
     hass: HomeAssistant,
-    async_describe_event: Callable[[str, str, Callable[[Event], dict]], None],
+    async_describe_event: Callable[[str, str, Callable[[Event], dict[str, str]]], None],
 ) -> None:
     """Describe logbook events."""
+    device_registry = dr.async_get(hass)
 
     @callback
-    def async_describe_deconz_alarm_event(event: Event) -> dict:
+    def async_describe_deconz_alarm_event(event: Event) -> dict[str, str]:
         """Describe deCONZ logbook alarm event."""
-        deconz_alarm_event: DeconzAlarmEvent | None = _get_deconz_event_from_device_id(
+        device = device_registry.devices[event.data[ATTR_DEVICE_ID]]
-            hass, event.data[ATTR_DEVICE_ID]
+        deconz_alarm_event = _get_deconz_event_from_device(hass, device)
-        )
 
         data = event.data[CONF_EVENT]
 
@@ -143,11 +141,10 @@ def async_describe_events(
         }
 
     @callback
-    def async_describe_deconz_event(event: Event) -> dict:
+    def async_describe_deconz_event(event: Event) -> dict[str, str]:
         """Describe deCONZ logbook event."""
-        deconz_event: DeconzEvent | None = _get_deconz_event_from_device_id(
+        device = device_registry.devices[event.data[ATTR_DEVICE_ID]]
-            hass, event.data[ATTR_DEVICE_ID]
+        deconz_event = _get_deconz_event_from_device(hass, device)
-        )
 
         action = None
         interface = None