uiprotect 3.8.0__py3-none-any.whl → 7.32.0__py3-none-any.whl

uiprotect/data/bootstrap.py

@@ -4,16 +4,16 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from aiohttp.client_exceptions import ServerDisconnectedError
-from pydantic.v1 import PrivateAttr, ValidationError
+from convertertools import pop_dict_set, pop_dict_tuple
+from pydantic import PrivateAttr, ValidationError
 
 from ..exceptions import ClientError
-from ..utils import normalize_mac, utc_now
+from ..utils import normalize_mac, to_snake_case, utc_now
 from .base import (
     RECENT_EVENT_MAX,
     ProtectBaseObject,
@@ -21,20 +21,22 @@ from .base import (
     ProtectModel,
     ProtectModelWithId,
 )
-from .convert import create_from_unifi_dict
+from .convert import MODEL_TO_CLASS, create_from_unifi_dict
 from .devices import (
+    AiPort,
     Bridge,
     Camera,
     Chime,
     Doorlock,
     Light,
     ProtectAdoptableDeviceModel,
+    Ringtone,
     Sensor,
     Viewer,
 )
 from .nvr import NVR, Event, Liveview
 from .types import EventType, FixSizeOrderedDict, ModelType
-from .user import Group, User
+from .user import Group, Keyrings, UlpUserKeyringBase, UlpUsers, User
 from .websocket import (
     WSAction,
     WSPacket,
@@ -98,6 +100,14 @@ CAMERA_EVENT_ATTR_MAP: dict[EventType, tuple[str, str]] = {
         "last_smart_audio_detect_event_id",
     ),
     EventType.RING: ("last_ring", "last_ring_event_id"),
+    EventType.NFC_CARD_SCANNED: (
+        "last_nfc_card_scanned",
+        "last_nfc_card_scanned_event_id",
+    ),
+    EventType.FINGERPRINT_IDENTIFIED: (
+        "last_fingerprint_identified",
+        "last_fingerprint_identified_event_id",
+    ),
 }
 
 
@@ -168,11 +178,13 @@ class Bootstrap(ProtectBaseObject):
     liveviews: dict[str, Liveview]
     nvr: NVR
     viewers: dict[str, Viewer]
-    lights: dict[str, Light]
-    bridges: dict[str, Bridge]
-    sensors: dict[str, Sensor]
-    doorlocks: dict[str, Doorlock]
-    chimes: dict[str, Chime]
+    lights: dict[str, Light] = {}
+    bridges: dict[str, Bridge] = {}
+    sensors: dict[str, Sensor] = {}
+    doorlocks: dict[str, Doorlock] = {}
+    chimes: dict[str, Chime] = {}
+    aiports: dict[str, AiPort] = {}
+    ringtones: list[Ringtone]
     last_update_id: str
 
     # TODO:
@@ -180,6 +192,8 @@ class Bootstrap(ProtectBaseObject):
     # agreements
 
     # not directly from UniFi
+    keyrings: Keyrings = Keyrings()
+    ulp_users: UlpUsers = UlpUsers()
     events: dict[str, Event] = FixSizeOrderedDict()
     capture_ws_stats: bool = False
     mac_lookup: dict[str, ProtectDeviceRef] = {}
@@ -201,9 +215,20 @@ class Bootstrap(ProtectBaseObject):
         data["idLookup"] = id_lookup
         data["macLookup"] = mac_lookup
 
+        # Fields that are not (always?) available in newer Protect versions
+        optional_fields = {"doorlocks"}
+
         for model_type in ModelType.bootstrap_models_types_set:
             key = model_type.devices_key  # type: ignore[attr-defined]
             items: dict[str, ProtectModel] = {}
+            if key not in data:
+                # Optional fields with defaults don't need logging or setting
+                if key not in optional_fields:
+                    data[key] = {}
+                    _LOGGER.error(
+                        f"Missing key in bootstrap: {key}. This may be fixed by updating Protect."
+                    )
+                continue
             for item in data[key]:
                 if (
                     api is not None
@@ -230,9 +255,7 @@ class Bootstrap(ProtectBaseObject):
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
 
-        for key in ("events", "captureWsStats", "macLookup", "idLookup"):
-            if key in data:
-                del data[key]
+        pop_dict_tuple(data, ("events", "captureWsStats", "macLookup", "idLookup"))
         for model_type in ModelType.bootstrap_models_types_set:
             attr = model_type.devices_key  # type: ignore[attr-defined]
             if attr in data and isinstance(data[attr], dict):
@@ -354,7 +377,7 @@ class Bootstrap(ProtectBaseObject):
         return WSSubscriptionMessage(
             action=WSAction.ADD,
             new_update_id=self.last_update_id,
-            changed_data=obj.dict(),
+            changed_data=obj.model_dump(),
             new_obj=obj,
         )
 
@@ -378,6 +401,60 @@ class Bootstrap(ProtectBaseObject):
             old_obj=device,
         )
 
+    def _process_ws_keyring_or_ulp_user_message(
+        self,
+        action: dict[str, Any],
+        data: dict[str, Any],
+        model_type: ModelType,
+    ) -> WSSubscriptionMessage | None:
+        action_id = action["id"]
+        obj_from_bootstrap: UlpUserKeyringBase[ProtectModelWithId] = getattr(
+            self, to_snake_case(model_type.devices_key)
+        )
+        action_type = action["action"]
+        if action_type == "add":
+            add_obj = create_from_unifi_dict(data, api=self._api, model_type=model_type)
+            if TYPE_CHECKING:
+                model_class = MODEL_TO_CLASS.get(model_type)
+                assert model_class is not None and isinstance(add_obj, model_class)
+            add_obj = cast(ProtectModelWithId, add_obj)
+            obj_from_bootstrap.add(add_obj)
+            return WSSubscriptionMessage(
+                action=WSAction.ADD,
+                new_update_id=self.last_update_id,
+                changed_data=add_obj.model_dump(),
+                new_obj=add_obj,
+            )
+        if action_type == "remove":
+            to_remove = obj_from_bootstrap.by_id(action_id)
+            if to_remove is None:
+                return None
+            obj_from_bootstrap.remove(to_remove)
+            return WSSubscriptionMessage(
+                action=WSAction.REMOVE,
+                new_update_id=self.last_update_id,
+                changed_data={},
+                old_obj=to_remove,
+            )
+        if action_type == "update":
+            updated_obj = obj_from_bootstrap.by_id(action_id)
+            if updated_obj is None:
+                return None
+
+            old_obj = updated_obj.model_copy()
+            updated_data = {to_snake_case(k): v for k, v in data.items()}
+            updated_obj.update_from_dict(updated_data)
+
+            return WSSubscriptionMessage(
+                action=WSAction.UPDATE,
+                new_update_id=self.last_update_id,
+                changed_data=updated_data,
+                new_obj=updated_obj,
+                old_obj=old_obj,
+            )
+        _LOGGER.debug("Unexpected ws action for %s: %s", model_type, action_type)
+        return None
+
     def _process_nvr_update(
         self,
         action: dict[str, Any],
@@ -385,8 +462,7 @@ class Bootstrap(ProtectBaseObject):
         ignore_stats: bool,
     ) -> WSSubscriptionMessage | None:
         if ignore_stats:
-            for key in STATS_KEYS.intersection(data):
-                del data[key]
+            pop_dict_set(data, STATS_KEYS)
         # nothing left to process
         if not data:
             return None
@@ -400,8 +476,8 @@ class Bootstrap(ProtectBaseObject):
         if not (data := self.nvr.unifi_dict_to_dict(data)):
             return None
 
-        old_nvr = self.nvr.copy()
-        self.nvr = self.nvr.update_from_dict(deepcopy(data))
+        old_nvr = self.nvr.model_copy()
+        self.nvr = self.nvr.update_from_dict(data)
 
         return WSSubscriptionMessage(
             action=WSAction.UPDATE,
@@ -435,8 +511,7 @@ class Bootstrap(ProtectBaseObject):
                 model_type, IGNORE_DEVICE_KEYS
             )
 
-        for key in remove_keys.intersection(data):
-            del data[key]
+        pop_dict_set(data, remove_keys)
 
         # nothing left to process
         if not data and not is_ping_back:
@@ -447,7 +522,7 @@ class Bootstrap(ProtectBaseObject):
         if action_id not in devices:
             # ignore updates to events that phase out
             if model_type is not ModelType.EVENT:
-                _LOGGER.debug("Unexpected %s: %s", key, action_id)
+                _LOGGER.debug("Unexpected %s: %s", model_type, action_id)
             return None
 
         obj = devices[action_id]
@@ -457,20 +532,13 @@ class Bootstrap(ProtectBaseObject):
             # nothing left to process
             return None
 
-        old_obj = obj.copy()
-        obj = obj.update_from_dict(deepcopy(data))
+        old_obj = obj.model_copy()
+        obj = obj.update_from_dict(data)
 
         if model_type is ModelType.EVENT:
             if TYPE_CHECKING:
                 assert isinstance(obj, Event)
             self.process_event(obj)
-        elif model_type is ModelType.CAMERA:
-            if TYPE_CHECKING:
-                assert isinstance(obj, Camera)
-            if "last_ring" in data and (last_ring := obj.last_ring):
-                if is_recent := last_ring + RECENT_EVENT_MAX >= utc_now():
-                    obj.set_ring_timeout()
-                _LOGGER.debug("last_ring for %s (%s)", obj.id, is_recent)
         elif model_type is ModelType.SENSOR:
             if TYPE_CHECKING:
                 assert isinstance(obj, Sensor)
@@ -499,9 +567,7 @@ class Bootstrap(ProtectBaseObject):
         capture_ws_stats = self.capture_ws_stats
         action = packet.action_frame.data
         data = packet.data_frame.data
-        if capture_ws_stats:
-            action = deepcopy(action)
-            data = deepcopy(data)
+        keys = list(data) if capture_ws_stats else None
 
         new_update_id: str | None = action["newUpdateId"]
         if new_update_id is not None:
@@ -512,11 +578,13 @@ class Bootstrap(ProtectBaseObject):
         )
 
         if capture_ws_stats:
