camera.ui3 0.0.30-alpha.0

package/dist/server/src/polyglot/python/plugins/typings.py

@@ -0,0 +1,253 @@
+from enum import Enum
+from typing import (
+    Any,
+    Callable,
+    Union,
+)
+
+from camera_ui_types import (
+    AudioSetEvent,
+    BatterySetEvent,
+    Camera,
+    CameraDelegate,
+    CameraPrebufferDelegate,
+    CameraPTZDelegate,
+    Container,
+    DoorbellSetEvent,
+    FrameData,
+    FrameMetadata,
+    ImageOptions,
+    LightSetEvent,
+    MotionSetEvent,
+    ObjectSetEvent,
+    PluginContract,
+    SirenSetEvent,
+    StateValues,
+)
+from typing_extensions import Literal, NotRequired, TypedDict
+from utilities.subscriptions import ProxySubscription
+
+
+class PLUGIN_STATUS(Enum):
+    READY = "ready"
+    STARTING = "starting"
+    STARTED = "started"
+    STOPPED = "stopped"
+    ERROR = "error"
+    UNKNOWN = "unknown"
+    DISABLED = "disabled"
+
+
+class PLUGIN_COMMAND(Enum):
+    START = "start"
+    STOP = "stop"
+
+
+class PluginStorage(TypedDict):
+    installPath: str
+    storagePath: str
+    configFile: str
+
+
+class PluginInfo(TypedDict):
+    id: str
+    name: str
+    contract: PluginContract
+
+
+class ProcessLoadMessage(TypedDict):
+    cameras: list[Camera]
+    plugin: PluginInfo
+    storage: PluginStorage
+
+
+class ProcessMessage(TypedDict, total=False):
+    type: str
+    data: ProcessLoadMessage
+
+
+class ProcessResponse(TypedDict, total=False):
+    type: str
+    data: str
+
+
+ProxyType = Literal["device", "plugin", "camera", "core"]
+
+ClientType = Literal[
+    "cameraFn",
+    "pluginFn",
+    "deviceFn",
+    "coreFn",
+    "storageFn",
+    "cameraDelegate",
+    "prebufferDelegate",
+    "ptzDelegate",
+]
+
+MessageType = Literal["request", "reply"]
+
+
+class QueueItem(TypedDict):
+    message: "ProxyMessageStructure"
+    resolve: Callable[[Any], None]
+    reject: Callable[["RemoteError"], None]
+
+
+class DeserializedError(TypedDict):
+    name: str
+    message: str
+    stack: str
+
+
+class RemoteError(Exception):
+    def __init__(self, error: DeserializedError, cause: "ProxyMessageStructure"):
+        super().__init__(error["message"])
+
+        self.name = error["name"]
+        self.message: str = error["message"]
+        self.cause = cause
+
+        if error["stack"] and error["stack"] != "":
+            self.stack = error["stack"]
+
+    def __str__(self):
+        return f"{self.name}: {self.message}"
+
+
+class ProxyMessageStructure(TypedDict):
+    requestId: str
+    cameraId: NotRequired[str]
+    targetId: str
+    targetName: NotRequired[str]
+    pluginId: str
+    type: MessageType
+    proxy: ProxyType
+    client: ClientType
+    fn: str
+    args: list[Any]
+    timeout: int
+    timestamp: int
+    response: NotRequired[Any]
+    error: NotRequired[DeserializedError]
+
+
+class AudioStreamOptions(TypedDict, total=False):
+    enabled: bool
+    codec: str
+    bitrate: int
+    sampleRate: int
+
+
+class VideoStreamOptions(TypedDict, total=False):
+    codec: str
+    width: int
+    height: int
+    bitrate: int
+    fps: int
+    idrInterval: int
+
+
+class StreamInfo(TypedDict):
+    audio: AudioStreamOptions
+    video: VideoStreamOptions
+
+
+class ProcessPrebufferedImageRequest(TypedDict):
+    frameData: FrameData
+    metadata: FrameMetadata
+    options: ImageOptions
+    prebufferDuration: int
+
+
+class ConnectData(TypedDict):
+    cameraId: str
+    pluginId: NotRequired[str]
+
+
+class DisconnectData(ConnectData): ...
+
+
+class RebootData(ConnectData): ...
+
+
+class StreamInfoData(ConnectData):
+    sourceName: str
+
+
+class FrameMetadataData(ConnectData): ...
+
+
+class FfmpegPathData(ConnectData): ...
+
+
+class IceServersData(ConnectData): ...
+
+
+class UpdateStateData(ConnectData):
+    stateName: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"]
+    eventData: Union[
+        LightSetEvent,
+        MotionSetEvent,
+        AudioSetEvent,
+        ObjectSetEvent,
+        DoorbellSetEvent,
+        SirenSetEvent,
+        BatterySetEvent,
+    ]
+
+
+class UpdatePrebufferStateData(ConnectData):
+    sourceId: str
+    container: Container
+
+
+class RefreshStatesData(ConnectData): ...
+
+
+class SnapshotData(ConnectData):
+    forceNew: NotRequired[bool]
+
+
+class IsPrebufferingData(TypedDict):
+    sourceName: str
+    container: Container
+    cameraId: str
+    pluginId: NotRequired[str]
+    state: bool
+    url: NotRequired[str]
+
+
+class RefreshStatesReturnData(TypedDict):
+    camera: Camera
+    states: StateValues
+    cameraState: bool
+
+
+CameraDeviceProxyMethodNames = Literal[
+    "connect",
+    "disconnect",
+    "updateState",
+    "updatePrebufferState",
+    "addCameraSource",
+    "removeCameraSource",
+    "updateCameraSource",
+    "refreshStates",
+]
+
+
+class CameraDelegates(TypedDict):
+    cameraDelegate: CameraDelegate
+    prebufferDelegate: CameraPrebufferDelegate
+    ptzDelegate: CameraPTZDelegate
+
+
+Delegates = Literal[
+    "cameraDelegate",
+    "prebufferDelegate",
+    "ptzDelegate",
+]
+
+
+class FrameSubscribtion(TypedDict):
+    request_id: str
+    subscriber: ProxySubscription

