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

package/dist/server/src/plugins/runtime/python/child.py

@@ -0,0 +1,248 @@
+import asyncio
+import json
+import os
+import sys
+from contextlib import suppress
+from pathlib import Path
+from typing import Any, Literal, Optional, Union, cast
+
+import setproctitle
+from lmdbm import Lmdb
+
+from _camera_ui_tools.camera_ui_common import (
+    LoggerOptions,
+    LoggerService,
+    SignalHandler,
+    TaskSet,
+)
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
+from _camera_ui_tools.camera_ui_types import Camera
+from _camera_ui_tools.camera_ui_types import CameraDevice as CameraDeviceInterface
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.plugin import Plugin
+from plugins.runtime.python.plugin_api import PluginAPI
+from plugins.runtime.python.proxy.camera_device import CameraDeviceProxy
+from plugins.runtime.python.proxy.core_manager import CoreManagerProxy
+from plugins.runtime.python.proxy.device_manager import DeviceManagerProxy
+from plugins.runtime.python.typings import (
+    API_EVENT,
+    PLUGIN_COMMAND,
+    PLUGIN_STATUS,
+    PluginInfo,
+    ProcessLoadMessage,
+    ProcessMessage,
+    ProcessResponse,
+)
+
+process_name = sys.argv[2] if len(sys.argv) > 2 else sys.argv[1] if len(sys.argv) > 1 else "Plugin"
+setproctitle.setproctitle(f"camera.ui - {process_name}")
+
+
+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"))
+
+
+class PluginChild(ClientInstance):
+    def __init__(self) -> None:
+        super().__init__(
+            "plugin",
+            {
+                "endpoints": [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")],
+                "auth": {
+                    "user": os.environ["PROXY_USER"],
+                    "password": os.environ["PROXY_PASSWORD"],
+                },
+                "tls": {
+                    "cert": os.environ["PROXY_CERT"],
+                    "key": os.environ["PROXY_KEY"],
+                    "ca": os.environ["PROXY_CA"],
+                },
+                "metadata": {
+                    "id": NamespaceManager.plugin_namespaces(os.environ["PLUGIN_ID"])["pluginChild"],
+                    "name": os.environ["PLUGIN_NAME"],
+                },
+                "connect": {
+                    "wait_for_server": True,
+                },
+                "reconnect": {
+                    "enabled": True,
+                },
+                "bundled_connection": False,
+            },
+        )
+
+        for key in ["PROXY_USER", "PROXY_PASSWORD", "PROXY_ENDPOINTS", "PROXY_CERT", "PROXY_KEY", "PROXY_CA"]:
+            if key in os.environ:
+                del os.environ[key]
+
+        self.display_name = process_name
+
+        logger_options: LoggerOptions = {
+            "prefix": self.display_name,
+            "disable_timestamps": os.environ.get("LOGGER_DISABLE_TIMESTAMPS") == "1",
+            "debug_enabled": os.environ.get("LOGGER_LEVEL") in ["debug", "trace"],
+            "trace_enabled": os.environ.get("LOGGER_LEVEL") == "trace",
+        }
+
+        self.logger = LoggerService(logger_options)
+
+        self.api: Optional[PluginAPI] = None
+        self.plugin: Optional[Plugin] = None
+        self.plugin_db: Optional[Lmdb[Literal["config"], dict[str, Any]]] = None
+
+        self.subscription: Optional[SubscriptionWrapper] = None
+        self.tasks: TaskSet = TaskSet(f"{self.display_name} PluginChild")
+
+        self.stopped = False
+
+        self.signal_handler = SignalHandler(
+            {
+                "display_name": "[Signal]",
+                "timeout_duration": 3,
+                "logger": self.logger,
+                "close_function": self.stop_plugin,
+            }
+        )
+
+    async def run(self) -> None:
+        try:
+            self.signal_handler.setup_handlers()
+            await self.start()
+            await self.signal_handler.shutdown_event.wait()
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self.stop_plugin()
+
+    async def on_start(self) -> None:
+        self.subscription = await self.on_server_message(self.on_message)
+        await self.send_message({"type": PLUGIN_STATUS.READY.value})
+
+    async def on_before_stop(self) -> None:
+        await self.stop_plugin()
+
+    async def on_stop(self) -> None:
+        pass
+
+    async def start_plugin(self, data: ProcessLoadMessage) -> None:
+        try:
+            storage_path = data["storage"]["storagePath"]
+            plugin_info = data["plugin"]
+            cameras = data["cameras"]
+
+            self.plugin_db = await self.configure_plugin_db(storage_path)
+
+            self.api = PluginAPI(
+                self,
+                plugin_info,
+                storage_path,
+                self.logger,
+                self.plugin_db,
+            )
+
+            self.plugin = Plugin(self, self.api, plugin_info, self.logger)
+
+            core_manager = cast(CoreManagerProxy, self.api.core_manager)
+            device_manager = cast(DeviceManagerProxy, self.api.device_manager)
+
+            await device_manager.init()
+            await core_manager.init()
+            await self.plugin.load()
+            await self.configure_cameras(self.api, plugin_info, cameras)
+
+            await self.send_message({"type": PLUGIN_STATUS.STARTED.value})
+
+            await asyncio.sleep(0.1)
+
+            self.api.emit("finishLaunching")
+        except Exception as e:
+            await self.send_message({"type": PLUGIN_STATUS.ERROR.value, "error": str(e)})
+
+    async def stop_plugin(self) -> None:
+        if self.stopped:
+            return
+
+        self.stopped = True
+
+        if self.api:
+            self.api.emit(API_EVENT.SHUTDOWN.value)
+            await asyncio.sleep(0.5)
+            self.api.cancel()
+
+        if self.plugin_db:
+            with suppress(Exception):
+                self.plugin_db.close()
+
+        if self.subscription:
+            await self.subscription.unsubscribe()
+            self.subscription = None
+
+        await self.stop()
+
+    async def send_message(self, message: ProcessResponse) -> None:
+        await self.send_to_server(message)
+
+    async def on_message(self, message: ProcessMessage) -> None:
+        if self.stopped:
+            return
+
+        if "type" in message:
+            if message["type"] == PLUGIN_COMMAND.START.value:
+                if not message["data"]:
+                    await self.send_message({"type": PLUGIN_STATUS.ERROR.value, "error": "No data provided"})
+                    return
+
+                await self.start_plugin(message["data"])
+            elif message["type"] == PLUGIN_COMMAND.STOP.value:
+                await self.stop_plugin()
+
+    async def configure_plugin_db(self, storage_path: str) -> Lmdb[Literal["config"], dict[str, Any]]:
+        db_path = Path(storage_path) / "volume"
+        Path(db_path).mkdir(parents=True, exist_ok=True)
+
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]] = JsonLmdb.open(file=str(db_path), flag="c")
+        config = cast(Union[dict[str, Any], None], plugin_db.get("config"))
+
+        if config is None:
+            plugin_db.update({"config": {}})
+
+        return plugin_db
+
+    async def configure_cameras(self, api: PluginAPI, plugin_info: PluginInfo, cameras: list[Camera]) -> None:
+        cameras_devices: list[CameraDeviceProxy] = []
+
+        for camera in cameras:
+            camera_logger = self.logger.create_logger({"suffix": camera["name"], "logger_id": camera["_id"]})
+            cameras_devices.append(
+                CameraDeviceProxy(
+                    self,
+                    api,
+                    camera,
+                    plugin_info,
+                    camera_logger,
+                )
+            )
+
+        if self.api:
+            device_manager = cast(DeviceManagerProxy, self.api.device_manager)
+            await device_manager.configure_cameras(cameras_devices)
+
+        if self.plugin:
+            await self.plugin.configureCameras(cast(list[CameraDeviceInterface], cameras_devices))
+
+
+if __name__ == "__main__":
+    plugin_child = PluginChild()
+    asyncio.run(plugin_child.run())

