uiprotect 1.16.0__tar.gz → 1.18.0__tar.gz

{uiprotect-1.16.0 → uiprotect-1.18.0}/PKG-INFO

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

{uiprotect-1.16.0 → uiprotect-1.18.0}/pyproject.toml

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

{uiprotect-1.16.0 → uiprotect-1.18.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,
@@ -448,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)
@@ -965,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.16.0 → uiprotect-1.18.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.16.0 → uiprotect-1.18.0}/src/uiprotect/data/devices.py

@@ -474,14 +474,9 @@ class SmartDetectSettings(ProtectBaseObject):
 
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
-        if "objectTypes" in data:
-            data["objectTypes"] = convert_smart_types(data.pop("objectTypes"))
-        if "audioTypes" in data:
-            data["audioTypes"] = convert_smart_audio_types(data.pop("audioTypes"))
-        if "autoTrackingObjectTypes" in data:
-            data["autoTrackingObjectTypes"] = convert_smart_types(
-                data.pop("autoTrackingObjectTypes"),
-            )
+        for key in ("objectTypes", "audioTypes", "autoTrackingObjectTypes"):
+            if key in data:
+                data[key] = convert_smart_types(data[key])
 
         return super().unifi_dict_to_dict(data)
 
@@ -578,22 +573,18 @@ class VideoStats(ProtectBaseObject):
 
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
-        if "recordingStart" in data:
-            data["recordingStart"] = convert_to_datetime(data["recordingStart"])
-        if "recordingEnd" in data:
-            data["recordingEnd"] = convert_to_datetime(data["recordingEnd"])
-        if "recordingStartLQ" in data:
-            data["recordingStartLQ"] = convert_to_datetime(data["recordingStartLQ"])
-        if "recordingEndLQ" in data:
-            data["recordingEndLQ"] = convert_to_datetime(data["recordingEndLQ"])
-        if "timelapseStart" in data:
-            data["timelapseStart"] = convert_to_datetime(data["timelapseStart"])
-        if "timelapseEnd" in data:
-            data["timelapseEnd"] = convert_to_datetime(data["timelapseEnd"])
-        if "timelapseStartLQ" in data:
-            data["timelapseStartLQ"] = convert_to_datetime(data["timelapseStartLQ"])
-        if "timelapseEndLQ" in data:
-            data["timelapseEndLQ"] = convert_to_datetime(data["timelapseEndLQ"])
+        for key in (
+            "recordingStart",
+            "recordingEnd",
+            "recordingStartLQ",
+            "recordingEndLQ",
+            "timelapseStart",
+            "timelapseEnd",
+            "timelapseStartLQ",
+            "timelapseEndLQ",
+        ):
+            if key in data:
+                data[key] = convert_to_datetime(data[key])
 
         return super().unifi_dict_to_dict(data)
 
@@ -1062,27 +1053,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 +2805,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.16.0 → uiprotect-1.18.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.16.0 → uiprotect-1.18.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
@@ -54,6 +56,9 @@ class BaseWSPacketFrame:
     is_deflated: bool = False
     length: int = 0
 
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} header={self.header} data={self.data}>"
+
     def set_data_from_binary(self, data: bytes) -> None:
         self.data = data
         if self.header is not None and self.header.deflated:
@@ -89,7 +94,7 @@ class BaseWSPacketFrame:
         i: payload_size
         """
         header_end = position + WS_HEADER_SIZE
-
+        payload_size: int
         try:
             (
                 packet_type,
@@ -97,8 +102,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 +121,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
@@ -187,12 +191,14 @@ class WSPacket:
     def __init__(self, data: bytes) -> None:
         self._raw = data
 
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} action_frame={self.action_frame} data_frame={self.data_frame}>"
+
     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 +208,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 +219,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.16.0 → uiprotect-1.18.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)