package/dist/server/src/polyglot/python/utilities/connection.py

@@ -0,0 +1,86 @@
+from typing import Any, Optional
+
+import nats
+from decoder.typings import AuthConfig
+from nats.aio.client import Client as NatsConnection
+
+from .packer import pack, unpack
+from .subscriptions import ProxySubscription
+from .task import TaskSet
+
+
+class ProxyConnection:
+    def __init__(self, name: str, servers: list[str], auth: AuthConfig) -> None:
+        self.name = name
+        self.servers = servers
+        self.auth = auth
+
+        self.tasks: TaskSet = TaskSet(f"{self.name} NatsSubscriber")
+        self.publisher: Optional[NatsConnection] = None
+        self.subscribers: list[ProxySubscription] = []
+
+        self.closed = False
+
+    async def connect(self) -> NatsConnection:
+        async def ignore_cb(e: Optional[Any] = None):
+            pass
+
+        self.publisher = await nats.connect(
+            servers=self.servers,
+            name=self.name,
+            user=self.auth["user"],
+            password=self.auth["password"],
+            max_reconnect_attempts=-1,
+            error_cb=ignore_cb,
+            disconnected_cb=ignore_cb,
+            closed_cb=ignore_cb,
+            reconnected_cb=ignore_cb,
+            discovered_server_cb=ignore_cb,
+        )
+
+        return self.publisher
+
+    async def subscribe(self, subject: str, skip_listening: bool = False) -> ProxySubscription:
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        subscriber = ProxySubscription(await self.publisher.subscribe(subject))
+
+        if not skip_listening:
+            self.tasks.add(subscriber.listen())
+
+        self.subscribers.append(subscriber)
+
+        return subscriber
+
+    async def publish(self, subject: str, message: Any) -> None:
+        if self.closed:
+            return
+
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        await self.publisher.publish(subject, pack(message))
+
+    async def request(self, subject: str, message: Any, timeout: float) -> Any:
+        if self.closed:
+            return
+
+        if not self.publisher:
+            raise Exception("Connection not established")
+
+        msg = await self.publisher.request(subject, pack(message), timeout)
+        response = unpack(msg.data)
+
+        return response
+
+    async def close(self) -> None:
+        self.closed = True
+
+        for subscriber in self.subscribers:
+            await subscriber.close()
+
+        if self.publisher:
+            await self.publisher.close()
+
+        self.tasks.remove_all()

