@camera.ui/server 0.0.22-alpha.1 → 0.0.22-alpha.3

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

@@ -1,253 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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