+            if TYPE_CHECKING:
+                assert keys is not None
             self._ws_stats.append(
                 WSStat(
-                    model=packet.action_frame.data["modelKey"],
-                    action=packet.action_frame.data["action"],
-                    keys=list(packet.data_frame.data),
+                    model=action["modelKey"],
+                    action=action["action"],
+                    keys=keys,
                     keys_set=[] if message is None else list(message.changed_data),
                     size=len(packet.raw),
                     filtered=message is None,
@@ -525,7 +593,7 @@ class Bootstrap(ProtectBaseObject):
 
         return message
 
-    def _make_ws_packet_message(
+    def _make_ws_packet_message(  # noqa: PLR0911
         self,
         action: dict[str, Any],
         data: dict[str, Any],
@@ -543,13 +611,16 @@ class Bootstrap(ProtectBaseObject):
             return None
 
         action_action: str = action["action"]
-        if action_action == "remove":
-            return self._process_remove_packet(model_type, action)
-
-        if not data and not is_ping_back:
-            return None
 
         try:
+            if model_type in {ModelType.KEYRING, ModelType.ULP_USER}:
+                return self._process_ws_keyring_or_ulp_user_message(
+                    action, data, model_type
+                )
+            if action_action == "remove":
+                return self._process_remove_packet(model_type, action)
+            if not data and not is_ping_back:
+                return None
             if action_action == "add":
                 return self._process_add_packet(model_type, data)
             if action_action == "update":
@@ -614,5 +685,5 @@ class Bootstrap(ProtectBaseObject):
         _LOGGER.debug("Successfully refresh model: %s %s", model_type, device_id)
 
     async def get_is_prerelease(self) -> bool:
-        """Get if current version of Protect is a prerelease version."""
-        return await self.nvr.get_is_prerelease()
+        """[DEPRECATED] Always returns False. Will be removed after HA 2025.8.0."""
+        return False

uiprotect/data/convert.py

@@ -2,10 +2,13 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
+
+from uiprotect.data.base import ProtectModelWithId
 
 from ..exceptions import DataDecodeError
 from .devices import (
+    AiPort,
     Bridge,
     Camera,
     Chime,
@@ -16,7 +19,7 @@ from .devices import (
 )
 from .nvr import NVR, Event, Liveview
 from .types import ModelType
-from .user import CloudAccount, Group, User, UserLocation
+from .user import CloudAccount, Group, Keyring, UlpUser, User, UserLocation
 
 if TYPE_CHECKING:
     from ..api import ProtectApiClient
@@ -38,6 +41,9 @@ MODEL_TO_CLASS: dict[str, type[ProtectModel]] = {
     ModelType.SENSOR: Sensor,
     ModelType.DOORLOCK: Doorlock,
     ModelType.CHIME: Chime,
+    ModelType.AIPORT: AiPort,
+    ModelType.KEYRING: Keyring,
+    ModelType.ULP_USER: UlpUser,
 }
 
 
@@ -79,3 +85,12 @@ def create_from_unifi_dict(
         klass = get_klass_from_dict(data)
 
     return klass.from_unifi_dict(**data, api=api)
+
+
+def list_from_unifi_list(
+    api: ProtectApiClient, unifi_list: list[dict[str, ProtectModelWithId]]
+) -> list[ProtectModelWithId]:
+    return [
+        cast(ProtectModelWithId, create_from_unifi_dict(obj_dict, api))
+        for obj_dict in unifi_list
+    ]