uiprotect 7.5.2__py3-none-any.whl → 7.32.0__py3-none-any.whl

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, Optional, 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"
@@ -50,7 +60,7 @@ EventCategories = Literal[
 ]
 
 ProgressCallback = Callable[[int, int, int], Coroutine[Any, Any, None]]
-IteratorCallback = Callable[[int, Optional[bytes]], Coroutine[Any, Any, None]]
+IteratorCallback = Callable[[int, bytes | None], Coroutine[Any, Any, None]]
 
 
 class FixSizeOrderedDict(dict[KT, VT]):
@@ -435,6 +445,8 @@ class VideoMode(str, ValuesEnumMixin, enum.Enum):
     HOMEKIT = "homekit"
     SPORT = "sport"
     SLOW_SHUTTER = "slowShutter"
+    LPR_NONE_REFLEX = "lprNoneReflex"
+    LPR_REFLEX = "lprReflex"
     # should only be for unadopted devices
     UNKNOWN = "unknown"
 
@@ -447,6 +459,7 @@ class AudioStyle(str, UnknownValuesEnumMixin, enum.Enum):
 
 @enum.unique
 class RecordingMode(str, ValuesEnumMixin, enum.Enum):
+    ADAPTIVE = "adaptive"
     ALWAYS = "always"
     NEVER = "never"
     SCHEDULE = "schedule"

uiprotect/stream.py

@@ -18,6 +18,12 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+CODEC_TO_ENCODER = {
+    "aac": {"encoder": "aac", "format": "adts"},
+    "opus": {"encoder": "libopus", "format": "rtp"},
+    "vorbis": {"encoder": "libvorbis", "format": "ogg"},
+}
+
 
 class FfmpegCommand:
     ffmpeg_path: Path | None
@@ -130,6 +136,11 @@ class TalkbackStream(FfmpegCommand):
         if len(input_args) > 0:
             input_args += " "
 
+        codec = camera.talkback_settings.type_fmt.value
+        encoder = CODEC_TO_ENCODER.get(codec)
+        if encoder is None:
+            raise ValueError(f"Unsupported codec: {codec}")
+
         # vn = no video
         # acodec = audio codec to encode output in (aac)
         # ac = number of output channels (1)
@@ -138,9 +149,9 @@ class TalkbackStream(FfmpegCommand):
         cmd = (
             "-loglevel info -hide_banner "
             f'{input_args}-i "{content_url}" -vn '
-            f"-acodec {camera.talkback_settings.type_fmt.value} -ac {camera.talkback_settings.channels} "
+            f"-acodec {encoder['encoder']} -ac {camera.talkback_settings.channels} "
             f"-ar {camera.talkback_settings.sampling_rate} -b:a {camera.talkback_settings.sampling_rate} -map 0:a "
-            f'-f adts "udp://{camera.host}:{camera.talkback_settings.bind_port}?bitrate={camera.talkback_settings.sampling_rate}"'
+            f'-f {encoder["format"]} "udp://{camera.host}:{camera.talkback_settings.bind_port}?bitrate={camera.talkback_settings.sampling_rate}"'
         )
 
         super().__init__(cmd, ffmpeg_path)

uiprotect/test_util/__init__.py

@@ -126,12 +126,12 @@ class SampleDataGenerator:
             "group": len(bootstrap["groups"]),
             "liveview": len(bootstrap["liveviews"]),
             "viewer": len(bootstrap["viewers"]),
-            "light": len(bootstrap["lights"]),
-            "bridge": len(bootstrap["bridges"]),
-            "sensor": len(bootstrap["sensors"]),
-            "doorlock": len(bootstrap["doorlocks"]),
-            "chime": len(bootstrap["chimes"]),
-            "aiport": len(bootstrap["aiports"]),
+            "light": len(bootstrap.get("lights", [])),
+            "bridge": len(bootstrap.get("bridges", [])),
+            "sensor": len(bootstrap.get("sensors", [])),
+            "doorlock": len(bootstrap.get("doorlocks", [])),
+            "chime": len(bootstrap.get("chimes", [])),
+            "aiport": len(bootstrap.get("aiports", [])),
         }
 
         self.log("Generating event data...")
