camera.ui3 0.0.30-alpha.0

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,391 @@
+import inspect
+from contextlib import suppress
+from copy import deepcopy
+from typing import Any, Optional, TypeVar, Union, cast
+
+from camera_ui_types import (
+    JsonBaseSchema,
+    JsonSchema,
+    JsonSchemaForm,
+    RootSchema,
+    SchemaConfig,
+)
+from deepdiff import DeepDiff
+from lmdbm import Lmdb
+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, merge_with
+
+P = TypeVar("P", str, int, float, bool, dict[Any, Any], list[Any], None)
+
+
+class CameraStorage:
+    def __init__(
+        self,
+        api: PluginAPI,
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
+        instance: Any,
+        camera_id: str,
+        schema: Optional[JsonSchemaForm] = None,
+    ) -> None:
+        if schema is None:
+            schema = {}
+        self.__api = api
+        self.__plugin_db = plugin_db
+        self.__instance = instance
+        self.__camera_id = camera_id
+        self.schema: JsonSchemaForm = schema or {}
+        self.values: dict[str, Any] = {}
+
+        self.__api.once("shutdown", self.__close)
+
+    def initializeStorage(self) -> None:
+        """
+        Initialize the storage.
+        This will load the configuration from the database.
+        """
+
+        config: Any = self.__plugin_db.get("config") or {}
+        camera_config = config.get(self.__camera_id, {})
+        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 getValue(self, path: str) -> Union[Any, None]: ...
+    @overload
+    async def getValue(self, path: str, default_value: P) -> P: ...
+    async def getValue(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: JsonBaseSchema = 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 setValue(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: JsonSchema = 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 hasValue(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: RootSchema = {"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 addSchema(self, schema_or_path: JsonSchemaForm) -> None: ...
+    @overload
+    async def addSchema(self, schema_or_path: str, schema: JsonSchema) -> None: ...
+    async def addSchema(
+        self,
+        schema_or_path: Union[JsonSchemaForm, str],
+        schema: Optional[JsonSchema] = 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 addSchema")
+
+        if should_save:
+            self.__save_db()
+
+    def removeSchema(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[JsonSchema] = 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.__save_db()
+
+    async def changeSchema(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[JsonSchema] = 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 getSchema(self, path: str) -> Optional[JsonSchema]:
+        """
+        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[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
+
+        return schema
+
+    def hasSchema(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[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
+
+        return schema is not None
+
+    async def __resolve_on_get_functions(
+        self,
+        schema: Union[JsonSchemaForm, JsonSchema],
+        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(JsonSchemaForm, 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: JsonSchemaForm,
+        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.getValue(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[JsonBaseSchema] = get_value_by_path(self.schema, schema_path)
+
+                if schema_item and schema_item["type"] != "button":
+                    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: JsonSchemaForm,
+        base_schema_path: str = "",
+        result: dict[str, Any] = {},
+    ) -> dict[str, Any]:
+        for key, value in schema.items():
+            if value["type"] == "button":
+                continue
+
+            if 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[JsonSchemaForm, JsonSchema],
+    ) -> bool:
+        if schema["type"] == "boolean":
+            return False
+
+        if "store" in schema and schema["store"]:
+            return True
+
+        if schema["type"] == "object" and "properties" in schema:
+            schema_values: Any = schema["properties"].values()
+            return any(self.__contains_storable_schema(sub_schema) for sub_schema in schema_values)
+        elif schema["type"] == "array" and "items" in schema:
+            return self.__contains_storable_schema(schema["items"])
+
+        return False
+
+    def __save_db(self) -> None:
+        config: Any = self.__plugin_db.get("config") or {}
+        storable_config = self.__filter_storable_values(self.schema)
+
+        config[self.__camera_id] = storable_config
+
+        self.__plugin_db.update({"config": config})
+
+    def __close(self) -> None:
+        with suppress(Exception):
+            self.__save_db()