uiprotect 7.21.1__tar.gz → 7.23.0__tar.gz

{uiprotect-7.21.1 → uiprotect-7.23.0}/PKG-INFO

@@ -1,14 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: uiprotect
-Version: 7.21.1
+Version: 7.23.0
 Summary: Python API for Unifi Protect (Unofficial)
-License: MIT
+License-Expression: MIT
+License-File: LICENSE
 Author: UI Protect Maintainers
 Author-email: ui@koston.org
 Requires-Python: >=3.10
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: aiofiles (>=24)

{uiprotect-7.21.1 → uiprotect-7.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uiprotect"
-version = "7.21.1"
+version = "7.23.0"
 license = "MIT"
 description = "Python API for Unifi Protect (Unofficial)"
 authors = [{ name = "UI Protect Maintainers", email = "ui@koston.org" }]
@@ -52,17 +52,17 @@ pydantic-extra-types = ">=2.10.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=7,<9"
-pytest-cov = ">=3,<7"
+pytest-cov = ">=3,<8"
 aiosqlite = ">=0.20.0"
 asttokens = ">=2.4.1,<4.0.0"
-pytest-asyncio = ">=0.23.7,<1.2.0"
+pytest-asyncio = ">=0.23.7,<1.3.0"
 pytest-benchmark = ">=4,<6"
-pytest-sugar = "^1.0.0"
+pytest-sugar = "^1.1.1"
 pytest-timeout = "^2.4.0"
 pytest-xdist = "^3.7.0"
-types-aiofiles = ">=23.2.0.20240403,<25.0.0.0"
+types-aiofiles = ">=23.2.0.20240403,<26.0.0.0"
 types-dateparser = "^1.2.2.20250809"
-mypy = "^1.17.1"
+mypy = "^1.18.2"
 
 [tool.poetry.group.docs]
 optional = true
@@ -73,13 +73,13 @@ sphinx = { version = ">=4.0", python = ">=3.11"}
 furo = { version = ">=2023.5.20", python = ">=3.11"}
 sphinx-autobuild = { version = ">=2024.0.0", python = ">=3.11"}
 mike = "^2.1.1"
-mkdocs-material = "^9.6.16"
+mkdocs-material = "^9.6.21"
 mkdocs-material-extensions = "^1.3.1"
 pymdown-extensions = "^10.16.1"
 mkdocs-git-revision-date-localized-plugin = "^1.4.7"
 mkdocs-include-markdown-plugin = ">=6.1.1,<8.0.0"
 mkdocstrings = ">=0.25.1,<0.31.0"
-mkdocstrings-python = "^1.16.12"
+mkdocstrings-python = "^1.18.2"
 
 [tool.semantic_release]
 version_toml = ["pyproject.toml:project.version"]
@@ -148,7 +148,6 @@ ignore = [
     "S110", # `try`-`except`-`pass` detected, consider logging the exception
     "D106", # Missing docstring in public nested class
     "UP007", # typer needs Optional syntax
-    "UP038", # Use `X | Y` in `isinstance` is slower
     "S603", #  check for execution of untrusted input
     "PERF203", # too many to fix right now
 ]

{uiprotect-7.21.1 → uiprotect-7.23.0}/src/uiprotect/api.py

@@ -54,6 +54,7 @@ from .data import (
     SmartDetectTrack,
     Version,
     Viewer,
+    WSAction,
     WSPacket,
     WSSubscriptionMessage,
     create_from_unifi_dict,
@@ -217,10 +218,14 @@ class BaseApiClient:
 
     headers: dict[str, str] | None = None
     _private_websocket: Websocket | None = None
+    _events_websocket: Websocket | None = None
+    _devices_websocket: Websocket | None = None
 
     private_api_path: str = "/proxy/protect/api/"
     public_api_path: str = "/proxy/protect/integration"
     private_ws_path: str = "/proxy/protect/ws/updates"
+    events_ws_path: str = "/proxy/protect/integration/v1/subscribe/events"
+    devices_ws_path: str = "/proxy/protect/integration/v1/subscribe/devices"
 
     cache_dir: Path
     config_dir: Path
@@ -276,9 +281,17 @@ class BaseApiClient:
         if self._port != 443:
             self._url = URL(f"https://{self._host}:{self._port}")
             self._ws_url = URL(f"wss://{self._host}:{self._port}{self.private_ws_path}")
+            self._events_ws_url = URL(
+                f"https://{self._host}:{self._port}{self.events_ws_path}"
+            )
+            self._devices_ws_url = URL(
+                f"https://{self._host}:{self._port}{self.devices_ws_path}"
+            )
         else:
             self._url = URL(f"https://{self._host}")
             self._ws_url = URL(f"wss://{self._host}{self.private_ws_path}")
+            self._events_ws_url = URL(f"https://{self._host}{self.events_ws_path}")
+            self._devices_ws_url = URL(f"https://{self._host}{self.devices_ws_path}")
 
         self.base_url = str(self._url)
 
@@ -294,6 +307,16 @@ class BaseApiClient:
         """Get Websocket URL."""
         return str(self._ws_url_object)
 
+    @property
+    def events_ws_url(self) -> str:
+        """Get Events Websocket URL."""
+        return str(self._events_ws_url)
+
+    @property
+    def devices_ws_url(self) -> str:
+        """Get Devices Websocket URL."""
+        return str(self._devices_ws_url)
+
     @property
     def config_file(self) -> Path:
         return self.config_dir / "unifi_protect.json"
@@ -329,6 +352,15 @@ class BaseApiClient:
         await self.ensure_authenticated()
         return self.headers
 
+    async def _auth_public_api_websocket(
+        self, force: bool = False
+    ) -> dict[str, str] | None:
+        """Authenticate for Public API Websocket."""
+        if self._api_key is None:
+            raise NotAuthorized("API key is required for public API WebSocket")
+
+        return {"X-API-KEY": self._api_key}
+
     def _get_websocket(self) -> Websocket:
         """Gets or creates current Websocket."""
         if self._private_websocket is None:
@@ -345,6 +377,38 @@ class BaseApiClient:
             )
         return self._private_websocket
 
+    def _get_events_websocket(self) -> Websocket:
+        """Gets or creates current Events Websocket."""
+        if self._events_websocket is None:
+            self._events_websocket = Websocket(
+                lambda: self._events_ws_url,
+                self._auth_public_api_websocket,
+                lambda: None,
+                self.get_public_api_session,
+                self._process_events_ws_message,
+                self._on_events_websocket_state_change,
+                verify=self._verify_ssl,
+                timeout=self._ws_timeout,
+                receive_timeout=self._ws_receive_timeout,
+            )
+        return self._events_websocket
+
+    def _get_devices_websocket(self) -> Websocket:
+        """Gets or creates current Devices Websocket."""
+        if self._devices_websocket is None:
+            self._devices_websocket = Websocket(
+                lambda: self._devices_ws_url,
+                self._auth_public_api_websocket,
+                lambda: None,
+                self.get_public_api_session,
+                self._process_devices_ws_message,
+                self._on_devices_websocket_state_change,
+                verify=self._verify_ssl,
+                timeout=self._ws_timeout,
+                receive_timeout=self._ws_receive_timeout,
+            )
+        return self._devices_websocket
+
     def _update_bootstrap_soon(self) -> None:
         """Update bootstrap soon."""
         _LOGGER.debug("Updating bootstrap soon")
@@ -781,10 +845,28 @@ class BaseApiClient:
             websocket.stop()
             await websocket.wait_closed()
             self._private_websocket = None
+        if self._events_websocket:
+            events_websocket = self._get_events_websocket()
+            events_websocket.stop()
+            await events_websocket.wait_closed()
+            self._events_websocket = None
+        if self._devices_websocket:
+            devices_websocket = self._get_devices_websocket()
+            devices_websocket.stop()
+            await devices_websocket.wait_closed()
+            self._devices_websocket = None
 
     def _process_ws_message(self, msg: aiohttp.WSMessage) -> None:
         raise NotImplementedError
 
+    def _process_events_ws_message(self, msg: aiohttp.WSMessage) -> None:
+        """Process events websocket message - to be implemented by subclass."""
+        raise NotImplementedError
+
+    def _process_devices_ws_message(self, msg: aiohttp.WSMessage) -> None:
+        """Process devices websocket message - to be implemented by subclass."""
+        raise NotImplementedError
+
     def _get_last_update_id(self) -> str | None:
         raise NotImplementedError
 
@@ -795,6 +877,14 @@ class BaseApiClient:
         """Websocket state changed."""
         _LOGGER.debug("Websocket state changed: %s", state)
 
+    def _on_events_websocket_state_change(self, state: WebsocketState) -> None:
+        """Events websocket state changed."""
+        _LOGGER.debug("Events websocket state changed: %s", state)
+
+    def _on_devices_websocket_state_change(self, state: WebsocketState) -> None:
+        """Devices websocket state changed."""
+        _LOGGER.debug("Devices websocket state changed: %s", state)
+
 
 class ProtectApiClient(BaseApiClient):
     """
@@ -832,7 +922,11 @@ class ProtectApiClient(BaseApiClient):
     _subscribed_models: set[ModelType]
     _ignore_stats: bool
     _ws_subscriptions: list[Callable[[WSSubscriptionMessage], None]]
+    _events_ws_subscriptions: list[Callable[[WSSubscriptionMessage], None]]
+    _devices_ws_subscriptions: list[Callable[[WSSubscriptionMessage], None]]
     _ws_state_subscriptions: list[Callable[[WebsocketState], None]]
+    _events_ws_state_subscriptions: list[Callable[[WebsocketState], None]]
+    _devices_ws_state_subscriptions: list[Callable[[WebsocketState], None]]
     _bootstrap: Bootstrap | None = None
     _last_update_dt: datetime | None = None
     _connection_host: IPv4Address | IPv6Address | str | None = None
@@ -881,7 +975,11 @@ class ProtectApiClient(BaseApiClient):
         self._subscribed_models = subscribed_models or set()
         self._ignore_stats = ignore_stats
         self._ws_subscriptions = []
+        self._events_ws_subscriptions = []
+        self._devices_ws_subscriptions = []
         self._ws_state_subscriptions = []
+        self._events_ws_state_subscriptions = []
+        self._devices_ws_state_subscriptions = []
         self.ignore_unadopted = ignore_unadopted
         self._update_lock = asyncio.Lock()
 
@@ -989,6 +1087,62 @@ class ProtectApiClient(BaseApiClient):
             except Exception:
                 _LOGGER.exception("Exception while running subscription handler")
 
+    def emit_events_message(self, msg: WSSubscriptionMessage) -> None:
+        """Emit message to all events subscriptions."""
+        if _LOGGER.isEnabledFor(logging.DEBUG):
+            if msg.new_obj is not None:
+                _LOGGER.debug(
+                    "emitting events message: %s:%s:%s:%s",
+                    msg.action,
+                    msg.new_obj.model,
+                    msg.new_obj.id,
+                    list(msg.changed_data),
+                )
+            elif msg.old_obj is not None:
+                _LOGGER.debug(
+                    "emitting events message: %s:%s:%s",
+                    msg.action,
+                    msg.old_obj.model,
+                    msg.old_obj.id,
+                )
+            else:
+                _LOGGER.debug("emitting events message: %s", msg.action)
+
+        for sub in self._events_ws_subscriptions:
+            try:
+                sub(msg)
+            except Exception:
+                _LOGGER.exception("Exception while running events subscription handler")
+
+    def emit_devices_message(self, msg: WSSubscriptionMessage) -> None:
+        """Emit message to all devices subscriptions."""
+        if _LOGGER.isEnabledFor(logging.DEBUG):
+            if msg.new_obj is not None:
+                _LOGGER.debug(
+                    "emitting devices message: %s:%s:%s:%s",
+                    msg.action,
+                    msg.new_obj.model,
+                    msg.new_obj.id,
+                    list(msg.changed_data),
+                )
+            elif msg.old_obj is not None:
+                _LOGGER.debug(
+                    "emitting devices message: %s:%s:%s",
+                    msg.action,
+                    msg.old_obj.model,
+                    msg.old_obj.id,
+                )
+            else:
+                _LOGGER.debug("emitting devices message: %s", msg.action)
+
+        for sub in self._devices_ws_subscriptions:
+            try:
+                sub(msg)
+            except Exception:
+                _LOGGER.exception(
+                    "Exception while running devices subscription handler"
+                )
+
     def _get_last_update_id(self) -> str | None:
         if self._bootstrap is None:
             return None
@@ -1006,6 +1160,110 @@ class ProtectApiClient(BaseApiClient):
 
         self.emit_message(processed_message)
 
+    def _process_events_ws_message(self, msg: aiohttp.WSMessage) -> None:
+        """Process events websocket message (Public API - JSON format)."""
+        if msg.type != aiohttp.WSMsgType.TEXT:
+            _LOGGER.debug("Ignoring non-text websocket message: %s", msg.type)
+            return
+
+        try:
+            data = orjson.loads(msg.data)
+            action_type = data.get("type")  # "update", "add", "remove"
+            item = data.get("item", {})
+            model_key = item.get("modelKey")
+
+            if not action_type or not model_key:
+                _LOGGER.debug("Invalid public API websocket message: %s", data)
+                return
+
+            # Create a WSSubscriptionMessage similar to private WS
+            model_type = ModelType.from_string(model_key)
+
+            if model_type is ModelType.UNKNOWN:
+                _LOGGER.debug("Unknown model type in public API message: %s", model_key)
+                return
+
+            # Create proper objects from the data
+            new_obj: ProtectModelWithId | None = None
+            old_obj: ProtectModelWithId | None = None
+            update_id = item.get("id", "")
+
+            if action_type in ("add", "update"):
+                try:
+                    new_obj = cast(
+                        ProtectModelWithId, create_from_unifi_dict(item, api=self)
+                    )
+                except Exception:
+                    _LOGGER.debug(
+                        "Could not create object from public API data: %s", item
+                    )
+
+            msg_obj = WSSubscriptionMessage(
+                action=WSAction(action_type),
+                new_update_id=update_id,
+                changed_data=item,
+                new_obj=new_obj,
+                old_obj=old_obj,
+            )
+
+            self.emit_events_message(msg_obj)
+        except Exception as e:
+            _LOGGER.exception(
+                "Error processing public API events websocket message: %s", e
+            )
+
+    def _process_devices_ws_message(self, msg: aiohttp.WSMessage) -> None:
+        """Process devices websocket message (Public API - JSON format)."""
+        if msg.type != aiohttp.WSMsgType.TEXT:
+            _LOGGER.debug("Ignoring non-text websocket message: %s", msg.type)
+            return
+
+        try:
+            data = orjson.loads(msg.data)
+            action_type = data.get("type")  # "update", "add", "remove"
+            item = data.get("item", {})
+            model_key = item.get("modelKey")
+
+            if not action_type or not model_key:
+                _LOGGER.debug("Invalid public API websocket message: %s", data)
+                return
+
+            # Create a WSSubscriptionMessage similar to private WS
+            model_type = ModelType.from_string(model_key)
+
+            if model_type is ModelType.UNKNOWN:
+                _LOGGER.debug("Unknown model type in public API message: %s", model_key)
+                return
+
+            # Create proper objects from the data
+            new_obj: ProtectModelWithId | None = None
+            old_obj: ProtectModelWithId | None = None
+            update_id = item.get("id", "")
+
+            if action_type in ("add", "update"):
+                try:
+                    new_obj = cast(
+                        ProtectModelWithId, create_from_unifi_dict(item, api=self)
+                    )
+                except Exception:
+                    _LOGGER.debug(
+                        "Could not create object from public API data: %s", item
+                    )
+
+            msg_obj = WSSubscriptionMessage(
+                action=WSAction(action_type),
+                new_update_id=update_id,
+                changed_data=item,
+                new_obj=new_obj,
+                old_obj=old_obj,
+            )
+
+            self.emit_devices_message(msg_obj)
+        except Exception as e:
+            _LOGGER.exception(
+                "Error processing public API devices websocket message: %s", e
+            )
+
     async def _get_event_paginate(
         self,
         params: dict[str, Any],
@@ -1251,6 +1509,34 @@ class ProtectApiClient(BaseApiClient):
         self._get_websocket().start()
         return partial(self._unsubscribe_websocket, ws_callback)
 
+    def subscribe_events_websocket(
+        self,
+        ws_callback: Callable[[WSSubscriptionMessage], None],
+    ) -> Callable[[], None]:
+        """
+        Subscribe to events websocket events.
+
+        Returns a callback that will unsubscribe.
+        """
+        _LOGGER.debug("Adding events subscription: %s", ws_callback)
+        self._events_ws_subscriptions.append(ws_callback)
+        self._get_events_websocket().start()
+        return partial(self._unsubscribe_events_websocket, ws_callback)
+
+    def subscribe_devices_websocket(
+        self,
+        ws_callback: Callable[[WSSubscriptionMessage], None],
+    ) -> Callable[[], None]:
+        """
+        Subscribe to devices websocket events.
+
+        Returns a callback that will unsubscribe.
+        """
+        _LOGGER.debug("Adding devices subscription: %s", ws_callback)
+        self._devices_ws_subscriptions.append(ws_callback)
+        self._get_devices_websocket().start()
+        return partial(self._unsubscribe_devices_websocket, ws_callback)
+
     def _unsubscribe_websocket(
         self,
         ws_callback: Callable[[WSSubscriptionMessage], None],
@@ -1261,6 +1547,26 @@ class ProtectApiClient(BaseApiClient):
         if not self._ws_subscriptions:
             self._get_websocket().stop()
 
+    def _unsubscribe_events_websocket(
+        self,
+        ws_callback: Callable[[WSSubscriptionMessage], None],
+    ) -> None:
+        """Unsubscribe to events websocket events."""
+        _LOGGER.debug("Removing events subscription: %s", ws_callback)
+        self._events_ws_subscriptions.remove(ws_callback)
+        if not self._events_ws_subscriptions:
+            self._get_events_websocket().stop()
+
+    def _unsubscribe_devices_websocket(
+        self,
+        ws_callback: Callable[[WSSubscriptionMessage], None],
+    ) -> None:
+        """Unsubscribe to devices websocket events."""
+        _LOGGER.debug("Removing devices subscription: %s", ws_callback)
+        self._devices_ws_subscriptions.remove(ws_callback)
+        if not self._devices_ws_subscriptions:
+            self._get_devices_websocket().stop()
+
     def subscribe_websocket_state(
         self,
         ws_callback: Callable[[WebsocketState], None],
@@ -1273,6 +1579,30 @@ class ProtectApiClient(BaseApiClient):
         self._ws_state_subscriptions.append(ws_callback)
         return partial(self._unsubscribe_websocket_state, ws_callback)
 
+    def subscribe_events_websocket_state(
+        self,
+        ws_callback: Callable[[WebsocketState], None],
+    ) -> Callable[[], None]:
+        """
+        Subscribe to events websocket state changes.
+
+        Returns a callback that will unsubscribe.
+        """
+        self._events_ws_state_subscriptions.append(ws_callback)
+        return partial(self._unsubscribe_events_websocket_state, ws_callback)
+
+    def subscribe_devices_websocket_state(
+        self,
+        ws_callback: Callable[[WebsocketState], None],
+    ) -> Callable[[], None]:
+        """
+        Subscribe to devices websocket state changes.
+
+        Returns a callback that will unsubscribe.
+        """
+        self._devices_ws_state_subscriptions.append(ws_callback)
+        return partial(self._unsubscribe_devices_websocket_state, ws_callback)
+
     def _unsubscribe_websocket_state(
         self,
         ws_callback: Callable[[WebsocketState], None],
@@ -1280,6 +1610,20 @@ class ProtectApiClient(BaseApiClient):
         """Unsubscribe to websocket state changes."""
         self._ws_state_subscriptions.remove(ws_callback)
 
+    def _unsubscribe_events_websocket_state(
+        self,
+        ws_callback: Callable[[WebsocketState], None],
+    ) -> None:
+        """Unsubscribe to events websocket state changes."""
+        self._events_ws_state_subscriptions.remove(ws_callback)
+
+    def _unsubscribe_devices_websocket_state(
+        self,
+        ws_callback: Callable[[WebsocketState], None],
+    ) -> None:
+        """Unsubscribe to devices websocket state changes."""
+        self._devices_ws_state_subscriptions.remove(ws_callback)
+
     def _on_websocket_state_change(self, state: WebsocketState) -> None:
         """Websocket state changed."""
         super()._on_websocket_state_change(state)
@@ -1289,6 +1633,26 @@ class ProtectApiClient(BaseApiClient):
             except Exception:
                 _LOGGER.exception("Exception while running websocket state handler")
 
+    def _on_events_websocket_state_change(self, state: WebsocketState) -> None:
+        """Events Websocket state changed."""
+        for sub in self._events_ws_state_subscriptions:
+            try:
+                sub(state)
+            except Exception:
+                _LOGGER.exception(
+                    "Exception while running events websocket state handler"
+                )
+
+    def _on_devices_websocket_state_change(self, state: WebsocketState) -> None:
+        """Devices Websocket state changed."""
+        for sub in self._devices_ws_state_subscriptions:
+            try:
+                sub(state)
+            except Exception:
+                _LOGGER.exception(
+                    "Exception while running devices websocket state handler"
+                )
+
     async def get_bootstrap(self) -> Bootstrap:
         """
         Gets bootstrap object from UFP instance

{uiprotect-7.21.1 → uiprotect-7.23.0}/src/uiprotect/data/base.py

@@ -27,14 +27,12 @@ from ..utils import (
     to_snake_case,
 )
 from .types import (
-    SHAPE_DICT_V1,
-    SHAPE_LIST_V1,
     ModelType,
     PercentFloat,
     PermissionNode,
     ProtectWSPayloadFormat,
     StateType,
-    extract_type_shape,
+    get_field_type,
 )
 from .websocket import (
     WSJSONPacketFrame,
@@ -223,11 +221,11 @@ class ProtectBaseObject(BaseModel):
 
         for name, field in cls.model_fields.items():
             try:
-                type_, shape = extract_type_shape(field.annotation)  # type: ignore[arg-type]
+                origin, type_ = get_field_type(field.annotation)  # type: ignore[arg-type]
                 if _is_protect_base_object(type_):
-                    if shape == SHAPE_LIST_V1:
+                    if origin is list:
                         lists[name] = type_
-                    elif shape == SHAPE_DICT_V1:
+                    elif origin is dict:
                         dicts[name] = type_
                     else:
                         objs[name] = type_
@@ -489,8 +487,8 @@ class ProtectBaseObject(BaseModel):
             has_unifi_objs,
             unifi_lists,
             has_unifi_lists,
-            unifi_dicts,
-            has_unifi_dicts,
+            _unifi_dicts,
+            _has_unifi_dicts,
         ) = self._get_protect_model()
         api = self._api
         _fields = self.__class__.model_fields

{uiprotect-7.21.1 → uiprotect-7.23.0}/src/uiprotect/data/types.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
 import enum
-from collections.abc import Callable, Coroutine
+import types
+from collections.abc import Callable, Coroutine, Sequence
 from functools import cache, lru_cache
-from typing import Annotated, Any, Literal, TypeVar, Union
+from typing import Annotated, Any, Literal, TypeVar, Union, get_args, get_origin
 
 from packaging.version import Version as BaseVersion
 from pydantic import BaseModel, Field
 from pydantic.types import StringConstraints
-from pydantic.v1.config import BaseConfig as BaseConfigV1
-from pydantic.v1.fields import SHAPE_DICT as SHAPE_DICT_V1  # noqa: F401
-from pydantic.v1.fields import SHAPE_LIST as SHAPE_LIST_V1  # noqa: F401
-from pydantic.v1.fields import SHAPE_SET as SHAPE_SET_V1  # noqa: F401
-from pydantic.v1.fields import ModelField as ModelFieldV1
 from pydantic_extra_types.color import Color  # noqa: F401
 
 from .._compat import cached_property
@@ -21,20 +17,34 @@ KT = TypeVar("KT")
 VT = TypeVar("VT")
 
 
-class _BaseConfigV1(BaseConfigV1):
-    arbitrary_types_allowed = True
-    validate_assignment = True
-
-
 @lru_cache(maxsize=512)
-def extract_type_shape(annotation: type[Any] | None) -> tuple[Any, int]:
-    """Extract the type from a type hint."""
+def get_field_type(annotation: type[Any] | None) -> tuple[type | None, Any]:
+    """Extract the origin and type from an annotation."""
     if annotation is None:
         raise ValueError("Type annotation cannot be None")
-    v1_field = ModelFieldV1(
-        name="", type_=annotation, class_validators=None, model_config=_BaseConfigV1
-    )
-    return v1_field.type_, v1_field.shape
+    origin = get_origin(annotation)
+    args: Sequence[Any]
+    if origin in (list, set):
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return origin, args[0]
+    if origin is dict:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return origin, args[1]
+    if origin is Annotated:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return None, args[0]
+    if origin is Union or origin is types.UnionType:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        args = [get_field_type(arg) for arg in args]
+        if len(args) == 2 and type(None) in list(zip(*args, strict=False))[1]:
+            # Strip '| None' type from Union
+            return next(arg for arg in args if arg[1] is not type(None))
+        return None, annotation
+    return origin, annotation
 
 
 DEFAULT = "DEFAULT_VALUE"

{uiprotect-7.21.1 → uiprotect-7.23.0}/src/uiprotect/utils.py

@@ -32,15 +32,12 @@ from aiohttp import ClientResponse
 from pydantic.fields import FieldInfo
 
 from .data.types import (
-    SHAPE_DICT_V1,
-    SHAPE_LIST_V1,
-    SHAPE_SET_V1,
     Color,
     SmartDetectAudioType,
     SmartDetectObjectType,
     Version,
     VideoMode,
-    extract_type_shape,
+    get_field_type,
 )
 from .exceptions import NvrError
 
@@ -208,22 +205,21 @@ def to_camel_case(name: str) -> str:
 
 
 _EMPTY_UUID = UUID("0" * 32)
-_SHAPE_TYPES = {SHAPE_DICT_V1, SHAPE_SET_V1, SHAPE_LIST_V1}
 
 
 def convert_unifi_data(value: Any, field: FieldInfo) -> Any:
     """Converts value from UFP data into pydantic field class"""
-    type_, shape = extract_type_shape(field.annotation)  # type: ignore[arg-type]
+    origin, type_ = get_field_type(field.annotation)  # type: ignore[arg-type]
 
     if type_ is Any:
         return value
 
-    if shape in _SHAPE_TYPES:
-        if shape == SHAPE_LIST_V1 and isinstance(value, list):
+    if origin is not None:
+        if origin is list and isinstance(value, list):
             return [convert_unifi_data(v, field) for v in value]
-        if shape == SHAPE_SET_V1 and isinstance(value, list):
+        if origin is set and isinstance(value, list):
             return {convert_unifi_data(v, field) for v in value}
-        if shape == SHAPE_DICT_V1 and isinstance(value, dict):
+        if origin is dict and isinstance(value, dict):
             return {k: convert_unifi_data(v, field) for k, v in value.items()}
 
     if value is not None: