uiprotect 1.18.0__py3-none-any.whl → 1.19.0__py3-none-any.whl

uiprotect/data/bootstrap.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime
@@ -66,9 +65,34 @@ STATS_KEYS = {
     "lastSeen",
     "recordingSchedules",
 }
+
 IGNORE_DEVICE_KEYS = {"nvrMac", "guid"}
 STATS_AND_IGNORE_DEVICE_KEYS = STATS_KEYS | IGNORE_DEVICE_KEYS
 
+_IGNORE_KEYS_BY_MODEL_TYPE = {
+    #
+    # `lastMotion` from cameras update every 100 milliseconds when a motion event is active
+    # this overrides the behavior to only update `lastMotion` when a new event starts
+    #
+    ModelType.CAMERA: {"lastMotion"},
+    #
+    # `cameraIds` is updated every 10s, but we don't need to process it since bootstrap
+    # is resynced every so often anyways.
+    #
+    ModelType.CHIME: {"cameraIds"},
+}
+
+
+IGNORE_DEVICE_KEYS_BY_MODEL_TYPE = {
+    model_type: IGNORE_DEVICE_KEYS | keys
+    for model_type, keys in _IGNORE_KEYS_BY_MODEL_TYPE.items()
+}
+STATS_AND_IGNORE_DEVICE_KEYS_BY_MODEL_TYPE = {
+    model_type: STATS_AND_IGNORE_DEVICE_KEYS | keys
+    for model_type, keys in _IGNORE_KEYS_BY_MODEL_TYPE.items()
+}
+
+
 CAMERA_EVENT_ATTR_MAP: dict[EventType, tuple[str, str]] = {
     EventType.MOTION: ("last_motion", "last_motion_event_id"),
     EventType.SMART_DETECT: ("last_smart_detect", "last_smart_detect_event_id"),
@@ -318,28 +342,9 @@ class Bootstrap(ProtectBaseObject):
 
         self.events[event.id] = event
 
-    def _create_stat(
-        self,
-        packet: WSPacket,
-        keys_set: Iterable[str] | None,
-        filtered: bool,
-    ) -> None:
-        if self.capture_ws_stats:
-            self._ws_stats.append(
-                WSStat(
-                    model=packet.action_frame.data["modelKey"],
-                    action=packet.action_frame.data["action"],
-                    keys=list(packet.data_frame.data),
-                    keys_set=[] if keys_set is None else list(keys_set),
-                    size=len(packet.raw),
-                    filtered=filtered,
-                ),
-            )
-
     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, model_type=model_type)
@@ -366,33 +371,26 @@ class Bootstrap(ProtectBaseObject):
             _LOGGER.debug("Unexpected bootstrap model type for add: %s", model_type)
             return None
 
-        updated = obj.dict()
-
-        self._create_stat(packet, updated, False)
-
         return WSSubscriptionMessage(
             action=WSAction.ADD,
             new_update_id=self.last_update_id,
-            changed_data=updated,
+            changed_data=obj.dict(),
             new_obj=obj,
         )
 
     def _process_remove_packet(
-        self, model_type: ModelType, packet: WSPacket
+        self, model_type: ModelType, action: dict[str, Any]
     ) -> WSSubscriptionMessage | None:
         devices_key = model_type.devices_key
         devices: dict[str, ProtectDeviceModel] | None = getattr(self, devices_key, None)
-
         if devices is None:
             return None
 
-        device_id: str = packet.action_frame.data["id"]
+        device_id: str = action["id"]
         self.id_lookup.pop(device_id, None)
         if (device := devices.pop(device_id, None)) is None:
             return None
         self.mac_lookup.pop(normalize_mac(device.mac), None)
