uiprotect 3.1.5__py3-none-any.whl → 3.1.6__py3-none-any.whl

uiprotect/data/base.py

@@ -6,7 +6,7 @@ import asyncio
 import logging
 from collections.abc import Callable
 from datetime import datetime, timedelta
-from functools import cache
+from functools import cache, cached_property
 from ipaddress import IPv4Address
 from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 from uuid import UUID
@@ -446,9 +446,6 @@ class ProtectBaseObject(BaseModel):
         for to_key in set(new_data).intersection(remaps):
             new_data[remaps[to_key]] = new_data.pop(to_key)
 
-        if "api" in new_data:
-            del new_data["api"]
-
         return new_data
 
     def update_from_dict(cls: ProtectObject, data: dict[str, Any]) -> ProtectObject:
@@ -466,8 +463,6 @@ class ProtectBaseObject(BaseModel):
         api = cls._api
         _fields = cls.__fields__
         unifi_obj: ProtectBaseObject | None
-        if "api" in data:
-            del data["api"]
         value: Any
 
         for key, item in data.items():
@@ -536,32 +531,40 @@ class ProtectModel(ProtectBaseObject):
         return data
 
 
+class UpdateSynchronization:
+    """Helper class for managing updates to Protect devices."""
+
+    @cached_property
+    def lock(self) -> asyncio.Lock:
+        """Lock to prevent multiple updates at once."""
+        return asyncio.Lock()
+
+    @cached_property
+    def queue(self) -> asyncio.Queue[Callable[[], None]]:
+        """Queue to store device updates."""
+        return asyncio.Queue()
+
+    @cached_property
+    def event(self) -> asyncio.Event:
+        """Event to signal when a device update has been queued."""
+        return asyncio.Event()
+
+
 class ProtectModelWithId(ProtectModel):
     id: str
 
-    _update_lock: asyncio.Lock = PrivateAttr(None)
-    _update_queue: asyncio.Queue[Callable[[], None]] = PrivateAttr(None)
-    _update_event: asyncio.Event = PrivateAttr(None)
+    _update_sync: UpdateSynchronization = PrivateAttr(None)
 
     def __init__(self, **data: Any) -> None:
-        update_lock = data.pop("update_lock", None)
-        update_queue = data.pop("update_queue", None)
-        update_event = data.pop("update_event", None)
+        update_sync = data.pop("update_sync", None)
         super().__init__(**data)
-        self._update_lock = update_lock or asyncio.Lock()
-        self._update_queue = update_queue or asyncio.Queue()
-        self._update_event = update_event or asyncio.Event()
+        self._update_sync = update_sync or UpdateSynchronization()
 
     @classmethod
     def construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self:
-        update_lock = values.pop("update_lock", None)
-        update_queue = values.pop("update_queue", None)
-        update_event = values.pop("update_event", None)
+        update_sync = values.pop("update_sync", None)
         obj = super().construct(_fields_set=_fields_set, **values)
-        obj._update_lock = update_lock or asyncio.Lock()
-        obj._update_queue = update_queue or asyncio.Queue()
-        obj._update_event = update_event or asyncio.Event()
-
+        obj._update_sync = update_sync or UpdateSynchronization()
         return obj
 
     @classmethod
@@ -609,28 +612,28 @@ class ProtectModelWithId(ProtectModel):
         This allows aggregating devices updates so if multiple ones come in all at once,
         they can be combined in a single PATCH.
         """
-        self._update_queue.put_nowait(callback)
+        self._update_sync.queue.put_nowait(callback)
 
-        self._update_event.set()
+        self._update_sync.event.set()
         await asyncio.sleep(
             0.001,
         )  # release execution so other `queue_update` calls can abort
-        self._update_event.clear()
+        self._update_sync.event.clear()
 
         try:
             async with asyncio_timeout(0.05):
-                await self._update_event.wait()
-            self._update_event.clear()
+                await self._update_sync.event.wait()
+            self._update_sync.event.clear()
             return
         except (TimeoutError, asyncio.TimeoutError, asyncio.CancelledError):
-            async with self._update_lock:
+            async with self._update_sync.lock:
                 # Important! Now that we have the lock, we yield to the event loop so any
                 # updates from the websocket are processed before we generate the diff
                 await asyncio.sleep(0)
                 # Save the initial data before we generate the diff
                 data_before_changes = self.dict_with_excludes()
-                while not self._update_queue.empty():
-                    callback = self._update_queue.get_nowait()
+                while not self._update_sync.queue.empty():
+                    callback = self._update_sync.queue.get_nowait()
                     callback()
                 # Important, do not yield to the event loop before generating the diff
                 # otherwise we may miss updates from the websocket
@@ -660,8 +663,8 @@ class ProtectModelWithId(ProtectModel):
         """
         # do not allow multiple save_device calls at once
         release_lock = False
-        if not self._update_lock.locked():
-            await self._update_lock.acquire()
+        if not self._update_sync.lock.locked():
+            await self._update_sync.lock.acquire()
             release_lock = True
 
         try:
@@ -673,7 +676,7 @@ class ProtectModelWithId(ProtectModel):
             )
         finally:
             if release_lock:
-                self._update_lock.release()
+                self._update_sync.lock.release()
 
     async def _save_device_changes(
         self,
@@ -692,7 +695,7 @@ class ProtectModelWithId(ProtectModel):
         )
 
         assert (
-            self._update_lock.locked()
+            self._update_sync.lock.locked()
         ), "save_device_changes should only be called when the update lock is held"
         read_only_fields = self.__class__._get_read_only_fields()
 

uiprotect/data/devices.py

