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

package/src/plugins/runtime/python/index.ts

@@ -1,73 +0,0 @@
-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';
-
-import type { Plugin } from '../../plugin.js';
-
-export class PythonPluginRuntime extends BasePluginRuntime {
-  private py: PythonInstaller;
-
-  constructor(plugin: Plugin) {
-    super(plugin);
-
-    this.py = new PythonInstaller(this.configService.HOME_PATH, this.logger, this.plugin.installPath, this.plugin.contract.pythonVersion);
-  }
-
-  public async start(): Promise<void> {
-    if (this.isRunning()) {
-      return;
-    }
-
-    await this.updatePython();
-
-    return new Promise<void>((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: string[] = ['-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));
-    });
-  }
-
-  private async updatePython(): Promise<void> {
-    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}.`);
-      }
-    }
-  }
-
-  private createPythonPath(): string {
-    const separator = platform() === 'win32' ? ';' : ':';
-    return [this.py.serverPackagesPath, pythonPath, this.py.pluginPackagesPath, this.plugin.mainPath].join(separator);
-  }
-}

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

@@ -1,101 +0,0 @@
-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/src/plugins/runtime/python/plugin.py

@@ -1,155 +0,0 @@
-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/src/plugins/runtime/python/plugin_api.py

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