@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/plugins/runtime/python/storage.py

@@ -0,0 +1,353 @@
+import asyncio
+import inspect
+from collections.abc import Awaitable
+from contextlib import suppress
+from copy import deepcopy
+from typing import Any, Callable, Optional, TypeVar, Union, cast
+
+from deepdiff.diff import DeepDiff
+from lmdbm import Lmdb
+from typing_extensions import Literal, overload
+
+from _camera_ui_tools.camera_ui_common import ObjectPath, merge, merge_with
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.utils.rpc import rpc
+from _camera_ui_tools.camera_ui_types import (
+    V1,
+    FormSubmitResponse,
+    JsonSchema,
+    PluginAPI,
+    SchemaConfig,
+)
+from _camera_ui_tools.camera_ui_types import DeviceStorage as DeviceStorageInterface
+from plugins.runtime.python.namespaces import (
+    NamespaceManager,
+    PluginAndPluginCameraNamespaces,
+)
+from plugins.runtime.python.schema import (
+    generate_config_from_schemas,
+    get_value_by_key,
+    remove_callbacks_from_schemas,
+)
+from plugins.runtime.python.typings import API_EVENT, PluginInfo
+
+P = TypeVar("P", str, int, float, bool, dict[Any, Any], list[Any], None)
+
+TKey = Union[str, int, None]
+
+
+def merge2(
+    source: Any,
+    target: Any,
+    key: TKey,
+    source_object: Union[dict[Any, Any], list[Any], Any],  # TSource
+    target_object: Union[dict[Any, Any], list[Any], Any],  # TTarget
+    stack: list[Any],
+) -> Any:
+    if isinstance(source, list):
+        return target
+    if target is None:
+        return source
+    return None
+
+
+class DeviceStorage(DeviceStorageInterface):
+    def __init__(
+        self,
+        api: PluginAPI,
+        proxy: ClientInstance,
+        plugin: PluginInfo,
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
+        instance: Any,
+        device_id: str,
+        schemas: Optional[list[JsonSchema]] = [],
+        is_plugin_storage: bool = False,
+    ) -> None:
+        if schemas is None:
+            schemas = []
+
+        self.schemas: list[JsonSchema] = schemas
+        self.values: dict[str, Any] = {}
+
+        self.__api = api
+        self.__proxy = proxy
+        self.__plugin = plugin
+        self.__plugin_db = plugin_db
+        self.__instance = instance
+        self.__device_id = device_id
+        self.__is_plugin_storage = is_plugin_storage
+
+        namespaces: PluginAndPluginCameraNamespaces = {
+            **NamespaceManager.plugin_camera_namespaces(plugin["id"], device_id),
+            **NamespaceManager.plugin_namespaces(plugin["id"]),
+        }
+
+        self.__storage_namespace = (
+            namespaces["cameraStorageRpc"] if not is_plugin_storage else namespaces["pluginStorageRpc"]
+        )
+
+        self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
+
+    @overload
+    async def getValue(self, key: str) -> Union[V1, None]: ...
+    @overload
+    async def getValue(self, key: str, default_value: V1) -> V1: ...
+    @rpc(public=True)
+    async def getValue(self, key: str, default_value: Optional[V1] = None) -> Union[V1, None]:
+        schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
+        config_value = ObjectPath.get(self.values, key)
+        schema_default_value = (
+            schema["defaultValue"] if "defaultValue" in schema and schema["defaultValue"] else None
+        )
+
+        if schema:
+            on_get_function = schema.get("onGet", None)
+            if on_get_function is not None:
+                if inspect.iscoroutinefunction(on_get_function):
+                    return await on_get_function()
+                else:
+                    res = on_get_function()
+
+                    if inspect.iscoroutine(res):
+                        return await res
+                    else:
+                        return on_get_function()  # type: ignore
+
+        if config_value is not None:
+            return config_value
+
+        if schema_default_value is not None:
+            return schema_default_value
+
+        if default_value is not None:
+            return default_value
+
+        return None
+
+    @rpc(public=True)
+    async def setValue(self, key: str, new_value: Any) -> None:
+        schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
+
+        if schema:
+            old_value = ObjectPath.get(self.values, key)
+            ObjectPath.set(self.values, key, new_value)
+
+            on_set_function = schema.get("onSet", None)
+            if on_set_function:
+                if inspect.iscoroutinefunction(on_set_function):
+                    await on_set_function(new_value, old_value)
+                else:
+                    res = on_set_function(new_value, old_value)
+
+                    if inspect.iscoroutine(res):
+                        await res
+                    else:
+                        on_set_function(new_value, old_value)
+
+            if self.__contains_storable_schema(schema):
+                self.save()
+
+    @rpc(public=True)
+    async def submitValue(self, key: str, new_value: Any) -> Union[FormSubmitResponse, None]:
+        schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
+
+        if schema and schema["type"] == "submit":
+            on_click_function = schema.get("onClick", None)
+            if on_click_function:
+                if inspect.iscoroutinefunction(on_click_function):
+                    return await on_click_function(new_value)
+                else:
+                    res = on_click_function(new_value)
+
+                    if inspect.iscoroutine(res):
+                        return await res
+                    else:
+                        return on_click_function(new_value)
+
+        return None
+
+    @rpc(public=True)
+    def hasValue(self, key: str) -> bool:
+        config_value = ObjectPath.get(self.values, key)
+        return config_value is not None
+
+    @rpc(public=True)
+    async def getConfig(self) -> SchemaConfig:
+        await self.__resolve_on_get_functions(self.schemas)
+        filtered_schema: Any = remove_callbacks_from_schemas(self.schemas)
+        schema_config: SchemaConfig = {"schema": filtered_schema, "config": self.values}
+        return schema_config
+
+    @rpc(public=True)
+    async def setConfig(self, new_config: dict[str, Any]) -> None:
+        old_config = deepcopy(self.values)
+        self.values = merge_with(self.values, new_config, merge)
+
+        await self.__trigger_on_set_for_changes(old_config, self.values)
+        self.save()
+
+    @rpc(public=True)
+    async def addSchema(self, schema: JsonSchema) -> None:
+        should_save = False
+
+        schema_exist = next((schema for schema in self.schemas if schema["key"] == schema["key"]), None)
+
+        if schema_exist:
+            raise Exception(f"Schema with key {schema['key']} already exists")
+        else:
+            self.schemas.append(schema)
+
+        await self.__resolve_on_get_functions(schema)
+
+        if self.__contains_storable_schema(schema):
+            should_save = True
+
+        if should_save:
+            self.save()
+
+    @rpc(public=True)
+    def removeSchema(self, key: str) -> None:
+        schema = next((schema for schema in self.schemas if schema["key"] == key), None)
+        self.schemas = [s for s in self.schemas if s["key"] != key]
+        ObjectPath.delete(self.values, key)
+
+        if schema and self.__contains_storable_schema(schema):
+            self.save()
+
+    @rpc(public=True)
+    async def changeSchema(self, key: str, new_schema: dict[str, Any]) -> None:
+        new_schema["key"] = key
+        schema = next((schema for schema in self.schemas if schema["key"] == new_schema["key"]), None)
+
+        if schema:
+            merge_with(schema, new_schema, merge)
+
+            await self.__resolve_on_get_functions(schema)
+
+            if self.__contains_storable_schema(schema):
+                self.save()
+
+    @rpc(public=True)
+    def getSchema(self, key: str) -> Optional[JsonSchema]:
+        return next((schema for schema in self.schemas if schema["key"] == key), None)
+
+    @rpc(public=True)
+    def hasSchema(self, key: str) -> bool:
+        return any(schema["key"] == key for schema in self.schemas)
+
+    @rpc(public=True)
+    async def destroy(self) -> None:
+        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
+        config: Any = cast(dict[str, Any], self.__plugin_db.get("config") or {})
+        if self.__device_id in config:
+            del config[self.__device_id]
+            self.values = {}
+            self.__plugin_db.update({"config": config})
+
+    def save(self) -> None:
+        config: Any = cast(dict[str, Any], self.__plugin_db.get("config") or {})
+
+        if len(self.schemas) > 0:
+            storable_config = self.__filter_storable_values(self.schemas)
+        else:
+            storable_config = self.values
+
+        config[self.__device_id] = storable_config
+        self.__plugin_db.update({"config": config})
+
+    # Internal method
+    def update_schema(self, instance: Any, schemas: list[JsonSchema] = []) -> None:
+        self.__instance = instance
+        self.schemas = schemas
+        self.__initializeStorage()
+
+    # Internal method
+    async def register_storage(self) -> None:
+        await self.__proxy.register_rpc_handler(self.__storage_namespace, self)
+
+    # Internal method
+    async def unregister_storage(self) -> None:
+        await self.__proxy.unregister_rpc_handler(self.__storage_namespace)
+
+    async def __resolve_on_get_functions(
+        self,
+        schemas: Union[JsonSchema, list[JsonSchema]],
+    ) -> None:
+        if not isinstance(schemas, list):
+            schemas = [schemas]
+
+        for schema in schemas:
+            if schema["type"] != "button" and schema["type"] != "submit" and "onGet" in schema:
+                schema_value = await self.getValue(schema["key"])
+                if schema_value is not None:
+                    ObjectPath.set(self.values, schema["key"], schema_value)
+
+    async def __trigger_on_set_for_changes(
+        self, old_config: dict[str, Any], new_config: dict[str, Any]
+    ) -> None:
+        tasks: list[Awaitable[Union[None, Any]]] = []
+
+        for config_key, _ in new_config.items():
+            old_value: Any = get_value_by_key(old_config, config_key) or {}
+            new_value: Any = new_config[config_key]
+
+            if DeepDiff(old_value, new_value, ignore_order=True) != {}:
+                schema = next((schema for schema in self.schemas if schema["key"] == config_key), None)
+                if schema and schema["type"] != "submit" and "onSet" in schema:
+                    on_set_function: Any = schema.get("onSet", None)
+                    if on_set_function:
+
+                        async def process_on_set(
+                            func: Union[
+                                Callable[[Any, Any], Awaitable[Union[None, Any]]],
+                                Callable[[Any, Any], Union[None, Any]],
+                            ],
+                            new_val: Any,
+                            old_val: Any,
+                        ) -> None:
+                            if inspect.iscoroutinefunction(func):
+                                await func(new_val, old_val)
+                            else:
+                                res = func(new_val, old_val)
+                                if inspect.iscoroutine(res):
+                                    await res
+
+                        tasks.append(process_on_set(on_set_function, new_value, old_value))
+
+        if tasks:
+            await asyncio.gather(*tasks)
+
+    def __filter_storable_values(
+        self,
+        schemas: list[JsonSchema],
+        result: dict[str, Any] = {},
+    ) -> dict[str, Any]:
+        for schema in schemas:
+            if schema["type"] == "button" or schema["type"] == "submit":
+                continue
+
+            if "store" in schema and schema["store"]:
+                config_value = get_value_by_key(self.values, schema["key"])
+                ObjectPath.set(result, schema["key"], config_value)
+
+        return result
+
+    def __contains_storable_schema(
+        self,
+        schema: JsonSchema,
+    ) -> bool:
+        if schema["type"] == "button" or schema["type"] == "submit":
+            return False
+
+        return bool("store" in schema and schema["store"])
+
+    def __initializeStorage(self) -> None:
+        config: Any = cast(dict[str, Any], self.__plugin_db.get("config") or {})
+        device_config = config.get(self.__device_id, {})
+        schema_config = generate_config_from_schemas(self.schemas)
+        self.values = merge_with(schema_config, device_config, merge2)
+
+    async def __close(self) -> None:
+        with suppress(Exception):
+            self.save()
+            await self.unregister_storage()

