@camera.ui/server 0.0.1

package/dist/server/src/polyglot/python/decoder/image_utils.py

@@ -0,0 +1,149 @@
+from typing import Any, Literal, Union
+
+import numpy as np
+from camera_ui_types import DecoderFormat, ImageCrop, ImageFormat, ImageOptions, ImageResize
+from PIL import Image
+from utilities.thread import to_thread
+
+
+async def process_image_threaded(
+    image_data: bytes,
+    input_width: int,
+    input_height: int,
+    input_format: Union[DecoderFormat, Literal["rgba"], Literal["gray"]],
+    options: ImageOptions,
+) -> bytes:
+    return await to_thread(
+        lambda: process_image(image_data, input_width, input_height, input_format, options)
+    )
+
+
+def process_image(
+    image_data: bytes,
+    input_width: int,
+    input_height: int,
+    input_format: Union[DecoderFormat, Literal["rgba"], Literal["gray"]],
+    options: ImageOptions,
+) -> bytes:
+    image: Union[Image.Image, None] = None
+
+    crop = options.get("crop", None)
+    resize = options.get("resize", None)
+    format = options.get("format", None)
+
+    if format and format["to"] == "gray":
+        if input_format == "yuv":
+            gray = yuv420_to_gray(image_data, input_width, input_height)
+            image = Image.fromarray(gray)
+        elif input_format == "rgb":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data).convert("L")
+        elif input_format == "rgba":
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data).convert("L")
+        else:
+            image = Image.frombytes("L", (input_width, input_height), image_data)
+
+        format = None
+    elif format and format["to"] == "rgba":
+        if input_format == "yuv":
+            rgba = yuv420_to_rgba(image_data, input_width, input_height)
+            image = Image.fromarray(rgba)
+        elif input_format == "rgb":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data).convert("RGBA")
+        elif input_format == "gray":
+            image = Image.frombytes("L", (input_width, input_height), image_data).convert("RGBA")
+        else:
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data)
+
+        format = None
+    else:
+        if input_format == "yuv":
+            rgb = yuv420_to_rgb(image_data, input_width, input_height)
+            image = Image.fromarray(rgb)
+        elif input_format == "rgb":
+            image = Image.frombytes("RGB", (input_width, input_height), image_data)
+        elif input_format == "gray":
+            image = Image.frombytes("L", (input_width, input_height), image_data)
+        else:
+            image = Image.frombytes("RGBA", (input_width, input_height), image_data)
+
+    if crop:
+        image = crop_image(image, crop)
+        input_width = crop["width"]
+        input_height = crop["height"]
+
+    if resize:
+        image = resize_image(image, input_width, input_height, resize)
+        input_width = resize.get("width", input_width)
+        input_height = resize.get("height", input_height)
+
+    if format:
+        image = format_image(image, format)
+
+    return image.tobytes()
+
+
+def crop_image(image: Image.Image, crop: ImageCrop) -> Image.Image:
+    crop_box = (
+        int(crop["left"]),
+        int(crop["top"]),
+        int(crop["left"] + crop["width"]),
+        int(crop["top"] + crop["height"]),
+    )
+
+    return image.crop(crop_box)
+
+
+def resize_image(image: Image.Image, input_width: int, input_height: int, resize: ImageResize) -> Image.Image:
+    width = resize.get("width", input_width)
+    height = resize.get("height", input_height)
+
+    if width and height and (width != input_width and height != input_height):
+        image = image.resize((int(width), int(height)), resample=Image.Resampling.BILINEAR)
+
+    return image
+
+
+def format_image(image: Image.Image, format: ImageFormat) -> Image.Image:
+    if format["to"] == "rgba":
+        image = image.convert("RGBA")
+    elif format["to"] == "gray":
+        image = image.convert("L")
+
+    return image
+
+
+def yuv420_to_rgb(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+    uv_size = frame_size // 4
+
+    raw_data = np.frombuffer(yuv_bytes, dtype=np.uint8)
+
+    y = raw_data[:frame_size].reshape((height, width)).astype(np.float32) - 16.0
+    u = (
+        raw_data[frame_size : frame_size + uv_size].reshape((height // 2, width // 2)).astype(np.float32)
+        - 128.0
+    )
+    v = raw_data[frame_size + uv_size :].reshape((height // 2, width // 2)).astype(np.float32) - 128.0
+
+    u = u.repeat(2, axis=0).repeat(2, axis=1)
+    v = v.repeat(2, axis=0).repeat(2, axis=1)
+
+    r = y + 1.402 * v
+    g = y - 0.344136 * u - 0.714136 * v
+    b = y + 1.772 * u
+
+    rgb = np.stack((r, g, b), axis=-1)
+    return np.clip(rgb, 0, 255).astype(np.uint8)
+
+
+def yuv420_to_rgba(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    rgb = yuv420_to_rgb(yuv_bytes, width, height)
+    alpha = np.full((height, width, 1), 255, dtype=np.uint8)
+    rgba = np.concatenate((rgb, alpha), axis=-1)
+    return rgba
+
+
+def yuv420_to_gray(yuv_bytes: bytes, width: int, height: int) -> np.ndarray[Any, Any]:
+    frame_size = width * height
+    raw_data = np.frombuffer(yuv_bytes, dtype=np.uint8)
+    return raw_data[:frame_size].reshape((height, width)).astype(np.uint8)

package/dist/server/src/polyglot/python/decoder/typings.py

@@ -0,0 +1,99 @@
+from typing import Any
+
+from camera_ui_types import FrameMetadata
+from typing_extensions import Literal, NotRequired, TypedDict
+
+WorkerMessage = Literal["started", "getFFmpegArgs", "updateClient", "removeClient"]
+
+MainMessage = Literal["setCameraName", "recoverClients"]
+
+
+class AuthConfig(TypedDict):
+    user: str
+    password: str
+
+
+class BaseFrameWorkerConfig(TypedDict):
+    frameWorkerId: str
+    cameraId: str
+    cameraName: str
+    ffmpegPath: str
+    logLevel: str
+    disableTimestamps: bool
+    auth: AuthConfig
+    proxyEndpoints: list[str]
+    fps: int
+    resolution: int
+
+
+class MainToWorkerMessage(TypedDict):
+    message: MainMessage
+    data: dict[str, Any]
+
+
+class WorkerToMainResponse(TypedDict):
+    response: NotRequired[dict[str, Any]]
+
+
+class WorkerToMainMessage(TypedDict):
+    message: WorkerMessage
+    data: dict[str, Any]
+
+
+class MainToWorkerResponse(TypedDict):
+    response: NotRequired[dict[str, Any]]
+
+
+class FfmpegArgs(TypedDict):
+    hwaccel: str
+    hwaccelArgs: list[str]
+    hwaccelFilter: str
+    threads: str
+
+
+class FfmpegArgsResponse(TypedDict):
+    cameraSource: str
+    ffmpegArgs: FfmpegArgs
+
+
+SignalingMessageType = Literal["connect", "disconnect", "metadata"]
+
+
+class SignalingRequest(TypedDict):
+    type: SignalingMessageType
+    requestId: str
+    cameraId: str
+    pluginId: str
+
+
+class SignalingResponse(TypedDict):
+    type: SignalingMessageType
+    requestId: str
+    metadata: NotRequired[FrameMetadata]
+
+
+class PingMessage(TypedDict):
+    type: Literal["ping"]
+    requestId: str
+
+
+class PongMessage(TypedDict):
+    type: Literal["pong"]
+    requestId: str
+
+
+class FrameWorkerClient:
+    def __init__(self, plugin_id: str, request_ids: list[str]):
+        self.plugin_id = plugin_id
+        self.request_ids = request_ids
+
+
+class RecoveredClient(TypedDict):
+    pluginId: str
+    requestIds: list[str]
+
+
+class PrebufferContainer(TypedDict):
+    frame_id: str
+    time: float
+    frame: bytes

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

@@ -0,0 +1,459 @@
+import inspect
+import json
+from contextlib import suppress
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Optional, TypeVar, Union, cast
+
+from camera_ui_types import (
+    PluginJsonBaseSchema,
+    PluginJsonSchema,
+    PluginJsonSchemaForm,
+    PluginRootSchema,
+    SchemaConfig,
+)
+from deepdiff import DeepDiff
+from lmdbm import Lmdb
+from logger import PluginLogger
+from plugin_api import PluginAPI
+from schema import (
+    config_path_to_schema_path,
+    generate_json_from_root_schema,
+    get_value_by_path,
+    remove_functions_from_schema_form,
+    schema_path_to_config_path,
+)
+from typing_extensions import Literal, overload
+from utilities.object_path import ObjectPath
+from utilities.utils import merge_with
+
+P = TypeVar("P", str, int, float, bool, dict[Any, Any], list[Any], None)
+
+
+def merge(
+    obj_value: Any,
+    src_value: Any,
+    key: Union[str, int],
+    object: Union[dict[str, Any], list[Any]],
+    source: Union[dict[str, Any], list[Any]],
+    stack: list[Any],
+) -> Any:
+    if isinstance(obj_value, list):
+        return src_value
+
+
+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 CameraStorage:
+    def __init__(
+        self,
+        api: PluginAPI,
+        logger: PluginLogger,
+        instance: Any,
+        camera_id: str,
+        schema: Optional[PluginJsonSchemaForm] = None,
+    ) -> None:
+        if schema is None:
+            schema = {}
+        self.__api = api
+        self.__logger = logger
+        self.__instance = instance
+        self.__camera_id = camera_id
+        self.__schema: PluginJsonSchemaForm = schema or {}
+        self.__values: dict[str, Any] = {}
+
+        db_path = Path(api.storage_path) / "volume"
+        self.__db: Lmdb[Literal["config"], dict[str, Any]] = JsonLmdb.open(file=str(db_path), flag="c")
+
+        self.__api.device_manager.once("cameraDeselected", self.__deselected)
+        self.__api.once("shutdown", self.__close)
+
+    @property
+    def values(self) -> dict[str, Any]:
+        return self.__values
+
+    def initialize_storage(self) -> None:
+        """
+        Initialize the storage.
+        This will load the configuration from the database.
+        """
+
+        camera_config: dict[str, Any] = {}
+
+        try:
+            config: Any = self.__db.get("config") or {}
+            camera_config = config.get(self.__camera_id, {})
+        except Exception as e:
+            self.__logger.error("Error loading config from database:", e)
+
+        schema_config = generate_json_from_root_schema({"schema": self.__schema})
+
+        self.__values = merge_with(schema_config, camera_config, merge, [])
+
+        self.__save_db()
+
+    @overload
+    async def get_value(self, path: str) -> Union[Any, None]: ...
+    @overload
+    async def get_value(self, path: str, default_value: P) -> P: ...
+    async def get_value(self, path: str, default_value: Optional[P] = None) -> Union[P, None]:
+        """
+        Get a value from the configuration by its key/path.
+        If the schema has an onGet function, the onGet function will be called.
+        If the onGet function is undefined, the value from the configuration will be returned.
+        If the schema has a default value, and the configuration value is undefined, the default value will be returned.
+
+        :param path: The path to the configuration value.
+        :param default_value: The default value to return if the actual value is undefined.
+        :return: The value from the configuration.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: PluginJsonBaseSchema = ObjectPath.get(self.__schema, schema_path)
+        config_value = ObjectPath.get(self.__values, path)
+
+        if schema:
+            on_get_function = schema.get("onGet", None)
+            if on_get_function is not None:
+                if inspect.iscoroutinefunction(on_get_function):
+                    return await on_get_function()
+                else:
+                    return on_get_function()  # type: ignore
+            if config_value is not None:
+                return config_value
+            if "default" in schema:
+                return schema["default"]
+            else:
+                return default_value
+
+    async def set_value(self, path: str, new_value: Any) -> None:
+        """
+        Set a new value for a given key/path in the configuration.
+        If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.
+        If the schema of the value is declared as storable, the value will be saved to the database.
+
+        :param path: The path to the configuration value.
+        :param new_value: The new value to set.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: PluginJsonSchema = ObjectPath.get(self.__schema, schema_path)
+
+        if schema:
+            old_config = deepcopy(self.__values)
+            ObjectPath.set(self.__values, path, new_value)
+
+            await self.__trigger_on_set_for_changes(old_config, self.__values)
+
+            if self.__contains_storable_schema(schema):
+                self.__save_db()
+
+    def has_value(self, path: str) -> bool:
+        """
+        Check if a value exists by its config path/key.
+
+        :param path: The path to the value to check.
+        :return: True if the value exists, false otherwise.
+        """
+
+        config_value = ObjectPath.get(self.__values, path)
+        return config_value is not None
+
+    async def getConfig(self) -> SchemaConfig:
+        """
+        Get the root schema and configuration.
+        This will also call the onGet functions for the schema.
+
+        :return: The root schema and configuration.
+        """
+
+        filtered_schema = remove_functions_from_schema_form(self.__schema)
+        root_schema: PluginRootSchema = {"schema": filtered_schema}
+
+        await self.__resolve_on_get_functions(self.__schema)
+
+        return {"rootSchema": root_schema, "config": self.__values}
+
+    async def setConfig(self, new_config: dict[str, Any]) -> None:
+        """
+        Set a new configuration.
+        If the schema of a value which has been changed has an onSet function, the onSet function will be called.
+
+        :param new_config: The new configuration to set.
+        """
+
+        old_config = deepcopy(self.__values)
+        self.__values = new_config
+
+        await self.__trigger_on_set_for_changes(old_config, self.__values)
+        self.__save_db()
+
+    @overload
+    async def add_schema(self, schema_or_path: PluginJsonSchemaForm) -> None: ...
+    @overload
+    async def add_schema(self, schema_or_path: str, schema: PluginJsonSchema) -> None: ...
+    async def add_schema(
+        self,
+        schema_or_path: Union[PluginJsonSchemaForm, str],
+        schema: Optional[PluginJsonSchema] = None,
+    ) -> None:
+        """
+        Add a new schema to the existing schema.
+        It will also add the value to the configuration.
+        If the schema is declared as storable, the value will be saved to the database.
+
+        :param schema: The new schema to add.
+        :param path: The path to the schema to add, optional.
+        """
+
+        should_save = False
+
+        if isinstance(schema_or_path, str) and schema is not None:
+            path = schema_or_path
+            schema_path = config_path_to_schema_path(path)
+
+            ObjectPath.set(self.__schema, schema_path, schema)
+
+            await self.__resolve_on_get_functions(schema, schema_path)
+
+            if self.__contains_storable_schema(schema):
+                should_save = True
+
+        elif isinstance(schema_or_path, dict) and schema is None:
+            new_schema = schema_or_path
+
+            self.__schema = merge_with(self.__schema, new_schema, merge, [])
+
+            await self.__resolve_on_get_functions(new_schema)
+
+            if self.__contains_storable_schema(new_schema):
+                should_save = True
+
+        else:
+            raise Exception("Invalid arguments for add_schema")
+
+        if should_save:
+            self.__save_db()
+
+    def remove_schema(self, path: str) -> None:
+        """
+        Remove a schema by its config path/key from the existing schema.
+        It will also remove the value from the configuration.
+        If the schema is declared as storable, the value will be removed from the database.
+
+        :param path: The path to the schema to remove.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+
+        if schema:
+            ObjectPath.delete(self.__schema, schema_path)
+            ObjectPath.delete(self.__values, path)
+
+            if self.__contains_storable_schema(schema):
+                self.__remove_db()
+
+    async def change_schema(self, path: str, new_schema: dict[str, Any]) -> None:
+        """
+        Change a schema by its config path/key from the existing schema.
+        It will also change the value from the configuration.
+        If the schema is declared as storable, the value will be saved to the database.
+
+        :param path: The path to the schema to change.
+        :param schema: The new schema to set.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+
+        if schema:
+            merge_with(schema, new_schema, merge, [])
+            ObjectPath.set(self.__schema, schema_path, schema)
+
+            await self.__resolve_on_get_functions(schema, schema_path)
+
+            if self.__contains_storable_schema(schema):
+                self.__save_db()
+
+    def get_schema(self, path: str) -> Optional[PluginJsonSchema]:
+        """
+        Get a schema by its config path/key.
+
+        :param path: The path to the schema to get.
+        :return: The schema.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+
+        return schema
+
+    def has_schema(self, path: str) -> bool:
+        """
+        Check if a schema exists by its config path/key.
+
+        :param path: The path to the schema to check.
+        :return: True if the schema exists, false otherwise.
+        """
+
+        schema_path = config_path_to_schema_path(path)
+        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+
+        return schema is not None
+
+    async def __resolve_on_get_functions(
+        self,
+        schema: Union[PluginJsonSchemaForm, PluginJsonSchema],
+        base_schema_path: str = "",
+    ) -> None:
+        if "onGet" in schema or "onSet" in schema:
+            await self.__resolve_on_get_functions_for_schema(base_schema_path)
+        elif "type" in schema and schema["type"] == "object":
+            if "properties" in schema:
+                await self.___resolve_on_get_functions_for_object(
+                    schema["properties"],  # type: ignore
+                    base_schema_path,
+                )
+        else:
+            _schema = cast(PluginJsonSchemaForm, schema)
+
+            for key, value in _schema.items():
+                schema_path = f"{base_schema_path}.{key}" if base_schema_path else key
+
+                if "type" in value and value["type"] == "object":
+                    if "properties" in value:
+                        s: Any = value["properties"]
+                        await self.__resolve_on_get_functions(s, schema_path)
+                else:
+                    await self.__resolve_on_get_functions_for_schema(schema_path)
+
+    async def ___resolve_on_get_functions_for_object(
+        self,
+        schema: PluginJsonSchemaForm,
+        base_schema_path: str,
+    ) -> None:
+        for key, _ in schema.items():
+            schema_path = f"{base_schema_path}.{key}" if base_schema_path else key
+            await self.__resolve_on_get_functions_for_schema(schema_path)
+
+    async def __resolve_on_get_functions_for_schema(self, schema_path: str) -> None:
+        config_path = schema_path_to_config_path(schema_path)
+        schema_value = await self.get_value(config_path)
+
+        if schema_value is not None:
+            ObjectPath.set(self.__values, config_path, schema_value)
+
+    async def __trigger_on_set_for_changes(
+        self, old_config: dict[str, Any], new_config: dict[str, Any], path: str = ""
+    ) -> None:
+        for key, _ in new_config.items():
+            new_path = f"{path}.{key}" if path else key
+            old_value: Any = get_value_by_path(old_config, key) or {}
+            new_value: Any = new_config[key]
+
+            if DeepDiff(old_value, new_value, ignore_order=True) != {}:
+                schema_path = config_path_to_schema_path(new_path)
+                schema_item: Optional[PluginJsonBaseSchema] = get_value_by_path(self.__schema, schema_path)
+
+                if schema_item:
+                    on_set_function = schema_item.get("onSet", None)
+                    if on_set_function:
+                        if inspect.iscoroutinefunction(on_set_function):
+                            await on_set_function(old_value, new_value)
+                        else:
+                            on_set_function(old_value, new_value)
+
+            if new_value and isinstance(new_value, dict):
+                nv: Any = new_value
+                await self.__trigger_on_set_for_changes(old_value, nv, new_path)
+
+    def __filter_storable_values(
+        self,
+        schema: PluginJsonSchemaForm,
+        base_schema_path: str = "",
+        result: dict[str, Any] = {},
+    ) -> dict[str, Any]:
+        for key, value in schema.items():
+            if "type" in value and value["type"] == "object":
+                if "properties" in value:
+                    s: Any = value["properties"]
+                    path = f"{base_schema_path}.{key}" if base_schema_path else key
+                    self.__filter_storable_values(s, path, result)
+            elif "store" in value and value["store"]:
+                schema_path = f"{base_schema_path}.{key}" if base_schema_path else key
+                config_path = schema_path_to_config_path(schema_path)
+                config_value = get_value_by_path(self.__values, config_path)
+
+                ObjectPath.set(result, config_path, config_value)
+
+        return result
+
+    def __contains_storable_schema(
+        self,
+        schema: Union[PluginJsonSchemaForm, PluginJsonSchema],
+    ) -> bool:
+        if "type" in schema and schema["type"] == "object":
+            if "type" in schema and schema["type"] == "object":
+                if "store" in schema and schema["store"]:
+                    return True
+                if "properties" in schema and schema["properties"]:
+                    for sub_schema in schema["properties"].values():
+                        sub: Any = sub_schema
+                        if self.__contains_storable_schema(sub):
+                            return True
+
+                return False
+
+            return False
+        else:
+            return any(
+                self.__contains_storable_schema(sub_schema)  # type: ignore
+                for sub_schema in schema.values()
+            )
+
+    def __save_db(self) -> None:
+        try:
+            config: Any = self.__db.get("config") or {}
+            storable_config = self.__filter_storable_values(self.__schema)
+
+            config[self.__camera_id] = storable_config
+
+            self.__db.update(
+                {
+                    "config": config,
+                }
+            )
+        except Exception as e:
+            self.__logger.error("Error saving to database:", e)
+
+    def __remove_db(self) -> None:
+        try:
+            config: Any = self.__db.get("config") or {}
+
+            if self.__camera_id in config:
+                del config[self.__camera_id]
+                self.__db.update(config)
+        except Exception as e:
+            self.__logger.error("Error removing from database:", e)
+
+    def __deselected(self, id: str) -> None:
+        if id == self.__camera_id:
+            self.__remove_db()
+
+    def __close(self) -> None:
+        with suppress(Exception):
+            self.__db.close()