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

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

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

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

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