@camera.ui/server 0.0.48 → 0.0.50-internal.0

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

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Generic, Literal, Protocol, TypeVar, runtime_checkable
+
+from typing_extensions import NotRequired, TypedDict
+
+from .base.errors import SerializedError
+
+# Type Variables for Generic Types
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class ConnectionState(Enum):
+    STARTING = "starting"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+class MessageType(Enum):
+    REQUEST = "request"
+    RESPONSE = "response"
+    BROADCAST = "broadcast"
+    RPCREQUEST = "rpcrequest"
+    RPCRESPONSE = "rpcresponse"
+    RPCSTREAMREQUEST = "rpcstreamrequest"
+
+
+class Metadata(TypedDict):
+    id: str
+    name: str
+
+
+class AuthConfig(TypedDict):
+    user: str
+    password: str
+
+
+class ConnectOptions(TypedDict, total=False):
+    wait_for_server: bool
+
+
+class ReconnectOptions(TypedDict, total=False):
+    enabled: bool
+    max_attempts: int
+    delay: int
+
+
+class TimeoutOptions(TypedDict, total=False):
+    connection: int
+    request: int
+    rpc: int
+
+
+class TLSOptions(TypedDict):
+    ca: str
+    cert: str
+    key: str
+
+
+class ClientConnectionOptions(TypedDict):
+    endpoints: list[str]
+    auth: AuthConfig
+    tls: TLSOptions
+    metadata: Metadata
+    connect: NotRequired[ConnectOptions | None]
+    reconnect: NotRequired[ReconnectOptions | None]
+    timeout: NotRequired[TimeoutOptions | None]
+    bundled_connection: NotRequired[bool | None]
+
+
+class RoutingSource(TypedDict):
+    id: str
+    type: Literal["plugin", "service", "server"]
+
+
+class RoutingTarget(TypedDict):
+    id: str
+    type: Literal["plugin", "service", "server"]
+
+
+class RoutingMetadata(TypedDict):
+    source: RoutingSource
+    target: RoutingTarget | None
+
+
+class Message(Generic[T], TypedDict):
+    type: MessageType
+    data: T
+    id: str
+    timestamp: float
+    metadata: Metadata
+    routing: NotRequired[RoutingMetadata | None]
+
+
+class RequestMessage(Message[T]):
+    type: Literal["request"]  # type: ignore
+    subject: str
+    replyTo: NotRequired[str | None]
+
+
+class ResponseMessage(Message[R]):
+    type: Literal["response"]  # type: ignore
+    requestId: str
+    error: NotRequired[SerializedError | None]
+
+
+class BroadcastMessage(Message[T]):
+    type: Literal["broadcast"]  # type: ignore
+    error: NotRequired[SerializedError | None]
+
+
+class RPCRequest(Message[T]):
+    type: Literal["rpcrequest"] | Literal["rpcstreamrequest"]  # type: ignore
+    subject: str
+    streamId: NotRequired[str | None]
+
+
+class RPCResponse(Message[R]):
+    type: Literal["rpcresponse"]  # type: ignore
+    requestId: str
+    streamId: NotRequired[str | None]
+    done: NotRequired[bool | None]
+    error: NotRequired[SerializedError | None]
+
+
+class GeneratorControl(TypedDict):
+    type: Literal["return", "throw", "ready"]
+    value: NotRequired[Any]
+
+
+class GeneratorMessage(TypedDict):
+    streamId: str
+    args: NotRequired[tuple[Any, ...]]
+
+
+class GeneratorResult(TypedDict):
+    requestId: str
+    streamId: NotRequired[str | None]
+    value: NotRequired[Any]
+    done: bool
+    error: NotRequired[SerializedError | None]
+
+
+class ConnectionMessage(TypedDict):
+    sourceId: str
+    sourceType: Literal["plugin", "service"]
+    timestamp: float
+
+
+class ClientMessage(TypedDict):
+    clientId: str
+
+
+class RegistrationResponse(TypedDict):
+    success: bool
+    serverMetadata: Metadata
+
+
+@runtime_checkable
+class RPCHandler(Protocol):
+    async def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+
+@runtime_checkable
+class Disposable(Protocol):
+    async def dispose(self) -> None: ...
+
+
+class ClientStatus(TypedDict):
+    id: str
+    type: str
+    state: ConnectionState
+    error: Exception | None
+    metadata: Metadata | None
+
+
+class RPCOptions(TypedDict):
+    timeout: int | None
+
+
+class ClientRequestsMetrics(TypedDict):
+    total: int
+    active: int
+    errors: int
+    perSecond: float
+    avgResponseTime: float
+
+
+class ClientMessagesMetrics(TypedDict):
+    published: int
+    received: int
+    errors: int
+
+
+class ClientRPCMetrics(TypedDict):
+    total: int
+    active: int
+    errors: int
+
+
+class ClientSubscriptionsMetrics(TypedDict):
+    active: int
+    messageHandlers: int
+    requestHandlers: int
+    rpcHandlers: int
+
+
+class ClientMetrics(TypedDict):
+    timestamp: int
+    startTime: int
+    requests: ClientRequestsMetrics
+    messages: ClientMessagesMetrics
+    rpc: ClientRPCMetrics
+    subscriptions: ClientSubscriptionsMetrics

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/connection_state.py