package/dist/server/src/polyglot/python/utilities/json_lmdb.py

@@ -0,0 +1,19 @@
+import json
+from typing import Any, Literal
+
+from lmdbm import Lmdb
+
+
+class JsonLmdb(Lmdb[Literal["config"], dict[str, Any]]):
+    def _pre_key(self, key: Literal["config"]) -> bytes:
+        return key.encode("utf-8")
+
+    def _post_key(self, key: bytes) -> Literal["config"]:
+        _key: Any = key.decode("utf-8")
+        return _key
+
+    def _pre_value(self, value: dict[str, Any]) -> bytes:
+        return json.dumps(value).encode("utf-8")
+
+    def _post_value(self, value: bytes) -> dict[str, Any]:
+        return json.loads(value.decode("utf-8"))

package/dist/server/src/polyglot/python/utilities/object_path.py

@@ -0,0 +1,195 @@
+from typing import Any, Optional, Union, cast
+
+Path = Union[list[Union[int, str]], list[str], list[int], int, str]
+
+
+def is_empty(value: Union[dict[str, Any], list[Any], Any]) -> bool:
+    if not value:
+        return True
+    if isinstance(value, list) and len(value) == 0:
+        return True
+    elif not isinstance(value, str):
+        return all(i not in value for i in value)
+    return False
+
+
+def get_key(key: Union[str, int]) -> Union[int, str]:
+    if isinstance(key, int):
+        return key
+    if key.isdigit():
+        return int(key)
+    return key
+
+
+class ObjectPath:
+    @staticmethod
+    def delete(obj: dict[Any, Any], path: Path) -> dict[Any, Any]:
+        if isinstance(path, int):
+            path = [path]
+
+        if is_empty(obj):
+            return obj
+
+        if isinstance(path, str):
+            return ObjectPath.delete(obj, path.split("."))
+
+        current_path = get_key(path[0])
+        ObjectPath.get_shallow_property_safely(obj, current_path)
+
+        if not ObjectPath.has_shallow_property(obj, current_path):
+            return obj
+
+        if len(path) == 1:
+            if isinstance(obj, list):
+                obj.pop(current_path)
+            else:
+                del obj[current_path]
+        else:
+            ObjectPath.delete(obj[current_path], path[1:])
+
+        return obj
+
+    @staticmethod
+    def has(obj: Union[dict[Any, Any], list[Any]], path: Path) -> bool:
+        if isinstance(path, int):
+            path = [path]
+        elif isinstance(path, str):
+            path = path.split(".")
+
+        if not path:
+            return bool(obj)
+
+        for item in path:
+            j = get_key(item)
+
+            if isinstance(obj, list):
+                if isinstance(j, int) and 0 <= j < len(obj):
+                    obj = obj[j]
+                else:
+                    return False
+            elif isinstance(obj, dict):  # type: ignore
+                if j in obj:
+                    obj = obj[j]
+                else:
+                    return False
+            else:
+                return False
+
+        return True
+
+    @staticmethod
+    def get(obj: dict[Any, Any], path: Path, default_value: Any = None) -> Any:
+        if isinstance(path, int):
+            path = [path]
+
+        if not path or len(path) == 0:
+            return obj
+
+        if isinstance(path, str):
+            return ObjectPath.get(obj, path.split("."), default_value)
+
+        current_path = get_key(path[0])
+        next_obj = ObjectPath.get_shallow_property_safely(obj, current_path)
+
+        if next_obj is None:
+            return default_value
+
+        if len(path) == 1:
+            return next_obj
+
+        return ObjectPath.get(obj[current_path], path[1:], default_value)
+
+    @staticmethod
+    def set(obj: dict[Any, Any], path: Path, value: Any, do_not_replace: bool = False) -> Any:
+        if isinstance(path, int):
+            path = [path]
+
+        if not path or len(path) == 0:
+            return obj
+
+        if isinstance(path, str):
+            keys = [get_key(key) for key in path.split(".") if key]
+            return ObjectPath.set(obj, keys, value, do_not_replace)
+
+        current_path = path[0]
+        current_value = ObjectPath.get_shallow_property_safely(obj, current_path)
+
+        if len(path) == 1:
+            if current_value is None or not do_not_replace:
+                obj[current_path] = value
+            return current_value
+
+        if current_value is None:
+            if isinstance(path[1], int):
+                obj[current_path] = []
+            else:
+                obj[current_path] = {}
+
+        return ObjectPath.set(obj[current_path], path[1:], value, do_not_replace)
+
+    @staticmethod
+    def push(obj: dict[Any, Any], path: Path, *items: Any) -> None:
+        arr = ObjectPath.get(obj, path)
+        if not isinstance(arr, list):
+            arr: Any = []
+            ObjectPath.set(obj, path, arr)
+
+        arr.extend(items)
+
+    @staticmethod
+    def coalesce(
+        obj: dict[Any, Any],
+        paths: Union[Path, list[Path]],
+        default_value: Optional[Any] = None,
+    ) -> Optional[Any]:
+        for path in paths if isinstance(paths, list) else [paths]:
+            value = ObjectPath.get(obj, path)
+            if value is not None:
+                return value
+        return default_value
+
+    @staticmethod
+    def empty(obj: dict[Any, Any], path: Path) -> Any:
+        if is_empty(path):
+            return
+
+        value = ObjectPath.get(obj, path)
+
+        if value is None:
+            return None
+
+        if isinstance(value, str):
+            return ObjectPath.set(obj, path, "")
+        elif isinstance(value, bool):
+            return ObjectPath.set(obj, path, False)
+        elif isinstance(value, (int, float)):
+            return ObjectPath.set(obj, path, 0)
+        elif isinstance(value, (list, dict)):
+            value.clear()
+            return cast(Any, value)
+        else:
+            return ObjectPath.set(obj, path, None)
+
+    @staticmethod
+    def ensure_exists(obj: dict[Any, Any], path: Path, value: Any) -> Any:
+        return ObjectPath.set(obj, path, value, True)
+
+    @staticmethod
+    def insert(obj: dict[Any, Any], path: Path, value: Any, at: int = 0) -> None:
+        arr = ObjectPath.get(obj, path)
+        at = int(at)
+        if not isinstance(arr, list):
+            arr: Any = []
+            ObjectPath.set(obj, path, arr)
+
+        arr.insert(at, value)
+
+    @staticmethod
+    def has_shallow_property(obj: dict[Any, Any], prop: Union[str, int]) -> bool:
+        return (isinstance(prop, int) and isinstance(obj, list)) or prop in obj
+
+    @staticmethod
+    def get_shallow_property_safely(obj: dict[Any, Any], prop: Union[str, int]) -> Any:
+        if ObjectPath.has_shallow_property(obj, prop):
+            return obj[prop]
+        return None

