@camera.ui/server 0.0.69 → 0.0.71-dev.0

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/__init__.py

@@ -1,350 +0,0 @@
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from collections.abc import Awaitable
-from contextlib import suppress
-from datetime import datetime
-from typing import Any, Callable, TypeVar, Union
-
-from .base.client import RPCClient
-from .base.connection import RPCConnectionManager
-from .base.errors import ERROR_CODES, ErrorFactory
-from .base.messaging import BaseMessaging
-from .base.rpc import RPCConnection
-from .constants import DEFAULTS, SUBJECTS
-from .typings import (
-    ClientConnectionOptions,
-    ClientMetrics,
-    ClientStatus,
-    ConnectionMessage,
-    ConnectionState,
-    Message,
-    ResponseMessage,
-    RPCOptions,
-)
-from .utils.logger import setup_logger
-from .utils.routing import EndpointType
-from .utils.subscriptions import SubscriptionWrapper
-from .utils.tasks import TaskSet
-from .utils.validate import ValidationUtils
-
-logger: logging.Logger = setup_logger("camera:ui:client:instance")
-
-# Types
-T = TypeVar("T")
-R = TypeVar("R")
-
-
-class ClientInstance(BaseMessaging, ABC):
-    type_: EndpointType
-    options: ClientConnectionOptions
-
-    _client: RPCClient
-    _status: ConnectionState
-    _error: Exception | None
-    _metrics_task: asyncio.Task[Any] | None
-    _task_set: TaskSet
-
-    def __init__(
-        self,
-        type_: EndpointType,
-        options: ClientConnectionOptions,
-    ):
-        super().__init__()
-        ValidationUtils.validate_connection_options(options)
-
-        self.options = options
-        self.type_ = type_
-        self._client = RPCClient(self.type_, options)
-        self._status = ConnectionState.STOPPED
-        self._error = None
-        self._metrics_task = None
-        self._task_set = TaskSet("ClientInstance")
-
-    async def start(self) -> None:
-        try:
-            if self._status == ConnectionState.RUNNING:
-                return
-
-            # Connect to NATS
-            await self._client.connect()
-
-            # Setup subscriptions
-            await self._setup_subscriptions()
-
-            # Start metrics collection
-            self._start_metrics_collection()
-
-            # Update state
-            await self._update_status(ConnectionState.RUNNING)
-
-            # Call client-specific start logic
-            self._task_set.add(self.on_start())
-
-            logger.debug(f"Client {self.options['metadata']['id']} started successfully")
-
-        except Exception as e:
-            raise ErrorFactory.connection.connection_failed(
-                e,
-                {
-                    "description": "Failed to start client",
-                    "code": ERROR_CODES.CONNECTION.FAILED,
-                    "metadata": {
-                        "type": self.type_,
-                        "metadata": self.options["metadata"],
-                    },
-                },
-            ) from e
-
-    async def stop(self) -> None:
-        try:
-            if self._status == ConnectionState.STOPPED:
-                return
-
-            self._task_set.remove_all()
-
-            # Stop metrics collection
-            self._stop_metrics_collection()
-
-            # Update state
-            await self._update_status(ConnectionState.STOPPING)
-
-            # Call client-specific before stop hook
-            if hasattr(self, "on_before_stop"):
-                await self.on_before_stop()
-
-            # Update state
-            await self._update_status(ConnectionState.STOPPED)
-
-            # Disconnect from NATS
-            await self._client.disconnect()
-
-            # Call client-specific stop logic
-            with suppress(Exception):
-                await asyncio.wait_for(self.on_stop(), timeout=3)
-
-            logger.debug(f"Client {self.options['metadata']['name']} stopped successfully")
-
-        except Exception as e:
-            raise ErrorFactory.connection.connection_failed(
-                e,
-                {
-                    "description": "Failed to stop client",
-                    "code": ERROR_CODES.CONNECTION.FAILED,
-                    "metadata": {
-                        "type": self.type_,
-                        "metadata": self.options["metadata"],
-                    },
-                },
-            ) from e
-
-    async def send_to_plugin(self, plugin_id: str, data: Any) -> None:
-        return await self._client.send_to_plugin(plugin_id, data)
-
-    async def send_to_service(self, service_id: str, data: Any) -> None:
-        return await self._client.send_to_service(service_id, data)
-
-    async def send_to_server(self, data: Any) -> None:
-        return await self._client.send_to_server(data)
-
-    async def request_from_plugin(
-        self, plugin_id: str, data: Any, timeout: int | None = None
-    ) -> ResponseMessage[Any]:
-        return await self._client.request_from_plugin(plugin_id, data, timeout)
-
-    async def request_from_service(
-        self, service_id: str, data: Any, timeout: int | None = None
-    ) -> ResponseMessage[Any]:
-        return await self._client.request_from_service(service_id, data, timeout)
-
-    async def request_from_server(self, data: Any, timeout: int | None = None) -> ResponseMessage[Any]:
-        return await self._client.request_from_server(data, timeout)
-
-    async def on_plugin_message(
-        self, plugin_id: str | None, handler: Callable[[T], Union[R, Awaitable[R | None]]]
-    ) -> None:
-        await self._client.on_plugin_message(plugin_id, handler)
-
-    async def on_service_message(
-        self, service_id: str | None, handler: Callable[[T], Union[R, Awaitable[R | None]]]
-    ) -> None:
-        await self._client.on_service_message(service_id, handler)
-
-    async def on_server_message(
-        self, handler: Callable[[T], Union[R, Awaitable[R | None]]]
-    ) -> SubscriptionWrapper:
-        return await self._client.on_server_message(handler)
-
-    async def register_rpc_handler(
-        self, namespace: str, handler: Union[dict[str, Callable[..., Any]], object]
-    ) -> None:
-        await self._client.register_rpc_handler(namespace, handler)
-
-    def register_rpc_handler_sync(
-        self, namespace: str, handler: Union[dict[str, Callable[..., Any]], object]
-    ) -> None:
-        self._task_set.add(self.register_rpc_handler(namespace, handler))
-
-    async def unregister_rpc_handler(self, namespace: str) -> None:
-        await self._client.unregister_rpc_handler(namespace)
-
-    async def create_rpc_proxy(
-        self, type: type[T], namespace: str, rpc_options: RPCOptions | None = None
-    ) -> T:
-        return await self._client.create_rpc_proxy(type, namespace, rpc_options)
-
-    async def create_rpc_connection(
-        self, namespace: str, rpc_options: RPCOptions | None = None
-    ) -> RPCConnection:
-        return await self._client.create_rpc_connection(namespace, rpc_options)
-
-    async def disconnect_rpc_connection(self, namespace: str) -> None:
-        return await self._client.disconnect_rpc_connection(namespace)
-
-    def get_status(self) -> ClientStatus:
-        return {
-            "id": self.options["metadata"]["id"],
-            "type": self.type_,
-            "state": self._status,
-            "error": self._error,
-            "metadata": self.options["metadata"],
-        }
-
-    def is_connected(self) -> bool:
-        return self._client.is_connected()
-
-    def get_connection_manager(self) -> RPCConnectionManager:
-        return self._client.get_connection_manager()
-
-    def get_connection_anager(self) -> RPCConnectionManager:
-        return self._client.get_connection_manager()
-
-    def is_running(self) -> bool:
-        return self._status == ConnectionState.RUNNING
-
-    def is_server_running(self) -> bool:
-        return self._client.is_server_running()
-
-    # Abstract methods that clients must implement
-    @abstractmethod
-    async def on_start(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    async def on_stop(self) -> None:
-        raise NotImplementedError
-
-    # Optional lifecycle hooks
-
-    async def on_before_stop(self) -> None:
-        pass
-
-    async def _setup_subscriptions(self) -> None:
-        await self.subscribe(
-            f"{SUBJECTS.HEALTH.PING}.{self.type_}.{self.options['metadata']['id']}", self._handle_ping
-        )
-
-    def _start_metrics_collection(self) -> None:
-        self._stop_metrics_collection()
-        self._metrics_task = self._task_set.add(self._metrics_collection_loop())
-
-    def _stop_metrics_collection(self) -> None:
-        self._task_set.remove(self._metrics_task)
-
-    async def _metrics_collection_loop(self) -> None:
-        while True:
-            try:
-                metrics = self._aggregate_metrics()
-                subject = f"{SUBJECTS.METRICS.UPDATE}.{self.type_}.{self.options['metadata']['id']}"
-                await self.publish(subject, metrics)
-                logger.debug(f"Published metrics for {self.options['metadata']['id']}: {metrics}")
-            except Exception:
-                logger.error(f"Failed to publish metrics for {self.options['metadata']['id']}", exc_info=True)
-
-            await asyncio.sleep(DEFAULTS.INTERVALS.METRICS / 1000)  # Convert ms to seconds
-
-    def _aggregate_metrics(self) -> ClientMetrics:
-        connection_managers = self._client.get_connection_managers()
-        logger.debug(f"Aggregating metrics from connection managers: {len(connection_managers)}")
-
-        # Initialize aggregated metrics
-        aggregated: ClientMetrics = {
-            "timestamp": int(datetime.now().timestamp() * 1000),  # Current time in milliseconds
-            "startTime": min(cm.get_metrics()["startTime"] for cm in connection_managers),
-            "requests": {"total": 0, "active": 0, "errors": 0, "perSecond": 0, "avgResponseTime": 0},
-            "messages": {"published": 0, "received": 0, "errors": 0},
-            "rpc": {"total": 0, "active": 0, "errors": 0},
-            "subscriptions": {"active": 0, "messageHandlers": 0, "requestHandlers": 0, "rpcHandlers": 0},
-        }
-
-        total_requests: int = 0
-        total_response_time: float = 0
-
-        # Collect metrics from all managers
-        for manager in connection_managers:
-            metrics = manager.get_metrics()
-
-            # Accumulate counters
-            aggregated["requests"]["total"] += metrics["requests"]["total"]
-            aggregated["requests"]["active"] += metrics["requests"]["active"]
-            aggregated["requests"]["errors"] += metrics["requests"]["errors"]
-
-            # Collect data for weighted average of RPS and response time
-            request_weight = metrics["requests"]["total"]
-            if request_weight > 0:
-                total_requests += request_weight
-                total_response_time += metrics["requests"]["avgResponseTime"] * request_weight
-                aggregated["requests"]["perSecond"] += metrics["requests"]["perSecond"]
-
-            # Accumulate other metrics
-            aggregated["messages"]["published"] += metrics["messages"]["published"]
-            aggregated["messages"]["received"] += metrics["messages"]["received"]
-            aggregated["messages"]["errors"] += metrics["messages"]["errors"]
-
-            aggregated["rpc"]["total"] += metrics["rpc"]["total"]
-            aggregated["rpc"]["active"] += metrics["rpc"]["active"]
-            aggregated["rpc"]["errors"] += metrics["rpc"]["errors"]
-
-            # For subscriptions we take the current values
-            aggregated["subscriptions"]["active"] += metrics["subscriptions"]["active"]
-            aggregated["subscriptions"]["messageHandlers"] += metrics["subscriptions"]["messageHandlers"]
-            aggregated["subscriptions"]["requestHandlers"] += metrics["subscriptions"]["requestHandlers"]
-            aggregated["subscriptions"]["rpcHandlers"] += metrics["subscriptions"]["rpcHandlers"]
-
-        # Calculate final values
-        if total_requests > 0:
-            aggregated["requests"]["avgResponseTime"] = total_response_time / total_requests
-
-        # RPS is averaged across all managers
-        if connection_managers:
-            aggregated["requests"]["perSecond"] = aggregated["requests"]["perSecond"] / len(
-                connection_managers
-            )
-
-        return aggregated
-
-    async def _handle_ping(self, _: Message[ConnectionMessage]) -> None:
-        status_subject = SUBJECTS.PLUGIN.STATUS if self.type_ == "plugin" else SUBJECTS.SERVICE.STATUS
-        await self._client.publish(
-            f"{status_subject}.{self.options['metadata']['id']}", self.get_status()["state"]
-        )
-
-    async def _update_status(self, state: ConnectionState, error: Exception | None = None) -> None:
-        if self._status == state:
-            return
-
-        self._status = state
-        self._error = error
-        logger.debug(f"Client {self.options['metadata']['name']} state changed to {state}")
-
-        try:
-            if self._client.is_connected():
-                status_subject = SUBJECTS.PLUGIN.STATUS if "plugin" else SUBJECTS.SERVICE.STATUS
-                await self._client.publish(
-                    f"{status_subject}.{self.options['metadata']['id']}", self.get_status()["state"]
-                )
-            else:
-                logger.debug("Skipping status update: Not connected to server")
-
-        except Exception:
-            logger.error("Failed to update state", exc_info=True)

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/base/base.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import inspect
-from abc import abstractmethod
-from collections.abc import Awaitable
-from typing import Any, Callable, TypeVar, cast
-
-from ..typings import ClientConnectionOptions, Message, ResponseMessage, RPCOptions
-from ..utils.routing import EndpointType, MessageRouter
-from ..utils.subscriptions import SubscriptionWrapper
-from ..utils.validate import ValidationUtils
-from .connection import RPCConnectionManager
-from .errors import ERROR_CODES, ErrorFactory
-from .messaging import BaseMessaging
-from .rpc import RPCConnection
-
-T = TypeVar("T")
-R = TypeVar("R")
-
-
-class RPCBase(BaseMessaging):
-    type_: EndpointType
-    options: ClientConnectionOptions
-
-    _connection: RPCConnectionManager
-    _rpc_managers: dict[str, RPCConnection]
-    _remote_rpc_managers: dict[str, RPCConnection]
-
-    def __init__(self, type_: EndpointType, options: ClientConnectionOptions) -> None:
-        super().__init__()
-        self.type_ = type_
-        self.options = options
-        self._connection = RPCConnectionManager(type_, options)
-        self._rpc_managers = {}
-        self._remote_rpc_managers = {}
-        ValidationUtils.validate_connection_options(options)
-
-    async def send_to_plugin(self, plugin_id: str, data: Any) -> None:
-        subject = self._get_plugin_subject(plugin_id)
-        routing = MessageRouter.create_routing_metadata(
-            self.type_, self.options["metadata"]["id"], self.type_, plugin_id
-        )
-        await self.publish(subject, data, routing)
-
-    async def send_to_service(self, service_id: str, data: Any) -> None:
-        subject = self._get_service_subject(service_id)
-        routing = MessageRouter.create_routing_metadata(
-            self.type_, self.options["metadata"]["id"], "service", service_id
-        )
-        await self.publish(subject, data, routing)
-
-    async def request_from_plugin(
-        self, plugin_id: str, data: Any, timeout: int | None = None
-    ) -> ResponseMessage[Any]:
-        subject = self._get_plugin_subject(plugin_id)
-        routing = MessageRouter.create_routing_metadata(
-            self.type_, self.options["metadata"]["id"], "plugin", plugin_id
-        )
-        return await self.request(subject, data, timeout, routing)
-
-    async def request_from_service(
-        self, target_service_id: str, data: Any, timeout: int | None = None
-    ) -> ResponseMessage[Any]:
-        subject = self._get_service_subject(target_service_id)
-        routing = MessageRouter.create_routing_metadata(
-            self.type_, self.options["metadata"]["id"], "service", target_service_id
-        )
-        return await self.request(subject, data, timeout, routing)
-
-    async def on_plugin_message(
-        self, plugin_id: str | None, handler: Callable[[T], R | Awaitable[R]]
-    ) -> SubscriptionWrapper:
-        if not plugin_id:
-            plugin_id = "*"
-
-        subject = (
-            MessageRouter.get_plugin_to_plugin_subject(plugin_id, self.options["metadata"]["id"])
-            if self.type_ == "plugin"
-            else MessageRouter.get_plugin_to_service_subject(plugin_id, self.options["metadata"]["id"])
-            if self.type_ == "service"
-            else MessageRouter.get_plugin_to_server_subject(plugin_id, self.options["metadata"]["id"])
-        )
-
-        async def wrapped_handler(message: Message[T]) -> R:
-            if inspect.iscoroutinefunction(handler) or inspect.isawaitable(handler):
-                return await cast(Awaitable[R], handler(message["data"]))
-            else:
-                return cast(R, handler(message["data"]))
-
-        return await self.handle_request(subject, wrapped_handler)
-
-    async def on_service_message(
-        self, service_id: str | None, handler: Callable[[T], R | Awaitable[R]]
-    ) -> SubscriptionWrapper:
-        if not service_id:
-            service_id = "*"
-
-        subject = (
-            MessageRouter.get_service_to_plugin_subject(service_id, self.options["metadata"]["id"])
-            if self.type_ == "plugin"
-            else MessageRouter.get_service_to_service_subject(service_id, self.options["metadata"]["id"])
-            if self.type_ == "service"
-            else MessageRouter.get_service_to_server_subject(service_id, self.options["metadata"]["id"])
-        )
-
-        async def wrapped_handler(message: Message[T]) -> R:
-            if inspect.iscoroutinefunction(handler) or inspect.isawaitable(handler):
-                return await cast(Awaitable[R], handler(message["data"]))
-            else:
-                return cast(R, handler(message["data"]))
-
-        return await self.handle_request(subject, wrapped_handler)
-
-    async def register_rpc_handler(
-        self,
-        namespace: str,
-        handler: dict[str, Callable[..., Any]] | object,
-        rpc_options: RPCOptions | None = None,
-    ) -> None:
-        manager = self._rpc_managers.get(namespace)
-
-        if not manager:
-            use_bundled = self.options.get("bundled_connection", True)
-            rpc_main_connection = (
-                self._connection if use_bundled else RPCConnectionManager(self.type_, self.options)
-            )
-            manager = RPCConnection(namespace, rpc_main_connection, self.options, rpc_options)
-            await manager.connect()
-            manager.register_handler(handler)
-            self._rpc_managers[namespace] = manager
-
-    async def unregister_rpc_handler(self, namespace: str) -> None:
-        manager = self._rpc_managers.get(namespace)
-        if manager:
-            await manager.disconnect()
-
-        if namespace in self._rpc_managers:
-            del self._rpc_managers[namespace]
-
-    async def create_rpc_proxy(
-        self, cls: type[T], namespace: str, rpc_options: RPCOptions | None = None
-    ) -> T:
-        manager = await self.create_rpc_connection(namespace, rpc_options)
-        return manager.create_proxy(cls)
-
-    async def create_rpc_connection(
-        self, namespace: str, rpc_options: RPCOptions | None = None
-    ) -> RPCConnection:
-        try:
-            manager = self._remote_rpc_managers.get(namespace)
-
-            if not manager:
-                use_bundled = self.options.get("bundled_connection", True)
-                remote_rpc_main_connection = (
-                    self._connection if use_bundled else RPCConnectionManager(self.type_, self.options)
-                )
-                manager = RPCConnection(namespace, remote_rpc_main_connection, self.options, rpc_options)
-                await manager.connect()
-                self._remote_rpc_managers[namespace] = manager
-
-            return manager
-
-        except Exception as e:
-            raise ErrorFactory.rpc.connection_failed(
-                e,
-                {
-                    "description": "Failed to connect to remote RPC",
-                    "code": ERROR_CODES.RPC.CONNECTION_FAILED,
-                    "metadata": {
-                        "namespace": namespace,
-                        "rpc_options": rpc_options,
-                    },
-                },
-            ) from e
-
-    async def disconnect_rpc_connection(self, namespace: str) -> None:
-        manager = self._remote_rpc_managers.get(namespace)
-        if manager:
-            await manager.disconnect()
-
-        if namespace in self._remote_rpc_managers:
-            del self._remote_rpc_managers[namespace]
-
-    @abstractmethod
-    async def _initialize(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    async def _setup_subscriptions(self) -> None:
-        raise NotImplementedError
-
-    async def cleanup(self) -> None:
-        await self._cleanup_rpc_connections()
-        await self._cleanup_remote_rpc_connections()
-
-    async def _cleanup_rpc_connections(self, namespace: str | None = None) -> None:
-        if namespace:
-            manager = self._rpc_managers.get(namespace)
-            if manager:
-                await manager.disconnect()
-                del self._rpc_managers[namespace]
-        else:
-            await asyncio.gather(
-                *[manager.disconnect() for manager in self._rpc_managers.values()], return_exceptions=False
-            )
-            self._rpc_managers.clear()
-
-    async def _cleanup_remote_rpc_connections(self, namespace: str | None = None) -> None:
-        if namespace:
-            manager = self._remote_rpc_managers.get(namespace)
-            if manager:
-                await manager.disconnect()
-                del self._remote_rpc_managers[namespace]
-        else:
-            await asyncio.gather(
-                *[manager.disconnect() for manager in self._remote_rpc_managers.values()],
-                return_exceptions=False,
-            )
-
-    def _get_plugin_subject(self, plugin_id: str) -> str:
-        return (
-            MessageRouter.get_plugin_to_plugin_subject(self.options["metadata"]["id"], plugin_id)
-            if self.type_ == "plugin"
-            else MessageRouter.get_service_to_plugin_subject(self.options["metadata"]["id"], plugin_id)
-            if self.type_ == "service"
-            else MessageRouter.get_server_to_plugin_subject(self.options["metadata"]["id"], plugin_id)
-        )
-
-    def _get_service_subject(self, service_id: str) -> str:
-        return (
-            MessageRouter.get_plugin_to_service_subject(self.options["metadata"]["id"], service_id)
-            if self.type_ == "plugin"
-            else MessageRouter.get_service_to_service_subject(self.options["metadata"]["id"], service_id)
-            if self.type_ == "service"
-            else MessageRouter.get_server_to_service_subject(self.options["metadata"]["id"], service_id)
-        )