uiprotect 6.6.5__tar.gz → 6.8.0__tar.gz

{uiprotect-6.6.5 → uiprotect-6.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uiprotect
-Version: 6.6.5
+Version: 6.8.0
 Summary: Python API for Unifi Protect (Unofficial)
 Home-page: https://github.com/uilibs/uiprotect
 Author: UI Protect Maintainers

{uiprotect-6.6.5 → uiprotect-6.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uiprotect"
-version = "6.6.5"
+version = "6.8.0"
 description = "Python API for Unifi Protect (Unofficial)"
 authors = ["UI Protect Maintainers <ui@koston.org>"]
 readme = "README.md"
@@ -52,7 +52,7 @@ propcache = ">=0.0.0"
 pytest = ">=7,<9"
 pytest-cov = ">=3,<7"
 aiosqlite = ">=0.20.0"
-asttokens = "^2.4.1"
+asttokens = ">=2.4.1,<4.0.0"
 pytest-asyncio = ">=0.23.7,<0.25.0"
 pytest-benchmark = ">=4,<6"
 pytest-sugar = "^1.0.0"

{uiprotect-6.6.5 → uiprotect-6.8.0}/src/uiprotect/api.py

@@ -27,6 +27,9 @@ from aiohttp import CookieJar, client_exceptions
 from platformdirs import user_cache_dir, user_config_dir
 from yarl import URL
 
+from uiprotect.data.convert import list_from_unifi_list
+from uiprotect.data.user import Keyring, Keyrings, UlpUser, UlpUsers
+
 from ._compat import cached_property
 from .data import (
     NVR,
@@ -90,6 +93,8 @@ If your Protect instance has a lot of events, this request will take much longer
 _LOGGER = logging.getLogger(__name__)
 _COOKIE_RE = re.compile(r"^set-cookie: ", re.IGNORECASE)
 
+NFC_FINGERPRINT_SUPPORT_VERSION = Version("5.1.57")
+
 # TODO: Urls to still support
 # Backups
 # * GET /backups - list backends
@@ -823,6 +828,23 @@ class ProtectApiClient(BaseApiClient):
         """
         async with self._update_lock:
             bootstrap = await self.get_bootstrap()
+            if bootstrap.nvr.version >= NFC_FINGERPRINT_SUPPORT_VERSION:
+                bootstrap.keyrings = Keyrings.from_list(
+                    cast(
+                        list[Keyring],
+                        list_from_unifi_list(
+                            self, await self.api_request_list("keyrings")
+                        ),
+                    )
+                )
+                bootstrap.ulp_users = UlpUsers.from_list(
+                    cast(
+                        list[UlpUser],
+                        list_from_unifi_list(
+                            self, await self.api_request_list("ulp-users")
+                        ),
+                    )
+                )
             self.__dict__.pop("bootstrap", None)
             self._bootstrap = bootstrap
             return bootstrap

{uiprotect-6.6.5 → uiprotect-6.8.0}/src/uiprotect/data/bootstrap.py

@@ -6,14 +6,14 @@ import asyncio
 import logging
 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 convertertools import pop_dict_set, pop_dict_tuple
 from pydantic.v1 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,7 +21,7 @@ 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 (
     Bridge,
     Camera,
@@ -34,7 +34,7 @@ from .devices import (
 )
 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,
@@ -188,6 +188,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] = {}
@@ -384,6 +386,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.dict(),
+                new_obj=add_obj,
+            )
+        elif 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,
+            )
+        elif action_type == "update":
+            updated_obj = obj_from_bootstrap.by_id(action_id)
+            if updated_obj is None:
+                return None
+
+            old_obj = updated_obj.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],
@@ -540,13 +596,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":

{uiprotect-6.6.5 → uiprotect-6.8.0}/src/uiprotect/data/convert.py

@@ -2,7 +2,9 @@
 
 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 (
@@ -16,7 +18,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 +40,8 @@ MODEL_TO_CLASS: dict[str, type[ProtectModel]] = {
     ModelType.SENSOR: Sensor,
     ModelType.DOORLOCK: Doorlock,
     ModelType.CHIME: Chime,
+    ModelType.KEYRING: Keyring,
+    ModelType.ULP_USER: UlpUser,
 }
 
 
@@ -79,3 +83,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
+    ]

{uiprotect-6.6.5 → uiprotect-6.8.0}/src/uiprotect/data/types.py

@@ -105,6 +105,8 @@ class ModelType(str, UnknownValuesEnumMixin, enum.Enum):
     CHIME = "chime"
     DEVICE_GROUP = "deviceGroup"
     RECORDING_SCHEDULE = "recordingSchedule"
+    ULP_USER = "ulpUser"
+    KEYRING = "keyring"
     UNKNOWN = "unknown"
 
     bootstrap_model_types: tuple[ModelType, ...]

{uiprotect-6.6.5 → uiprotect-6.8.0}/src/uiprotect/data/user.py

@@ -2,15 +2,22 @@
 
 from __future__ import annotations
 
+import sys
+from abc import abstractmethod
 from datetime import datetime
 from functools import cache
-from typing import Any
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from pydantic.v1.fields import PrivateAttr
 
 from .base import ProtectBaseObject, ProtectModel, ProtectModelWithId
 from .types import ModelType, PermissionNode
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 
 class Permission(ProtectBaseObject):
     raw_permission: str
@@ -234,3 +241,112 @@ class User(ProtectModelWithId):
                 return True
         self._perm_cache[perm_str] = False
         return False
+
+
+T = TypeVar("T", bound="ProtectModelWithId")
+
+
+class UlpUserKeyringBase(Generic[T]):
+    """Base class for collections of ULP users and keyrings."""
+
+    def __init__(self) -> None:
+        self._id_to_item: dict[str, T] = {}
+
+    @classmethod
+    def from_list(cls, items: list[T]) -> Self:
+        instance = cls()
+        for item in items:
+            instance.add(item)
+        return instance
+
+    def add(self, item: T) -> None:
+        """Add an item to the collection."""
+        self._id_to_item[item.id] = item
+
+    def remove(self, item: T) -> None:
+        """Remove an item from the collection."""
+        self._id_to_item.pop(item.id, None)
+
+    def by_id(self, item_id: str) -> T | None:
+        """Retrieve an item by its ID."""
+        return self._id_to_item.get(item_id)
+
+    @abstractmethod
+    def by_ulp_id(self, item_id: str) -> T | None:
+        """Retrieve an item by its ULP ID."""
+
+    def as_list(self) -> list[T]:
+        return list(self._id_to_item.values())
+
+    def __eq__(self, other: Any) -> bool:
+        if TYPE_CHECKING:
+            assert isinstance(other, UlpUserKeyringBase)
+        return self._id_to_item == other._id_to_item
+
+
+class Keyring(ProtectModelWithId):
+    device_type: str
+    device_id: str
+    registry_type: str
+    registry_id: str
+    last_activity: datetime | None = None
+    ulp_user: str
+
+
+class Keyrings(UlpUserKeyringBase[Keyring]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._keyrings_by_registry_id: dict[str, Keyring] = {}
+        self._keyrings_by_ulp_user: dict[str, Keyring] = {}
+
+    def add(self, keyring: Keyring) -> None:
+        super().add(keyring)
+        self._keyrings_by_registry_id[keyring.registry_id] = keyring
+        self._keyrings_by_ulp_user[keyring.ulp_user] = keyring
+
+    def remove(self, keyring: Keyring) -> None:
+        super().remove(keyring)
+        self._keyrings_by_registry_id.pop(keyring.registry_id, None)
+        self._keyrings_by_ulp_user.pop(keyring.ulp_user, None)
+
+    def by_ulp_id(self, ulp_id: str) -> Keyring | None:
+        return self._keyrings_by_ulp_user.get(ulp_id)
+
+    def by_registry_id(self, registry_id: str) -> Keyring | None:
+        return self._keyrings_by_registry_id.get(registry_id)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Keyrings):
+            return NotImplemented
+        return super().__eq__(other)
+
+
+class UlpUser(ProtectModelWithId):
+    ulp_id: str
+    first_name: str
+    last_name: str
+    full_name: str
+    avatar: str
+    status: str
+
+
+class UlpUsers(UlpUserKeyringBase[UlpUser]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._users_by_ulp_id: dict[str, UlpUser] = {}
+
+    def add(self, user: UlpUser) -> None:
+        super().add(user)
+        self._users_by_ulp_id[user.ulp_id] = user
+
+    def remove(self, user: UlpUser) -> None:
+        super().remove(user)
+        self._users_by_ulp_id.pop(user.ulp_id, None)
+
+    def by_ulp_id(self, ulp_id: str) -> UlpUser | None:
+        return self._users_by_ulp_id.get(ulp_id)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, UlpUsers):
+            return NotImplemented
+        return super().__eq__(other)