uiprotect 1.15.0__tar.gz → 1.17.0__tar.gz

{uiprotect-1.15.0 → uiprotect-1.17.0}/PKG-INFO

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

{uiprotect-1.15.0 → uiprotect-1.17.0}/pyproject.toml

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

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/data/base.py

@@ -185,12 +185,6 @@ class ProtectBaseObject(BaseModel):
         """
         return {}
 
-    @classmethod
-    @cache
-    def _get_unifi_remaps_set(self) -> set[str]:
-        """Helper method to get set of all child UFP objects."""
-        return set(self._get_unifi_remaps())
-
     @classmethod
     @cache
     def _get_to_unifi_remaps(cls) -> dict[str, str]:
@@ -238,9 +232,9 @@ class ProtectBaseObject(BaseModel):
 
     @classmethod
     @cache
-    def _get_protect_objs_set(cls) -> set[str]:
-        """Helper method to get all child UFP objects"""
-        return set(cls._get_protect_objs())
+    def _get_excluded_fields(cls) -> set[str]:
+        """Helper method to get all excluded fields for the current object."""
+        return set(cls._get_protect_objs()) | set(cls._get_protect_lists())
 
     @classmethod
     @cache
@@ -251,12 +245,6 @@ class ProtectBaseObject(BaseModel):
             assert cls._protect_lists is not None
         return cls._protect_lists
 
-    @classmethod
-    @cache
-    def _get_protect_lists_set(cls) -> set[str]:
-        """Helper method to get all child UFP objects"""
-        return set(cls._get_protect_lists())
-
     @classmethod
     @cache
     def _get_protect_dicts(cls) -> dict[str, type[ProtectBaseObject]]:
@@ -266,12 +254,6 @@ class ProtectBaseObject(BaseModel):
             assert cls._protect_dicts is not None
         return cls._protect_dicts
 
-    @classmethod
-    @cache
-    def _get_protect_dicts_set(cls) -> set[str]:
-        """Helper method to get all child UFP objects"""
-        return set(cls._get_protect_dicts())
-
     @classmethod
     def _clean_protect_obj(
         cls,
@@ -401,15 +383,12 @@ class ProtectBaseObject(BaseModel):
         if not isinstance(value, list):
             return value
 
-        items: list[Any] = []
-        for item in value:
-            if isinstance(item, ProtectBaseObject):
-                new_item = item.unifi_dict()
-            else:
-                new_item = klass.construct({}).unifi_dict(data=item)  # type: ignore[arg-type]
-            items.append(new_item)
-
-        return items
+        return [
+            item.unifi_dict()
+            if isinstance(item, ProtectBaseObject)
+            else klass.construct({}).unifi_dict(data=item)  # type: ignore[arg-type]
+            for item in value
+        ]
 
     def _unifi_dict_protect_obj_dict(
         self,
@@ -424,13 +403,10 @@ class ProtectBaseObject(BaseModel):
         if not isinstance(value, dict):
             return value
 
-        items: dict[Any, Any] = {}
-        for obj_key, obj in value.items():
-            if isinstance(obj, ProtectBaseObject):
-                obj = obj.unifi_dict()
-            items[obj_key] = obj
-
-        return items
+        return {
+            obj_key: obj.unifi_dict() if isinstance(obj, ProtectBaseObject) else obj
+            for obj_key, obj in value.items()
+        }
 
     def unifi_dict(
         self,
@@ -454,9 +430,7 @@ class ProtectBaseObject(BaseModel):
         """
         use_obj = False
         if data is None:
-            excluded_fields = (
-                self._get_protect_objs_set() | self._get_protect_lists_set()
-            )
+            excluded_fields = self._get_excluded_fields()
             if exclude is not None:
                 excluded_fields |= exclude
             data = self.dict(exclude=excluded_fields)
