uiprotect 3.1.5__tar.gz → 3.1.6__tar.gz

{uiprotect-3.1.5 → uiprotect-3.1.6}/PKG-INFO

@@ -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 → uiprotect-3.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uiprotect"
-version = "3.1.5"
+version = "3.1.6"
 description = "Python API for Unifi Protect (Unofficial)"
 authors = ["UI Protect Maintainers <ui@koston.org>"]
 license = "MIT"

{uiprotect-3.1.5 → uiprotect-3.1.6}/src/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-3.1.5 → uiprotect-3.1.6}/src/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-3.1.5 → uiprotect-3.1.6}/src/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()