uiprotect 6.6.5__py3-none-any.whl → 6.8.0__py3-none-any.whl

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/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/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/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/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)

{uiprotect-6.6.5.dist-info → uiprotect-6.8.0.dist-info}/METADATA

@@ -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.dist-info → uiprotect-6.8.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 uiprotect/__init__.py,sha256=Oz6i1tonIz4QWVnEPkbielJDJ3WQdwZVgYtjY4IwGAQ,636
 uiprotect/__main__.py,sha256=C_bHCOkv5qj6WMy-6ELoY3Y6HDhLxOa1a30CzmbZhsg,462
 uiprotect/_compat.py,sha256=HThmb1zQZCEssCxYYbQzFhJq8zYYlVaSnIEZabKc-6U,302
-uiprotect/api.py,sha256=Gc_x8mo-W-xtEFAhRIkiQyW99MJQgWdkkXlKxl3h-JU,67978
+uiprotect/api.py,sha256=pSQ_C2cjtttnFnrVzjmHlqS7zOfMH-bwk4NxbraUCKI,68850
 uiprotect/cli/__init__.py,sha256=1MO8rJmjjAsfVx2x01gn5DJo8B64xdPGo6gRVJbWd18,8868
 uiprotect/cli/backup.py,sha256=ZiS7RZnJGKI8TJKLW2cOUzkRM8nyTvE5Ov_jZZGtvSM,36708
 uiprotect/cli/base.py,sha256=k-_qGuNT7br0iV0KE5F4wYXF75iyLLjBEckTqxC71xM,7591
@@ -16,12 +16,12 @@ uiprotect/cli/sensors.py,sha256=fQtcDJCVxs4VbAqcavgBy2ABiVxAW3GXtna6_XFBp2k,8153
 uiprotect/cli/viewers.py,sha256=2cyrp104ffIvgT0wYGIO0G35QMkEbFe7fSVqLwDXQYQ,2171
 uiprotect/data/__init__.py,sha256=OcfuJl2qXfHcj_mdnrHhzZ5tEIZrw8auziX5IE7dn-I,2938
 uiprotect/data/base.py,sha256=sn7IHKQN96uiZL6ImN1gdCHV97EpUmy-X7xWTUAtWsg,35054
-uiprotect/data/bootstrap.py,sha256=iROUw-pPdJpytaV8Dg5peOJotI7jidXJABsEzCQGid8,20704
-uiprotect/data/convert.py,sha256=8h6Il_DhMkPRDPj9F_rA2UZIlTuchS3BQD24peKpk2A,2185
+uiprotect/data/bootstrap.py,sha256=j7bVRWwc3zI6gjn30LA_N5rqQbUYu6yxdy8RmrmCuSc,23224
+uiprotect/data/convert.py,sha256=CDPkSMxSEhvDigmzmLFKpjrz0oa5FOvOdkNIHZrOZ4Q,2586
 uiprotect/data/devices.py,sha256=P5U47i_YMpvD0jaWiDYbFz_mZt_Wiop_ssWGWnEMySU,113489
 uiprotect/data/nvr.py,sha256=FGI0eIAyy3Zy9kaxcr67HxwaVCUU8wq3oZyWvoDq7Sg,47251
-uiprotect/data/types.py,sha256=PA9YOEJCmh9DAlJajHh2Y6hi4aTjlQ8LhWN8ZH5x7Fc,18522
-uiprotect/data/user.py,sha256=1o5gyPHafn4lHARpoSMD_NWbo5IbzGPfiSASwqqDvWs,7002
+uiprotect/data/types.py,sha256=8fEf-fdm_Fqrfb3zwiJJle0ten-Rv3_0Vwk5uimf_vk,18571
+uiprotect/data/user.py,sha256=4rDMUPo02LhoVGfDjwXB9NASL4RnZjP3pvqtwjudZeE,10398
 uiprotect/data/websocket.py,sha256=m4EV1Qfh08eKOihy70ycViYgEQpeNSGZQJWdtGIYJDA,6791
 uiprotect/exceptions.py,sha256=kgn0cRM6lTtgLza09SDa3ZiX6ue1QqHCOogQ4qu6KTQ,965
 uiprotect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -31,8 +31,8 @@ uiprotect/test_util/__init__.py,sha256=Ky8mTL61nhp5II2mxTKBAsSGvNqK8U_CfKC5AGwTo
 uiprotect/test_util/anonymize.py,sha256=f-8ijU-_y9r-uAbhIPn0f0I6hzJpAkvJzc8UpWihObI,8478
 uiprotect/utils.py,sha256=jIWT7n_reL90oY91svBfQ4naRxo28qHzP5jNOL12mQE,20342
 uiprotect/websocket.py,sha256=tEyenqblNXHcjWYuf4oRP1E7buNwx6zoECMwpBr-jig,8191
-uiprotect-6.6.5.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
-uiprotect-6.6.5.dist-info/METADATA,sha256=t0RgidtqlAO2hJS0N2I4M2XO2lOm7OtAf73ADVCOZlQ,11096
-uiprotect-6.6.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-uiprotect-6.6.5.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
-uiprotect-6.6.5.dist-info/RECORD,,
+uiprotect-6.8.0.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-6.8.0.dist-info/METADATA,sha256=8FkmORQLIos0mSeuDePD0xTl_CfGdDiE68a1VNTpb9o,11096
+uiprotect-6.8.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+uiprotect-6.8.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-6.8.0.dist-info/RECORD,,