@camera.ui/server 0.0.22-alpha.1 → 0.0.22-alpha.3

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

@@ -1,182 +0,0 @@
-import asyncio
-from typing import Any, Callable, cast
-
-from nats.aio.msg import Msg
-from plugin_logger import PluginLogger
-from plugins.constants import NATS_SERVER_SUBJECT
-from typings import ProxyMessageStructure, QueueItem, RemoteError
-from utilities.connection import ProxyConnection
-from utilities.packer import unpack
-from utilities.subscriptions import ProxySubscription
-from utilities.task import TaskSet
-
-
-class MessageQueue:
-    def __init__(
-        self,
-        logger: PluginLogger,
-        publisher: ProxyConnection,
-        subscriber: ProxySubscription,
-        request_handler: Callable[[ProxyMessageStructure], Any],
-    ):
-        self.logger = logger
-        self.publisher = publisher
-        self.subscriber = subscriber
-        self.request_handler = request_handler
-
-        self.aborted = False
-        self.is_processing = False
-
-        self.tasks: TaskSet = TaskSet(f"MessageQueue {self.publisher.name}")
-        self.queue: list[QueueItem] = []
-        self.pending_responses: dict[str, QueueItem] = {}
-
-        self.subscriber.on("message", self.__on_message)
-
-    def abort_queue(self) -> None:
-        self.aborted = True
-        self.is_processing = False
-
-        while self.queue:
-            item = self.queue.pop(0)
-            remote_error = RemoteError(
-                {
-                    "name": "AbortError",
-                    "message": "Message processing aborted",
-                    "stack": "",
-                },
-                item["message"],
-            )
-
-            item["reject"](remote_error)
-
-        for request_id, handlers in self.pending_responses.items():
-            remote_error = RemoteError(
-                {
-                    "name": "AbortError",
-                    "message": "Request aborted due to queue abort",
-                    "stack": "",
-                },
-                handlers["message"],
-            )
-
-            handlers["reject"](remote_error)
-            del self.pending_responses[request_id]
-
-    async def enqueue(self, message: ProxyMessageStructure) -> Any:
-        if message["type"] == "request" and message["timeout"] > 0:
-            # print(
-            #     "CLIENT => Enqueueing message:", json.dumps(message, indent=4)
-            # )
-
-            promise = asyncio.get_event_loop().create_future()
-
-            queue_item: QueueItem = {
-                "message": message,
-                "resolve": promise.set_result,
-                "reject": promise.set_exception,
-            }
-
-            self.queue.append(queue_item)
-
-            if not self.is_processing:
-                self.tasks.add(self.__process_queue())
-
-            return await promise
-        else:
-            await self.publisher.publish(NATS_SERVER_SUBJECT, message)
-
-    async def __process_queue(self) -> None:
-        if self.is_processing or not self.queue or self.aborted:
-            return
-
-        self.is_processing = True
-
-        while self.queue and not self.aborted:
-            current_item = self.queue.pop(0)
-            request_id: str = current_item["message"].get("requestId", "")
-
-            # print(
-            #     "CLIENT => Sending request to SERVER:",
-            #     json.dumps(current_item["message"], indent=4),
-            # )
-
-            timeout = current_item["message"].get("timeout", 5000) / 1000
-
-            def cleanup():
-                if request_id in self.pending_responses:
-                    handle.cancel()
-                    del self.pending_responses[request_id]
-
-            def on_timeout():
-                if not self.aborted:
-                    remote_error = RemoteError(
-                        {
-                            "name": "TimeoutError",
-                            "message": f"Request timed out after {timeout} seconds",
-                            "stack": "",
-                        },
-                        current_item["message"],
-                    )
-
-                    current_item["reject"](remote_error)
-                    cleanup()
-
-            loop = asyncio.get_event_loop()
-            handle = loop.call_later(timeout, on_timeout)
-
-            def response(response: Any):
-                if not self.aborted:
-                    current_item["resolve"](response)
-                    cleanup()
-
-            def reject(error: RemoteError):
-                if not self.aborted:
-                    current_item["reject"](error)
-                    cleanup()
-
-            self.pending_responses[request_id] = {
-                "message": current_item["message"],
-                "resolve": response,
-                "reject": reject,
-            }
-
-            await self.publisher.publish(NATS_SERVER_SUBJECT, current_item["message"])
-
-        self.is_processing = False
-
-    async def __on_message(self, msg: Msg) -> None:
-        if self.aborted:
-            return
-
-        message = cast(ProxyMessageStructure, unpack(msg.data))
-
-        if message.get("type") == "reply":
-            # print(
-            #     "CLIENT => Received reply from SERVER:",
-            #     json.dumps(message, indent=4),
-            # )
-
-            request_id = message.get("requestId", "")
-
-            current_item = self.pending_responses.get(request_id, None)
-
-            if current_item is None:
-                # self.logger.error("Unknown reply from server:", message)
-                return
-
-            if "error" in message:
-                error = message.pop("error")
-                cause: Any = {k: v for k, v in message.items()}
-                current_item["reject"](RemoteError(error, cause))
-            else:
-                current_item["resolve"](message.get("response", {}))
-        elif message.get("type") == "request":
-            # print(
-            #     "CLIENT => Received request from SERVER:",
-            #     json.dumps(message, indent=4),
-            # )
-
-            self.tasks.add(self.request_handler(message))
-        else:
-            raise Exception(f"Invalid message type received: {message['type']}")

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