@@ -142,6 +142,7 @@ class SampleDataGenerator:
 
         if close_session:
             await self.client.close_session()
+            await self.client.close_public_api_session()
 
         await self.write_json_file("sample_constants", self.constants, anonymize=False)
 
@@ -308,10 +309,18 @@ class SampleDataGenerator:
         await self.write_json_file("sample_camera", deepcopy(obj))
         self.constants["camera_online"] = camera_is_online
 
+        # Check if camera has channels
+        if not obj.get("channels") or len(obj["channels"]) == 0:
+            self.log(
+                "Camera has no channels, skipping snapshot, thumbnail and heatmap generation",
+            )
+            return
+
         if not camera_is_online:
             self.log(
                 "Camera is not online, skipping snapshot, thumbnail and heatmap generation",
             )
+            return
 
         # snapshot
         width = obj["channels"][0]["width"]
@@ -324,6 +333,15 @@ class SampleDataGenerator:
             snapshot = await self.client.get_camera_snapshot(obj["id"], width, height)
             await self.write_image_file(filename, snapshot)
 
+        # public api snapshot
+        pub_filename = "sample_camera_public_api_snapshot"
+        if self.anonymize:
+            self.log(f"Writing {pub_filename}...")
+            placeholder_image(self.output_folder / f"{pub_filename}.png", width, height)
+        else:
+            pub_snapshot = await self.client.get_public_api_camera_snapshot(obj["id"])
+            await self.write_image_file(pub_filename, pub_snapshot)
+
     async def generate_motion_data(
         self,
         motion_event: dict[str, Any] | None,
@@ -442,7 +460,12 @@ class SampleDataGenerator:
         await self.write_json_file("sample_sensor", obj)
 
     async def generate_lock_data(self) -> None:
-        objs = await self.client.api_request_list("doorlocks")
+        try:
+            objs = await self.client.api_request_list("doorlocks")
+        except BadRequest:
+            self.log("No doorlock endpoint available. Skipping doorlock endpoints...")
+            return
+
         device_id: str | None = None
         for obj_dict in objs:
             device_id = obj_dict["id"]

uiprotect/test_util/anonymize.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import secrets
 import string
 import uuid
+import warnings
 from typing import Any
 from urllib.parse import urlparse
 
-import typer
-
 from ..data import ModelType
 
 object_id_mapping: dict[str, str] = {}
@@ -72,7 +71,7 @@ def anonymize_user(user_dict: dict[str, Any]) -> dict[str, Any]:
     return user_dict
 
 
-def anonymize_value(value: Any, name: str | None = None) -> Any:
+def anonymize_value(value: Any, name: str | None = None) -> Any:  # noqa: PLR0912
     if isinstance(value, str):
         if name == "accessKey":
             value = f"{random_number(13)}:{random_hex(24)}:{random_hex(128)}"
@@ -105,13 +104,13 @@ def anonymize_value(value: Any, name: str | None = None) -> Any:
     return value
 
 
-def anonymize_dict(obj: dict[str, Any], name: str | None = None) -> dict[str, Any]:
+def anonymize_dict(obj: dict[str, Any], name: str | None = None) -> dict[str, Any]:  # noqa: PLR0912
     obj_type = None
     if "modelKey" in obj:
         if obj["modelKey"] in [m.value for m in ModelType]:
             obj_type = ModelType(obj["modelKey"])
         else:
-            typer.secho(f"Unknown modelKey: {obj['modelKey']}", fg="yellow")
+            warnings.warn(f"Unknown modelKey: {obj['modelKey']}", stacklevel=2)
 
     if obj_type == ModelType.USER:
         return anonymize_user(obj)

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
 
@@ -74,8 +71,6 @@ SNAKE_CASE_MATCH_3 = re.compile("([a-z0-9])([A-Z])")
 
 _LOGGER = logging.getLogger(__name__)
 
-RELEASE_CACHE = Path(__file__).parent / "release_cache.json"
-
 _CREATE_TYPES = {IPv6Address, IPv4Address, UUID, Color, Decimal, Path, Version}
 _BAD_UUID = "00000000-0000-00 0- 000-000000000000"
 
@@ -210,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:
+def convert_unifi_data(value: Any, field: FieldInfo) -> Any:  # noqa: PLR0911, PLR0912
     """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:
@@ -237,10 +231,13 @@ def convert_unifi_data(value: Any, field: FieldInfo) -> Any:
             # cannot do this check too soon because some types cannot be used in isinstance
             if isinstance(value, type_):
                 return value
-            # handle edge case for improperly formatted UUIDs
-            # 00000000-0000-00 0- 000-000000000000
-            if type_ is UUID and value == _BAD_UUID:
-                return _EMPTY_UUID
+            if type_ is UUID:
+                if not value:
+                    return None
+                # handle edge case for improperly formatted UUIDs
+                # 00000000-0000-00 0- 000-000000000000
+                if value == _BAD_UUID:
+                    return _EMPTY_UUID
             if (type_ is IPv4Address) and value == "":
                 return None
             return type_(value)
@@ -272,7 +269,7 @@ def _is_from_string_enum(type_: Any) -> bool:
     return hasattr(type_, "from_string")
 
 
-def serialize_unifi_obj(value: Any, levels: int = -1) -> Any:
+def serialize_unifi_obj(value: Any, levels: int = -1) -> Any:  # noqa: PLR0911
     """Serializes UFP data"""
     if unifi_dict := getattr(value, "unifi_dict", None):
         value = unifi_dict()
@@ -362,13 +359,41 @@ def convert_video_modes(items: Iterable[str]) -> list[VideoMode]:
     return types
 
 
-def ip_from_host(host: str) -> IPv4Address | IPv6Address:
+async def ip_from_host(host: str) -> IPv4Address | IPv6Address:
+    """
+    Resolve hostname to IP address (IPv4 or IPv6).
+
+    Raises:
+        ValueError: If host cannot be resolved to IP address
+
+    """
     try:
         return ip_address(host)
     except ValueError:
         pass
 
-    return ip_address(socket.gethostbyname(host))
+    try:
+        loop = asyncio.get_running_loop()
+        addr_info = await loop.getaddrinfo(host, None)
+        ip_str = addr_info[0][4][0]
+    except (socket.gaierror, OSError) as err:
+        raise ValueError(f"Cannot resolve hostname '{host}' to IP address") from err
+
+    return ip_address(ip_str)
+
+
+def format_host_for_url(host: IPv4Address | IPv6Address | str) -> str:
+    """Format host for URLs. IPv6 addresses are wrapped in brackets."""
+    if isinstance(host, str):
+        try:
+            parsed_host = ip_address(host)
+        except ValueError:
+            return host
+        host = parsed_host
+
+    if isinstance(host, IPv6Address):
+        return f"[{host}]"
+    return str(host)
 
 
 def dict_diff(orig: dict[str, Any] | None, new: dict[str, Any]) -> dict[str, Any]:
@@ -424,7 +449,7 @@ def print_ws_stat_summary(
 ) -> None:
     # typer<0.4.1 is incompatible with click>=8.1.0
     # allows only the CLI interface to break if both are installed
-    import typer
+    import typer  # noqa: PLC0415
 
     if output is None:
         output = typer.echo if typer is not None else print
@@ -519,7 +544,7 @@ def format_duration(duration: timedelta) -> str:
 
 
 def _set_timezone(tz: tzinfo | str) -> tzinfo:
-    global TIMEZONE_GLOBAL
+    global TIMEZONE_GLOBAL  # noqa: PLW0603
 
     if isinstance(tz, str):
         tz = zoneinfo.ZoneInfo(tz)
@@ -535,7 +560,9 @@ def get_local_timezone() -> tzinfo:
         return TIMEZONE_GLOBAL
 
     try:
-        from homeassistant.util import dt as dt_util  # type: ignore[import-not-found]
+        from homeassistant.util import (  # noqa: PLC0415
+            dt as dt_util,  # type: ignore[import-not-found]
+        )
 
         return _set_timezone(dt_util.DEFAULT_TIME_ZONE)
     except ImportError:
@@ -572,7 +599,7 @@ def local_datetime(dt: datetime | None = None) -> datetime:
 
 
 def log_event(event: Event) -> None:
-    from uiprotect.data import EventType
+    from uiprotect.data import EventType  # noqa: PLC0415
 
     _LOGGER.debug("event WS msg: %s", event.model_dump())
     if "smart" not in event.type.value:
@@ -699,3 +726,8 @@ def make_required_getter(ufp_required_field: str) -> Callable[[T], bool]:
 @lru_cache
 def timedelta_total_seconds(td: timedelta) -> float:
     return td.total_seconds()
+
+
+def pybool_to_json_bool(value: bool) -> str:
+    """Convert a Python bool to a JSON boolean string ('true'/'false')."""
+    return "true" if value else "false"

uiprotect/websocket.py

@@ -8,7 +8,7 @@ import logging
 from collections.abc import Awaitable, Callable, Coroutine
 from enum import Enum
 from http import HTTPStatus
-from typing import Any, Optional
+from typing import Any
 
 import aiohttp
 from aiohttp import (
@@ -24,7 +24,7 @@ from yarl import URL
 from .exceptions import NotAuthorized, NvrError
 
 _LOGGER = logging.getLogger(__name__)
-AuthCallbackType = Callable[..., Coroutine[Any, Any, Optional[dict[str, str]]]]
+AuthCallbackType = Callable[..., Coroutine[Any, Any, dict[str, str] | None]]
 GetSessionCallbackType = Callable[[], Awaitable[ClientSession]]
 UpdateBootstrapCallbackType = Callable[[], None]
 _CLOSE_MESSAGE_TYPES = {WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.CLOSED}
@@ -137,7 +137,7 @@ class Websocket:
                 if msg_type is WSMsgType.ERROR:
                     _LOGGER.exception("Error from Websocket: %s", msg.data)
                     break
-                elif msg_type in _CLOSE_MESSAGE_TYPES:
+                if msg_type in _CLOSE_MESSAGE_TYPES:
                     _LOGGER.debug("Websocket closed: %s", msg)
                     break
 

{uiprotect-7.5.2.dist-info → uiprotect-7.32.0.dist-info}/METADATA

@@ -1,13 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: uiprotect
-Version: 7.5.2
+Version: 7.32.0
 Summary: Python API for Unifi Protect (Unofficial)
+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
@@ -15,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)
@@ -92,6 +94,31 @@ Install this via pip (or your favorite package manager):
 
 `pip install uiprotect`
 
+## Developer Setup
+
+The recommended way to develop is using the provided **devcontainer** with VS Code:
+
+1. Install [VS Code](https://code.visualstudio.com/) and the [Dev Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
+2. Open the project in VS Code
+3. When prompted, click "Reopen in Container" (or use Command Palette: "Dev Containers: Reopen in Container")
+4. The devcontainer will automatically set up Python, Poetry, pre-commit hooks, and all dependencies
+
+Alternatively, if you want to develop natively without devcontainer:
+
+```bash
+# Install dependencies
+poetry install --with dev
+
+# Install pre-commit hooks
+poetry run pre-commit install --install-hooks
+
+# Run tests
+poetry run pytest
+
+# Run pre-commit checks manually
+poetry run pre-commit run --all-files
+```
+
 ## History
 
 This project was split off from `pyunifiprotect` because that project changed its license to one that would not be accepted in Home Assistant. This project is committed to keeping the MIT license.
@@ -122,14 +149,6 @@ The API is not documented by Ubiquiti, so there might be misses and/or frequent
 
 The module is primarily written for the purpose of being used in Home Assistant core [integration for UniFi Protect](https://www.home-assistant.io/integrations/unifiprotect) but might be used for other purposes also.
 
-## Smart Detections now Require Remote Access to enable
-
-Smart Detections (person, vehicle, animal, face), a feature that previously could be used with local only console, [now requires you to enable remote access to enable](https://community.ui.com/questions/Cannot-enable-Smart-Detections/e3d50641-5c00-4607-9723-453cda557e35#answer/1d146426-89aa-4022-a0ae-fd5000846028).
-
-Enabling Remote Access may grant other users access to your console [due to the fact Ubiquiti can reconfigure access controls at any time](https://community.ui.com/questions/Bug-Fix-Cloud-Access-Misconfiguration/fe8d4479-e187-4471-bf95-b2799183ceb7).
-
-If you are not okay with the feature being locked behind Remote Access, [let Ubiquiti know](https://community.ui.com/questions/Cannot-enable-Smart-Detections/e3d50641-5c00-4607-9723-453cda557e35).
-
 ## Documentation
 
 [Full documentation for the project](https://uiprotect.readthedocs.io/).
@@ -138,8 +157,8 @@ If you are not okay with the feature being locked behind Remote Access, [let Ubi
 
 If you want to install `uiprotect` natively, the below are the requirements:
 
-- [UniFi Protect](https://ui.com/camera-security) version 1.20+
-  - Latest version of library is generally only tested against the two latest minor version. This is either two latest stable versions (such as 1.21.x and 2.0.x) or the latest EA version and stable version (such as 2.2.x EA and 2.1.x).
+- [UniFi Protect](https://ui.com/camera-security) version 6.0+
+  - Only UniFi Protect version 6 and newer are supported. The library is generally tested against the latest stable version and the latest EA version.
 - [Python](https://www.python.org/) 3.10+
 - POSIX compatible system
   - Library is only tested on Linux, specifically the latest Debian version available for the official Python Docker images, but there is no reason the library should not work on any Linux distro or macOS.
@@ -177,7 +196,7 @@ function uiprotect() {
       -e UFP_PASSWORD=YOUR_PASSWORD_HERE \
       -e UFP_ADDRESS=YOUR_IP_ADDRESS \
       -e UFP_PORT=443 \
-      -e UFP_SSL_VERIFY=True \
+      -e UFP_SSL_VERIFY=false \
       -e TZ=America/New_York \
       -v $PWD:/data ghcr.io/uilibs/uiprotect:latest "$@"
 }
@@ -203,13 +222,42 @@ export UFP_USERNAME=YOUR_USERNAME_HERE
 export UFP_PASSWORD=YOUR_PASSWORD_HERE
 export UFP_ADDRESS=YOUR_IP_ADDRESS
 export UFP_PORT=443
-# change to false if you do not have a valid HTTPS certificate for your instance
-export UFP_SSL_VERIFY=True
+# set to true if you have a valid HTTPS certificate for your instance
+export UFP_SSL_VERIFY=false
+
+# Alternatively, use an API key for authentication (required for public API operations)
+export UFP_API_KEY=YOUR_API_KEY_HERE
 
 uiprotect --help
 uiprotect nvr
 ```
 
+#### Available CLI Commands
+
+**Top-level commands:**
+
+- `uiprotect shell` - Start an interactive Python shell with the API client
+- `uiprotect create-api-key <name>` - Create a new API key for authentication
+- `uiprotect get-meta-info` - Get metadata information
+- `uiprotect generate-sample-data` - Generate sample data for testing
+- `uiprotect profile-ws` - Profile WebSocket performance
+- `uiprotect decode-ws-msg` - Decode WebSocket messages
+
+**Device management commands:**
+
+- `uiprotect nvr` - NVR information and settings
+- `uiprotect events` - Event management and export
+- `uiprotect cameras` - Camera management
+- `uiprotect lights` - Light device management
+- `uiprotect sensors` - Sensor management
+- `uiprotect viewers` - Viewer management
+- `uiprotect liveviews` - Live view configuration
+- `uiprotect chimes` - Chime management
+- `uiprotect doorlocks` - Door lock management
+- `uiprotect aiports` - AI port management
+
+For more details on any command, use `uiprotect <command> --help`.
+
 ### Python
 
 UniFi Protect itself is 100% async, so as such this library is primarily designed to be used in an async context.
@@ -219,8 +267,12 @@ The main interface for the library is the `uiprotect.ProtectApiClient`:
 ```python
 from uiprotect import ProtectApiClient
 
+# Initialize with username/password
 protect = ProtectApiClient(host, port, username, password, verify_ssl=True)
 
+# Or with API key (required for public API operations)
+protect = ProtectApiClient(host, port, username, password, api_key=api_key, verify_ssl=True)
+
 await protect.update() # this will initialize the protect .bootstrap and open a Websocket connection for updates
 
 # get names of your cameras
@@ -240,6 +292,8 @@ unsub()
 
 ## TODO / Planned / Not Implemented
 
+Switching from Protect Private API to the New Public API
+
 Generally any feature missing from the library is planned to be done eventually / nice to have with the following exceptions
 
 ### UniFi OS Features
@@ -254,5 +308,4 @@ Anything that is strictly a UniFi OS feature. If it is ever done, it will be in
 Some features that require an Ubiquiti Account or "Remote Access" to be enabled are currently not implemented. Examples include:
 
 - Stream sharing
-- Face detection
 

uiprotect-7.32.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+uiprotect/__init__.py,sha256=Oz6i1tonIz4QWVnEPkbielJDJ3WQdwZVgYtjY4IwGAQ,636
+uiprotect/__main__.py,sha256=C_bHCOkv5qj6WMy-6ELoY3Y6HDhLxOa1a30CzmbZhsg,462
+uiprotect/_compat.py,sha256=HThmb1zQZCEssCxYYbQzFhJq8zYYlVaSnIEZabKc-6U,302
+uiprotect/api.py,sha256=5wOjGvi4NfevJWooHD12X-hmjI9l2BW1yrbIyT_Cocg,101631
+uiprotect/cli/__init__.py,sha256=BvmuccQA16q4__YXnig4vhwMqfeXwEH1V3kNiCmroRU,11905
+uiprotect/cli/aiports.py,sha256=22sC-OVkUFfBGJR2oID8QzWsk4GQfLEmam06-LBP2Z0,1545
+uiprotect/cli/backup.py,sha256=lC44FujSYgVBUs32CbsY8pBejO4qScy6U94UzO-l2fc,36742
+uiprotect/cli/base.py,sha256=FojWPuLHlZ3kpn7WZTQjCbWwweWtP-xDpmtT88xAcds,7565
+uiprotect/cli/cameras.py,sha256=sdlhrQj2o63Se9hgZeiZs7HIMJrtaPH702ExIGYcTEU,21328
+uiprotect/cli/chimes.py,sha256=5-ARR0hVsmg8EvtCQMllCvIsHHjB81hfVdgG8Y6ZEOw,5283
+uiprotect/cli/doorlocks.py,sha256=zoRYE0IsnEI0x7t8aBj08GFZeDNnDGe5IrUFpP6Mxqk,3489
+uiprotect/cli/events.py,sha256=x2a9-18Bt-SPqz1xwNH4CjKAtvbIrpeOiUwSQj065BA,7137
+uiprotect/cli/lights.py,sha256=U7K-YHg2nnsfZfcpjJr5RB0UUVbd3Vn5nlDIA6ng6yo,3530
+uiprotect/cli/liveviews.py,sha256=wJLJh33UVqSOB6UpQhR3tO--CXxGTtJz_WBhPLZLPkc,1832
+uiprotect/cli/nvr.py,sha256=TwxEg2XT8jXAbOqv6gc7KFXELKadeItEDYweSL4_-e8,4260
+uiprotect/cli/sensors.py,sha256=crz_R52X7EFKQtBgL2QzacThExOOoN5NubERQuw5jpk,8119
+uiprotect/cli/viewers.py,sha256=IgJpOzwdo9HVs55Osf3uC5d0raeU19WFIW-RfrnnOug,2137
+uiprotect/data/__init__.py,sha256=audwJBjxRiYdNPeYlP6iofFIOq3gyQzh6VpDsOCM2dQ,2964
+uiprotect/data/base.py,sha256=_xFBNq6Uwd8u1gRy8Z3K4-qnhDTWy0L8F6m7qSBzvPw,35533
+uiprotect/data/bootstrap.py,sha256=ZZD8f1uz2nOWogedFQJWvLuFllcdaoYAYbL4uWEDdG4,23853
+uiprotect/data/convert.py,sha256=xEN878_hm0HZZCVYGwJSxcSp2as9zpkvsemVIibReOA,2628
+uiprotect/data/devices.py,sha256=8ntKqhtRNSE6eL9HYWyqHrAnlBt4yNTY2DUMf3au1z4,120633
+uiprotect/data/nvr.py,sha256=53PGBaduKyLp1mFFiBaBpzlX0IMGrgsmTa8r-hFsX2k,51060
+uiprotect/data/types.py,sha256=szB5vOzLaiJm0o3Lhdtaoawq54kNtiOFMWKjfSVuy4o,19869
+uiprotect/data/user.py,sha256=Del5LUmt5uCfAQMI9-kl_GaKm085oTLjxmcCrlEKXxc,10526
+uiprotect/data/websocket.py,sha256=m4EV1Qfh08eKOihy70ycViYgEQpeNSGZQJWdtGIYJDA,6791
+uiprotect/exceptions.py,sha256=kgn0cRM6lTtgLza09SDa3ZiX6ue1QqHCOogQ4qu6KTQ,965
+uiprotect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uiprotect/release_cache.json,sha256=NamnSFy78hOWY0DPO87J9ELFCAN6NnVquv8gQO75ZG4,386
+uiprotect/stream.py,sha256=ls65vMOXF4IlJ5axewFITfhcaTh_ihaFeCkCTfhy0Nk,5168
+uiprotect/test_util/__init__.py,sha256=W57cVs3F6lv1F7wZd7In4UMo66l1JU68J3CeHr2fieY,20276
+uiprotect/test_util/anonymize.py,sha256=GTtl-SSFS0gjhWK9Jlrk70RB78w6_spYKa-VM0jhAD4,8517
+uiprotect/utils.py,sha256=id5_3jbseiJfULH0g0bCkU-9wHEyM5I-TgqyPuOUlHU,21533
+uiprotect/websocket.py,sha256=BedfEVLWhiTP5Il4ULerw2cUNGlr2OLyb_91QOh3iSs,8176
+uiprotect-7.32.0.dist-info/METADATA,sha256=eDJdE_Xq85TZ5xuhiF8dFKc9jYw6HEPC8tMcve3KGkY,12409
+uiprotect-7.32.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+uiprotect-7.32.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-7.32.0.dist-info/licenses/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-7.32.0.dist-info/RECORD,,

{uiprotect-7.5.2.dist-info → uiprotect-7.32.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any