@@ -0,0 +1,86 @@
+import logging
+from datetime import datetime
+from typing import TypedDict
+
+from ..base.errors import NatsError
+from ..typings import ConnectionState
+from ..utils.logger import setup_logger
+
+logger: logging.Logger = setup_logger("camera:ui:connection:state")
+
+
+class ConnectionInfo(TypedDict):
+    state: ConnectionState
+    lastError: str | None
+    lastConnected: str | None
+    lastDisconnected: str | None
+    currentReconnectAttempt: int
+
+
+class ConnectionStateManager:
+    _state: ConnectionState
+    _last_error: Exception | NatsError | None
+    _last_connected: datetime | None
+    _last_disconnected: datetime | None
+    _current_reconnect_attempt: int
+
+    def __init__(self) -> None:
+        self._state = ConnectionState.STOPPED
+        self._last_error = None
+        self._last_connected = None
+        self._last_disconnected = None
+        self._current_reconnect_attempt = 0
+
+    def set_state(self, new_state: ConnectionState, error: Exception | NatsError | None = None) -> None:
+        if self._state != new_state:
+            logger.debug(f"Connection state changed to {new_state}")
+
+        self._state = new_state
+        if error:
+            self._last_error = error
+            self._last_disconnected = datetime.now()
+        if new_state == ConnectionState.RUNNING:
+            self._last_connected = datetime.now()
+            self._last_error = None
+            self._current_reconnect_attempt = 0
+        if new_state == ConnectionState.STOPPED:
+            self._last_disconnected = datetime.now()
+            self._current_reconnect_attempt = 0
+
+    def increment_reconnect_attempt(self) -> int:
+        self._current_reconnect_attempt += 1
+        return self._current_reconnect_attempt
+
+    def get_current_reconnect_attempt(self) -> int:
+        return self._current_reconnect_attempt
+
+    def get_state(self) -> ConnectionState:
+        return self._state
+
+    def get_last_error(self) -> Exception | NatsError | None:
+        return self._last_error
+
+    def is_terminal_state(self) -> bool:
+        return self._state in (ConnectionState.STOPPED, ConnectionState.ERROR)
+
+    def can_connect(self) -> bool:
+        return self._state in (ConnectionState.STOPPED, ConnectionState.ERROR)
+
+    def get_last_connected(self) -> datetime | None:
+        return self._last_connected
+
+    def get_last_disconnected(self) -> datetime | None:
+        return self._last_disconnected
+
+    def get_info(self) -> ConnectionInfo:
+        return {
+            "state": self._state,
+            "lastError": self._last_error.get_error_summary()
+            if isinstance(self._last_error, NatsError)
+            else str(self._last_error)
+            if self._last_error
+            else None,
+            "lastConnected": self._last_connected.isoformat() if self._last_connected else None,
+            "lastDisconnected": self._last_disconnected.isoformat() if self._last_disconnected else None,
+            "currentReconnectAttempt": self._current_reconnect_attempt,
+        }

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/logger.py

@@ -0,0 +1,30 @@
+import logging
+import os
+
+
+def setup_logger(namespace: str) -> logging.Logger:
+    logger: logging.Logger = logging.getLogger(namespace)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    logger.propagate = False
+
+    debug_env = os.getenv("DEBUG", "").lower().split(",")
+
+    def matches_pattern(pattern: str, namespace: str) -> bool:
+        if pattern == "*":
+            return True
+        if pattern.endswith(":*"):
+            return namespace.startswith(pattern[:-2])
+        return pattern == namespace
+
+    if any(matches_pattern(pattern, namespace) for pattern in debug_env):
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.WARNING)
+
+    return logger

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/metrics.py