package/src/plugins/runtime/python/storage_controller.py

@@ -0,0 +1,102 @@
+from typing import Any, Literal, Optional, overload
+
+from lmdbm import Lmdb
+
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_types import JsonSchema, PluginAPI
+from _camera_ui_tools.camera_ui_types import StorageController as StorageControllerInterface
+from plugins.runtime.python.storage import DeviceStorage
+from plugins.runtime.python.typings import PluginInfo
+
+
+class StorageController(StorageControllerInterface):
+    def __init__(
+        self,
+        api: PluginAPI,
+        proxy: ClientInstance,
+        plugin: PluginInfo,
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
+    ) -> None:
+        self.__api = api
+        self.__proxy = proxy
+        self.__plugin = plugin
+        self.__storages: dict[str, DeviceStorage] = {}
+        self.__plugin_db = plugin_db
+
+    def create_camera_storage(
+        self, instance: Any, camera_id: str, schemas: Optional[list[JsonSchema]] = []
+    ) -> DeviceStorage:
+        if schemas is None:
+            schemas = []
+
+        camera_storage = self.__storages.get(camera_id)
+
+        if not camera_storage:
+            camera_storage = DeviceStorage(
+                self.__api, self.__proxy, self.__plugin, self.__plugin_db, instance, camera_id, schemas, False
+            )
+            self.__storages[camera_id] = camera_storage
+        else:
+            camera_storage.update_schema(instance, schemas)
+
+        return camera_storage
+
+    def create_plugin_storage(self, instance: Any, schemas: Optional[list[JsonSchema]] = []) -> DeviceStorage:
+        if schemas is None:
+            schemas = []
+
+        plugin_storage = self.__storages.get("storage")
+
+        if not plugin_storage:
+            plugin_storage = DeviceStorage(
+                self.__api, self.__proxy, self.__plugin, self.__plugin_db, instance, "storage", schemas, True
+            )
+            self.__storages["storage"] = plugin_storage
+        else:
+            plugin_storage.update_schema(instance, schemas)
+
+        return plugin_storage
+
+    def get_camera_storage(self, camera_id: str) -> Optional[DeviceStorage]:
+        return self.__storages.get(camera_id)
+
+    def get_plugin_storage(self) -> Optional[DeviceStorage]:
+        return self.__storages.get("storage")
+
+    # Internal method
+    @overload
+    async def create_storage(self, type_: Literal["camera"], device_id: str) -> DeviceStorage: ...
+    @overload
+    async def create_storage(
+        self, type_: Literal["plugin"], device_id: Optional[str] = None
+    ) -> DeviceStorage: ...
+    async def create_storage(
+        self, type_: Literal["camera", "plugin"], device_id: Optional[str] = None
+    ) -> DeviceStorage:
+        storage: Optional[DeviceStorage] = None
+
+        if type_ == "camera":
+            if not device_id:
+                raise ValueError("ID is required for storage creation")
+
+            storage = self.create_camera_storage(None, device_id)
+        else:
+            storage = self.create_plugin_storage(None)
+
+        await storage.register_storage()
+        return storage
+
+    # Internal method
+    @overload
+    async def remove_storage(self, type_: Literal["camera"], device_id: str) -> None: ...
+    @overload
+    async def remove_storage(self, type_: Literal["plugin"], device_id: None) -> None: ...
+    async def remove_storage(self, type_: Literal["camera", "plugin"], device_id: Optional[str]) -> None:
+        id = device_id if type_ == "camera" else "storage"
+        if not id:
+            raise ValueError("ID is required for storage removal")
+
+        if id in self.__storages:
+            await self.__storages[id].destroy()
+            await self.__storages[id].unregister_storage()
+            del self.__storages[id]

