uiprotect 7.18.1__tar.gz → 7.20.0__tar.gz

{uiprotect-7.18.1 → uiprotect-7.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uiprotect
-Version: 7.18.1
+Version: 7.20.0
 Summary: Python API for Unifi Protect (Unofficial)
 License: MIT
 Author: UI Protect Maintainers

{uiprotect-7.18.1 → uiprotect-7.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uiprotect"
-version = "7.18.1"
+version = "7.20.0"
 license = "MIT"
 description = "Python API for Unifi Protect (Unofficial)"
 authors = [{ name = "UI Protect Maintainers", email = "ui@koston.org" }]
@@ -55,7 +55,7 @@ pytest = ">=7,<9"
 pytest-cov = ">=3,<7"
 aiosqlite = ">=0.20.0"
 asttokens = ">=2.4.1,<4.0.0"
-pytest-asyncio = ">=0.23.7,<1.1.0"
+pytest-asyncio = ">=0.23.7,<1.2.0"
 pytest-benchmark = ">=4,<6"
 pytest-sugar = "^1.0.0"
 pytest-timeout = "^2.4.0"
@@ -150,6 +150,7 @@ ignore = [
     "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
 ]
 select = [
     "B",   # flake8-bugbear
@@ -157,11 +158,15 @@ select = [
     "C4",  # flake8-comprehensions
     "S",   # flake8-bandit
     "F",   # pyflake
+    "FURB", # refurb rules
     "E",   # pycodestyle
     "W",   # pycodestyle
     "UP",  # pyupgrade
     "I",   # isort
+    "PERF", # performance
+    "RET", # return rules
     "RUF", # ruff specific
+    "SIM", # simplify
 ]
 
 [tool.ruff.lint.per-file-ignores]

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/api.py

@@ -27,6 +27,7 @@ from aiohttp import CookieJar, client_exceptions
 from platformdirs import user_cache_dir, user_config_dir
 from yarl import URL
 
+from uiprotect.data.base import ProtectBaseObject
 from uiprotect.data.convert import list_from_unifi_list
 from uiprotect.data.nvr import MetaInfo
 from uiprotect.data.user import Keyring, Keyrings, UlpUser, UlpUsers
@@ -157,6 +158,46 @@ def get_user_hash(host: str, username: str) -> str:
     return session.hexdigest()
 
 
+class RTSPSStreams(ProtectBaseObject):
+    """RTSPS stream URLs for a camera."""
+
+    model_config = {"extra": "allow"}
+    # Intentionally no variables like 'high', 'medium', 'low' are defined here.
+    # The API naming appears inconsistent - what's called "quality" might actually be "channels".
+    # Besides standard qualities (high/medium/low), there are special cases like "package" for doorbells
+    # and unclear implementation for 180° cameras with dual sensors. Dynamic handling via __pydantic_extra__ is safer.
+
+    def get_stream_url(self, quality: str) -> str | None:
+        """Get stream URL for a specific quality level."""
+        return getattr(self, quality, None)
+
+    def get_available_stream_qualities(self) -> list[str]:
+        """Get list of available RTSPS stream quality levels (including inactive ones with null values)."""
+        if self.__pydantic_extra__ is None:
+            return []
+        return list(self.__pydantic_extra__.keys())
+
+    def get_active_stream_qualities(self) -> list[str]:
+        """Get list of currently active RTSPS stream quality levels (only those with stream URLs)."""
+        if self.__pydantic_extra__ is None:
+            return []
+        return [
+            key
+            for key, value in self.__pydantic_extra__.items()
+            if isinstance(value, str) and value is not None
+        ]
+
+    def get_inactive_stream_qualities(self) -> list[str]:
+        """Get list of inactive RTSPS stream quality levels (supported but not currently active)."""
+        if self.__pydantic_extra__ is None:
+            return []
+        return [
+            key
+            for key, value in self.__pydantic_extra__.items()
+            if not (isinstance(value, str) and value is not None)
+        ]
+
+
 class BaseApiClient:
     _host: str
     _port: int
@@ -443,7 +484,8 @@ class BaseApiClient:
         )
 
         try:
-            if response.status != 200:
+            # Check for successful status codes (2xx range)
+            if not (200 <= response.status < 300):
                 await self._raise_for_status(response, raise_exception)
                 return None
 
@@ -466,16 +508,20 @@ class BaseApiClient:
         msg = "Request failed: %s - Status: %s - Reason: %s"
         status = response.status
 
+        # Success status codes (2xx) should not raise exceptions
+        if 200 <= status < 300:
+            return
+
         if raise_exception:
             if status in {
                 HTTPStatus.UNAUTHORIZED.value,
                 HTTPStatus.FORBIDDEN.value,
             }:
                 raise NotAuthorized(msg % (url, status, reason))
-            elif status == HTTPStatus.TOO_MANY_REQUESTS.value:
+            if status == HTTPStatus.TOO_MANY_REQUESTS.value:
                 _LOGGER.debug("Too many requests - Login is rate limited: %s", response)
                 raise NvrError(msg % (url, status, reason))
-            elif (
+            if (
                 status >= HTTPStatus.BAD_REQUEST.value
                 and status < HTTPStatus.INTERNAL_SERVER_ERROR.value
             ):
@@ -1533,6 +1579,83 @@ class ProtectApiClient(BaseApiClient):
             params={"highQuality": pybool_to_json_bool(high_quality)},
         )
 
+    async def create_camera_rtsps_streams(
+        self,
+        camera_id: str,
+        qualities: list[str] | str,
+    ) -> RTSPSStreams | None:
+        """Creates RTSPS streams for a camera using public API."""
+        if isinstance(qualities, str):
+            qualities = [qualities]
+
+        data = {"qualities": qualities}
+        response = await self.api_request_raw(
+            public_api=True,
+            url=f"/v1/cameras/{camera_id}/rtsps-stream",
+            method="POST",
+            json=data,
+        )
+
+        if response is None:
+            return None
+
+        try:
+            response_json = orjson.loads(response)
+            return RTSPSStreams(**response_json)
+        except (orjson.JSONDecodeError, TypeError) as ex:
+            _LOGGER.error(
+                "Could not decode JSON response for create RTSPS streams (camera %s): %s",
+                camera_id,
+                ex,
+            )
+            return None
+
+    async def get_camera_rtsps_streams(
+        self,
+        camera_id: str,
+    ) -> RTSPSStreams | None:
+        """Gets existing RTSPS streams for a camera using public API."""
+        response = await self.api_request_raw(
+            public_api=True,
+            url=f"/v1/cameras/{camera_id}/rtsps-stream",
+            method="GET",
+        )
+
+        if response is None:
+            return None
+
+        try:
+            response_json = orjson.loads(response)
+            return RTSPSStreams(**response_json)
+        except (orjson.JSONDecodeError, TypeError) as ex:
+            _LOGGER.error(
+                "Could not decode JSON response for get RTSPS streams (camera %s): %s",
+                camera_id,
+                ex,
+            )
+            return None
+
+    async def delete_camera_rtsps_streams(
+        self,
+        camera_id: str,
+        qualities: list[str] | str,
+    ) -> bool:
+        """Deletes RTSPS streams for a camera using public API."""
+        if isinstance(qualities, str):
+            qualities = [qualities]
+
+        # Build query parameters for qualities
+        params = [("qualities", quality) for quality in qualities]
+
+        response = await self.api_request_raw(
+            public_api=True,
+            url=f"/v1/cameras/{camera_id}/rtsps-stream",
+            method="DELETE",
+            params=params,
+        )
+
+        return response is not None
+
     async def get_package_camera_snapshot(
         self,
         camera_id: str,
@@ -2120,6 +2243,17 @@ class ProtectApiClient(BaseApiClient):
 
         return response["data"]["full_api_key"]
 
+    def set_api_key(self, api_key: str) -> None:
+        """Set the API key for the NVR."""
+        if not api_key:
+            raise BadRequest("API key cannot be empty")
+
+        self._api_key = api_key
+
+    def is_api_key_set(self) -> bool:
+        """Check if the API key is set."""
+        return bool(self._api_key)
+
     async def get_meta_info(self) -> MetaInfo:
         """Get metadata about the NVR."""
         data = await self.api_request(

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/cli/__init__.py

@@ -61,12 +61,10 @@ OPTION_PASSWORD = typer.Option(
     envvar="UFP_PASSWORD",
 )
 OPTION_API_KEY = typer.Option(
-    ...,
+    None,
     "--api-key",
     "-k",
-    help="UniFi Protect API key",
-    prompt=True,
-    hide_input=True,
+    help="UniFi Protect API key (required for public API operations)",
     envvar="UFP_API_KEY",
 )
 OPTION_ADDRESS = typer.Option(
@@ -149,7 +147,7 @@ def main(
     ctx: typer.Context,
     username: str = OPTION_USERNAME,
     password: str = OPTION_PASSWORD,
-    api_key: str = OPTION_API_KEY,
+    api_key: str | None = OPTION_API_KEY,
     address: str = OPTION_ADDRESS,
     port: int = OPTION_PORT,
     verify: bool = OPTION_VERIFY,

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/cli/cameras.py

@@ -572,3 +572,118 @@ def set_lcd_text(
     obj: d.Camera = ctx.obj.device
 
     base.run(ctx, obj.set_lcd_text(text_type, text, reset_at))
+
+
+@app.command()
+def create_rtsps_streams(
+    ctx: typer.Context,
+    qualities: list[str] = typer.Argument(
+        ...,
+        help="List of stream qualities to create (e.g., high medium low)",
+    ),
+) -> None:
+    """
+    Creates RTSPS streams for camera.
+
+    Available qualities are typically: high, medium, low, ultra.
+    Requires API key authentication and public API access.
+    """
+    base.require_device_id(ctx)
+    obj: d.Camera = ctx.obj.device
+
+    async def create_streams() -> None:
+        try:
+            result = await obj.create_rtsps_streams(qualities)
+            if result is None:
+                typer.secho("Failed to create RTSPS streams", fg="red")
+                raise typer.Exit(1)
+
+            if ctx.obj.output_format == base.OutputFormatEnum.JSON:
+                stream_data = {
+                    quality: result.get_stream_url(quality)
+                    for quality in result.get_available_stream_qualities()
+                }
+                base.json_output(stream_data)
+            else:
+                for quality in result.get_available_stream_qualities():
+                    url = result.get_stream_url(quality)
+                    typer.echo(f"{quality:10}\t{url}")
+        except Exception as e:
+            typer.secho(f"Error creating RTSPS streams: {e}", fg="red")
+            raise typer.Exit(1) from e
+
+    base.run(ctx, create_streams())
+
+
+@app.command()
+def get_rtsps_streams(ctx: typer.Context) -> None:
+    """
+    Gets existing RTSPS streams for camera.
+
+    Requires API key authentication and public API access.
+    """
+    base.require_device_id(ctx)
+    obj: d.Camera = ctx.obj.device
+
+    async def get_streams() -> None:
+        try:
+            result = await obj.get_rtsps_streams()
+            if result is None:
+                typer.secho("No RTSPS streams found or failed to retrieve", fg="yellow")
+                return
+
+            if ctx.obj.output_format == base.OutputFormatEnum.JSON:
+                stream_data = {
+                    quality: result.get_stream_url(quality)
+                    for quality in result.get_available_stream_qualities()
+                }
+                base.json_output(stream_data)
+            else:
+                available_qualities = result.get_available_stream_qualities()
+                if not available_qualities:
+                    typer.echo("No RTSPS streams available")
+                else:
+                    for quality in available_qualities:
+                        url = result.get_stream_url(quality)
+                        typer.echo(f"{quality:10}\t{url}")
+        except Exception as e:
+            typer.secho(f"Error getting RTSPS streams: {e}", fg="red")
+            raise typer.Exit(1) from e
+
+    base.run(ctx, get_streams())
+
+
+@app.command()
+def delete_rtsps_streams(
+    ctx: typer.Context,
+    qualities: list[str] = typer.Argument(
+        ...,
+        help="List of stream qualities to delete (e.g., high medium low)",
+    ),
+) -> None:
+    """
+    Deletes RTSPS streams for camera.
+
+    Requires API key authentication and public API access.
+    """
+    base.require_device_id(ctx)
+    obj: d.Camera = ctx.obj.device
+
+    async def delete_streams() -> None:
+        try:
+            result = await obj.delete_rtsps_streams(qualities)
+            if result:
+                typer.secho(
+                    f"Successfully deleted RTSPS streams: {', '.join(qualities)}",
+                    fg="green",
+                )
+            else:
+                typer.secho(
+                    f"Failed to delete RTSPS streams: {', '.join(qualities)}", fg="red"
+                )
+                raise typer.Exit(1)
+        except Exception as e:
+            typer.secho(f"Error deleting RTSPS streams: {e}", fg="red")
+            raise typer.Exit(1) from e
+
+    base.run(ctx, delete_streams())

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/data/bootstrap.py

@@ -420,7 +420,7 @@ class Bootstrap(ProtectBaseObject):
                 changed_data=add_obj.model_dump(),
                 new_obj=add_obj,
             )
-        elif action_type == "remove":
+        if action_type == "remove":
             to_remove = obj_from_bootstrap.by_id(action_id)
             if to_remove is None:
                 return None
@@ -431,7 +431,7 @@ class Bootstrap(ProtectBaseObject):
                 changed_data={},
                 old_obj=to_remove,
             )
-        elif action_type == "update":
+        if action_type == "update":
             updated_obj = obj_from_bootstrap.by_id(action_id)
             if updated_obj is None:
                 return None

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/data/devices.py

@@ -80,6 +80,7 @@ from .types import (
 from .user import User
 
 if TYPE_CHECKING:
+    from ..api import RTSPSStreams
     from .nvr import Event, Liveview
 
 PRIVACY_ZONE_NAME = "pyufp_privacy_zone"
@@ -1150,12 +1151,13 @@ class Camera(ProtectMotionDeviceModel):
 
     def update_from_dict(self, data: dict[str, Any]) -> Camera:
         # a message in the past is actually a signal to wipe the message
-        if (reset_at := data.get("lcd_message", {}).get("reset_at")) is not None:
-            if utc_now() > from_js_time(reset_at):
-                # Important: Make a copy of the data before modifying it
-                # since unifi_dict_to_dict will otherwise report incorrect changes
-                data = data.copy()
-                data["lcd_message"] = None
+        if (
+            reset_at := data.get("lcd_message", {}).get("reset_at")
+        ) is not None and utc_now() > from_js_time(reset_at):
+            # Important: Make a copy of the data before modifying it
+            # since unifi_dict_to_dict will otherwise report incorrect changes
+            data = data.copy()
+            data["lcd_message"] = None
 
         return super().update_from_dict(data)
 
@@ -2101,6 +2103,29 @@ class Camera(ProtectMotionDeviceModel):
             camera_id=self.id, high_quality=high_quality
         )
 
+    async def create_rtsps_streams(
+        self, qualities: list[str] | str
+    ) -> RTSPSStreams | None:
+        """Creates RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot create RTSPS streams without an API key.")
+
+        return await self._api.create_camera_rtsps_streams(self.id, qualities)
+
+    async def get_rtsps_streams(self) -> RTSPSStreams | None:
+        """Gets existing RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot get RTSPS streams without an API key.")
+
+        return await self._api.get_camera_rtsps_streams(self.id)
+
+    async def delete_rtsps_streams(self, qualities: list[str] | str) -> bool:
+        """Deletes RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot delete RTSPS streams without an API key.")
+
+        return await self._api.delete_camera_rtsps_streams(self.id, qualities)
+
     async def get_package_snapshot(
         self,
         width: int | None = None,

{uiprotect-7.18.1 → uiprotect-7.20.0}/src/uiprotect/websocket.py

@@ -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