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

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

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

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

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