camera.ui3 0.0.30-alpha.0 → 0.0.30-alpha.1

package/dist/server/src/polyglot/python/plugins/proxy/core_manager.py

@@ -1,145 +0,0 @@
-from contextlib import suppress
-from datetime import datetime
-from typing import Any, Optional
-from uuid import uuid4
-
-from camera_ui_types import IceServer
-from decoder.typings import AuthConfig
-from message_queue import MessageQueue
-from nats.aio.msg import Msg
-from plugin_api import PluginAPI
-from plugin_logger import PluginLogger
-from pyeecui.asyncio import AsyncIOEventEmitter
-from typings import PluginInfo, ProxyMessageStructure
-from utilities.connection import ProxyConnection
-from utilities.packer import unpack
-from utilities.subscriptions import ProxySubscription
-from utilities.task import TaskSet
-
-
-class CoreManager(AsyncIOEventEmitter):
-    def __init__(
-        self,
-        api: PluginAPI,
-        logger: PluginLogger,
-        plugin: PluginInfo,
-        proxy_endpoints: list[str],
-        auth: AuthConfig,
-    ):
-        super().__init__()
-
-        self.initialized = False
-
-        self.api = api
-        self.logger = logger
-
-        self.auth = auth
-        self.proxy_endpoints = proxy_endpoints
-        self.plugin = plugin
-
-        self.subject = f"{self.plugin['id']}.coreManager"
-        self.cm_subject = "coreManager.subscriber"
-
-        self.publisher: Optional[ProxyConnection] = None
-        self.cm_publisher: Optional[ProxyConnection] = None
-
-        self.subscriber: Optional[ProxySubscription] = None
-        self.cm_subscriber: Optional[ProxySubscription] = None
-
-        self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} CoreManager")
-        self.message_queue: Optional[MessageQueue] = None
-
-        # print("CoreManager", self.plugin["name"], self.dealer_id, self.subscriber_ids)
-
-        self.api.once("shutdown", self.__close)
-
-    async def init(self):
-        if self.initialized:
-            return
-
-        self.initialized = True
-
-        servers = [endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")]
-
-        self.publisher = ProxyConnection(self.subject, servers, self.auth)
-        await self.publisher.connect()
-
-        self.cm_publisher = ProxyConnection(self.cm_subject, servers, self.auth)
-        await self.cm_publisher.connect()
-
-        self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.message_queue = MessageQueue(
-            self.logger,
-            self.publisher,
-            self.subscriber,
-            self.__request_handler,
-        )
-
-        self.cm_subscriber = await self.cm_publisher.subscribe(subject=self.cm_subject)
-        self.cm_subscriber.on("message", self.__on_proxy_message)
-
-    async def get_ffmpeg_path(self) -> str:
-        return await self.__on_request("getFFmpegPath")
-
-    async def get_ice_servers(self) -> list[IceServer]:
-        return await self.__on_request("getIceServers")
-
-    async def get_server_addresses(self) -> list[str]:
-        return await self.__on_request("getServerAddresses")
-
-    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
-        pass
-
-    async def __request_handler(self, message: ProxyMessageStructure):
-        pass
-
-    async def __emit_event(self, msg: Msg) -> None:
-        message = unpack(msg.data)
-
-        type = message.get("type")
-        data = message.get("data", {})
-        system = data.get("system", {})
-
-        if type == "systemUpdated":
-            super().emit(type, system)
-
-    async def __on_proxy_message(self, msg: Msg) -> None:
-        if not self.initialized:
-            return
-
-        self.tasks.add(self.__emit_event(msg))
-
-    async def __on_request(self, fn: str, args: list[Any] = []) -> Any:
-        if not self.message_queue:
-            raise Exception("Message queue is not initialized")
-
-        message: ProxyMessageStructure = {
-            "requestId": str(uuid4()),
-            "targetId": self.subject,
-            "targetName": self.plugin["name"],
-            "pluginId": self.plugin["id"],
-            "type": "request",
-            "proxy": "core",
-            "client": "coreFn",
-            "fn": fn,
-            "args": args,
-            "timestamp": int(datetime.now().timestamp() * 1000),
-            "timeout": 5000,
-        }
-
-        return await self.message_queue.enqueue(message)
-
-    async def __close(self) -> None:
-        self.initialized = False
-        self.remove_all_listeners()
-        self.api.remove_listener("shutdown", self.__close)
-
-        if self.message_queue:
-            self.message_queue.abort_queue()
-
-        with suppress(Exception):
-            if self.publisher:
-                await self.publisher.close()
-
-            if self.cm_publisher:
-                await self.cm_publisher.close()

package/dist/server/src/polyglot/python/plugins/proxy/device_manager.py

@@ -1,226 +0,0 @@
-from contextlib import suppress
-from datetime import datetime
-from typing import Any, Optional, Union, cast
-from uuid import uuid4
-
-from camera_ui_types import Camera, CameraConfig
-from decoder.typings import AuthConfig
-from message_queue import MessageQueue
-from nats.aio.msg import Msg
-from plugin_api import PluginAPI
-from plugin_logger import PluginLogger
-from pyeecui.asyncio import AsyncIOEventEmitter
-from typings import PluginInfo, ProxyMessageStructure
-from utilities.connection import ProxyConnection
-from utilities.packer import unpack
-from utilities.subscriptions import ProxySubscription
-from utilities.task import TaskSet
-
-from .camera_device import CameraDeviceProxy
-
-
-class DeviceManager(AsyncIOEventEmitter):
-    def __init__(
-        self,
-        api: PluginAPI,
-        logger: PluginLogger,
-        plugin: PluginInfo,
-        proxy_endpoints: list[str],
-        auth: AuthConfig,
-    ):
-        super().__init__()
-
-        self.initialized = False
-
-        self.devices: dict[str, CameraDeviceProxy] = {}
-
-        self.api = api
-        self.logger = logger
-
-        self.auth = auth
-        self.proxy_endpoints = proxy_endpoints
-        self.plugin = plugin
-
-        self.subject = f"{self.plugin['id']}.deviceManager"
-        self.dm_subject = f"{self.plugin['id']}.deviceManager.subscriber"
-
-        self.publisher: Optional[ProxyConnection] = None
-        self.dm_publisher: Optional[ProxyConnection] = None
-
-        self.subscriber: Optional[ProxySubscription] = None
-        self.dm_subscriber: Optional[ProxySubscription] = None
-
-        self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} DeviceManager")
-        self.message_queue: Optional[MessageQueue] = None
-
-        # print("DeviceManager", self.plugin["name"], self.dealer_id, self.subscriber_ids)
-
-        self.api.once("shutdown", self.__close)
-
-    async def init(self):
-        if self.initialized:
-            return
-
-        self.initialized = True
-
-        servers = [endpoint for endpoint in self.proxy_endpoints if endpoint.startswith("nats://")]
-
-        self.publisher = ProxyConnection(self.subject, servers, self.auth)
-        await self.publisher.connect()
-
-        self.dm_publisher = ProxyConnection(self.dm_subject, servers, self.auth)
-        await self.dm_publisher.connect()
-
-        self.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.message_queue = MessageQueue(
-            self.logger,
-            self.publisher,
-            self.subscriber,
-            self.__request_handler,
-        )
-
-        self.dm_subscriber = await self.dm_publisher.subscribe(subject=self.dm_subject)
-        self.dm_subscriber.on("message", self.__on_proxy_message)
-
-    async def get_camera_by_id(self, id: str) -> Optional[CameraDeviceProxy]:
-        camera_device = await self.__add_or_get_camera(id)
-
-        if not camera_device:
-            camera: Camera = await self.__on_request("getCameraById", [id])
-
-            if camera:
-                camera_device = await self.__add_or_get_camera(camera)
-
-        return camera_device
-
-    async def get_camera_by_name(self, name: str) -> Optional[CameraDeviceProxy]:
-        camera_device = next((device for device in self.devices.values() if device.name == name), None)
-
-        if not camera_device:
-            camera: Camera = await self.__on_request("getCameraByName", [name])
-
-            if camera:
-                camera_device = await self.__add_or_get_camera(camera)
-
-        return camera_device
-
-    async def create_camera(self, camera_config: CameraConfig) -> CameraDeviceProxy:
-        camera: Camera = await self.__on_request("createCamera", [camera_config])
-        camera_device = cast(CameraDeviceProxy, await self.__add_or_get_camera(camera))
-        return camera_device
-
-    async def remove_camera_by_name(self, name: str) -> None:
-        camera = await self.__on_request("getCameraByName", [name])
-
-        if camera:
-            await self.__on_request("removeCameraByName", [name])
-            del self.devices[camera["_id"]]
-
-    async def remove_camera_by_id(self, id: str) -> None:
-        await self.__on_request("removeCameraById", [id])
-        del self.devices[id]
-
-    def configure_cameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
-        for camera_device in camera_devices:
-            self.devices[camera_device.id] = camera_device
-
-    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
-        pass
-
-    async def __request_handler(self, message: ProxyMessageStructure):
-        pass
-
-    async def __emit_event(self, msg: Msg) -> None:
-        message = unpack(msg.data)
-
-        type = message.get("type")
-        data = message.get("data", {})
-        camera = data.get("camera")
-        extension = data.get("extension")
-
-        if type == "cameraSelected":
-            camera_device = await self.__add_or_get_camera(camera)
-
-            super().emit(type, camera_device, extension)
-        elif type == "cameraDeselected":
-            camera_device = self.devices.get(camera["_id"])
-
-            if camera_device:
-                await camera_device.cleanup()
-
-            del self.devices[camera["_id"]]
-
-            super().emit(type, camera["_id"], extension)
-
-    async def __on_proxy_message(self, msg: Msg) -> None:
-        if not self.initialized:
-            return
-
-        self.tasks.add(self.__emit_event(msg))
-
-    async def __on_request(self, fn: str, args: list[Any] = []) -> Any:
-        if not self.message_queue:
-            raise Exception("Message queue is not initialized")
-
-        message: ProxyMessageStructure = {
-            "requestId": str(uuid4()),
-            "targetId": self.subject,
-            "targetName": self.plugin["name"],
-            "pluginId": self.plugin["id"],
-            "type": "request",
-            "proxy": "device",
-            "client": "deviceFn",
-            "fn": fn,
-            "args": args,
-            "timestamp": int(datetime.now().timestamp() * 1000),
-            "timeout": 5000,
-        }
-
-        return await self.message_queue.enqueue(message)
-
-    async def __add_or_get_camera(self, camera_or_id: Union[Camera, str]) -> Optional[CameraDeviceProxy]:
-        camera_device: Optional[CameraDeviceProxy] = None
-
-        if isinstance(camera_or_id, str):
-            id = camera_or_id
-
-            camera_device: Optional[CameraDeviceProxy] = next(
-                (device for device in self.devices.values() if device.id == id or device.name == id),
-                None,
-            )
-        else:
-            camera = camera_or_id
-
-            if camera["_id"] in self.devices:
-                camera_device = self.devices[camera["_id"]]
-            else:
-                camera_device = CameraDeviceProxy(
-                    self.api,
-                    self.logger,
-                    camera,
-                    self.plugin,
-                    self.proxy_endpoints,
-                    self.auth,
-                )
-
-                self.devices[camera["_id"]] = camera_device
-
-        if camera_device:
-            await camera_device.init()
-
-        return camera_device
-
-    async def __close(self) -> None:
-        self.initialized = False
-        self.remove_all_listeners()
-        self.api.remove_listener("shutdown", self.__close)
-
-        if self.message_queue:
-            self.message_queue.abort_queue()
-
-        with suppress(Exception):
-            if self.publisher:
-                await self.publisher.close()
-
-            if self.dm_publisher:
-                await self.dm_publisher.close()