@@ -971,16 +945,13 @@ class ProtectAdoptableDeviceModel(ProtectDeviceModel):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-
-        if "wiredConnectionState" in data and data["wiredConnectionState"] is None:
-            del data["wiredConnectionState"]
-        if "wifiConnectionState" in data and data["wifiConnectionState"] is None:
-            del data["wifiConnectionState"]
-        if (
-            "bluetoothConnectionState" in data
-            and data["bluetoothConnectionState"] is None
+        for key in (
+            "wiredConnectionState",
+            "wifiConnectionState",
+            "bluetoothConnectionState",
         ):
-            del data["bluetoothConnectionState"]
+            if key in data and data[key] is None:
+                del data[key]
         return data
 
     @classmethod

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/data/bootstrap.py

@@ -8,7 +8,6 @@ from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime
-from functools import cache
 from typing import TYPE_CHECKING, Any
 
 from aiohttp.client_exceptions import ServerDisconnectedError
@@ -220,11 +219,6 @@ class Bootstrap(ProtectBaseObject):
 
         return super().unifi_dict_to_dict(data)
 
-    @classmethod
-    @cache
-    def _unifi_dict_remove_keys(cls) -> set[str]:
-        return {"events", "captureWsStats", "macLookup", "idLookup"}
-
     def unifi_dict(
         self,
         data: dict[str, Any] | None = None,
@@ -232,7 +226,7 @@ class Bootstrap(ProtectBaseObject):
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
 
-        for key in Bootstrap._unifi_dict_remove_keys():
+        for key in ("events", "captureWsStats", "macLookup", "idLookup"):
             if key in data:
                 del data[key]
         for model_type in ModelType.bootstrap_models_types_set:

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/data/devices.py

@@ -1062,27 +1062,21 @@ class Camera(ProtectMotionDeviceModel):
                 ]
 
         data = super().unifi_dict(data=data, exclude=exclude)
+        for key in (
+            "lastRingEventId",
+            "lastSmartDetect",
+            "lastSmartAudioDetect",
+            "lastSmartDetectEventId",
+            "lastSmartAudioDetectEventId",
+            "lastSmartDetects",
+            "lastSmartAudioDetects",
+            "lastSmartDetectEventIds",
+            "lastSmartAudioDetectEventIds",
+            "talkbackStream",
+        ):
+            if key in data:
+                del data[key]
 
-        if "lastRingEventId" in data:
-            del data["lastRingEventId"]
-        if "lastSmartDetect" in data:
-            del data["lastSmartDetect"]
-        if "lastSmartAudioDetect" in data:
-            del data["lastSmartAudioDetect"]
-        if "lastSmartDetectEventId" in data:
-            del data["lastSmartDetectEventId"]
-        if "lastSmartAudioDetectEventId" in data:
-            del data["lastSmartAudioDetectEventId"]
-        if "lastSmartDetects" in data:
-            del data["lastSmartDetects"]
-        if "lastSmartAudioDetects" in data:
-            del data["lastSmartAudioDetects"]
-        if "lastSmartDetectEventIds" in data:
-            del data["lastSmartDetectEventIds"]
-        if "lastSmartAudioDetectEventIds" in data:
-            del data["lastSmartAudioDetectEventIds"]
-        if "talkbackStream" in data:
-            del data["talkbackStream"]
         if "lcdMessage" in data and data["lcdMessage"] is None:
             data["lcdMessage"] = {}
 
@@ -2820,18 +2814,15 @@ class Sensor(ProtectAdoptableDeviceModel):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-
-        if "lastMotionEventId" in data:
-            del data["lastMotionEventId"]
-        if "lastContactEventId" in data:
-            del data["lastContactEventId"]
-        if "lastValueEventId" in data:
-            del data["lastValueEventId"]
-        if "lastAlarmEventId" in data:
-            del data["lastAlarmEventId"]
-        if "extremeValueDetectedAt" in data:
-            del data["extremeValueDetectedAt"]
-
+        for key in (
+            "lastMotionEventId",
+            "lastContactEventId",
+            "lastValueEventId",
+            "lastAlarmEventId",
+            "extremeValueDetectedAt",
+        ):
+            if key in data:
+                del data[key]
         return data
 
     @property

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/data/nvr.py

@@ -309,9 +309,9 @@ class Event(ProtectModelWithId):
 
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
-        for key in {"start", "end", "timestamp", "deletedAt"}.intersection(data):
-            data[key] = convert_to_datetime(data[key])
-
+        for key in ("start", "end", "timestamp", "deletedAt"):
+            if key in data:
+                data[key] = convert_to_datetime(data[key])
         return super().unifi_dict_to_dict(data)
 
     def unifi_dict(

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/data/websocket.py

@@ -47,6 +47,8 @@ class WSSubscriptionMessage:
 
 
 class BaseWSPacketFrame:
+    UNPACK_FORMAT = struct.Struct("!bbbbi")
+
     data: Any
     position: int = 0
     header: WSPacketFrameHeader | None = None
@@ -89,7 +91,7 @@ class BaseWSPacketFrame:
         i: payload_size
         """
         header_end = position + WS_HEADER_SIZE
-
+        payload_size: int
         try:
             (
                 packet_type,
@@ -97,8 +99,7 @@ class BaseWSPacketFrame:
                 deflated,
                 unknown,
                 payload_size,
-            ) = struct.unpack(
-                "!bbbbi",
+            ) = BaseWSPacketFrame.UNPACK_FORMAT.unpack(
                 data[position:header_end],
             )
         except struct.error as e:
@@ -117,9 +118,9 @@ class BaseWSPacketFrame:
             unknown=unknown,
             payload_size=payload_size,
         )
-        frame.length = WS_HEADER_SIZE + frame.header.payload_size
-        frame.is_deflated = bool(frame.header.deflated)
-        frame_end = header_end + frame.header.payload_size
+        frame.length = WS_HEADER_SIZE + payload_size
+        frame.is_deflated = bool(deflated)
+        frame_end = header_end + payload_size
         frame.set_data_from_binary(data[header_end:frame_end])
 
         return frame
@@ -188,11 +189,10 @@ class WSPacket:
         self._raw = data
 
     def decode(self) -> None:
-        self._action_frame = WSRawPacketFrame.from_binary(self._raw)
-        self._data_frame = WSRawPacketFrame.from_binary(
-            self._raw,
-            self._action_frame.length,
-        )
+        data = self._raw
+        self._action_frame = WSRawPacketFrame.from_binary(data)
+        length = self._action_frame.length
+        self._data_frame = WSRawPacketFrame.from_binary(data, length)
 
     @cached_property
     def action_frame(self) -> BaseWSPacketFrame:
@@ -202,6 +202,7 @@ class WSPacket:
         if self._action_frame is None:
             raise WSDecodeError("Packet unexpectedly not decoded")
 
+        self.__dict__["data_frame"] = self._data_frame
         return self._action_frame
 
     @cached_property
@@ -212,6 +213,7 @@ class WSPacket:
         if self._data_frame is None:
             raise WSDecodeError("Packet unexpectedly not decoded")
 
+        self.__dict__["action_frame"] = self._action_frame
         return self._data_frame
 
     @property

{uiprotect-1.15.0 → uiprotect-1.17.0}/src/uiprotect/utils.py

@@ -17,7 +17,7 @@ from copy import deepcopy
 from datetime import datetime, timedelta, timezone, tzinfo
 from decimal import Decimal
 from enum import Enum
-from functools import lru_cache
+from functools import cache, lru_cache
 from hashlib import sha224
 from http.cookies import Morsel
 from inspect import isclass
@@ -96,22 +96,20 @@ IP_TYPES = {
     Union[IPv6Address, IPv4Address, None],
 }
 
-if sys.version_info[:2] < (3, 11):
-    pass
-else:
-    pass
-
 
 def set_debug() -> None:
     """Sets ENV variable for UFP_DEBUG to on (True)"""
     os.environ[DEBUG_ENV] = str(True)
+    is_debug.cache_clear()
 
 
 def set_no_debug() -> None:
     """Sets ENV variable for UFP_DEBUG to off (False)"""
     os.environ[DEBUG_ENV] = str(False)
+    is_debug.cache_clear()
 
 
+@cache
 def is_debug() -> bool:
     """Returns if debug ENV is on (True)"""
     return os.environ.get(DEBUG_ENV) == str(True)