package/dist/server/src/polyglot/python/utilities/packer.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+import msgpack
+
+
+def pack(data: Any) -> bytes:
+    return msgpack.packb(data, datetime=True)  # type: ignore
+
+
+def unpack(data: bytes) -> Any:
+    return msgpack.unpackb(data, timestamp=0)  # type: ignore

package/dist/server/src/polyglot/python/utilities/subscriptions.py

@@ -0,0 +1,22 @@
+import asyncio
+
+from nats.aio.subscription import Subscription as NatsSubscription
+from pyeecui.asyncio import AsyncIOEventEmitter
+
+
+class ProxySubscription(AsyncIOEventEmitter):
+    def __init__(self, subscriber: NatsSubscription, max_concurrent: int = 25) -> None:
+        super().__init__()
+        self.subscriber = subscriber
+        self.semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def listen(self):
+        async for msg in self.subscriber.messages:
+            if len(msg.data) == 0:
+                continue
+            async with self.semaphore:
+                self.emit("message", msg)
+
+    async def close(self):
+        self.remove_all_listeners()
+        await self.subscriber.unsubscribe()

package/dist/server/src/polyglot/python/utilities/task.py

@@ -0,0 +1,35 @@
+import asyncio
+from collections.abc import Coroutine
+from typing import Any, Optional
+
+
+class TaskSet:
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.tasks = set[asyncio.Task[Any]]()
+        self.name = name
+
+    def log_prefix(self) -> str:
+        return f"[{self.name}]"
+
+    def add(self, coroutine: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
+        task = asyncio.create_task(coroutine, name=self.name)
+        self.tasks.add(task)
+        task.add_done_callback(lambda _: self.remove(task))
+
+        return task
+
+    def remove(self, task: asyncio.Task[Any]) -> None:
+        if task in self.tasks:
+            if not task.cancelled():
+                task.cancel()
+
+            self.tasks.remove(task)
+
+    def remove_all(self) -> None:
+        for task in self.tasks:
+            self.remove(task)
+
+        self.tasks.clear()
+
+    def __await__(self) -> Any:
+        return asyncio.gather(*self.tasks).__await__()

package/dist/server/src/polyglot/python/utilities/thread.py

@@ -0,0 +1,10 @@
+import asyncio
+import concurrent.futures
+from typing import Any
+
+toThreadExecutor = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="worker")
+
+
+async def to_thread(f: Any) -> Any:
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(toThreadExecutor, f)