package/dist/server/src/polyglot/python/plugins/schema.py

@@ -1,181 +0,0 @@
-import re
-from typing import Any, cast
-
-from camera_ui_types import (
-    JsonSchema,
-    JsonSchemaForm,
-    RootSchema,
-)
-
-
-def config_path_to_schema_path(config_path: str) -> str:
-    """
-    Converts a configuration path to a schema path by handling array indices and nested properties.
-
-    This function transforms the config path to match the structure expected by a JSON schema. For instance, converting array
-    indices and adding 'properties' keywords as needed to represent the hierarchical structure of the schema.
-
-    :param config_path: A dot-separated path string representing the location of a configuration item.
-    :return: A dot-separated path string adjusted to align with JSON schema structure.
-    """
-    path_parts = config_path.split(".")
-    schema_path_parts: list[str] = []
-
-    for index, part in enumerate(path_parts):
-        is_numeric_index = bool(re.match(r"^\d+$", part))
-        is_last_part = index == len(path_parts) - 1
-
-        if is_numeric_index:
-            schema_path_parts.extend(["items", "properties"])
-        else:
-            schema_path_parts.append(part)
-            if not is_last_part and not re.match(r"^\d+$", path_parts[index + 1]):
-                schema_path_parts.append("properties")
-
-    return ".".join(schema_path_parts)
-
-
-def generate_json_from_root_schema(
-    root_schema: RootSchema,
-) -> dict[str, Any]:
-    """
-    Generates a default JSON object based on the provided root schema. This function iterates through the schema's properties,
-    creating a nested JSON object that matches the structure of the schema with default values where specified.
-
-    :param root_schema: The root schema object which defines the structure and default values for the JSON object.
-    :return: A JSON object that conforms to the provided schema.
-    """
-    json_object: dict[str, Any] = {}
-
-    for key, json_schema in root_schema["schema"].items():
-        json_object[key] = generate_json_from_schema(json_schema)
-
-    return json_object
-
-
-def generate_json_from_schema(
-    json_schema: JsonSchema,
-) -> Any:
-    """
-    Generates JSON data based on a single schema definition. Depending on the schema type, this may generate a string, number,
-    boolean, object, or array, incorporating default values and nested structures as defined in the schema.
-
-    :param json_schema: The JSON schema from which to generate data.
-    :return: Generated JSON data that conforms to the specified schema.
-    """
-    schema_type = json_schema.get("type")
-
-    if schema_type in ["string", "number", "boolean"]:
-        if "enum" in json_schema:
-            if json_schema.get("multiple"):
-                return [json_schema.get("defaultValue")] if "defaultValue" in json_schema else []
-            else:
-                return json_schema.get(
-                    "defaultValue",
-                    json_schema["enum"][0] if json_schema.get("required", False) else None,
-                )
-        else:
-            return json_schema.get("defaultValue")
-    elif schema_type == "object":
-        properties = json_schema.get("properties")
-        if properties:
-            return {k: generate_json_from_schema(v) for k, v in properties.items()}
-        return {}
-    elif schema_type == "array":
-        items = json_schema.get("items")
-        if items:
-            return [generate_json_from_schema(items)]
-        return []
-    else:
-        return None
-
-
-def get_value_by_path(obj: dict[str, Any], path: str) -> Any:
-    """
-    Retrieves a value from a nested object or a list based on a dot-separated path. If the path includes indices for accessing
-    array elements, these are handled accordingly. If any part of the path is not found, None is returned.
-
-    :param obj: The object or list from which to retrieve the value.
-    :param path: A dot-separated path string representing the location of the item.
-    :return: The value at the specified path, or None if the path is not found.
-    """
-
-    keys: list[str] = []
-    for key in path.split("."):
-        if "[" in key:
-            path_key, index = key.split("[")
-            keys.append(path_key)
-            keys.append(index[:-1])
-        else:
-            keys.append(key)
-
-    current = obj
-    for key in keys:
-        if current is None:
-            return None
-        current = current.get(key)
-
-    return current
-
-
-def remove_functions_from_schema_form(
-    schema_form: JsonSchemaForm,
-) -> JsonSchemaForm:
-    """
-    Removes 'onSet' and 'onGet' functions from a schema form, making it suitable for serialization or scenarios where these
-    executable functions should not be included. This is particularly useful for preparing a schema for transmission over a
-    network or storing in a format that does not support functions.
-
-    :param schema_form: The schema form from which to remove functions.
-    :return: A new schema form with the functions removed.
-    """
-    filtered_schema_form: JsonSchemaForm = {}
-
-    for key, json_schema in schema_form.items():
-        filtered_schema_form[key] = remove_functions_from_schema(json_schema)
-
-    return filtered_schema_form
-
-
-def remove_functions_from_schema(
-    json_schema: JsonSchema,
-) -> JsonSchema:
-    """
-    Similar to 'remove_functions_from_schema_form', but operates on a single schema object. It removes 'onSet' and 'onGet'
-    functions if present.
-
-    :param json_schema: The individual schema from which to remove functions.
-    :return: A new schema with the functions removed.
-    """
-    json_schema_items = cast(dict[str, Any], json_schema.items())  # type: ignore
-    filtered_schema = cast(JsonSchema, {k: v for k, v in json_schema_items if k not in ["onSet", "onGet"]})
-
-    if filtered_schema["type"] == "object" and "properties" in filtered_schema:
-        filtered_schema["properties"] = remove_functions_from_schema_form(filtered_schema["properties"])
-    elif filtered_schema["type"] == "array" and "items" in filtered_schema:
-        filtered_schema["items"] = remove_functions_from_schema(filtered_schema["items"])
-
-    return filtered_schema
-
-
-def schema_path_to_config_path(schema_path: str) -> str:
-    """
-    Converts a schema path back to a configuration path by removing 'properties' and 'items' keywords, effectively reversing
-    the operation performed by 'config_path_to_schema_path'. This is useful for mapping a location within a schema to a
-    corresponding location in a configuration object or file.
-
-    :param schema_path: A dot-separated path string representing the location within a schema.
-    :return: A dot-separated path string representing the corresponding location within a configuration.
-    """
-    path_parts = schema_path.split(".")
-    config_path_parts: list[str] = []
-
-    for part in path_parts:
-        if part != "properties" and part != "items":
-            is_numeric_index = bool(re.match(r"^\d+$", part))
-            if is_numeric_index:
-                config_path_parts.append(f"[{part}]")
-            else:
-                config_path_parts.append(part)
-
-    return ".".join(config_path_parts)

