uiprotect 0.1.0__py3-none-any.whl

uiprotect/data/user.py

@@ -0,0 +1,236 @@
+"""UniFi Protect User models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from functools import cache
+from typing import Any
+
+from pydantic.v1.fields import PrivateAttr
+
+from uiprotect.data.base import ProtectBaseObject, ProtectModel, ProtectModelWithId
+from uiprotect.data.types import ModelType, PermissionNode
+
+
+class Permission(ProtectBaseObject):
+    raw_permission: str
+    model: ModelType
+    nodes: set[PermissionNode]
+    obj_ids: set[str] | None
+
+    @classmethod
+    def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
+        permission = data.get("rawPermission", "")
+        parts = permission.split(":")
+        if len(parts) < 2:
+            raise ValueError(f"Invalid permission: {permission}")
+
+        data["model"] = ModelType(parts[0])
+        if parts[1] == "*":
+            data["nodes"] = list(PermissionNode)
+        else:
+            data["nodes"] = [PermissionNode(n) for n in parts[1].split(",")]
+
+        if len(parts) == 3 and parts[2] != "*":
+            if parts[2] == "$":
+                data["obj_ids"] = ["self"]
+            else:
+                data["obj_ids"] = parts[2].split(",")
+
+        return super().unifi_dict_to_dict(data)
+
+    def unifi_dict(  # type: ignore[override]
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> str:
+        return self.raw_permission
+
+    @property
+    def objs(self) -> list[ProtectModelWithId] | None:
+        if self.obj_ids == {"self"} or self.obj_ids is None:
+            return None
+
+        devices = getattr(self.api.bootstrap, f"{self.model.value}s")
+        return [devices[oid] for oid in self.obj_ids]
+
+
+class Group(ProtectModelWithId):
+    name: str
+    permissions: list[Permission]
+    type: str
+    is_default: bool
+
+    @classmethod
+    def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "permissions" in data:
+            permissions = data.pop("permissions")
+            data["permissions"] = [{"rawPermission": p} for p in permissions]
+
+        return super().unifi_dict_to_dict(data)
+
+
+class UserLocation(ProtectModel):
+    is_away: bool
+    latitude: float | None
+    longitude: float | None
+
+
+class CloudAccount(ProtectModelWithId):
+    first_name: str
+    last_name: str
+    email: str
+    user_id: str
+    name: str
+    location: UserLocation | None
+    profile_img: str | None = None
+
+    @classmethod
+    @cache
+    def _get_unifi_remaps(cls) -> dict[str, str]:
+        return {**super()._get_unifi_remaps(), "user": "userId"}
+
+    def unifi_dict(
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> dict[str, Any]:
+        data = super().unifi_dict(data=data, exclude=exclude)
+
+        # id and cloud ID are always the same
+        if "id" in data:
+            data["cloudId"] = data["id"]
+        if "location" in data and data["location"] is None:
+            del data["location"]
+
+        return data
+
+    @property
+    def user(self) -> User:
+        return self.api.bootstrap.users[self.user_id]
+
+
+class UserFeatureFlags(ProtectBaseObject):
+    notifications_v2: bool
+
+
+class User(ProtectModelWithId):
+    permissions: list[Permission]
+    last_login_ip: str | None
+    last_login_time: datetime | None
+    is_owner: bool
+    enable_notifications: bool
+    has_accepted_invite: bool
+    all_permissions: list[Permission]
+    scopes: list[str] | None = None
+    location: UserLocation | None
+    name: str
+    first_name: str
+    last_name: str
+    email: str | None
+    local_username: str
+    group_ids: list[str]
+    cloud_account: CloudAccount | None
+    feature_flags: UserFeatureFlags
+
+    # TODO:
+    # settings
+    # alertRules
+    # notificationsV2
+    # notifications
+    # cloudProviders
+
+    _groups: list[Group] | None = PrivateAttr(None)
+    _perm_cache: dict[str, bool] = PrivateAttr({})
+
+    def __init__(self, **data: Any) -> None:
+        if "permissions" in data:
+            permissions = data.pop("permissions")
+            data["permissions"] = [
+                {"raw_permission": p} if isinstance(p, str) else p for p in permissions
+            ]
+        if "allPermissions" in data:
+            permissions = data.pop("allPermissions")
+            data["allPermissions"] = [
+                {"raw_permission": p} if isinstance(p, str) else p for p in permissions
+            ]
+
+        super().__init__(**data)
+
+    @classmethod
+    def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "permissions" in data:
+            permissions = data.pop("permissions")
+            data["permissions"] = [{"rawPermission": p} for p in permissions]
+        if "allPermissions" in data:
+            permissions = data.pop("allPermissions")
+            data["allPermissions"] = [{"rawPermission": p} for p in permissions]
+
+        return super().unifi_dict_to_dict(data)
+
+    @classmethod
+    @cache
+    def _get_unifi_remaps(cls) -> dict[str, str]:
+        return {**super()._get_unifi_remaps(), "groups": "groupIds"}
+
+    def unifi_dict(
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> dict[str, Any]:
+        data = super().unifi_dict(data=data, exclude=exclude)
+
+        if "location" in data and data["location"] is None:
+            del data["location"]
+
+        return data
+
+    @property
+    def groups(self) -> list[Group]:
+        """
+        Groups the user is in
+
+        Will always be empty if the user only has read only access.
+        """
+        if self._groups is not None:
+            return self._groups
+
+        self._groups = [
+            self.api.bootstrap.groups[g]
+            for g in self.group_ids
+            if g in self.api.bootstrap.groups
+        ]
+        return self._groups
+
+    def can(
+        self,
+        model: ModelType,
+        node: PermissionNode,
+        obj: ProtectModelWithId | None = None,
+    ) -> bool:
+        """Checks if a user can do a specific action"""
+        check_self = False
+        if model == self.model and obj is not None and obj.id == self.id:
+            perm_str = f"{model.value}:{node.value}:$"
+            check_self = True
+        else:
+            perm_str = (
+                f"{model.value}:{node.value}:{obj.id if obj is not None else '*'}"
+            )
+        if perm_str in self._perm_cache:
+            return self._perm_cache[perm_str]
+
+        for perm in self.all_permissions:
+            if model != perm.model or node not in perm.nodes:
+                continue
+            if perm.obj_ids is None:
+                self._perm_cache[perm_str] = True
+                return True
+            if check_self and perm.obj_ids == {"self"}:
+                self._perm_cache[perm_str] = True
+                return True
+            if perm.obj_ids is not None and obj is not None and obj.id in perm.obj_ids:
+                self._perm_cache[perm_str] = True
+                return True
+        self._perm_cache[perm_str] = False
+        return False

uiprotect/data/websocket.py

@@ -0,0 +1,236 @@
+"""Classes for decoding/encoding data from UniFi OS Websocket"""
+
+from __future__ import annotations
+
+import base64
+import enum
+import struct
+import zlib
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+import orjson
+
+from uiprotect.data.types import ProtectWSPayloadFormat
+from uiprotect.exceptions import WSDecodeError, WSEncodeError
+
+if TYPE_CHECKING:
+    from uiprotect.data.base import ProtectModelWithId
+
+WS_HEADER_SIZE = 8
+
+
+@dataclass
+class WSPacketFrameHeader:
+    packet_type: int
+    payload_format: int
+    deflated: int
+    unknown: int
+    payload_size: int
+
+
+@enum.unique
+class WSAction(str, enum.Enum):
+    ADD = "add"
+    UPDATE = "update"
+    REMOVE = "remove"
+
+
+@dataclass
+class WSSubscriptionMessage:
+    action: WSAction
+    new_update_id: UUID
+    changed_data: dict[str, Any]
+    new_obj: ProtectModelWithId | None = None
+    old_obj: ProtectModelWithId | None = None
+
+
+class BaseWSPacketFrame:
+    data: Any
+    position: int = 0
+    header: WSPacketFrameHeader | None = None
+    payload_format: ProtectWSPayloadFormat = ProtectWSPayloadFormat.NodeBuffer
+    is_deflated: bool = False
+    length: int = 0
+
+    def set_data_from_binary(self, data: bytes) -> None:
+        self.data = data
+        if self.header is not None and self.header.deflated:
+            self.data = zlib.decompress(self.data)
+
+    def get_binary_from_data(self) -> bytes:
+        raise NotImplementedError
+
+    @staticmethod
+    def klass_from_format(format_raw: int) -> type[BaseWSPacketFrame]:
+        payload_format = ProtectWSPayloadFormat(format_raw)
+
+        if payload_format == ProtectWSPayloadFormat.JSON:
+            return WSJSONPacketFrame
+
+        return WSRawPacketFrame
+
+    @staticmethod
+    def from_binary(
+        data: bytes,
+        position: int = 0,
+        klass: type[WSRawPacketFrame] | None = None,
+    ) -> BaseWSPacketFrame:
+        """
+        Decode a unifi updates websocket frame.
+
+        The format of the frame is
+        b: packet_type
+        b: payload_format
+        b: deflated
+        b: unknown
+        i: payload_size
+        """
+        header_end = position + WS_HEADER_SIZE
+
+        try:
+            (
+                packet_type,
+                payload_format,
+                deflated,
+                unknown,
+                payload_size,
+            ) = struct.unpack(
+                "!bbbbi",
+                data[position:header_end],
+            )
+        except struct.error as e:
+            raise WSDecodeError from e
+
+        if klass is None:
+            frame = WSRawPacketFrame.klass_from_format(payload_format)()
+        else:
+            frame = klass()
+            frame.payload_format = ProtectWSPayloadFormat(payload_format)
+
+        frame.header = WSPacketFrameHeader(
+            packet_type=packet_type,
+            payload_format=payload_format,
+            deflated=deflated,
+            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.set_data_from_binary(data[header_end:frame_end])
+
+        return frame
+
+    @property
+    def packed(self) -> bytes:
+        if self.header is None:
+            raise WSEncodeError("No header to encode")
+
+        data = self.get_binary_from_data()
+        header = struct.pack(
+            "!bbbbi",
+            self.header.packet_type,
+            self.header.payload_format,
+            self.header.deflated,
+            self.header.unknown,
+            len(data),
+        )
+
+        return header + data
+
+
+class WSRawPacketFrame(BaseWSPacketFrame):
+    data: bytes = b""
+
+    def get_binary_from_data(self) -> bytes:
+        data = self.data
+        if self.is_deflated:
+            data = zlib.compress(data)
+
+        return data
+
+
+class WSJSONPacketFrame(BaseWSPacketFrame):
+    data: dict[str, Any] = {}
+    payload_format: ProtectWSPayloadFormat = ProtectWSPayloadFormat.NodeBuffer
+
+    def set_data_from_binary(self, data: bytes) -> None:
+        if self.header is not None and self.header.deflated:
+            data = zlib.decompress(data)
+
+        self.data = orjson.loads(data)
+
+    def get_binary_from_data(self) -> bytes:
+        data = self.json
+        if self.is_deflated:
+            data = zlib.compress(data)
+
+        return data
+
+    @property
+    def json(self) -> bytes:
+        return orjson.dumps(self.data)
+
+
+class WSPacket:
+    _raw: bytes
+    _raw_encoded: str | None = None
+
+    _action_frame: BaseWSPacketFrame | None = None
+    _data_frame: BaseWSPacketFrame | None = None
+
+    def __init__(self, data: bytes):
+        self._raw = data
+
+    def decode(self) -> None:
+        self._action_frame = WSRawPacketFrame.from_binary(self._raw)
+        self._data_frame = WSRawPacketFrame.from_binary(
+            self._raw,
+            self._action_frame.length,
+        )
+
+    @property
+    def action_frame(self) -> BaseWSPacketFrame:
+        if self._action_frame is None:
+            self.decode()
+
+        if self._action_frame is None:
+            raise WSDecodeError("Packet unexpectedly not decoded")
+
+        return self._action_frame
+
+    @property
+    def data_frame(self) -> BaseWSPacketFrame:
+        if self._data_frame is None:
+            self.decode()
+
+        if self._data_frame is None:
+            raise WSDecodeError("Packet unexpectedly not decoded")
+
+        return self._data_frame
+
+    @property
+    def raw(self) -> bytes:
+        return self._raw
+
+    @raw.setter
+    def raw(self, data: bytes) -> None:
+        self._raw = data
+        self._action_frame = None
+        self._data_frame = None
+        self._raw_encoded = None
+
+    @property
+    def raw_base64(self) -> str:
+        if self._raw_encoded is None:
+            self._raw_encoded = base64.b64encode(self._raw).decode("utf-8")
+
+        return self._raw_encoded
+
+    def pack_frames(self) -> bytes:
+        self._raw_encoded = None
+        self._raw = self.action_frame.packed + self.data_frame.packed
+
+        return self._raw

uiprotect/exceptions.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+
+class UnifiProtectError(Exception):
+    """Base class for all other UniFi Protect errors"""
+
+
+class StreamError(UnifiProtectError):
+    """Expcetion raised when trying to stream content"""
+
+
+class DataDecodeError(UnifiProtectError):
+    """Exception raised when trying to decode a UniFi Protect object"""
+
+
+class WSDecodeError(UnifiProtectError):
+    """Exception raised when decoding Websocket packet"""
+
+
+class WSEncodeError(UnifiProtectError):
+    """Exception raised when encoding Websocket packet"""
+
+
+class ClientError(UnifiProtectError):
+    """Base Class for all other UniFi Protect client errors"""
+
+
+class BadRequest(ClientError):
+    """Invalid request from API Client"""
+
+
+class Invalid(ClientError):
+    """Invalid return from Authorization Request."""
+
+
+class NotAuthorized(PermissionError, BadRequest):
+    """Wrong username, password or permission error."""
+
+
+class NvrError(ClientError):
+    """Other error."""

uiprotect/release_cache.json

@@ -0,0 +1 @@
+["1.13.4","1.13.7","1.14.11","1.15.0","1.16.9","1.17.1","1.17.2","1.17.3","1.17.4","1.18.0","1.18.1","1.19.0","1.19.1","1.19.2","1.20.0","1.20.1","1.20.2","1.20.3","1.21.0","1.21.2","1.21.3","1.21.4","1.21.5","1.21.6","2.0.0","2.0.1","2.1.1","2.1.2","2.10.10","2.10.11","2.11.21","2.2.11","2.2.2","2.2.6","2.2.9","2.6.17","2.7.18","2.7.33","2.7.34","2.8.28","2.8.35","2.9.42","3.0.22"]

uiprotect/stream.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from asyncio.streams import StreamReader
+from asyncio.subprocess import PIPE, Process, create_subprocess_exec
+from pathlib import Path
+from shlex import split
+from typing import TYPE_CHECKING
+from urllib.parse import urlparse
+
+from aioshutil import which
+
+from uiprotect.exceptions import BadRequest, StreamError
+
+if TYPE_CHECKING:
+    from uiprotect.data import Camera
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FfmpegCommand:
+    ffmpeg_path: Path | None
+    args: list[str]
+    process: Process | None = None
+
+    stdout: list[str] = []
+    stderr: list[str] = []
+
+    def __init__(self, cmd: str, ffmpeg_path: Path | None = None) -> None:
+        self.args = split(cmd)
+
+        if "ffmpeg" in self.args[0] and ffmpeg_path is None:
+            self.ffmpeg_path = Path(self.args.pop(0))
+        else:
+            self.ffmpeg_path = ffmpeg_path
+
+    @property
+    def is_started(self) -> bool:
+        return self.process is not None
+
+    @property
+    def is_running(self) -> bool:
+        if self.process is None:
+            return False
+
+        return self.process.returncode is None
+
+    @property
+    def is_error(self) -> bool:
+        if self.process is None:
+            raise StreamError("ffmpeg has not started")
+
+        if self.is_running:
+            return False
+
+        return self.process.returncode != 0
+
+    async def start(self) -> None:
+        if self.is_started:
+            raise StreamError("ffmpeg command already started")
+
+        if self.ffmpeg_path is None:
+            system_ffmpeg = await which("ffmpeg")
+
+            if system_ffmpeg is None:
+                raise StreamError("Could not find ffmpeg")
+            self.ffmpeg_path = Path(system_ffmpeg)
+
+        if not self.ffmpeg_path.exists():
+            raise StreamError("Could not find ffmpeg")
+
+        _LOGGER.debug("ffmpeg: %s %s", self.ffmpeg_path, " ".join(self.args))
+        self.process = await create_subprocess_exec(
+            self.ffmpeg_path,
+            *self.args,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+
+    async def stop(self) -> None:
+        if self.process is None:
+            raise StreamError("ffmpeg has not started")
+
+        self.process.kill()
+        await self.process.wait()
+
+    async def _read_stream(self, stream: StreamReader | None, attr: str) -> None:
+        if stream is None:
+            return
+
+        while True:
+            line = await stream.readline()
+            if line:
+                getattr(self, attr).append(line.decode("utf8").rstrip())
+            else:
+                break
+
+    async def run_until_complete(self) -> None:
+        if not self.is_started:
+            await self.start()
+
+        if self.process is None:
+            raise StreamError("Could not start stream")
+
+        await asyncio.wait(
+            [
+                asyncio.create_task(self._read_stream(self.process.stdout, "stdout")),
+                asyncio.create_task(self._read_stream(self.process.stderr, "stderr")),
+            ],
+        )
+        await self.process.wait()
+
+
+class TalkbackStream(FfmpegCommand):
+    camera: Camera
+    content_url: str
+
+    def __init__(
+        self,
+        camera: Camera,
+        content_url: str,
+        ffmpeg_path: Path | None = None,
+    ):
+        if not camera.feature_flags.has_speaker:
+            raise BadRequest("Camera does not have a speaker for talkback")
+
+        content_url = self.clean_url(content_url)
+        input_args = self.get_args_from_url(content_url)
+        if len(input_args) > 0:
+            input_args += " "
+
+        bitrate = camera.talkback_settings.bits_per_sample * 1000
+        # 8000 seems to result in best quality without overloading the camera
+        udp_bitrate = bitrate + 8000
+
+        # vn = no video
+        # acodec = audio codec to encode output in (aac)
+        # ac = number of output channels (1)
+        # ar = output sampling rate (22050)
+        # b:a = set bit rate of output audio
+        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"-ar {camera.talkback_settings.sampling_rate} -b:a {bitrate} -map 0:a "
+            f'-f adts "udp://{camera.host}:{camera.talkback_settings.bind_port}?bitrate={udp_bitrate}"'
+        )
+
+        super().__init__(cmd, ffmpeg_path)
+
+    @classmethod
+    def clean_url(cls, content_url: str) -> str:
+        parsed = urlparse(content_url)
+        if parsed.scheme in {"file", ""}:
+            path = Path(parsed.netloc + parsed.path)
+            if not path.exists():
+                raise BadRequest(f"File {path} does not exist")
+            content_url = str(path.absolute())
+
+        return content_url
+
+    @classmethod
+    def get_args_from_url(cls, content_url: str) -> str:
+        # TODO:
+        return ""