@@ -159,10 +159,9 @@ class Light(ProtectMotionDeviceModel):
 
     async def set_paired_camera(self, camera: Camera | None) -> None:
         """Sets the camera paired with the light"""
-        async with self._update_lock:
-            await asyncio.sleep(
-                0,
-            )  # yield to the event loop once we have the lock to process any pending updates
+        async with self._update_sync.lock:
+            # yield to the event loop once we have the lock to process any pending updates
+            await asyncio.sleep(0)
             data_before_changes = self.dict_with_excludes()
             if camera is None:
                 self.camera_id = None
@@ -2378,10 +2377,9 @@ class Camera(ProtectMotionDeviceModel):
             raise BadRequest("Camera does not have an LCD screen")
 
         if text_type is None:
-            async with self._update_lock:
-                await asyncio.sleep(
-                    0,
-                )  # yield to the event loop once we have the lock to process any pending updates
+            async with self._update_sync.lock:
+                # yield to the event loop once we have the lock to process any pending updates
+                await asyncio.sleep(0)
                 data_before_changes = self.dict_with_excludes()
                 self.lcd_message = None
                 # UniFi Protect bug: clearing LCD text message does _not_ emit a WS message
@@ -2704,10 +2702,9 @@ class Viewer(ProtectAdoptableDeviceModel):
         if self._api is not None and liveview.id not in self._api.bootstrap.liveviews:
             raise BadRequest("Unknown liveview")
 
-        async with self._update_lock:
-            await asyncio.sleep(
-                0,
-            )  # yield to the event loop once we have the lock to process any pending updates
+        async with self._update_sync.lock:
+            # yield to the event loop once we have the lock to process any pending updates
+            await asyncio.sleep(0)
             data_before_changes = self.dict_with_excludes()
             self.liveview_id = liveview.id
             # UniFi Protect bug: changing the liveview does _not_ emit a WS message

uiprotect/data/nvr.py

@@ -1184,7 +1184,7 @@ class NVR(ProtectDeviceModel):
         self, update_callback: Callable[[], None]
     ) -> None:
         """Updates doorbell messages and saves to Protect."""
-        async with self._update_lock:
+        async with self._update_sync.lock:
             # yield to the event loop once we have the lock to ensure websocket updates are processed
             await asyncio.sleep(0)
             data_before_changes = self.dict_with_excludes()

{uiprotect-3.1.5.dist-info → uiprotect-3.1.6.dist-info}/METADATA

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

{uiprotect-3.1.5.dist-info → uiprotect-3.1.6.dist-info}/RECORD

@@ -14,11 +14,11 @@ uiprotect/cli/nvr.py,sha256=TwxEg2XT8jXAbOqv6gc7KFXELKadeItEDYweSL4_-e8,4260
 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=g7keZfJlSycASwW_hJFpn4YtjRCd430O8zmznkvJ9mI,35484
+uiprotect/data/base.py,sha256=0dfm5qLHpDJYTO04tYpEB869DkVoT0uev9BmgPR9HrA,35436
 uiprotect/data/bootstrap.py,sha256=aF6BJ8qgE7sEDsTKPdRXsrMsL_CTmo8Xr-TUNZjfU6I,21810
 uiprotect/data/convert.py,sha256=8h6Il_DhMkPRDPj9F_rA2UZIlTuchS3BQD24peKpk2A,2185
-uiprotect/data/devices.py,sha256=A4ambSBi36IT9Sg_88QR0t7r1TrDBjHa4yfN5cdR8-E,110412
-uiprotect/data/nvr.py,sha256=H0QIxwzQZJYGGeGhY_itb-WYqZnaQ_KcTlWTtrc-LLM,47456
+uiprotect/data/devices.py,sha256=n2TVY0J-xhO7fXgrvC0hqsHjNc-B_DdySDKHOIKPeqs,110363
+uiprotect/data/nvr.py,sha256=4EzeRFogmdT96VJ9yY17rqpUMx7NuKBRnUrgRbQ5YJs,47461
 uiprotect/data/types.py,sha256=3CocULpkdTgF4is1nIEDYIlwf2EOkNNM7L4kJ7NkAwM,17654
 uiprotect/data/user.py,sha256=YvgXJKV4_y-bm0eySWz9f_ie9aR5lpVn17t9H0Pix8I,6998
 uiprotect/data/websocket.py,sha256=vnn3FUc1H3e4dvA3INGob_asbmVCaA99H1DnwDEmpdw,6709
@@ -30,8 +30,8 @@ uiprotect/test_util/__init__.py,sha256=whiOUb5LfDLNT3AQG6ISiKtAqO2JnhCIdFavhWDK4
 uiprotect/test_util/anonymize.py,sha256=f-8ijU-_y9r-uAbhIPn0f0I6hzJpAkvJzc8UpWihObI,8478
 uiprotect/utils.py,sha256=3SJFF8qs1Jz8t3mD8qwc1hFSocolFjdXI_v4yVlC7o4,20088
 uiprotect/websocket.py,sha256=D5DZrMzo434ecp8toNxOB5HM193kVwYw42yEcg99yMw,8029
-uiprotect-3.1.5.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
-uiprotect-3.1.5.dist-info/METADATA,sha256=PkMfFtqsNFCU_7tTDuZeHIuDDLv_E8GSVawNOHqet88,10982
-uiprotect-3.1.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-uiprotect-3.1.5.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
-uiprotect-3.1.5.dist-info/RECORD,,
+uiprotect-3.1.6.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-3.1.6.dist-info/METADATA,sha256=kvjDUNT1Q8B75cIVkrbdYm4em87HseeDcyJgQXlSttI,10982
+uiprotect-3.1.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+uiprotect-3.1.6.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-3.1.6.dist-info/RECORD,,