-
-        self._create_stat(packet, None, False)
         return WSSubscriptionMessage(
             action=WSAction.REMOVE,
             new_update_id=self.last_update_id,
@@ -402,7 +400,7 @@ class Bootstrap(ProtectBaseObject):
 
     def _process_nvr_update(
         self,
-        packet: WSPacket,
+        action: dict[str, Any],
         data: dict[str, Any],
         ignore_stats: bool,
     ) -> WSSubscriptionMessage | None:
@@ -411,24 +409,20 @@ class Bootstrap(ProtectBaseObject):
                 del data[key]
         # nothing left to process
         if not data:
-            self._create_stat(packet, None, True)
             return None
 
         # for another NVR in stack
-        nvr_id: str | None = packet.action_frame.data.get("id")
+        nvr_id: str | None = action.get("id")
         if nvr_id and nvr_id != self.nvr.id:
-            self._create_stat(packet, None, True)
             return None
 
         # nothing left to process
         if not (data := self.nvr.unifi_dict_to_dict(data)):
-            self._create_stat(packet, None, True)
             return None
 
         old_nvr = self.nvr.copy()
         self.nvr = self.nvr.update_from_dict(deepcopy(data))
 
-        self._create_stat(packet, data, False)
         return WSSubscriptionMessage(
             action=WSAction.UPDATE,
             new_update_id=self.last_update_id,
@@ -440,7 +434,6 @@ class Bootstrap(ProtectBaseObject):
     def _process_device_update(
         self,
         model_type: ModelType,
-        packet: WSPacket,
         action: dict[str, Any],
         data: dict[str, Any],
         ignore_stats: bool,
@@ -453,18 +446,20 @@ class Bootstrap(ProtectBaseObject):
         that was generated internally as a result of an event
         that will expire and result in a state change.
         """
-        remove_keys = (
-            STATS_AND_IGNORE_DEVICE_KEYS if ignore_stats else IGNORE_DEVICE_KEYS
-        )
+        if ignore_stats:
+            remove_keys = STATS_AND_IGNORE_DEVICE_KEYS_BY_MODEL_TYPE.get(
+                model_type, STATS_AND_IGNORE_DEVICE_KEYS
+            )
+        else:
+            remove_keys = IGNORE_DEVICE_KEYS_BY_MODEL_TYPE.get(
+                model_type, IGNORE_DEVICE_KEYS
+            )
+
         for key in remove_keys.intersection(data):
             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 is ModelType.CAMERA and "lastMotion" in data:
-            del data["lastMotion"]
+
         # nothing left to process
         if not data and not is_ping_back:
-            self._create_stat(packet, None, True)
             return None
 
         devices: dict[str, ProtectModelWithId] = getattr(self, model_type.devices_key)
@@ -480,7 +475,6 @@ class Bootstrap(ProtectBaseObject):
 
         if not data and not is_ping_back:
             # nothing left to process
-            self._create_stat(packet, None, True)
             return None
 
         old_obj = obj.copy()
@@ -506,7 +500,6 @@ class Bootstrap(ProtectBaseObject):
                 _LOGGER.debug("alarm_triggered_at for %s (%s)", obj.id, is_recent)
 
         devices[action_id] = obj
-        self._create_stat(packet, data, False)
         return WSSubscriptionMessage(
             action=WSAction.UPDATE,
             new_update_id=self.last_update_id,
@@ -523,9 +516,10 @@ class Bootstrap(ProtectBaseObject):
         is_ping_back: bool = False,
     ) -> WSSubscriptionMessage | None:
         """Process a WS packet."""
+        capture_ws_stats = self.capture_ws_stats
         action = packet.action_frame.data
         data = packet.data_frame.data
-        if self.capture_ws_stats:
+        if capture_ws_stats:
             action = deepcopy(action)
             data = deepcopy(data)
 
@@ -533,33 +527,57 @@ class Bootstrap(ProtectBaseObject):
         if new_update_id is not None:
             self.last_update_id = new_update_id
 
+        message = self._make_ws_packet_message(
+            action, data, models, ignore_stats, is_ping_back
+        )
+
+        if capture_ws_stats:
+            self._ws_stats.append(
+                WSStat(
+                    model=packet.action_frame.data["modelKey"],
+                    action=packet.action_frame.data["action"],
+                    keys=list(packet.data_frame.data),
+                    keys_set=[] if message is None else list(message.changed_data),
+                    size=len(packet.raw),
+                    filtered=message is None,
+                ),
+            )
+
+        return message
+
+    def _make_ws_packet_message(
+        self,
+        action: dict[str, Any],
+        data: dict[str, Any],
+        models: set[ModelType] | None,
+        ignore_stats: bool,
+        is_ping_back: bool,
+    ) -> WSSubscriptionMessage | None:
+        """Process a WS packet."""
         model_key: str = action["modelKey"]
         if (model_type := ModelType.from_string(model_key)) is ModelType.UNKNOWN:
             _LOGGER.debug("Unknown model type: %s", model_key)
-            self._create_stat(packet, None, True)
             return None
 
         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(model_type, packet)
+            return self._process_remove_packet(model_type, action)
 
         if not data and not is_ping_back:
-            self._create_stat(packet, None, True)
             return None
 
         try:
             if action_action == "add":
-                return self._process_add_packet(model_type, packet, data)
+                return self._process_add_packet(model_type, data)
             if action_action == "update":
                 if model_type is ModelType.NVR:
-                    return self._process_nvr_update(packet, data, ignore_stats)
+                    return self._process_nvr_update(action, data, ignore_stats)
                 if model_type in ModelType.bootstrap_models_types_and_event_set:
                     return self._process_device_update(
-                        model_type, packet, action, data, ignore_stats, is_ping_back
+                        model_type, action, data, ignore_stats, is_ping_back
                     )
         except (ValidationError, ValueError) as err:
             self._handle_ws_error(action, err)
@@ -567,7 +585,6 @@ class Bootstrap(ProtectBaseObject):
         _LOGGER.debug(
             "Unexpected bootstrap model type deviceadoptedfor update: %s", model_key
         )
-        self._create_stat(packet, None, True)
         return None
 
     def _handle_ws_error(self, action: dict[str, Any], err: Exception) -> None:

uiprotect/data/devices.py

@@ -474,7 +474,9 @@ class SmartDetectSettings(ProtectBaseObject):
 
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
-        for key in ("objectTypes", "audioTypes", "autoTrackingObjectTypes"):
+        if "audioTypes" in data:
+            data["audioTypes"] = convert_smart_audio_types(data["audioTypes"])
+        for key in ("objectTypes", "autoTrackingObjectTypes"):
             if key in data:
                 data[key] = convert_smart_types(data[key])
 

{uiprotect-1.18.0.dist-info → uiprotect-1.19.0.dist-info}/METADATA

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

{uiprotect-1.18.0.dist-info → uiprotect-1.19.0.dist-info}/RECORD

@@ -15,9 +15,9 @@ 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=q5lpNJ4keAQ4oDjalwg9eL3kaVzEapfwtcTzZZlrN_M,35691
-uiprotect/data/bootstrap.py,sha256=epMt3lRNCp4mu_gkyjV12Ec62snB1FUOP_obVIsWp-w,21723
+uiprotect/data/bootstrap.py,sha256=ZieXqE0526F3iRbdJ1pRM6QclSatn_SmecfoOPS3nNg,21922
 uiprotect/data/convert.py,sha256=8h6Il_DhMkPRDPj9F_rA2UZIlTuchS3BQD24peKpk2A,2185
-uiprotect/data/devices.py,sha256=c32wLGkjP-9IiWSlofKqesMVhsyAtrKwsdzwDsncQS0,110387
+uiprotect/data/devices.py,sha256=450T-8qXsFad0xNNnXwm3x53e09NT4dgqlefl7lrc2Q,110485
 uiprotect/data/nvr.py,sha256=zCEAI-rKLEpp9P63QDvJi0hGRsuv-PWGssgHw1POYeQ,47648
 uiprotect/data/types.py,sha256=8z8jIoMlfDre7Op1JAN45PLZdAE-4i3gDPSo2uymqu4,17996
 uiprotect/data/user.py,sha256=Wb-ZWSwIJbyUbfVuENtUYbuW-uftHNDcoMH85dvEjkw,7071
@@ -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=kVRJwvHP683Sjhi2pnxwCwbaRl_uMQ2qFYSvt9kpfoU,18426
 uiprotect/websocket.py,sha256=JHI_2EZeRPqPyQopsBZS0dr3tu0HaTiqeLazfBXhW_8,7339
-uiprotect-1.18.0.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
-uiprotect-1.18.0.dist-info/METADATA,sha256=-XSKOa6e4RDLO-07RvVVy26J7ujyabN9FhC0UqneUa0,10985
-uiprotect-1.18.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-uiprotect-1.18.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
-uiprotect-1.18.0.dist-info/RECORD,,
+uiprotect-1.19.0.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-1.19.0.dist-info/METADATA,sha256=L8ov7HOBW9HUayl354kr_XlTo60zmbCvG0ZsMAAm98M,10985
+uiprotect-1.19.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+uiprotect-1.19.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-1.19.0.dist-info/RECORD,,