@camera.ui/server 0.0.49 → 0.0.50-internal.1

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

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar
+
+from ..base.connection import (
+    MessageHandlers,
+    MessageWithResponseHandler,
+    RPCConnectionManager,
+)
+from ..typings import (
+    ResponseMessage,
+    RoutingMetadata,
+)
+from ..utils.logger import setup_logger
+from ..utils.subscriptions import SubscriptionWrapper
+
+logger: logging.Logger = setup_logger("camera:ui:messaging")
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class BaseMessaging(ABC):
+    @abstractmethod
+    def get_connection_manager(self) -> RPCConnectionManager:
+        raise NotImplementedError
+
+    async def publish(self, subject: str, data: Any, routing: RoutingMetadata | None = None) -> None:
+        await self.get_connection_manager().publish(subject, data, None, routing)
+
+    async def request(
+        self,
+        subject: str,
+        data: Any,
+        timeout: int | None = None,
+        routing: RoutingMetadata | None = None,
+    ) -> ResponseMessage[Any]:
+        return await self.get_connection_manager().request(subject, data, timeout, routing)
+
+    async def handle_request(
+        self,
+        subject: str,
+        handler: MessageWithResponseHandler[T, R],
+    ) -> SubscriptionWrapper:
+        return await self.get_connection_manager().handle_request(subject, handler)
+
+    async def subscribe(
+        self,
+        subject: str,
+        handler: MessageHandlers[T],
+    ) -> SubscriptionWrapper:
+        return await self.get_connection_manager().subscribe(subject, handler, "message")
+
+    async def unsubscribe(self, subject: str, handler_id: str) -> None:
+        await self.get_connection_manager().unsubscribe(subject, handler_id)

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

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import AsyncGenerator, Coroutine
+from types import MethodType
+from typing import Any, Callable, TypedDict, TypeVar, cast, get_origin
+
+from ..typings import (
+    ClientConnectionOptions,
+    RPCOptions,
+)
+from ..utils.logger import setup_logger
+from ..utils.rpc import MethodExtractor, RPCMetadata
+from ..utils.subscriptions import SubscriptionWrapper
+from ..utils.tasks import TaskSet
+from ..utils.uid import uid
+from .connection import RPCConnectionManager
+from .rpc_generator import RPCGeneratorManager
+
+logger: logging.Logger = setup_logger("camera:ui:rpc")
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class ProxyOptions(TypedDict):
+    is_generator: bool
+
+
+class RPCSubscriptions(TypedDict):
+    subject: str
+    handler_id: str
+    task: asyncio.Task[SubscriptionWrapper]
+
+
+class RPCHandlerSubscription(TypedDict):
+    handler: dict[str, Callable[..., Any]] | object
+    subscriptions: list[RPCSubscriptions]
+
+
+class RPCConnection:
+    namespace: str
+    rpc_options: RPCOptions | None
+
+    _options: ClientConnectionOptions
+    _connection: RPCConnectionManager
+    _generator_manager: RPCGeneratorManager
+    _handlers: dict[str, RPCHandlerSubscription]
+    _remote_method_types: dict[str, RPCMetadata]
+    _task_set: TaskSet
+
+    def __init__(
+        self,
+        namespace: str,
+        connection: RPCConnectionManager,
+        options: ClientConnectionOptions,
+        rpc_options: RPCOptions | None = None,
+    ):
+        self.namespace = namespace
+        self.rpc_options = rpc_options
+        self._options = options
+        self._connection = connection
+        self._generator_manager = RPCGeneratorManager(self.namespace, self._connection, self._options)
+        self._handlers = {}
+        self._remote_method_types = {}
+        self._task_set = TaskSet("RPCConnection")
+
+    async def connect(self) -> None:
+        if not self._options.get("bundled_connection"):
+            try:
+                await self._connection.connect()
+                logger.debug(f"[{self.namespace}] Main connection established.")
+            except Exception as error:
+                logger.debug(f"[{self.namespace}] Failed to establish main connection: {error}")
+                raise
+        else:
+            logger.debug(f"[{self.namespace}] Main connection is bundled, skipping connect.")
+
+    async def disconnect(self) -> None:
+        logger.debug(f"[{self.namespace}] Disconnecting RPCConnection...")
+        self._task_set.remove_all()
+        await self.dispose()  # Dispose calls generatorManager.dispose()
+
+        if self._options.get("bundled_connection"):
+            logger.debug(f"[{self.namespace}] Skipping disconnect of bundled main connection.")
+            return
+
+        if not self._connection.is_closed():
+            try:
+                await self._connection.disconnect()
+                logger.debug(f"[{self.namespace}] Main connection disconnected.")
+            except Exception as error:
+                logger.debug(f"[{self.namespace}] Error disconnecting main connection: {error}")
+
+        logger.debug(f"[{self.namespace}] RPCConnection disconnected.")
+
+    def is_connected(self) -> bool:
+        return self._connection.is_connected()
+
+    def register_handler(self, handler: dict[str, Callable[..., Any]] | object) -> None:
+        methods = MethodExtractor.extract_methods(handler)
+
+        for method_name, rpc_method in methods.items():
+            actual_method_name = rpc_method.get("name") or method_name
+
+            if actual_method_name in self._handlers:
+                logger.debug(
+                    f"[{self.namespace}] Handler for method '{actual_method_name}' already registered."
+                )
+                continue
+
+            handler_subscription: RPCHandlerSubscription = {
+                "handler": handler,
+                "subscriptions": [],
+            }
+
+            self._handlers[actual_method_name] = handler_subscription
+
+            logger.debug(
+                f"[{self.namespace}] Registering handler for method: {actual_method_name} ({rpc_method['type']})"
+            )
+            bound_method = (
+                MethodType(rpc_method["method"], handler)
+                if not isinstance(handler, dict)
+                else rpc_method["method"]
+            )
+
+            if rpc_method["type"] == "asyncGenerator":
+                self._task_set.add(self._generator_manager.handle_generator(actual_method_name, bound_method))
+            else:
+                subject = f"{self.namespace}.{actual_method_name}"
+                handler_id = uid()
+
+                try:
+                    task = self._task_set.add(
+                        self._connection.subscribe(
+                            subject,
+                            bound_method,
+                            handler_id,
+                            type_="rpc",
+                        )
+                    )
+
+                    handler_subscription["subscriptions"].append(
+                        {
+                            "subject": subject,
+                            "handler_id": handler_id,
+                            "task": task,
+                        }
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"[{self.namespace}] Failed to register handler for method: {actual_method_name}", e
+                    )
+                    del self._handlers[actual_method_name]  # Remove handler if subscription fails
+
+    def call(self, method: str, *args: Any) -> Coroutine[Any, Any, Any]:
+        return self._request_rpc_and_resolve(method, args)
+
+    def call_generator(self, method: str, *args: Any) -> AsyncGenerator[Any, None]:
+        return cast(AsyncGenerator[Any, None], self._generator_manager.create_generator(method, *args))
+
+    def create_proxy(self, cls: type[T]) -> T:
+        manager = self
+
+        class RPCProxy:
+            def __init__(self):
+                pass
+
+            def __getattr__(self, method: str) -> Callable[..., Any]:
+                original_method = getattr(cls, method, None)
+                if original_method is None:
+                    raise AttributeError(f"'{cls.__name__}' has no attribute '{method}'")
+
+                return_type = original_method.__annotations__.get("return")
+                is_generator = get_origin(return_type) is AsyncGenerator
+
+                def _proxy(*args: Any) -> Any:
+                    if is_generator:
+                        logger.debug(f"Creating generator proxy for: {method}")
+                        return manager.call_generator(method, *args)
+                    else:
+                        logger.debug(f"Creating async proxy for: {method}")
+                        return manager._request_rpc_and_resolve(method, args)
+
+                return _proxy
+
+        return cast(T, RPCProxy())
+
+    def get_connection_manager(self) -> RPCConnectionManager:
+        return self._connection
+
+    async def _request_rpc_and_resolve(self, method: str, args: Any = None) -> Any:
+        subject = f"{self.namespace}.{method}"
+        timeout = self.rpc_options.get("timeout") if self.rpc_options else None
+        response = await self._connection.request_rpc(subject, args, timeout)
+        return response["data"]
+
+    async def dispose(self) -> None:
+        logger.debug(f"[{self.namespace}] Disposing RPCConnection resources...")
+
+        if self._generator_manager:
+            await self._generator_manager.dispose()
+
+        unsubscribe_promises: list[asyncio.Task[Any]] = []
+
+        for handler_subscriptions in self._handlers.values():
+            for subscription in handler_subscriptions["subscriptions"]:
+                subject = subscription["subject"]
+                handler_id = subscription["handler_id"]
+                task = subscription["task"]
+                task.cancel()
+
+                unsubscribe_promises.append(asyncio.create_task(self._safe_unsubscribe(subject, handler_id)))
+
+        if unsubscribe_promises:
+            await asyncio.gather(*unsubscribe_promises, return_exceptions=True)
+
+        self._handlers.clear()
+        self._remote_method_types.clear()
+        logger.debug(f"[{self.namespace}] Finished disposing RPCConnection resources.")
+
+    async def _safe_unsubscribe(self, subject: str, handler_id: str) -> None:
+        with contextlib.suppress(Exception):
+            await self._connection.unsubscribe(subject, handler_id)