package/dist/server/src/polyglot/python/utilities/utils.py

@@ -0,0 +1,73 @@
+from typing import Any, Callable, Optional, Union
+
+TObject = Union[Any, dict[str, Any], list[Any]]
+TSource = Union[Any, dict[str, Any], list[Any]]
+TKey = Union[str, int]
+Customizer = Callable[[Any, Any, TKey, TObject, TSource, list[Any]], Any]
+
+
+def merge_with(
+    object: TObject,
+    source: TSource,
+    customizer: Customizer,
+    stack: Optional[list[Any]] = None,
+) -> Any:
+    if stack is None:
+        stack = []
+
+    if isinstance(object, list) and isinstance(source, list):
+        result = object.copy()
+        for i in range(max(len(object), len(source))):
+            if i < len(source):
+                stack.append({"key": i, "object": object, "source": source})
+                if i < len(object):
+                    obj_value = object[i]
+                    src_value = source[i]
+                    customized_value = customizer(obj_value, src_value, i, object, source, stack)
+                    if customized_value is not None:
+                        result[i] = customized_value
+                    elif isinstance(obj_value, (dict, list)) and isinstance(src_value, (dict, list)):
+                        result[i] = merge_with(obj_value, src_value, customizer, stack)  # type: ignore
+                    else:
+                        result[i] = src_value
+                else:
+                    result.append(source[i])
+                stack.pop()
+        return result
+
+    elif isinstance(object, dict) and isinstance(source, dict):
+        for key in source:
+            if key in source:
+                obj_value = object.get(key)
+                src_value = source[key]
+
+                stack.append({"key": key, "object": object, "source": source})
+
+                customized_value = customizer(obj_value, src_value, key, object, source, stack)
+
+                if customized_value is not None:
+                    object[key] = customized_value
+                elif isinstance(obj_value, (dict, list)) and isinstance(src_value, (dict, list)):
+                    object[key] = merge_with(obj_value, src_value, customizer, stack)  # type: ignore
+                else:
+                    object[key] = src_value
+
+                stack.pop()
+
+        return object
+
+    else:
+        return source
+
+
+def merge(
+    obj_value: Any,
+    src_value: Any,
+    key: TKey,
+    object: TObject,
+    source: TSource,
+    stack: list[Any],
+) -> Any:
+    if isinstance(obj_value, list):
+        return src_value
+    return None