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

package/src/plugins/runtime/python/proxy/core_manager.py

@@ -0,0 +1,126 @@
+import asyncio
+from typing import Any, Optional
+
+from pyeecui.asyncio import AsyncIOEventEmitter
+
+from _camera_ui_tools.camera_ui_common.logger_service.logger import LoggerService
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.base.rpc import RPCConnection
+from _camera_ui_tools.camera_ui_rpc_client.typings import Message
+from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
+from _camera_ui_tools.camera_ui_types import (
+    CoreManager,
+    CuiPlugin,
+    FfmpegArgs,
+    HWAccelOptions,
+    IceServer,
+)
+from _camera_ui_tools.camera_ui_types import PluginAPI as PluginAPIInterface
+from plugins.runtime.python.namespaces import CoreManagerPluginNamespaces, NamespaceManager
+from plugins.runtime.python.typings import API_EVENT, CoreManagerInterface, PluginInfo
+
+
+class CoreManagerProxy(AsyncIOEventEmitter, CoreManager):
+    def __init__(
+        self,
+        proxy: ClientInstance,
+        api: PluginAPIInterface,
+        logger: LoggerService,
+        plugin: PluginInfo,
+    ):
+        super().__init__()
+
+        self.__initialized = False
+
+        self.__api = api
+        self.__proxy = proxy
+        self.__logger = logger
+        self.__plugin = plugin
+
+        self.__subscription: Optional[SubscriptionWrapper] = None
+        self.__namespaces: CoreManagerPluginNamespaces = {
+            **NamespaceManager.core_manager_namespaces(),
+            **NamespaceManager.plugin_namespaces(self.__plugin["id"]),
+        }
+
+        self.__rpc_connections: dict[str, RPCConnection] = {}
+
+        self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
+
+    async def init(self) -> None:
+        if self.__initialized:
+            return
+
+        self.__initialized = True
+        self.__subscription = await self.__proxy.subscribe(
+            self.__namespaces["coreManagerSubject"], self.__on_event_message
+        )
+
+    async def connect_to_plugin(self, plugin_name: str) -> Optional[CuiPlugin]:
+        try:
+            core_manager_proxy = await self.__core_manager_proxy()
+            plugin = await core_manager_proxy.getPlugin(plugin_name)
+
+            if not plugin:
+                return None
+
+            namespaces = NamespaceManager.plugin_namespaces(plugin["id"])
+            rpc_connection: Optional[RPCConnection] = None
+
+            if namespaces["pluginChildRpc"] in self.__rpc_connections:
+                rpc_connection = self.__rpc_connections[namespaces["pluginChildRpc"]]
+                await rpc_connection.connect()
+            else:
+                rpc_connection = await self.__proxy.create_rpc_connection(namespaces["pluginChildRpc"])
+                self.__rpc_connections[namespaces["pluginChildRpc"]] = rpc_connection
+
+            return rpc_connection.create_proxy(CuiPlugin)
+        except:  # noqa
+            return None
+
+    async def get_ffmpeg_path(self) -> str:
+        core_manager_proxy = await self.__core_manager_proxy()
+        return await core_manager_proxy.getFFmpegPath()
+
+    async def get_hwaccel_info(self, options: HWAccelOptions) -> list[FfmpegArgs]:
+        core_manager_proxy = await self.__core_manager_proxy()
+        return await core_manager_proxy.getHwaccelInfo(options)
+
+    async def get_ice_servers(self) -> list[IceServer]:
+        core_manager_proxy = await self.__core_manager_proxy()
+        return await core_manager_proxy.getIceServers()
+
+    async def get_server_addresses(self) -> list[str]:
+        core_manager_proxy = await self.__core_manager_proxy()
+        return await core_manager_proxy.getServerAddresses()
+
+    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    async def __core_manager_proxy(self) -> CoreManagerInterface:
+        return await self.__proxy.create_rpc_proxy(CoreManagerInterface, self.__namespaces["coreManagerRpc"])
+
+    async def __on_event_message(self, event: Message[Any]) -> None:
+        message = event["data"]
+        type = message.get("type")
+        data = message.get("data", {})
+        system = data.get("system", {})
+
+        if type == "systemUpdated":
+            super().emit(type, system)
+
+    async def __close(self) -> None:
+        self.__initialized = False
+        self.cancel()
+        self.remove_all_listeners()
+        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
+        if self.__subscription:
+            await self.__subscription.unsubscribe()
+            self.__subscription = None
+        await self.__disconnect_rpc()
+
+    async def __disconnect_rpc(self) -> None:
+        await self.__proxy.disconnect_rpc_connection(self.__namespaces["coreManagerRpc"])
+        await asyncio.gather(
+            *[rpc_connection.disconnect() for rpc_connection in self.__rpc_connections.values()]
+        )

package/src/plugins/runtime/python/proxy/device_manager.py

