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

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

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

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

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