package/src/plugins/runtime/python/typings.py

@@ -0,0 +1,195 @@
+from collections.abc import AsyncGenerator
+from enum import Enum
+from typing import (
+    Optional,
+    Protocol,
+    overload,
+    runtime_checkable,
+)
+
+from typing_extensions import Literal, NotRequired, TypedDict
+
+from _camera_ui_tools.camera_ui_types import (
+    AudioSetEvent,
+    BatterySetEvent,
+    Camera,
+    CameraConfig,
+    CameraDeviceCapability,
+    CameraExtension,
+    DoorbellSetEvent,
+    FfmpegArgs,
+    HWAccelOptions,
+    IceServer,
+    ImageOptions,
+    LightSetEvent,
+    MotionSetEvent,
+    ObjectSetEvent,
+    PartialCameraConfig,
+    ProbeConfig,
+    ProbeStream,
+    PTZInterface,
+    SirenSetEvent,
+    SnapshotInterface,
+    StateValues,
+    StreamingInterface,
+    VideoFrame,
+)
+
+
+class ProcessLoadMessage(TypedDict):
+    cameras: list[Camera]
+    plugin: "PluginInfo"
+    storage: "PluginStorage"
+
+
+class ProcessMessage(TypedDict):
+    type: str
+    data: Optional[ProcessLoadMessage]
+
+
+class ProcessResponse(TypedDict):
+    type: str
+    error: NotRequired[Optional[str]]
+
+
+class API_EVENT(Enum):
+    SHUTDOWN = "shutdown"
+    FINISH_LAUNCHING = "finishLaunching"
+
+
+class PLUGIN_STATUS(Enum):
+    READY = "ready"
+    STARTING = "starting"
+    STARTED = "started"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+    UNKNOWN = "unknown"
+    DISABLED = "disabled"
+
+
+class PLUGIN_COMMAND(Enum):
+    START = "start"
+    STOP = "stop"
+
+
+class PluginStorage(TypedDict):
+    installPath: str
+    storagePath: str
+
+
+class PluginInfo(TypedDict):
+    id: str
+    name: str
+    contract: "PluginContract"
+
+
+class PluginContract(TypedDict):
+    extensions: list[CameraExtension]
+    dependencies: NotRequired[list[str]]
+    pythonVersion: NotRequired[str]
+    bundled: NotRequired[bool]
+
+
+class RefreshedStates(TypedDict):
+    camera: Camera
+    states: StateValues
+    cameraState: bool
+    frameWorkerState: bool
+    capabilities: list["PluginCapabilities"]
+
+
+@runtime_checkable
+class CoreManagerInterface(Protocol):
+    async def getFFmpegPath(self) -> str: ...
+    async def getHwaccelInfo(self, options: HWAccelOptions) -> list[FfmpegArgs]: ...
+    async def getServerAddresses(self) -> list[str]: ...
+    async def getIceServers(self) -> list[IceServer]: ...
+    async def getPlugin(self, plugin_name: str) -> Optional[PluginInfo]: ...
+
+
+@runtime_checkable
+class DeviceManagerInterface(Protocol):
+    async def createCamera(self, camera_config: CameraConfig, plugin_id: str) -> Camera: ...
+    async def updateCamera(
+        self, camera_id_or_name: str, camera_config: PartialCameraConfig, plugin_id: str
+    ) -> Camera: ...
+    async def getCamera(self, camera_id_or_name: str, plugin_id: str) -> Optional[Camera]: ...
+    async def removeCamera(self, camera_id_or_name: str, plugin_id: str) -> None: ...
+
+
+@runtime_checkable
+class CameraDeviceInterface(Protocol):
+    async def connect(self) -> None: ...
+    async def disconnect(self) -> None: ...
+    async def addPluginCapabilities(
+        self, plugin_id: str, capabilities: list[CameraDeviceCapability]
+    ) -> None: ...
+    async def removePluginCapabilities(
+        self, plugin_id: str, capabilities: Optional[list[CameraDeviceCapability]] = []
+    ) -> None: ...
+    @overload
+    def getFrames(
+        self, frame_type: Literal["stream"], options: Optional[ImageOptions] = None
+    ) -> AsyncGenerator[VideoFrame, None]: ...
+    @overload
+    def getFrames(
+        self, frame_type: Literal["motion"], options: Optional[ImageOptions] = None
+    ) -> AsyncGenerator[VideoFrame, None]: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["light"],
+        event_data: LightSetEvent,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["motion"],
+        event_data: MotionSetEvent,
+        frame: Optional[VideoFrame] = None,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["audio"],
+        event_data: AudioSetEvent,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["object"],
+        event_data: ObjectSetEvent,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["doorbell"],
+        event_data: DoorbellSetEvent,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["siren"],
+        event_data: SirenSetEvent,
+    ) -> None: ...
+    @overload
+    async def updateState(
+        self,
+        state_name: Literal["battery"],
+        event_data: BatterySetEvent,
+    ) -> None: ...
+    async def refreshStates(self) -> RefreshedStates: ...
+    async def snapshot(self, source_id: str, force_new: Optional[bool]) -> Optional[bytes]: ...
+    async def probeStream(
+        self, source_id: str, probe_config: Optional[ProbeConfig], refresh: Optional[bool]
+    ) -> Optional[ProbeStream]: ...
+
+
+class CameraInterfaces(PTZInterface, SnapshotInterface, StreamingInterface):
+    pass
+
+
+class PluginCapabilities(TypedDict):
+    pluginId: str
+    capabilities: list[CameraDeviceCapability]