@@ -0,0 +1,152 @@
+import logging
+from datetime import datetime
+from typing import Any, Literal
+
+from ..constants import BASE_METRICS, DEFAULTS
+from ..typings import ClientMetrics
+from ..utils.logger import setup_logger
+
+logger: logging.Logger = setup_logger("camera:ui:_metrics")
+
+
+class ConnectionMetricsTracker:
+    _start_time: int
+    _metrics_window: int
+    _metrics: dict[str, Any]
+
+    def __init__(self) -> None:
+        self._start_time = int(datetime.now().timestamp() * 1000)
+        self._metrics_window = DEFAULTS.METRICS.TTL
+        self._metrics = {**BASE_METRICS}
+
+    def track_request_start(self, request_id: str) -> None:
+        logger.debug(f"Tracking request start: {request_id}")
+        self._metrics["requests"]["active"] += 1
+        self._metrics["requests"]["total"] += 1
+        self._metrics["requests"]["timings"][request_id] = int(datetime.now().timestamp() * 1000)
+        self._metrics["requests"]["in_window"]["count"] += 1
+
+    def track_request_end(self, request_id: str, error: bool = False) -> None:
+        logger.debug(f"Tracking request end: {request_id}")
+        start_time = self._metrics["requests"]["timings"].get(request_id)
+        if start_time:
+            self._metrics["requests"]["in_window"]["response_times"].append(
+                int(datetime.now().timestamp() * 1000) - start_time
+            )
+            del self._metrics["requests"]["timings"][request_id]
+
+        self._metrics["requests"]["active"] -= 1
+        if error:
+            self._metrics["requests"]["errors"] += 1
+            self._metrics["requests"]["in_window"]["errors"] += 1
+
+    def track_publish(self) -> None:
+        logger.debug("Tracking message publish")
+        self._metrics["messages"]["published"] += 1
+
+    def track_receive(self) -> None:
+        logger.debug("Tracking message receive")
+        self._metrics["messages"]["received"] += 1
+
+    def track_message_error(self) -> None:
+        logger.debug("Tracking message error")
+        self._metrics["messages"]["errors"] += 1
+
+    def track_rpc_start(self) -> None:
+        logger.debug("Tracking RPC start")
+        self._metrics["rpc"]["active"] += 1
+        self._metrics["rpc"]["total"] += 1
+
+    def track_rpc_end(self, error: bool = False) -> None:
+        logger.debug("Tracking RPC end")
+        self._metrics["rpc"]["active"] -= 1
+        if error:
+            self._metrics["rpc"]["errors"] += 1
+
+    def track_subscription_change(
+        self, diff: int, type_: Literal["message", "request", "rpc", "generator"]
+    ) -> None:
+        logger.debug(f"Tracking subscription change: {diff} {type_}")
+
+        # Update specific handler count
+        if type_ == "message":
+            self._metrics["subscriptions"]["message_handlers"] = max(
+                0, self._metrics["subscriptions"]["message_handlers"] + diff
+            )
+        elif type_ == "request":
+            self._metrics["subscriptions"]["request_handlers"] = max(
+                0, self._metrics["subscriptions"]["request_handlers"] + diff
+            )
+        elif type_ == "rpc" or type_ == "generator":
+            self._metrics["subscriptions"]["rpc_handlers"] = max(
+                0, self._metrics["subscriptions"]["rpc_handlers"] + diff
+            )
+
+        # Update total active subscriptions
+        self._metrics["subscriptions"]["active"] = sum(
+            [
+                self._metrics["subscriptions"]["message_handlers"],
+                self._metrics["subscriptions"]["request_handlers"],
+                self._metrics["subscriptions"]["rpc_handlers"],
+            ]
+        )
+
+    def get_metrics(self) -> ClientMetrics:
+        self._clean_old_metrics()
+
+        now = int(datetime.now().timestamp() * 1000)
+        window_duration = (now - self._metrics["requests"]["in_window"]["start_time"]) / 1000
+
+        # Calculate requests per second
+        requests_per_second = (
+            self._metrics["requests"]["in_window"]["count"] / max(1, window_duration)
+            if window_duration > 0
+            else 0
+        )
+
+        # Calculate average response time
+        response_times = self._metrics["requests"]["in_window"]["response_times"]
+        avg_response_time = sum(response_times) / len(response_times) if response_times else 0
+
+        client_metrics: ClientMetrics = {
+            "timestamp": now,
+            "startTime": self._start_time,
+            "requests": {
+                "total": self._metrics["requests"]["total"],
+                "active": self._metrics["requests"]["active"],
+                "errors": self._metrics["requests"]["errors"],
+                "perSecond": requests_per_second if requests_per_second != float("inf") else 0,
+                "avgResponseTime": avg_response_time,
+            },
+            "messages": {
+                "published": self._metrics["messages"]["published"],
+                "received": self._metrics["messages"]["received"],
+                "errors": self._metrics["messages"]["errors"],
+            },
+            "rpc": {
+                "total": self._metrics["rpc"]["total"],
+                "active": self._metrics["rpc"]["active"],
+                "errors": self._metrics["rpc"]["errors"],
+            },
+            "subscriptions": {
+                "active": self._metrics["subscriptions"]["active"],
+                "messageHandlers": self._metrics["subscriptions"]["message_handlers"],
+                "requestHandlers": self._metrics["subscriptions"]["request_handlers"],
+                "rpcHandlers": self._metrics["subscriptions"]["rpc_handlers"],
+            },
+        }
+
+        return client_metrics
+
+    def reset_metrics(self) -> None:
+        self._metrics = {**BASE_METRICS}
+
+    def _clean_old_metrics(self) -> None:
+        now = int(datetime.now().timestamp() * 1000)
+        if now - self._metrics["requests"]["in_window"]["start_time"] >= self._metrics_window:
+            self._metrics["requests"]["in_window"] = {
+                "count": 0,
+                "errors": 0,
+                "response_times": [],
+                "start_time": now,
+            }

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/packer.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from typing import Any, cast
+
+import msgpack
+
+
+def default_handler(obj: Any) -> Any:
+    if isinstance(obj, Enum):
+        return obj.value
+    return obj
+
+
+def pack(data: Any) -> bytes:
+    msg = cast(bytes, msgpack.packb(data, default=default_handler, datetime=True))
+    return msg
+
+
+def unpack(data: bytes) -> Any:
+    msg = cast(Any, msgpack.unpackb(data, timestamp=0))
+    return msg

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/routing.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from ..typings import RoutingMetadata
+
+EndpointType = Literal["plugin", "service", "server"]
+
+
+class MessageRouter:
+    @staticmethod
+    def get_plugin_to_plugin_subject(source_id: str, target_id: str) -> str:
+        return MessageRouter.create_routing_pattern("plugin", "plugin", source_id, target_id)
+
+    @staticmethod
+    def get_plugin_to_service_subject(plugin_id: str, service_id: str) -> str:
+        return MessageRouter.create_routing_pattern("plugin", "service", plugin_id, service_id)
+
+    @staticmethod
+    def get_service_to_service_subject(source_id: str, target_id: str) -> str:
+        return MessageRouter.create_routing_pattern("service", "service", source_id, target_id)
+
+    @staticmethod
+    def get_service_to_plugin_subject(service_id: str, plugin_id: str) -> str:
+        return MessageRouter.create_routing_pattern("service", "plugin", service_id, plugin_id)
+
+    @staticmethod
+    def get_plugin_to_server_subject(plugin_id: str, server_id: str) -> str:
+        return MessageRouter.create_routing_pattern("plugin", "server", plugin_id, server_id)
+
+    @staticmethod
+    def get_service_to_server_subject(service_id: str, server_id: str) -> str:
+        return MessageRouter.create_routing_pattern("service", "server", service_id, server_id)
+
+    @staticmethod
+    def get_server_to_plugin_subject(server_id: str, plugin_id: str) -> str:
+        return MessageRouter.create_routing_pattern("server", "plugin", server_id, plugin_id)
+
+    @staticmethod
+    def get_server_to_service_subject(server_id: str, service_id: str) -> str:
+        return MessageRouter.create_routing_pattern("server", "service", server_id, service_id)
+
+    @staticmethod
+    def create_routing_metadata(
+        source_type: EndpointType,
+        source_id: str,
+        target_type: EndpointType | None = None,
+        target_id: str | None = None,
+    ) -> RoutingMetadata:
+        metadata: RoutingMetadata = {
+            "source": {
+                "type": source_type,
+                "id": source_id,
+            },
+            "target": None,
+        }
+
+        if target_type and target_id:
+            metadata["target"] = {
+                "type": target_type,
+                "id": target_id,
+            }
+
+        return metadata
+
+    @staticmethod
+    def create_routing_pattern(
+        source_type: EndpointType,
+        target_type: EndpointType,
+        source_id: str,
+        target_id: str | None = None,
+    ) -> str:
+        if target_id:
+            return f"{source_type}.{target_type}.{source_id}.{target_id}"
+        return f"{source_type}.{target_type}.{source_id}.*"