@@ -1,34 +0,0 @@
-from typing import Any, Literal
-
-from config_service import PluginConfigService
-from decoder.typings import AuthConfig
-from lmdbm import Lmdb
-from plugin_logger import PluginLogger
-from pyeecui.asyncio import AsyncIOEventEmitter
-from typings import PluginInfo
-
-
-class PluginAPI(AsyncIOEventEmitter):
-    def __init__(
-        self,
-        plugin: PluginInfo,
-        storage_path: str,
-        config_file: str,
-        logger: PluginLogger,
-        proxy_endpoints: list[str],
-        auth: AuthConfig,
-        plugin_db: Lmdb[Literal["config"], dict[str, Any]],
-    ) -> None:
-        super().__init__()
-
-        from proxy.core_manager import CoreManager
-        from proxy.device_manager import DeviceManager
-        from storage_controller import StorageController
-
-        self.storage_path = storage_path
-        self.config_file = config_file
-
-        self.config_service = PluginConfigService(config_file)
-        self.storage_controller = StorageController(self, plugin_db)
-        self.core_manager = CoreManager(self, logger, plugin, proxy_endpoints, auth)
-        self.device_manager = DeviceManager(self, logger, plugin, proxy_endpoints, auth)

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

@@ -1,111 +0,0 @@
-import json
-import traceback
-from datetime import datetime
-from typing import Any
-
-
-class Colors:
-    RESET = "\033[0m"
-    WHITE = "\033[37m"
-    BLUE = "\033[34m"
-    CYAN = "\033[36m"
-    RED = "\033[31m"
-    YELLOW = "\033[33m"
-    MAGENTA = "\033[35m"
-    LIGHT_BLACK = "\033[90m"
-    RED_BACKGROUND = "\033[41m"
-    YELLOW_BACKGROUND = "\033[43m"
-    MAGENTA_BACKGROUND = "\033[45m"
-    WHITE_BACKGROUND = "\033[47m"
-    BOLD = "\033[1m"
-
-
-class PluginLogger:
-    def __init__(self, prefix: str, disable_timestamps: bool) -> None:
-        self.__prefix = "camera.ui"
-        self.__disable_timestamps = disable_timestamps
-        self.__logger_prefix = prefix
-
-        self.debug_enabled = True
-        self.trace_enabled = True
-
-    @property
-    def prefix(self) -> str:
-        if not self.__disable_timestamps:
-            return f"{Colors.WHITE}[{self.__format_date_time()}] {Colors.BLUE}[{self.__prefix}] {Colors.CYAN}[{self.__logger_prefix}]{Colors.RESET}"
-        else:
-            return f"{Colors.BLUE}[{self.__prefix}] {Colors.CYAN}[{self.__logger_prefix}]{Colors.RESET}"
-
-    def log(self, *args: Any) -> None:
-        formatted_args = self.__format_args(args)
-        print(self.prefix, *formatted_args)
-
-    def error(self, *args: Any) -> None:
-        formatted_args = self.__format_args(args)
-        print(
-            self.prefix,
-            f"{Colors.RED_BACKGROUND}{Colors.BOLD} ERROR {Colors.RESET}",
-            f"{Colors.RED}{' '.join(formatted_args)}{Colors.RESET}",
-        )
-
-    def warn(self, *args: Any) -> None:
-        formatted_args = self.__format_args(args)
-        print(
-            self.prefix,
-            f"{Colors.YELLOW_BACKGROUND}{Colors.BOLD} WARN {Colors.RESET}",
-            f"{Colors.YELLOW}{' '.join(formatted_args)}{Colors.RESET}",
-        )
-
-    def attention(self, *args: Any) -> None:
-        formatted_args = self.__format_args(args)
-        print(
-            self.prefix,
-            f"{Colors.MAGENTA_BACKGROUND}{Colors.BOLD} ATTENTION {Colors.RESET}",
-            f"{Colors.MAGENTA}{' '.join(formatted_args)}{Colors.RESET}",
-        )
-
-    def debug(self, *args: Any) -> None:
-        if not self.debug_enabled:
-            return
-
-        formatted_args = self.__format_args(args)
-        print(
-            self.prefix,
-            f"{Colors.LIGHT_BLACK}{' '.join(formatted_args)}{Colors.RESET}",
-        )
-
-    def trace(self, *args: Any) -> None:
-        if not self.trace_enabled:
-            return
-
-        formatted_args = self.__format_args(args)
-        print(
-            self.prefix,
-            f"{Colors.WHITE_BACKGROUND}{Colors.BOLD} TRACE {Colors.RESET}",
-            f"{Colors.LIGHT_BLACK}{' '.join(formatted_args)}{Colors.RESET}",
-        )
-
-    def __format_args(self, args: Any) -> list[str]:
-        formatted_args: list[str] = []
-        for arg in args:
-            if isinstance(arg, BaseException):
-                message = f"{arg.__class__.__name__}: {arg}"
-                formatted_args.append(message)
-                traceback_info = traceback.format_exception(type(arg), arg, arg.__traceback__)
-                formatted_args.append("\n")
-                formatted_args.extend(traceback_info)
-                # formatted_args.extend(traceback_info[:-1])
-            elif isinstance(arg, dict):
-                try:
-                    formatted_args.append(json.dumps(arg, indent=2))
-                except TypeError:
-                    formatted_args.append(repr(arg))  # type: ignore
-            else:
-                formatted_args.append(str(arg))
-        return formatted_args
-
-    def __format_date_time(self) -> str:
-        try:
-            return datetime.now().strftime("%d.%m.%Y, %H:%M:%S")
-        except:  # noqa
-            return "Unknown"