package/dist/server/src/plugins/runtime/python/index.d.ts

@@ -0,0 +1,9 @@
+import { BasePluginRuntime } from '../base.js';
+import type { Plugin } from '../../plugin.js';
+export declare class PythonPluginRuntime extends BasePluginRuntime {
+    private py;
+    constructor(plugin: Plugin);
+    start(): Promise<void>;
+    private updatePython;
+    private createPythonPath;
+}

package/dist/server/src/plugins/runtime/python/index.js

@@ -0,0 +1,57 @@
+import { spawn } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { platform } from 'node:os';
+import { join } from 'node:path';
+import { pythonPath, pythonPluginPath } from '../../../utils/path.js';
+import { DEFAULT_PY_VERSION, PythonInstaller } from '../../../utils/pythonInstaller.js';
+import { BasePluginRuntime } from '../base.js';
+export class PythonPluginRuntime extends BasePluginRuntime {
+    py;
+    constructor(plugin) {
+        super(plugin);
+        this.py = new PythonInstaller(this.configService.HOME_PATH, this.logger, this.plugin.installPath, this.plugin.contract.pythonVersion);
+    }
+    async start() {
+        if (this.isRunning()) {
+            return;
+        }
+        await this.updatePython();
+        return new Promise((resolve, reject) => {
+            this.logger.log(`Starting plugin: ${this.plugin.displayName} (${this.plugin.pluginName}.${this.plugin.info.installedVersion})...`);
+            const command = this.py.pluginPythonPath;
+            const processNames = [this.plugin.pluginName, this.plugin.displayName];
+            const args = ['-u', pythonPluginPath, ...processNames];
+            this.logger.debug(`Spawning plugin: ${this.plugin.pluginName}`);
+            this.worker = spawn(this.py.pluginPythonPath, args, {
+                env: {
+                    PYTHONUNBUFFERED: '1',
+                    PYTHONPATH: this.createPythonPath(),
+                    ...this.getEnv(),
+                },
+                cwd: this.plugin.mainPath,
+            });
+            this.worker.on('spawn', this.onSpawn.bind(this, this.worker.pid, command, args, processNames, resolve));
+            this.worker.on('error', this.onError.bind(this, reject));
+            this.worker.on('exit', this.onExit.bind(this));
+            this.worker.stdout?.on('data', this.onData.bind(this));
+            this.worker.stderr?.on('data', this.onData.bind(this));
+        });
+    }
+    async updatePython() {
+        if (this.plugin.isPython) {
+            await this.py.installPluginPython();
+            const requirementsPath = join(this.plugin.installPath, 'requirements.txt');
+            if (existsSync(requirementsPath) && statSync(requirementsPath).size > 0) {
+                await this.py.updatePluginDependencies(requirementsPath);
+            }
+            if (!this.pluginManager.installedPythonVersions.has(this.plugin.contract.pythonVersion ?? DEFAULT_PY_VERSION)) {
+                throw new Error(`Python version ${this.plugin.contract.pythonVersion ?? DEFAULT_PY_VERSION} is not installed! Cannot start ${this.plugin.pluginName}.`);
+            }
+        }
+    }
+    createPythonPath() {
+        const separator = platform() === 'win32' ? ';' : ':';
+        return [this.py.serverPackagesPath, pythonPath, this.py.pluginPackagesPath, this.plugin.mainPath].join(separator);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/server/src/plugins/runtime/python/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/plugins/runtime/python/index.ts"],"names":[],"mappings":"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"}

package/dist/server/src/plugins/runtime/python/namespaces.py

@@ -0,0 +1,101 @@
+from typing import TypedDict
+
+
+class CoreManagerNamespaces(TypedDict):
+    coreManagerSubject: str
+    coreManagerRpc: str
+
+
+class DeviceManagerNamespaces(TypedDict):
+    deviceManagerSubject: str
+    deviceManagerRpc: str
+
+
+class FrameWorkerNamespaces(TypedDict):
+    frameWorkerChildRpc: str
+    frameWorkerChild: str
+
+
+class PluginNamespaces(TypedDict):
+    pluginDeviceManagerSubject: str
+    pluginChildRpc: str
+    pluginChild: str
+    pluginStorageRpc: str
+
+
+class CameraNamespaces(TypedDict):
+    cameraSubject: str
+    cameraControllerRpc: str
+    cameraMotionFrameSubject: str
+
+
+class PluginCameraNamespaces(TypedDict):
+    cameraInterfacesRpc: str
+    cameraStorageRpc: str
+
+
+class PluginAndPluginCameraNamespaces(PluginNamespaces, PluginCameraNamespaces):
+    pass
+
+
+class DeviceManagerPluginNamespaces(DeviceManagerNamespaces, PluginNamespaces):
+    pass
+
+
+class CoreManagerPluginNamespaces(CoreManagerNamespaces, PluginNamespaces):
+    pass
+
+
+class FrameWorkerCoreManagerNamespaces(FrameWorkerNamespaces, CoreManagerNamespaces):
+    pass
+
+
+class CameraFrameWorkerPluginNamespaces(CameraNamespaces, FrameWorkerNamespaces, PluginCameraNamespaces):
+    pass
+
+
+class NamespaceManager:
+    @staticmethod
+    def core_manager_namespaces() -> CoreManagerNamespaces:
+        return {
+            "coreManagerSubject": "coreManager.subscriber",
+            "coreManagerRpc": "coreManager.rpc",
+        }
+
+    @staticmethod
+    def device_manager_namespaces() -> DeviceManagerNamespaces:
+        return {
+            "deviceManagerSubject": "deviceManager.subscriber",
+            "deviceManagerRpc": "deviceManager.rpc",
+        }
+
+    @staticmethod
+    def frame_worker_namespaces(camera_id: str) -> FrameWorkerNamespaces:
+        return {
+            "frameWorkerChildRpc": f"camera.{camera_id}.frameWorker.child.rpc",
+            "frameWorkerChild": f"camera.{camera_id}.frameWorker.child",
+        }
+
+    @staticmethod
+    def plugin_namespaces(plugin_id: str) -> PluginNamespaces:
+        return {
+            "pluginDeviceManagerSubject": f"plugin.{plugin_id}.deviceManager.subscriber",
+            "pluginChildRpc": f"plugin.{plugin_id}.child.rpc",
+            "pluginChild": f"plugin.{plugin_id}.child",
+            "pluginStorageRpc": f"plugin.{plugin_id}.storage.rpc",
+        }
+
+    @staticmethod
+    def camera_namespaces(camera_id: str) -> CameraNamespaces:
+        return {
+            "cameraSubject": f"camera.{camera_id}.subscriber",
+            "cameraMotionFrameSubject": f"camera.{camera_id}.motionFrame.subscriber",
+            "cameraControllerRpc": f"camera.{camera_id}.controller.rpc",
+        }
+
+    @staticmethod
+    def plugin_camera_namespaces(plugin_id: str, camera_id: str) -> PluginCameraNamespaces:
+        return {
+            "cameraInterfacesRpc": f"plugin.{plugin_id}.camera.{camera_id}.cameraInterfaces.rpc",
+            "cameraStorageRpc": f"plugin.{plugin_id}.camera.{camera_id}.cameraStorage.rpc",
+        }

package/dist/server/src/plugins/runtime/python/plugin.py

@@ -0,0 +1,155 @@
+import importlib.util
+import os
+import sys
+from types import ModuleType
+from typing import Any, Optional, cast
+
+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.utils.rpc import rpc
+from _camera_ui_tools.camera_ui_types import (
+    AudioDetectionPluginResponse,
+    AudioMetadata,
+    CameraDevice,
+    CuiPlugin,
+    CuiPluginCapability,
+    ImageMetadata,
+    JsonSchema,
+    MotionDetectionPluginResponse,
+    ObjectDetectionPluginResponse,
+)
+from plugins.runtime.python.namespaces import NamespaceManager, PluginNamespaces
+from plugins.runtime.python.plugin_api import PluginAPI
+from plugins.runtime.python.storage_controller import StorageController
+from plugins.runtime.python.typings import PluginInfo
+
+
+class Plugin(CuiPlugin):
+    def __init__(self, proxy: ClientInstance, api: PluginAPI, plugin_info: PluginInfo, logger: LoggerService):
+        self.proxy: ClientInstance = proxy
+        self.api: PluginAPI = api
+        self.plugin_info: PluginInfo = plugin_info
+        self.logger: LoggerService = logger
+
+        self.plugin: Optional[CuiPlugin] = None
+        self.namespaces: PluginNamespaces = NamespaceManager.plugin_namespaces(self.plugin_info["id"])
+
+    async def load(self) -> None:
+        plugin_constructor = self.load_plugin()
+        storage_controller = cast(StorageController, self.api.storage_controller)
+        plugin_storage = await storage_controller.create_storage("plugin")
+        self.plugin = cast(CuiPlugin, plugin_constructor(self.logger, self.api, plugin_storage))
+        await self.proxy.register_rpc_handler(self.namespaces["pluginChildRpc"], self)
+
+    @rpc(public=True)
+    async def configureCameras(self, camera_devices: list[CameraDevice]) -> None:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        await self.plugin.configureCameras(camera_devices)
+
+    @rpc(public=True)
+    async def getCapabilities(self) -> list[CuiPluginCapability]:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        return await self.plugin.getCapabilities()
+
+    @rpc(public=True)
+    async def interfaceSchema(self) -> list[JsonSchema] | None:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        return await self.plugin.interfaceSchema()
+
+    @rpc(public=True)
+    async def detectAudio(
+        self, audio_data: bytes, metadata: AudioMetadata, config: dict[str, Any]
+    ) -> Optional[AudioDetectionPluginResponse]:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        return await self.plugin.detectAudio(audio_data, metadata, config)
+
+    @rpc(public=True)
+    async def detectMotion(
+        self, video_data: bytes, config: dict[str, Any]
+    ) -> Optional[MotionDetectionPluginResponse]:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        return await self.plugin.detectMotion(video_data, config)
+
+    @rpc(public=True)
+    async def detectObjects(
+        self, image_data: bytes, metadata: ImageMetadata, config: dict[str, Any]
+    ) -> Optional[ObjectDetectionPluginResponse]:
+        if not self.plugin:
+            raise Exception("Plugin not loaded")
+
+        return await self.plugin.detectObjects(image_data, metadata, config)
+
+    def load_plugin(self) -> Any:
+        module_path = os.environ.get("MODULE_PATH")
+        if not module_path:
+            raise Exception("MODULE_PATH environment variable not set")
+
+        if not os.path.exists(module_path):
+            raise Exception(f"Module path does not exist: {module_path}")
+
+        spec = importlib.util.spec_from_file_location("plugin_module", module_path)
+        if spec is None:
+            raise Exception(f"Could not load module from '{module_path}'.")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["plugin_module"] = module
+
+        if spec.loader is None:
+            raise Exception(f"Could not load module from '{module_path}'.")
+
+        spec.loader.exec_module(module)
+        plugin_constructor = self.find_plugin_constructor(module)
+        # self.check_plugin_class_methods(plugin_constructor)
+
+        return plugin_constructor
+
+    def find_plugin_constructor(self, module: ModuleType) -> Any:
+        if hasattr(module, "__main__"):
+            main_func = module.__main__
+            if callable(main_func):
+                plugin_base_class = cast(CuiPlugin, main_func())
+                if isinstance(plugin_base_class, type):
+                    return plugin_base_class
+                else:
+                    raise Exception("Plugin's __main__ must return a plugin constructor.")
+            else:
+                raise Exception("Plugin's __main__ is not callable.")
+
+        else:
+            raise Exception("Plugin does not have a __main__ function.")
+
+    def check_plugin_class_methods(self, cls: Any) -> None:
+        base_plugin_methods = {
+            name
+            for name in dir(CuiPlugin)
+            if callable(getattr(CuiPlugin, name)) and not name.startswith("__")
+        }
+
+        for method_name in base_plugin_methods:
+            if not hasattr(cls, method_name):
+                raise Exception(f"Method '{method_name}' is not implemented in plugin.")
+
+            cls_method = getattr(cls, method_name)
+            if not callable(cls_method):
+                raise Exception(f"Method '{method_name}' is not callable.")
+
+            # base_method = getattr(CuiPlugin, method_name)
+            # cls_signature = inspect.signature(cls_method)
+            # base_signature = inspect.signature(base_method)
+
+            # if cls_signature.return_annotation != base_signature.return_annotation:
+            #     raise Exception(
+            #         f"Method '{method_name}' has a different return type than the one in CuiPlugin. "
+            #         f"Expected: {base_signature.return_annotation}, "
+            #         f"Actual: {cls_signature.return_annotation}"
+            #     )

package/dist/server/src/plugins/runtime/python/plugin_api.py

@@ -0,0 +1,29 @@
+from typing import Any, Literal
+
+from lmdbm import Lmdb
+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_types import PluginAPI as PluginAPIInterface
+from plugins.runtime.python.proxy.core_manager import CoreManagerProxy
+from plugins.runtime.python.proxy.device_manager import DeviceManagerProxy
+from plugins.runtime.python.storage_controller import StorageController
+from plugins.runtime.python.typings import PluginInfo
+
+
+class PluginAPI(AsyncIOEventEmitter, PluginAPIInterface):
+    def __init__(
+        self,
+        proxy: ClientInstance,
+        plugin: PluginInfo,
+        storage_path: str,
+        logger: LoggerService,
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
+    ) -> None:
+        super().__init__()
+
+        self.storage_path = storage_path
+        self.storage_controller = StorageController(self, proxy, plugin, plugin_db)
+        self.core_manager = CoreManagerProxy(proxy, self, logger, plugin)
+        self.device_manager = DeviceManagerProxy(proxy, self, self.storage_controller, logger, plugin)