@@ -0,0 +1,197 @@
+import asyncio
+from typing import Any, Optional, Union, cast
+
+from pyeecui.asyncio import AsyncIOEventEmitter
+
+from _camera_ui_tools.camera_ui_common import (
+    LoggerService,
+)
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.typings import Message
+from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
+from _camera_ui_tools.camera_ui_types import (
+    Camera,
+    CameraConfig,
+    CameraExtension,
+    DeviceManager,
+    DeviceManagerEventType,
+    PartialCameraConfig,
+)
+from _camera_ui_tools.camera_ui_types import PluginAPI as PluginAPIInterface
+from plugins.runtime.python.namespaces import (
+    DeviceManagerPluginNamespaces,
+    NamespaceManager,
+)
+from plugins.runtime.python.storage_controller import StorageController
+from plugins.runtime.python.typings import API_EVENT, DeviceManagerInterface, PluginInfo
+
+from .camera_device import CameraDeviceProxy
+
+
+class DeviceManagerProxy(AsyncIOEventEmitter, DeviceManager):  # type: ignore
+    def __init__(
+        self,
+        proxy: ClientInstance,
+        api: PluginAPIInterface,
+        storage_controller: StorageController,
+        logger: LoggerService,
+        plugin: PluginInfo,
+    ):
+        super().__init__()
+
+        self.__initialized = False
+
+        self.__api = api
+        self.__proxy = proxy
+        self.__storage_controller = storage_controller
+        self.__logger = logger
+        self.__plugin = plugin
+
+        self.__devices: dict[str, CameraDeviceProxy] = {}
+        self.__requests: Optional[SubscriptionWrapper] = None
+        self.__namespaces: DeviceManagerPluginNamespaces = {
+            **NamespaceManager.device_manager_namespaces(),
+            **NamespaceManager.plugin_namespaces(self.__plugin["id"]),
+        }
+
+        self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
+
+    async def init(self) -> None:
+        if self.__initialized:
+            return
+
+        self.__initialized = True
+        self.__requests = await self.__proxy.handle_request(
+            self.__namespaces["pluginDeviceManagerSubject"], self.__on_event_message
+        )
+
+    async def get_camera(self, camera_id_or_name: str) -> Optional[CameraDeviceProxy]:
+        camera_device = await self.__get_camera_device(camera_id_or_name)
+
+        if not camera_device:
+            device_manager_proxy = await self.__device_manager_proxy()
+            camera = await device_manager_proxy.getCamera(camera_id_or_name, self.__plugin["id"])
+
+            if camera:
+                camera_device = await self.__get_camera_device(camera)
+
+        return camera_device
+
+    async def create_camera(self, camera_config: CameraConfig) -> CameraDeviceProxy:
+        device_manager_proxy = await self.__device_manager_proxy()
+        camera = await device_manager_proxy.createCamera(camera_config, self.__plugin["id"])
+        camera_device = cast(CameraDeviceProxy, await self.__get_camera_device(camera))
+        return camera_device
+
+    async def update_camera(
+        self, camera_id_or_name: str, camera_config: PartialCameraConfig
+    ) -> CameraDeviceProxy:
+        device_manager_proxy = await self.__device_manager_proxy()
+        camera = await device_manager_proxy.updateCamera(
+            camera_id_or_name, camera_config, self.__plugin["id"]
+        )
+        camera_device = cast(CameraDeviceProxy, await self.__get_camera_device(camera))
+        return camera_device
+
+    async def remove_camera(self, camera_id_or_name: str) -> None:
+        device_manager_proxy = await self.__device_manager_proxy()
+        camera = await device_manager_proxy.getCamera(camera_id_or_name, self.__plugin["id"])
+
+        if camera:
+            await device_manager_proxy.removeCamera(camera_id_or_name, self.__plugin["id"])
+            del self.__devices[camera["_id"]]
+
+    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+    async def configure_cameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
+        await asyncio.gather(*[self.__get_camera_device(camera_device) for camera_device in camera_devices])
+
+    async def __device_manager_proxy(self) -> DeviceManagerInterface:
+        return await self.__proxy.create_rpc_proxy(
+            DeviceManagerInterface, self.__namespaces["deviceManagerRpc"]
+        )
+
+    async def __on_event_message(self, event: Message[Any]) -> None:
+        if not self.__initialized:
+            return
+
+        message = event["data"]
+        type: DeviceManagerEventType = message.get("type")
+        data = message.get("data", {})
+        camera: Camera = data.get("camera")
+        extension: CameraExtension = data.get("extension")
+
+        if type == "cameraSelected":
+            camera_device = await self.__get_camera_device(camera)
+            super().emit(type, camera_device, extension)
+        elif type == "cameraDeselected":
+            camera_device = self.__devices.get(camera["_id"])
+            super().emit(type, camera["_id"], extension)
+
+            if camera_device:
+                await camera_device.cleanup()
+
+            await self.__remove_camera_storage(camera["_id"])
+            del self.__devices[camera["_id"]]
+
+    async def __get_camera_device(
+        self, camera_or_id: Union[Camera, CameraDeviceProxy, str]
+    ) -> Optional[CameraDeviceProxy]:
+        camera_device: Optional[CameraDeviceProxy] = None
+
+        if isinstance(camera_or_id, str):
+            id = camera_or_id
+
+            camera_device = next(
+                (device for device in self.__devices.values() if device.id == id or device.name == id),
+                None,
+            )
+        elif isinstance(camera_or_id, CameraDeviceProxy):
+            camera_device = camera_or_id
+            if camera_device.id in self.__devices:
+                camera_device = self.__devices[camera_device.id]
+            else:
+                self.__devices[camera_device.id] = camera_device
+        else:
+            camera = camera_or_id
+            if camera["_id"] in self.__devices:
+                camera_device = self.__devices[camera["_id"]]
+            else:
+                camera_logger = self.__logger.create_logger(
+                    {"suffix": camera["name"], "logger_id": camera["_id"]}
+                )
+                camera_device = CameraDeviceProxy(
+                    self.__proxy,
+                    self.__api,
+                    camera,
+                    self.__plugin,
+                    camera_logger,
+                )
+
+                self.__devices[camera["_id"]] = camera_device
+
+        if camera_device:
+            await self.__create_camera_storage(camera_device.id)
+            await camera_device.init()
+
+        return camera_device
+
+    async def __create_camera_storage(self, camera_id: str) -> None:
+        await self.__storage_controller.create_storage("camera", camera_id)
+
+    async def __remove_camera_storage(self, camera_id: str) -> None:
+        await self.__storage_controller.remove_storage("camera", camera_id)
+
+    async def __close(self) -> None:
+        self.__initialized = False
+        self.cancel()
+        self.remove_all_listeners()
+        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
+        if self.__requests:
+            await self.__requests.unsubscribe()
+            self.__requests = None
+        await self.__disconnect_rpc()
+
+    async def __disconnect_rpc(self) -> None:
+        await self.__proxy.disconnect_rpc_connection(self.__namespaces["deviceManagerRpc"])

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