package/dist/server/src/polyglot/python/plugins/storage_controller.py

@@ -1,58 +0,0 @@
-from typing import Any, Literal, Optional
-
-from camera_storage import CameraStorage
-from camera_ui_types import JsonSchemaForm
-from lmdbm import Lmdb
-from plugin_api import PluginAPI
-
-
-class StorageController:
-    def __init__(self, api: PluginAPI, plugin_db: Lmdb[Literal["config"], dict[str, Any]]) -> None:
-        self.__api = api
-        self.__camera_storages: dict[str, CameraStorage] = {}
-        self.__plugin_db = plugin_db
-
-    def create_camera_storage(
-        self,
-        instance: Any,
-        camera_id: str,
-        schema: Optional[JsonSchemaForm] = None,
-    ) -> CameraStorage:
-        """
-        Creates or retrieves an existing camera storage instance for the specified camera ID. If a storage instance does not already exist, it is initialized and stored.
-
-        :param instance: The plugin instance associated with this camera storage.
-        :param camera_id: A unique identifier for the camera.
-        :param schema: The JSON schema form defining the data structure for this camera's storage.
-        :return: An instance of CameraStorage for the specified camera.
-        """
-        if schema is None:
-            schema = {}
-
-        camera_storage = self.__camera_storages.get(camera_id) or CameraStorage(
-            self.__api, self.__plugin_db, instance, camera_id, schema
-        )
-
-        camera_storage.initializeStorage()
-
-        self.__camera_storages[camera_id] = camera_storage
-
-        return camera_storage
-
-    def get_camera_storage(self, camera_id: str) -> Optional[CameraStorage]:
-        """
-        Retrieves a camera storage instance for the specified camera ID, if one exists.
-
-        :param camera_id: The unique identifier for the camera whose storage instance is being requested.
-        :return: The CameraStorage instance for the specified camera, or None if no such instance exists.
-        """
-        return self.__camera_storages.get(camera_id)
-
-    def remove_camera_storage(self, camera_id: str) -> None:
-        """
-        Removes the camera storage instance associated with the specified camera ID, if it exists.
-
-        :param camera_id: The unique identifier for the camera whose storage instance should be removed.
-        """
-        if camera_id in self.__camera_storages:
-            del self.__camera_storages[camera_id]