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

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

@@ -1,394 +0,0 @@
-import asyncio
-import importlib.util
-import inspect
-import os
-import signal
-import sys
-import traceback
-from asyncio import AbstractEventLoop
-from contextlib import suppress
-from pathlib import Path
-from types import ModuleType
-from typing import Any, Literal, Optional, cast
-
-from camera_ui_types import BasePlugin, CameraDevice
-from decoder.typings import AuthConfig
-from lmdbm import Lmdb
-from message_queue import MessageQueue
-from nats.aio.msg import Msg
-from plugin_api import PluginAPI
-from plugin_logger import PluginLogger
-from proxy.camera_device import CameraDeviceProxy
-from typings import (
-    PLUGIN_COMMAND,
-    PLUGIN_STATUS,
-    DeserializedError,
-    ProcessLoadMessage,
-    ProcessMessage,
-    ProcessResponse,
-    ProxyMessageStructure,
-)
-from utilities.connection import ProxyConnection
-from utilities.json_lmdb import JsonLmdb
-from utilities.packer import unpack
-from utilities.subscriptions import ProxySubscription
-from utilities.task import TaskSet
-
-if sys.platform == "win32":
-    import ctypes
-
-    def force_exit():
-        kernel32 = ctypes.windll.kernel32
-        kernel32.TerminateProcess(kernel32.GetCurrentProcess(), 1)
-else:
-
-    def force_exit():
-        os.kill(os.getpid(), signal.SIGKILL)
-
-
-def find_plugin_constructor(module: ModuleType) -> Any:
-    if hasattr(module, "__main__"):
-        main_func = module.__main__
-        if callable(main_func):
-            plugin_base_class: BasePlugin = 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(cls: Any) -> None:
-    base_plugin_methods = {
-        name for name in dir(BasePlugin) if callable(getattr(BasePlugin, 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(BasePlugin, 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 BasePlugin. "
-        #         f"Expected: {base_signature.return_annotation}, "
-        #         f"Actual: {cls_signature.return_annotation}"
-        #     )
-
-
-class PluginChild:
-    def __init__(self) -> None:
-        self.proxy_endpoints = [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")]
-
-        self.auth: AuthConfig = {
-            "user": os.environ["PROXY_USER"],
-            "password": os.environ["PROXY_PASSWORD"],
-        }
-
-        del os.environ["PROXY_USER"]
-        del os.environ["PROXY_PASSWORD"]
-        del os.environ["PROXY_ENDPOINTS"]
-
-        self.display_name = sys.argv[1] if len(sys.argv) > 1 else "PluginChild"
-        self.logger = PluginLogger(self.display_name, os.environ["LOGGER_DISABLE_TIMESTAMPS"] == "true")
-        self.plugin_db: Optional[Lmdb[Literal["config"], dict[str, Any]]] = None
-
-        self.subject = f"{os.environ['WORKER_ID']}.ipc.subscriber"
-        self.plugin_subject = f"{os.environ['PLUGIN_ID']}.child"
-        self.target_subject = f"{os.environ['WORKER_ID']}.ipc.publisher"
-
-        self.publisher: Optional[ProxyConnection] = None
-        self.subscriber: Optional[ProxySubscription] = None
-        self.plugin_subscriber: Optional[ProxySubscription] = None
-
-        self.tasks: TaskSet = TaskSet(f"{self.display_name} PluginChild")
-        self.message_queue: Optional[MessageQueue] = None
-
-        self.api: Optional[PluginAPI] = None
-        self.plugin: Optional[BasePlugin] = None
-
-        self.stopped = False
-        self.closed = False
-
-    async def run(self):
-        try:
-            self.shutdown_event = asyncio.Event()
-            self.setup_signal_handlers()
-            await self.init()
-            await self.shutdown_event.wait()
-        except asyncio.CancelledError:
-            pass
-
-    async def init(self) -> None:
-        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.subscriber = await self.publisher.subscribe(subject=self.subject)
-        self.subscriber.on("message", self.on_worker_message)
-
-        self.plugin_subscriber = await self.publisher.subscribe(subject=self.plugin_subject)
-        self.message_queue = MessageQueue(
-            self.logger,
-            self.publisher,
-            self.plugin_subscriber,
-            self.request_handler,
-        )
-
-        await self.send_message({"type": PLUGIN_STATUS.READY.value})
-
-    async def start(self, data: ProcessLoadMessage) -> None:
-        storage_path = data["storage"]["storagePath"]
-        config_file = data["storage"]["configFile"]
-        plugin_info = data["plugin"]
-        cameras = data["cameras"]
-
-        db_path = Path(storage_path) / "volume"
-        Path(db_path).mkdir(parents=True, exist_ok=True)
-
-        self.plugin_db = JsonLmdb.open(file=str(db_path), flag="c")
-
-        config: Any = self.plugin_db.get("config")
-        if config is None:
-            self.plugin_db.update({"config": {}})
-
-        self.api = PluginAPI(
-            plugin_info,
-            storage_path,
-            config_file,
-            self.logger,
-            self.proxy_endpoints,
-            self.auth,
-            self.plugin_db,
-        )
-
-        plugin_constructor = self.load_plugin()
-        self.plugin = cast(BasePlugin, plugin_constructor(self.logger, self.api))
-
-        await asyncio.gather(
-            self.api.core_manager.init(),
-            self.api.device_manager.init(),
-        )
-
-        cameras_devices = [
-            CameraDeviceProxy(
-                self.api,
-                self.logger,
-                camera,
-                plugin_info,
-                self.proxy_endpoints,
-                self.auth,
-            )
-            for camera in cameras
-        ]
-
-        await asyncio.gather(*(camera_device.init() for camera_device in cameras_devices))
-
-        self.api.device_manager.configure_cameras(cameras_devices)
-        self.plugin.configure_cameras(cast(list[CameraDevice], cameras_devices))
-
-        await self.send_message({"type": PLUGIN_STATUS.STARTED.value})
-
-        self.api.emit("finishLaunching")
-
-    async def stop(self) -> None:
-        if self.stopped:
-            return
-
-        self.stopped = True
-
-        if self.api:
-            self.api.emit("shutdown")
-
-        if self.message_queue:
-            self.message_queue.abort_queue()
-
-        if self.publisher:
-            with suppress(Exception):
-                await self.publisher.close()
-
-        if self.plugin_db:
-            await asyncio.sleep(0.5)
-            with suppress(Exception):
-                self.plugin_db.close()
-
-        self.shutdown_event.set()
-
-    def load_plugin(self) -> Any:
-        module_path = os.environ.get("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 = find_plugin_constructor(module)
-
-        check_plugin_class_methods(plugin_constructor)
-
-        return plugin_constructor
-
-    async def send_message(self, message: ProcessResponse) -> None:
-        if not self.publisher:
-            raise Exception("Publisher is not initialized")
-
-        await self.publisher.publish(self.target_subject, message)
-
-    async def request_handler(self, message: ProxyMessageStructure) -> None:
-        if not self.message_queue:
-            raise Exception("Message queue not initialized")
-
-        reply = message.copy()
-        reply["type"] = "reply"
-
-        try:
-            if not self.plugin or not self.api:
-                raise Exception("Plugin not initialized")
-
-            fn = message["fn"]
-            args = message["args"]
-            camera_id = message.get("cameraId", None)
-            camera_storage = self.api.storage_controller.get_camera_storage(camera_id or "")
-
-            if hasattr(self.plugin, fn) and callable(getattr(self.plugin, fn)):
-                method_to_call = getattr(self.plugin, fn)
-
-                if inspect.iscoroutinefunction(method_to_call):
-                    reply["response"] = await method_to_call(*args)
-                else:
-                    reply["response"] = method_to_call(*args)
-            elif camera_storage and hasattr(camera_storage, fn) and callable(getattr(camera_storage, fn)):
-                method_to_call = getattr(camera_storage, fn)
-
-                if inspect.iscoroutinefunction(method_to_call):
-                    reply["response"] = await method_to_call(*args)
-                else:
-                    reply["response"] = method_to_call(*args)
-            else:
-                raise Exception(f"Unknown function: {fn}")
-        except Exception as e:
-            deserialized_error: DeserializedError = {
-                "name": type(e).__name__,
-                "message": str(e),
-                "stack": traceback.format_exc(),
-            }
-
-            reply["error"] = deserialized_error
-
-        if message["timeout"] == 0:
-            return
-        else:
-            await self.message_queue.enqueue(reply)
-
-    async def on_worker_message(self, msg: Msg) -> None:
-        if self.stopped:
-            return
-
-        message: ProcessMessage = unpack(msg.data)
-
-        if "type" in message:
-            if message["type"] == PLUGIN_COMMAND.START.value and "data" in message:
-                await self.start(message["data"])
-            elif message["type"] == PLUGIN_COMMAND.STOP.value:
-                await self.stop()
-
-    async def gracefully_close(self, signame: str, reason: Any = "unknown"):
-        if self.stopped or self.closed:
-            return
-
-        self.closed = True
-
-        self.logger.log(
-            f"{self.display_name} is gracefully closing from signal='{signame}' reason='{reason}'..."
-        )
-
-        try:
-            stop_task = asyncio.create_task(self.stop(), name=f"{self.display_name} Stop")
-            await asyncio.wait_for(stop_task, timeout=2)
-            self.force_exit()
-        except asyncio.TimeoutError:
-            self.logger.warn("Failed to gracefully close before timeout, force quit!")
-            self.force_exit()
-
-    def setup_signal_handlers(self):
-        loop = asyncio.get_running_loop()
-        loop.set_exception_handler(self.handle_exception)
-
-        if sys.platform == "win32":
-            try:
-                from win32api import SetConsoleCtrlHandler
-
-                def handler(ctrl_type: int) -> bool:
-                    if ctrl_type in (0, 1, 2):  # CTRL_C_EVENT, CTRL_BREAK_EVENT, CTRL_CLOSE_EVENT
-                        asyncio.create_task(self.gracefully_close("SIGINT"))
-                        return True
-                    return False
-
-                SetConsoleCtrlHandler(handler, True)
-            except ImportError:
-                # self.logger.warn("win32api not available, falling back to limited signal support")
-                self.setup_limited_signal_handlers(loop)
-
-    def setup_limited_signal_handlers(self, loop: AbstractEventLoop):
-        for signame in ("SIGINT", "SIGTERM"):
-            try:  # noqa: SIM105
-                loop.add_signal_handler(
-                    getattr(signal, signame),
-                    lambda signame=signame: asyncio.create_task(self.gracefully_close(signame)),
-                )
-            except NotImplementedError:
-                # self.logger.warn(f"Signal {signame} is not supported on this platform")
-                pass
-
-    def force_exit(self):
-        if sys.platform == "win32":
-            # Windows-spezifisches Beenden
-            import ctypes
-
-            kernel32 = ctypes.windll.kernel32
-            kernel32.TerminateProcess(kernel32.GetCurrentProcess(), 1)
-        else:
-            # Unix-basiertes Beenden
-            os.kill(os.getpid(), signal.SIGKILL)
-
-    def handle_exception(self, loop: AbstractEventLoop, context: Any):
-        print("Exception context:", context)
-        traceback.print_exc()
-
-        msg = context.get("message", "Unknown error")
-        exception = context.get("exception")
-
-        if exception:
-            tb_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))  # type: ignore
-
-            self.logger.error(f"Caught exception: {msg}\n{tb_str}")
-        else:
-            self.logger.error(f"Caught exception: {msg}")
-
-        if loop.is_running():
-            asyncio.create_task(self.gracefully_close("uncaughtException", msg))
-
-
-if __name__ == "__main__":
-    plugin_child = PluginChild()
-    asyncio.run(plugin_child.run())
-    # asyncio.run(plugin_child.run(), debug=True)

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

@@ -1,187 +0,0 @@
-import json
-import os
-from typing import Any, Callable, Optional
-
-from camera_ui_types import JSONValue, PluginConfig
-from utilities.object_path import ObjectPath, Path
-
-
-class PluginConfigService:
-    def __init__(self, config_file: str):
-        self.__config_file = config_file
-        self.__config: PluginConfig = {}
-        self.__init()
-
-    def get(
-        self,
-        key: Path,
-        default_value: Optional[JSONValue] = None,
-        validate: Optional[Callable[[Any], bool]] = None,
-        refresh: bool = False,
-        write_if_not_valid: bool = False,
-    ) -> Any:
-        if refresh:
-            self.__read()
-
-        val = ObjectPath.get(self.__config, key, default_value)
-
-        if validate and default_value is not None:
-            is_valid = validate(val)
-
-            if not is_valid:
-                self.set(key, default_value, write_if_not_valid)
-
-        return val
-
-    def has(self, key: Path, refresh: bool = False) -> bool:
-        if refresh:
-            self.__read()
-
-        return ObjectPath.has(self.__config, key)
-
-    def ensure_exists(self, key: Path, default_value: JSONValue, write: bool = False) -> None:
-        exists = self.has(key)
-
-        ObjectPath.ensure_exists(self.__config, key, default_value)
-
-        if write and not exists:
-            self.__write()
-
-    def set(self, key: Path, value: Any, write: bool = False) -> None:
-        ObjectPath.set(self.__config, key, value)
-
-        if write:
-            self.__write()
-
-    def insert(self, key: Path, value: Any, at: int = 0, write: bool = False) -> None:
-        ObjectPath.insert(self.__config, key, value, at)
-
-        if write:
-            self.__write()
-
-    def push(self, key: Path, write: bool = False, *items: Any) -> None:
-        ObjectPath.push(self.__config, key, *items)
-
-        if write:
-            self.__write()
-
-    def delete(self, key: Path, write: bool = False) -> None:
-        ObjectPath.delete(self.__config, key)
-
-        if write:
-            self.__write()
-
-    def all(self, refresh: bool = False) -> PluginConfig:
-        if refresh:
-            self.__read()
-
-        return self.__config.copy()
-
-    def replace(self, config: PluginConfig, write: bool = False) -> None:
-        self.__config = config
-
-        if write:
-            self.__write()
-
-    def update_value(
-        self,
-        path: str,
-        search_key: str,
-        search_value: Any,
-        target_key: str,
-        new_value: Any,
-        write: bool = False,
-    ) -> None:
-        path_segments = path.split(".")
-
-        def update_recursive(obj: Any, index: int) -> None:
-            if index == len(path_segments):
-                if obj.get(search_key) == search_value:
-                    obj[target_key] = new_value
-                return
-
-            current_path = path_segments[index]
-
-            if isinstance(obj.get(current_path), list):
-                for element in obj[current_path]:
-                    update_recursive(element, index + 1)
-            elif obj.get(current_path) is not None:
-                update_recursive(obj[current_path], index + 1)
-
-        update_recursive(self.__config, 0)
-
-        self.set(path_segments[0], self.__config[path_segments[0]], write)
-
-    def replace_or_add_item(
-        self,
-        path: str,
-        search_key: str,
-        search_value: Any,
-        new_item: Any,
-        write: bool = False,
-    ) -> None:
-        path_segments = path.split(".")
-
-        def ensure_path_exists(obj: Any, path_segments: list[str], index: int) -> None:
-            if index >= len(path_segments):
-                return
-
-            current_path = path_segments[index]
-
-            if obj.get(current_path) is None:
-                obj[current_path] = [] if index == len(path_segments) - 1 else {}
-
-            ensure_path_exists(obj[current_path], path_segments, index + 1)
-
-        def find_and_replace_or_add_recursive(obj: Any, path_index: int) -> None:
-            if isinstance(obj, list):
-                o: list[Any] = obj
-                for sub_obj in o:
-                    find_and_replace_or_add_recursive(sub_obj, path_index)
-            else:
-                current_path = path_segments[path_index]
-                if path_index == len(path_segments) - 1:
-                    if isinstance(obj.get(current_path), list):
-                        item_index = next(
-                            (
-                                index
-                                for index, item in enumerate(obj[current_path])
-                                if item.get(search_key) == search_value
-                            ),
-                            -1,
-                        )
-                        if item_index != -1:
-                            obj[current_path][item_index] = new_item
-                        else:
-                            obj[current_path].append(new_item)
-                elif obj.get(current_path) is not None:
-                    find_and_replace_or_add_recursive(obj[current_path], path_index + 1)
-
-        ensure_path_exists(self.__config, path_segments, 0)
-        find_and_replace_or_add_recursive(self.__config, 0)
-
-        self.set(path_segments[0], self.__config[path_segments[0]], write)
-
-    def __init(self) -> None:
-        directory = os.path.dirname(self.__config_file)
-
-        if not os.path.exists(directory):
-            os.makedirs(directory)
-
-        if not os.path.exists(self.__config_file):
-            open(self.__config_file, "a").close()
-
-        self.__read()
-
-    def __read(self) -> None:
-        try:
-            with open(self.__config_file) as file:
-                config = json.load(file)
-        except (FileNotFoundError, json.JSONDecodeError):
-            config = {}
-
-        self.__config = config or self.__config or {}
-
-    def __write(self) -> None:
-        with open(self.__config_file, "w") as file:
-            json.dump(self.__config, file, indent=2)

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

@@ -1 +0,0 @@
-NATS_SERVER_SUBJECT = "camera.ui-server"