@@ -0,0 +1,99 @@
+from typing import Any, Optional, Union, cast
+
+from _camera_ui_tools.camera_ui_types import (
+    JsonSchema,
+    JsonSchemaWithoutCallbacks,
+    JsonSchemaWithoutCallbacksAndKey,
+)
+
+
+# Generate default value for a schema field
+def generate_default_value(schema: JsonSchema) -> Any:
+    # Return explicit default if provided
+    if "defaultValue" in schema:
+        return schema["defaultValue"]
+
+    # Generate default based on type
+    match schema["type"]:
+        case "string":
+            if "enum" in schema:
+                if "multiple" in schema and schema["multiple"]:
+                    return []
+                elif "required" in schema and schema["required"]:
+                    return schema["enum"][0]
+            return ""
+        case "number":
+            return 0
+        case "boolean":
+            return False
+        case "array":
+            return []
+        case _:
+            return None
+
+
+# Generate a config object from schema definitions
+def generate_config_from_schemas(schemas: list[JsonSchema]) -> dict[str, Any]:
+    config: dict[str, Any] = {}
+
+    for schema in schemas:
+        # Skip button and submit types as they don't have values
+        if schema["type"] == "button" or schema["type"] == "submit":
+            continue
+
+        config[schema["key"]] = generate_default_value(schema)
+
+    return config
+
+
+def get_value_by_key(config: Optional[dict[str, Any]] = None, key: str = "") -> Any:
+    if config is None:
+        config = {}
+
+    # For simple keys without nesting
+    if "." not in key and "[" not in key:
+        return config.get(key)
+
+    # For nested keys or array access
+    keys: list[str] = []
+    for part in key.split("."):
+        if "[" in part:
+            parts = part.split("[")
+            keys.append(parts[0])
+            # Handle potential multiple array indices like a[0][1]
+            for index_part in parts[1:]:
+                keys.append(index_part.rstrip("]"))
+        else:
+            keys.append(part)
+
+    current: Any = config
+    for k in keys:
+        if current is None or not isinstance(current, (dict, list)):
+            return None
+
+        if isinstance(current, dict):
+            current = cast(Any, current.get(k))
+        elif k.isdigit():
+            index = int(k)
+            current = cast(Any, current[index] if 0 <= index < len(current) else None)
+        else:
+            return None
+
+    return current
+
+
+# Remove callback functions from schema - useful for serialization
+def remove_callbacks_from_schema(
+    schema: Union[JsonSchema, JsonSchemaWithoutCallbacks, JsonSchemaWithoutCallbacksAndKey],
+) -> JsonSchemaWithoutCallbacks:
+    rest = {k: v for k, v in schema.items() if k not in ["onSet", "onGet", "onClick"]}
+
+    if rest["type"] == "array" and "items" in rest:
+        rest["items"] = remove_callbacks_from_schema(cast(JsonSchema, rest["items"]))
+
+    return cast(JsonSchemaWithoutCallbacks, rest)
+
+
+# Remove callbacks from all schemas
+def remove_callbacks_from_schemas(schemas: list[JsonSchema]) -> list[JsonSchemaWithoutCallbacks]:
+    return [remove_callbacks_from_schema(schema) for schema in schemas]