uiprotect 1.2.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

uiprotect/api.py

@@ -1146,7 +1146,7 @@ class ProtectApiClient(BaseApiClient):
 
     async def get_devices_raw(self, model_type: ModelType) -> list[dict[str, Any]]:
         """Gets a raw device list given a model_type"""
-        return await self.api_request_list(f"{model_type.value}s")
+        return await self.api_request_list(model_type.devices_key)
 
     async def get_devices(
         self,
@@ -1703,7 +1703,7 @@ class ProtectApiClient(BaseApiClient):
 
     async def adopt_device(self, model_type: ModelType, device_id: str) -> None:
         """Adopts a device"""
-        key = f"{model_type.value}s"
+        key = model_type.devices_key
         data = await self.api_request_obj(
             "devices/adopt",
             method="post",

uiprotect/data/bootstrap.py

@@ -80,12 +80,9 @@ CAMERA_EVENT_ATTR_MAP: dict[EventType, tuple[str, str]] = {
 }
 
 
-def _process_light_event(event: Event) -> None:
-    if event.light is None:
-        return
-
-    if _event_is_in_range(event, event.light.last_motion):
-        event.light.last_motion_event_id = event.id
+def _process_light_event(event: Event, light: Light) -> None:
+    if _event_is_in_range(event, light.last_motion):
+        light.last_motion_event_id = event.id
 
 
 def _event_is_in_range(event: Event, dt: datetime | None) -> bool:
@@ -95,22 +92,20 @@ def _event_is_in_range(event: Event, dt: datetime | None) -> bool:
     )
 
 
-def _process_sensor_event(event: Event) -> None:
-    if event.sensor is None:
-        return
+def _process_sensor_event(event: Event, sensor: Sensor) -> None:
     if event.type is EventType.MOTION_SENSOR:
-        if _event_is_in_range(event, event.sensor.motion_detected_at):
-            event.sensor.last_motion_event_id = event.id
+        if _event_is_in_range(event, sensor.motion_detected_at):
+            sensor.last_motion_event_id = event.id
     elif event.type in {EventType.SENSOR_CLOSED, EventType.SENSOR_OPENED}:
-        if _event_is_in_range(event, event.sensor.open_status_changed_at):
-            event.sensor.last_contact_event_id = event.id
+        if _event_is_in_range(event, sensor.open_status_changed_at):
+            sensor.last_contact_event_id = event.id
     elif event.type is EventType.SENSOR_EXTREME_VALUE:
-        if _event_is_in_range(event, event.sensor.extreme_value_detected_at):
-            event.sensor.extreme_value_detected_at = event.end
-            event.sensor.last_value_event_id = event.id
+        if _event_is_in_range(event, sensor.extreme_value_detected_at):
+            sensor.extreme_value_detected_at = event.end
+            sensor.last_value_event_id = event.id
     elif event.type is EventType.SENSOR_ALARM:
-        if _event_is_in_range(event, event.sensor.alarm_triggered_at):
-            event.sensor.last_value_event_id = event.id
+        if _event_is_in_range(event, sensor.alarm_triggered_at):
+            sensor.last_value_event_id = event.id
 
 
 _CAMERA_SMART_AND_LINE_EVENTS = {
@@ -120,10 +115,7 @@ _CAMERA_SMART_AND_LINE_EVENTS = {
 _CAMERA_SMART_AUDIO_EVENT = EventType.SMART_AUDIO_DETECT
 
 
-def _process_camera_event(event: Event) -> None:
-    if (camera := event.camera) is None:
-        return
-
+def _process_camera_event(event: Event, camera: Camera) -> None:
     event_type = event.type
     dt_attr, event_attr = CAMERA_EVENT_ATTR_MAP[event_type]
     dt: datetime | None = getattr(camera, dt_attr)
@@ -205,8 +197,8 @@ class Bootstrap(ProtectBaseObject):
         )
         data["macLookup"] = {}
         data["idLookup"] = {}
-        for model_type in ModelType.bootstrap_models():
-            key = f"{model_type}s"
+        for model_type in ModelType.bootstrap_models_types_set():
+            key = model_type.devices_key
             items: dict[str, ProtectModel] = {}
             for item in data[key]:
                 if (
@@ -242,8 +234,8 @@ class Bootstrap(ProtectBaseObject):
         if "idLookup" in data:
             del data["idLookup"]
 
-        for model_type in ModelType.bootstrap_models():
-            attr = f"{model_type}s"
+        for model_type in ModelType.bootstrap_models_types_set():
+            attr = model_type.devices_key
             if attr in data and isinstance(data[attr], dict):
                 data[attr] = list(data[attr].values())
 
@@ -310,7 +302,7 @@ class Bootstrap(ProtectBaseObject):
         if ref is None:
             return None
 
-        devices: dict[str, ProtectModelWithId] = getattr(self, f"{ref.model.value}s")
+        devices: dict[str, ProtectModelWithId] = getattr(self, ref.model.devices_key)
         return cast(ProtectAdoptableDeviceModel, devices.get(ref.id))
 
     def get_device_from_id(self, device_id: str) -> ProtectAdoptableDeviceModel | None:
@@ -318,16 +310,17 @@ class Bootstrap(ProtectBaseObject):
         ref = self.id_lookup.get(device_id)
         if ref is None:
             return None
-        devices: dict[str, ProtectModelWithId] = getattr(self, f"{ref.model.value}s")
+        devices: dict[str, ProtectModelWithId] = getattr(self, ref.model.devices_key)
         return cast(ProtectAdoptableDeviceModel, devices.get(ref.id))
 
     def process_event(self, event: Event) -> None:
-        if event.type in CAMERA_EVENT_ATTR_MAP and event.camera is not None:
-            _process_camera_event(event)
-        elif event.type == EventType.MOTION_LIGHT and event.light is not None:
-            _process_light_event(event)
-        elif event.type == EventType.MOTION_SENSOR and event.sensor is not None:
-            _process_sensor_event(event)
+        event_type = event.type
+        if event_type in CAMERA_EVENT_ATTR_MAP and (camera := event.camera):
+            _process_camera_event(event, camera)
+        elif event_type is EventType.MOTION_LIGHT and (light := event.light):
+            _process_light_event(event, light)
+        elif event_type is EventType.MOTION_SENSOR and (sensor := event.sensor):
+            _process_sensor_event(event, sensor)
 
         self.events[event.id] = event
 
@@ -351,21 +344,24 @@ class Bootstrap(ProtectBaseObject):
 
     def _process_add_packet(
         self,
+        model_type: ModelType,
         packet: WSPacket,
         data: dict[str, Any],
     ) -> WSSubscriptionMessage | None:
-        obj = create_from_unifi_dict(data, api=self._api)
-
-        if isinstance(obj, Event):
+        obj = create_from_unifi_dict(data, api=self._api, model_type=model_type)
+        if model_type is ModelType.EVENT:
+            if TYPE_CHECKING:
+                assert isinstance(obj, Event)
             self.process_event(obj)
-        elif isinstance(obj, NVR):
+        if model_type is ModelType.NVR:
+            if TYPE_CHECKING:
+                assert isinstance(obj, NVR)
             self.nvr = obj
-        elif (
-            isinstance(obj, ProtectAdoptableDeviceModel)
-            and obj.model is not None
-            and obj.model.value in ModelType.bootstrap_models_set()
-        ):
-            key = f"{obj.model.value}s"
+        elif model_type in ModelType.bootstrap_models_types_set():
+            if TYPE_CHECKING:
+                assert isinstance(obj, ProtectAdoptableDeviceModel)
+                assert isinstance(obj.model, ModelType)
+            key = obj.model.devices_key
             if not self._api.ignore_unadopted or (
                 obj.is_adopted and not obj.is_adopted_by_other
             ):
@@ -388,9 +384,12 @@ class Bootstrap(ProtectBaseObject):
             new_obj=obj,
         )
 
-    def _process_remove_packet(self, packet: WSPacket) -> WSSubscriptionMessage | None:
-        model: str | None = packet.action_frame.data.get("modelKey")
-        devices: dict[str, ProtectDeviceModel] | None = getattr(self, f"{model}s", None)
+    def _process_remove_packet(
+        self, model_type: ModelType, packet: WSPacket
+    ) -> WSSubscriptionMessage | None:
+        devices: dict[str, ProtectDeviceModel] | None = getattr(
+            self, model_type.devices_key, None
+        )
 
         if devices is None:
             return None
@@ -450,12 +449,12 @@ class Bootstrap(ProtectBaseObject):
 
     def _process_device_update(
         self,
+        model_type: ModelType,
         packet: WSPacket,
         action: dict[str, Any],
         data: dict[str, Any],
         ignore_stats: bool,
     ) -> WSSubscriptionMessage | None:
-        model_type = action["modelKey"]
         remove_keys = (
             STATS_AND_IGNORE_DEVICE_KEYS if ignore_stats else IGNORE_DEVICE_KEYS
         )
@@ -463,33 +462,31 @@ class Bootstrap(ProtectBaseObject):
             del data[key]
         # `last_motion` from cameras update every 100 milliseconds when a motion event is active
         # this overrides the behavior to only update `last_motion` when a new event starts
-        if model_type == "camera" and "lastMotion" in data:
+        if model_type is ModelType.CAMERA and "lastMotion" in data:
             del data["lastMotion"]
         # nothing left to process
         if not data:
             self._create_stat(packet, None, True)
             return None
 
-        key = f"{model_type}s"
-        devices: dict[str, ProtectModelWithId] = getattr(self, key)
+        devices: dict[str, ProtectModelWithId] = getattr(self, model_type.devices_key)
         action_id: str = action["id"]
         if action_id not in devices:
             # ignore updates to events that phase out
-            if model_type != _ModelType_Event_value:
+            if model_type is not ModelType.EVENT:
                 _LOGGER.debug("Unexpected %s: %s", key, action_id)
             return None
 
         obj = devices[action_id]
-        model = obj.model
         data = obj.unifi_dict_to_dict(data)
         old_obj = obj.copy()
         obj = obj.update_from_dict(deepcopy(data))
 
-        if model is ModelType.EVENT:
+        if model_type is ModelType.EVENT:
             if TYPE_CHECKING:
                 assert isinstance(obj, Event)
             self.process_event(obj)
-        elif model is ModelType.CAMERA:
+        elif model_type is ModelType.CAMERA:
             if TYPE_CHECKING:
                 assert isinstance(obj, Camera)
             if "last_ring" in data and obj.last_ring:
@@ -497,7 +494,7 @@ class Bootstrap(ProtectBaseObject):
                 _LOGGER.debug("last_ring for %s (%s)", obj.id, is_recent)
                 if is_recent:
                     obj.set_ring_timeout()
-        elif model is ModelType.SENSOR:
+        elif model_type is ModelType.SENSOR:
             if TYPE_CHECKING:
                 assert isinstance(obj, Sensor)
             if "alarm_triggered_at" in data and obj.alarm_triggered_at:
@@ -539,13 +536,14 @@ class Bootstrap(ProtectBaseObject):
             self._create_stat(packet, None, True)
             return None
 
-        if models and ModelType(model_key) not in models:
+        model_type = ModelType.from_string(model_key)
+        if models and model_type not in models:
             self._create_stat(packet, None, True)
             return None
 
         action_action: str = action["action"]
         if action_action == "remove":
-            return self._process_remove_packet(packet)
+            return self._process_remove_packet(model_type, packet)
 
         if not data:
             self._create_stat(packet, None, True)
@@ -553,16 +551,13 @@ class Bootstrap(ProtectBaseObject):
 
         try:
             if action_action == "add":
-                return self._process_add_packet(packet, data)
+                return self._process_add_packet(model_type, packet, data)
             if action_action == "update":
-                if model_key == _ModelType_NVR_value:
+                if model_type is ModelType.NVR:
                     return self._process_nvr_update(packet, data, ignore_stats)
-
-                if (
-                    model_key in ModelType.bootstrap_models_set()
-                    or model_key == _ModelType_Event_value
-                ):
+                if model_type in ModelType.bootstrap_models_types_and_event_set():
                     return self._process_device_update(
+                        model_type,
                         packet,
                         action,
                         data,
@@ -583,7 +578,7 @@ class Bootstrap(ProtectBaseObject):
             msg = f"Validation error processing event: {action['id']}. Ignoring event."
         else:
             try:
-                model_type = ModelType(action["modelKey"])
+                model_type = ModelType.from_string(action["modelKey"])
                 device_id: str = action["id"]
                 task = asyncio.create_task(self.refresh_device(model_type, device_id))
                 self._refresh_tasks.add(task)
@@ -616,7 +611,7 @@ class Bootstrap(ProtectBaseObject):
             self.nvr = device
         else:
             devices: dict[str, ProtectModelWithId] = getattr(
-                self, f"{model_type.value}s"
+                self, model_type.devices_key
             )
             devices[device.id] = device
         _LOGGER.debug("Successfully refresh model: %s %s", model_type, device_id)

uiprotect/data/convert.py

@@ -63,6 +63,7 @@ def create_from_unifi_dict(
     data: dict[str, Any],
     api: ProtectApiClient | None = None,
     klass: type[ProtectModel] | None = None,
+    model_type: ModelType | None = None,
 ) -> ProtectModel:
     """
     Helper method to read the `modelKey` from a UFP JSON dict and convert to currect Python class.
@@ -71,6 +72,9 @@ def create_from_unifi_dict(
     if "modelKey" not in data:
         raise DataDecodeError("No modelKey")
 
+    if model_type is not None and klass is None:
+        klass = MODEL_TO_CLASS.get(model_type)
+
     if klass is None:
         klass = get_klass_from_dict(data)
 

uiprotect/data/types.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 from collections.abc import Callable, Coroutine
-from functools import cache
+from functools import cache, cached_property
 from typing import Any, Literal, Optional, TypeVar, Union
 
 from packaging.version import Version as BaseVersion
@@ -109,31 +109,62 @@ class ModelType(str, UnknownValuesEnumMixin, enum.Enum):
     RECORDING_SCHEDULE = "recordingSchedule"
     UNKNOWN = "unknown"
 
+    @cached_property
+    def devices_key(self) -> str:
+        """Return the devices key."""
+        return f"{self.value}s"
+
+    @classmethod
+    @cache
+    def from_string(cls, value: str) -> ModelType:
+        return cls(value)
+
     @staticmethod
     @cache
-    def bootstrap_models() -> tuple[str, ...]:
+    def bootstrap_model_types() -> tuple[ModelType, ...]:
+        """Return the bootstrap models as a tuple."""
         # TODO:
         # legacyUFV
         # display
-
         return (
-            ModelType.CAMERA.value,
-            ModelType.USER.value,
-            ModelType.GROUP.value,
-            ModelType.LIVEVIEW.value,
-            ModelType.VIEWPORT.value,
-            ModelType.LIGHT.value,
-            ModelType.BRIDGE.value,
-            ModelType.SENSOR.value,
-            ModelType.DOORLOCK.value,
-            ModelType.CHIME.value,
+            ModelType.CAMERA,
+            ModelType.USER,
+            ModelType.GROUP,
+            ModelType.LIVEVIEW,
+            ModelType.VIEWPORT,
+            ModelType.LIGHT,
+            ModelType.BRIDGE,
+            ModelType.SENSOR,
+            ModelType.DOORLOCK,
+            ModelType.CHIME,
+        )
+
+    @staticmethod
+    @cache
+    def bootstrap_models() -> tuple[str, ...]:
+        """Return the bootstrap models strings as a tuple."""
+        return tuple(
+            model_type.value for model_type in ModelType.bootstrap_model_types()
         )
 
     @staticmethod
     @cache
     def bootstrap_models_set() -> set[str]:
+        """Return the set of bootstrap models strings as a set."""
         return set(ModelType.bootstrap_models())
 
+    @staticmethod
+    @cache
+    def bootstrap_models_types_set() -> set[ModelType]:
+        """Return the set of bootstrap models as a set."""
+        return set(ModelType.bootstrap_model_types())
+
+    @staticmethod
+    @cache
+    def bootstrap_models_types_and_event_set() -> set[ModelType]:
+        """Return the set of bootstrap models and the event model as a set."""
+        return ModelType.bootstrap_models_types_set() | {ModelType.EVENT}
+
 
 @enum.unique
 class EventType(str, ValuesEnumMixin, enum.Enum):

uiprotect/data/user.py

@@ -54,7 +54,7 @@ class Permission(ProtectBaseObject):
         if self.obj_ids == {"self"} or self.obj_ids is None:
             return None
 
-        devices = getattr(self._api.bootstrap, f"{self.model.value}s")
+        devices = getattr(self._api.bootstrap, self.model.devices_key)
         return [devices[oid] for oid in self.obj_ids]
 
 

{uiprotect-1.2.2.dist-info → uiprotect-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uiprotect
-Version: 1.2.2
+Version: 1.4.0
 Summary: Python API for Unifi Protect (Unofficial)
 Home-page: https://github.com/uilibs/uiprotect
 License: MIT

{uiprotect-1.2.2.dist-info → uiprotect-1.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 uiprotect/__init__.py,sha256=llnQNtiBfwQG8IkQXovvFz4LZeFjrJx7XdmmUhu3a9E,289
 uiprotect/__main__.py,sha256=C_bHCOkv5qj6WMy-6ELoY3Y6HDhLxOa1a30CzmbZhsg,462
-uiprotect/api.py,sha256=hN1PvNhOTFIfOmBtnUCfpujIXBEBYIKttaYnqlS_2es,66463
+uiprotect/api.py,sha256=t3E1wMja0av6ENtvXJHGv70WC6NCCWbF_wFIJxOLS0I,66463
 uiprotect/cli/__init__.py,sha256=sSLW9keVQOkgFcMW18HTDjRrt9sJ0KWjn9DJDA6f9Pc,8658
 uiprotect/cli/backup.py,sha256=ZiS7RZnJGKI8TJKLW2cOUzkRM8nyTvE5Ov_jZZGtvSM,36708
 uiprotect/cli/base.py,sha256=zpTm2kyJe_GLixnv3Uadke__iRLh64AEwQzp-2hqS7g,7730
@@ -15,12 +15,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=kkPrRhvJV7igGyB3wv1fDvWH26Xzlbz94BjJkDiTvU4,38375
-uiprotect/data/bootstrap.py,sha256=JsbdZQAdlmLNg7dSv02pAhx1n3_wtFfLqSoj7kd8A-0,21296
-uiprotect/data/convert.py,sha256=rOQplUMIdTMD2SbAx_iI9BNPDscnhDvyRVLEMDhtADg,2047
+uiprotect/data/bootstrap.py,sha256=INRUEbLWnsEJuzlcoFlm7RAT-WPx6odje3aD092QKGo,21465
+uiprotect/data/convert.py,sha256=8h6Il_DhMkPRDPj9F_rA2UZIlTuchS3BQD24peKpk2A,2185
 uiprotect/data/devices.py,sha256=Nq3bOko5PFf5LvEBoD4JV8kmbq50laRdh3VHMWX7t-0,111809
 uiprotect/data/nvr.py,sha256=jwJEl4o2kbvoYFB9wSJPghNj0905847-86ElT51nNs0,47580
-uiprotect/data/types.py,sha256=6Z5ZqWTbH4Igy0l4QJShqQZ_zvrJKD0G-hZLjoBNP-U,16193
-uiprotect/data/user.py,sha256=Y7DnnxwUOJRJYw5FntztAtwN-o-Fs48SNS3mHi4Y5To,7071
+uiprotect/data/types.py,sha256=1dj9jCk7btAa2hkiEo1Y5NoAFsQtOroCWT6KQKqG5eo,17213
+uiprotect/data/user.py,sha256=Wb-ZWSwIJbyUbfVuENtUYbuW-uftHNDcoMH85dvEjkw,7071
 uiprotect/data/websocket.py,sha256=WZJVA7EfYuKYMv-9jmvGgMWXKzE9ES25SKv1NQ2eHjc,6281
 uiprotect/exceptions.py,sha256=kgn0cRM6lTtgLza09SDa3ZiX6ue1QqHCOogQ4qu6KTQ,965
 uiprotect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,8 +30,8 @@ uiprotect/test_util/__init__.py,sha256=d2g7afa0LSdixQ0kjEDYwafDFME_UlW2LzxpamZ2B
 uiprotect/test_util/anonymize.py,sha256=f-8ijU-_y9r-uAbhIPn0f0I6hzJpAkvJzc8UpWihObI,8478
 uiprotect/utils.py,sha256=6OLY8hNiCzk418PjJJIlFW7jjPzVt1vxBKEzBSqMeTk,18418
 uiprotect/websocket.py,sha256=IzDPyqbzrkOMREvahN-e2zdvVD0VABSCWy6jSoCwOT0,7299
-uiprotect-1.2.2.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
-uiprotect-1.2.2.dist-info/METADATA,sha256=pU-rmbBF_iFXCpjNQkujk-qjuiJBH1zMDw5ALwnlhQ4,10984
-uiprotect-1.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-uiprotect-1.2.2.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
-uiprotect-1.2.2.dist-info/RECORD,,
+uiprotect-1.4.0.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-1.4.0.dist-info/METADATA,sha256=BZe2l7Ns5304fpwkOl7u7HuJA8AjTg9D0ilGahzubEs,10984
+uiprotect-1.4.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+uiprotect-1.4.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-1.4.0.dist-info/RECORD,,