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

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

@@ -0,0 +1,584 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from dataclasses import dataclass
+from functools import partial
+from typing import Any
+
+from ..typings import (
+    BroadcastMessage,
+    ClientConnectionOptions,
+    GeneratorControl,
+    GeneratorMessage,
+    GeneratorResult,
+)
+from ..utils.logger import setup_logger
+from ..utils.subscriptions import SubscriptionWrapper
+from ..utils.uid import uid
+from .connection import RPCConnectionManager
+from .errors import ErrorFactory, NatsError
+
+logger: logging.Logger = setup_logger("camera:ui:rpc:generator")
+
+
+@dataclass
+class ConsumerGeneratorState:
+    """State for the consumer side of the generator."""
+
+    message_queue: list[GeneratorResult]
+    resolve_next: asyncio.Future[Any] | None
+    stream_subscription: SubscriptionWrapper
+    control_subject: str
+    dedicated_connection: RPCConnectionManager
+    error: Exception | None = None
+    is_done: bool = False
+    last_processed_time: float = 0.0
+    is_processing: bool = False
+
+    def __post_init__(self) -> None:
+        self.last_processed_time = asyncio.get_event_loop().time()
+
+
+@dataclass
+class ProducerGeneratorState:
+    """State for the producer side of the generator."""
+
+    stream_subject: str
+    control_subject: str
+    request_id: str
+    stream_id: str
+    generator: AsyncGenerator[Any, None]
+    dedicated_connection: RPCConnectionManager
+    control_subscription: SubscriptionWrapper
+    is_waiting_for_client: bool = False
+    last_sent_time: float = 0.0
+
+    def __post_init__(self) -> None:
+        self.last_sent_time = asyncio.get_event_loop().time()
+
+
+class RPCGeneratorManager:
+    def __init__(
+        self, namespace: str, main_connection: RPCConnectionManager, options: ClientConnectionOptions
+    ):
+        self._namespace: str = namespace
+        self._main_connection: RPCConnectionManager = main_connection
+        self._options: ClientConnectionOptions = options
+        self._consumer_generator_states: dict[str, ConsumerGeneratorState] = {}
+        self._producer_generator_states: dict[str, ProducerGeneratorState] = {}
+        self._handler_subscriptions: dict[str, SubscriptionWrapper] = {}
+        self._pending_ready_signals: dict[str, set[asyncio.Future[Any]]] = {}
+        self._MAX_QUEUE_SIZE: int = 100
+
+    async def create_generator(self, method: str, *args: Any) -> AsyncGenerator[Any, None]:
+        """Client-side: Create and consume a remote generator stream with dedicated connection."""
+
+        stream_id = uid()
+        subject = f"{self._namespace}.{method}.generator"
+        stream_subject = f"{subject}.stream.{stream_id}"
+        control_subject = f"{subject}.control.{stream_id}"
+
+        logger.debug(f"[C:{stream_id}] Starting generator stream for {method}")
+
+        consumer_connection: RPCConnectionManager | None = None
+        consumer_state: ConsumerGeneratorState | None = None
+
+        try:
+            # 1. Create and connect consumer connection
+            logger.debug(f"[C:{stream_id}] Creating dedicated consumer connection...")
+
+            consumer_connection = RPCConnectionManager(
+                self._main_connection.type,
+                {
+                    **self._options,
+                    "metadata": {
+                        **self._options.get("metadata", {}),
+                        "id": f"{self._options.get('metadata', {}).get('id', 'rpc')}-cg-{stream_id[:8]}",
+                    },
+                    "bundled_connection": False,
+                    "timeout": self._options.get("timeout", {}),
+                },
+            )
+
+            await consumer_connection.connect()
+
+            logger.debug(f"[C:{stream_id}] Dedicated consumer connection established.")
+
+            # 2. Subscribe to data stream (using dedicated connection)
+            stream_subscription = await consumer_connection.subscribe(
+                stream_subject, partial(self._handle_stream_message, stream_id), None, "generator"
+            )
+
+            logger.debug(f"[C:{stream_id}] Subscribed to data stream: {stream_subject}")
+
+            # 3. Initialize consumer state
+            consumer_state = ConsumerGeneratorState(
+                message_queue=[],
+                resolve_next=None,
+                stream_subscription=stream_subscription,
+                control_subject=control_subject,
+                dedicated_connection=consumer_connection,
+            )
+
+            self._consumer_generator_states[stream_id] = consumer_state
+
+            # 4. Send initiation request (using main connection)
+            logger.debug(f"[C:{stream_id}] Sending initiation request via main connection to {subject}")
+            await self._main_connection.publish(
+                subject,
+                {
+                    "streamId": stream_id,
+                    "args": args,
+                },
+            )
+
+            # 5. Consumption loop
+            while not consumer_state.is_done:
+                if consumer_state.error:
+                    raise consumer_state.error
+
+                # Process queued messages first
+                if consumer_state.message_queue:
+                    response = consumer_state.message_queue.pop(0)
+                    consumer_state.is_processing = True
+
+                    try:
+                        yield response.get("value")
+                    finally:
+                        consumer_state.is_processing = False
+                        consumer_state.last_processed_time = asyncio.get_event_loop().time()
+                        await self._send_ready_signal(
+                            stream_id, consumer_state.control_subject, consumer_state.dedicated_connection
+                        )
+                    continue
+
+                # Wait for next value
+                consumer_state.is_processing = False
+
+                # We need to re-check state for safety
+                next_future: asyncio.Future[Any] = asyncio.Future()
+                current_state = self._consumer_generator_states.get(stream_id)
+                if current_state:
+                    current_state.resolve_next = next_future
+                    next_result = await next_future
+                else:
+                    break  # State was removed
+
+                consumer_generator = self._consumer_generator_states.get(stream_id)
+                if next_result["done"] or consumer_generator and consumer_generator.is_done:
+                    break
+
+                # Ensure state is current
+                consumer_state = self._consumer_generator_states[stream_id]
+                consumer_state.is_processing = True
+
+                try:
+                    yield next_result["value"].get("value")
+                finally:
+                    consumer_state.is_processing = False
+                    consumer_state.last_processed_time = asyncio.get_event_loop().time()
+                    await self._send_ready_signal(
+                        stream_id, consumer_state.control_subject, consumer_state.dedicated_connection
+                    )
+
+            logger.debug(f"[C:{stream_id}] Consumption loop finished.")
+
+        finally:
+            # Cleanup
+            logger.debug(f"[C:{stream_id}] Cleaning up consumer side...")
+
+            final_state = self._consumer_generator_states.get(stream_id)
+
+            if final_state:
+                await self._cleanup_consumer_generator(stream_id, final_state)
+            elif consumer_connection and not consumer_connection.is_closed():
+                potential_control_subject = f"{self._namespace}.{method}.generator.control.{stream_id}"
+                await self._cleanup_consumer_connection(
+                    stream_id, consumer_connection, potential_control_subject
+                )
+
+            self._consumer_generator_states.pop(stream_id, None)
+            logger.debug(f"[C:{stream_id}] Consumer cleanup finished.")
+
+    async def handle_generator(self, method: str, handler: Callable[..., AsyncGenerator[Any, None]]) -> None:
+        """Producer: Register handler (subscribes on main connection)"""
+
+        init_subject = f"{self._namespace}.{method}.generator"
+        logger.debug(f"[P] Setting up generator handler for: {init_subject}")
+
+        # Cleanup any existing subscription
+        if init_subject in self._handler_subscriptions:
+            await self._handler_subscriptions[init_subject].unsubscribe()
+
+        # Create new subscription using main connection
+        subscription = await self._main_connection.subscribe(
+            init_subject,
+            partial(self._handle_generator_request_wrapper, method, handler),
+            None,
+            "generator",
+        )
+
+        self._handler_subscriptions[init_subject] = subscription
+
+    async def _handle_generator_request_wrapper(
+        self,
+        method: str,
+        handler: Callable[..., AsyncGenerator[Any, None]],
+        message: BroadcastMessage[GeneratorMessage],
+    ) -> None:
+        """Wrapper to handle exceptions at the top level of generator request handling"""
+        try:
+            await self._handle_generator_request(method, handler, message)
+        except Exception as error:
+            stream_id = message["data"].get("streamId", "unknown")
+            logger.debug(f"[P:{stream_id}] Critical error setting up generator handler for {method}: {error}")
+
+    async def _handle_generator_request(
+        self,
+        method: str,
+        handler: Callable[..., AsyncGenerator[Any, None]],
+        message: BroadcastMessage[GeneratorMessage],
+    ) -> None:
+        """Producer: Handle specific request, create dedicated connection"""
+        stream_id = message["data"].get("streamId")
+        if not stream_id:
+            logger.debug(f"[P:unknown] Received generator request for {method} without streamId. Discarding.")
+            return
+
+        subject = f"{self._namespace}.{method}.generator"
+        stream_subject = f"{subject}.stream.{stream_id}"
+        control_subject = f"{subject}.control.{stream_id}"
+        logger.debug(f"[P:{stream_id}] Received generator request for {method}")
+
+        producer_connection: RPCConnectionManager | None = None
+        producer_state: ProducerGeneratorState | None = None
+        generator: AsyncGenerator[Any, None] | None = None
+
+        try:
+            # 1. Create and connect producer connection
+            logger.debug(f"[P:{stream_id}] Creating dedicated producer connection...")
+
+            producer_connection = RPCConnectionManager(
+                self._main_connection.type,
+                {
+                    **self._options,
+                    "metadata": {
+                        **self._options.get("metadata", {}),
+                        "id": f"{self._options.get('metadata', {}).get('id', 'rpc')}-pg-{stream_id[:8]}",
+                    },
+                    "bundled_connection": False,
+                    "timeout": self._options.get("timeout", {}),
+                },
+            )
+
+            await producer_connection.connect()
+
+            logger.debug(f"[P:{stream_id}] Dedicated producer connection established.")
+
+            # 2. Setup ready signal map entry
+            if stream_id not in self._pending_ready_signals:
+                self._pending_ready_signals[stream_id] = set()
+
+            # 3. Subscribe to control messages (using dedicated connection)
+            control_subscription = await producer_connection.subscribe(
+                control_subject, partial(self._handle_control_message, stream_id), None, "generator"
+            )
+
+            logger.debug(f"[P:{stream_id}] Subscribed to control subject: {control_subject}")
+
+            # 4. Invoke user generator
+            args = tuple(message["data"].get("args", ()))
+
+            generator = handler(*args)
+
+            # 5. Initialize producer state
+            producer_state = ProducerGeneratorState(
+                stream_subject=stream_subject,
+                control_subject=control_subject,
+                request_id=message["id"],
+                stream_id=stream_id,
+                generator=generator,
+                dedicated_connection=producer_connection,
+                control_subscription=control_subscription,
+            )
+
+            self._producer_generator_states[stream_id] = producer_state
+            logger.debug(f"[P:{stream_id}] Generator handler invoked. Processing frames...")
+
+            try:
+                next_result = await generator.__anext__()
+
+                while True:
+                    if self._producer_generator_states.get(stream_id) != producer_state:
+                        logger.debug(f"[P:{stream_id}] Producer state removed. Aborting loop.")
+                        break
+
+                    # If done (end of generator), send done message
+                    if next_result is None:  # stop iteration will be raised automatically
+                        await producer_connection.publish(
+                            stream_subject, {"requestId": message["id"], "streamId": stream_id, "done": True}
+                        )
+                        logger.debug(f"[P:{stream_id}] Generator completed normally.")
+                        break
+
+                    # Send via dedicated connection
+                    await producer_connection.publish(
+                        stream_subject,
+                        {
+                            "requestId": message["id"],
+                            "streamId": stream_id,
+                            "value": next_result,
+                            "done": False,
+                        },
+                    )
+
+                    producer_state.last_sent_time = asyncio.get_event_loop().time()
+
+                    # Wait for ready signal
+                    producer_state.is_waiting_for_client = True
+
+                    wait_future: asyncio.Future[Any] = asyncio.Future()
+                    ready_signals = self._pending_ready_signals.get(stream_id, set())
+                    ready_signals.add(wait_future)
+
+                    try:
+                        # 10s timeout
+                        await asyncio.wait_for(wait_future, 10.0)
+                    except asyncio.TimeoutError:
+                        logger.debug(f"[P:{stream_id}] Ready signal timeout.")
+                        ready_signals.discard(wait_future)
+
+                    if self._producer_generator_states.get(stream_id) != producer_state:
+                        logger.debug(f"[P:{stream_id}] Producer state changed during wait. Aborting loop.")
+                        break
+
+                    try:
+                        next_result = await generator.__anext__()
+                    except StopAsyncIteration:
+                        await producer_connection.publish(
+                            stream_subject,
+                            {
+                                "requestId": message["id"],
+                                "streamId": stream_id,
+                                "done": True,
+                            },
+                        )
+                        logger.debug(f"[P:{stream_id}] Generator completed normally.")
+                        break
+
+            except StopAsyncIteration:
+                # Generator is empty
+                await producer_connection.publish(
+                    stream_subject,
+                    {
+                        "requestId": message["id"],
+                        "streamId": stream_id,
+                        "done": True,
+                    },
+                )
+                logger.debug(f"[P:{stream_id}] Generator is empty (StopAsyncIteration on first next).")
+
+        except Exception as error:
+            # Error handling
+            logger.debug(f"[P:{stream_id}] Error during generator execution: {error}")
+            if producer_connection and stream_id in self._producer_generator_states:
+                nats_error = ErrorFactory.rpc.internal_error(
+                    error, {"description": "Error processing generator request"}
+                )
+                try:
+                    await producer_connection.publish(
+                        stream_subject,
+                        {
+                            "requestId": message["id"],
+                            "streamId": stream_id,
+                            "done": True,
+                            "error": nats_error.to_json(),
+                        },
+                    )
+                except Exception as publish_error:
+                    logger.debug(f"[P:{stream_id}] Error sending error message: {publish_error}")
+
+        finally:
+            # Cleanup
+            logger.debug(f"[P:{stream_id}] Cleaning up producer side...")
+            final_state = self._producer_generator_states.get(stream_id)
+
+            if final_state:
+                await self._cleanup_producer_generator(stream_id, final_state)
+            elif producer_connection and not producer_connection.is_closed():
+                await self._cleanup_producer_connection(producer_connection, None)
+
+            self._producer_generator_states.pop(stream_id, None)
+            self._pending_ready_signals.pop(stream_id, None)
+            logger.debug(f"[P:{stream_id}] Producer side cleanup finished.")
+
+    async def dispose(self) -> None:
+        """Dispose all resources"""
+        logger.debug("Disposing RPCGeneratorManager...")
+
+        # Create cleanup tasks
+        cleanup_tasks: list[Awaitable[Any]] = []
+
+        # Clean up consumer generators
+        for stream_id, state in list(self._consumer_generator_states.items()):
+            cleanup_tasks.append(self._cleanup_consumer_generator(stream_id, state))
+
+        # Clean up producer generators
+        for stream_id, state in list(self._producer_generator_states.items()):
+            cleanup_tasks.append(self._cleanup_producer_generator(stream_id, state))
+
+        # Wait for all cleanup to complete
+        if cleanup_tasks:
+            await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+
+        # Clear all state
+        self._consumer_generator_states.clear()
+        self._producer_generator_states.clear()
+        self._pending_ready_signals.clear()
+
+        # Unsubscribe all handlers
+        for subscription in list(self._handler_subscriptions.values()):
+            await subscription.unsubscribe()
+
+        self._handler_subscriptions.clear()
+        logger.debug("RPCGeneratorManager disposed.")
+
+    async def _handle_stream_message(
+        self, stream_id: str, message: BroadcastMessage[GeneratorResult]
+    ) -> None:
+        """Consumer: Handles incoming stream messages"""
+        state = self._consumer_generator_states.get(stream_id)
+        if not state:
+            return
+
+        if "error" in message and message["error"]:
+            # Handle error
+            state.error = NatsError.from_json(message["error"])
+            state.is_done = True
+            if state.resolve_next and not state.resolve_next.done():
+                state.resolve_next.set_result({"done": True, "value": None})
+                state.resolve_next = None
+            return
+
+        if message["data"].get("done"):
+            # Handle completion
+            state.is_done = True
+            if state.resolve_next and not state.resolve_next.done():
+                state.resolve_next.set_result({"done": True, "value": message["data"]})
+                state.resolve_next = None
+            return
+
+        if state.resolve_next and not state.resolve_next.done():
+            # Resolve waiting consumer
+            state.resolve_next.set_result({"done": False, "value": message["data"]})
+            state.resolve_next = None
+        else:
+            # Queue message
+            if len(state.message_queue) >= self._MAX_QUEUE_SIZE:
+                state.message_queue.pop(0)  # Remove oldest
+            state.message_queue.append(message["data"])
+
+    async def _handle_control_message(
+        self, stream_id: str, control_message: BroadcastMessage[GeneratorControl]
+    ) -> None:
+        """Producer: Handles incoming control messages"""
+        producer_state = self._producer_generator_states.get(stream_id)
+        if not producer_state:
+            return
+
+        if control_message["data"]["type"] in ("return", "throw"):
+            # Client requested termination
+            await self._cleanup_producer_generator(stream_id, producer_state)
+        elif control_message["data"]["type"] == "ready":
+            # Client is ready for next message
+            producer_state.is_waiting_for_client = False
+            ready_signals = self._pending_ready_signals.get(stream_id, set())
+
+            # Resolve all waiting futures
+            for future in list(ready_signals):
+                if not future.done():
+                    future.set_result(None)
+
+            ready_signals.clear()
+
+    async def _send_ready_signal(
+        self, stream_id: str, control_subject: str, connection: RPCConnectionManager
+    ) -> None:
+        """Consumer: Sends 'ready' signal via dedicated connection"""
+        if connection.is_closed():
+            return
+
+        try:
+            await connection.publish(control_subject, {"type": "ready"})
+            logger.debug(f"[C:{stream_id}] Sent ready signal")
+        except Exception as error:
+            logger.debug(f"[C:{stream_id}] Error sending ready signal: {error}")
+
+    async def _cleanup_consumer_generator(self, stream_id: str, state: ConsumerGeneratorState) -> None:
+        """Consumer: Initiates cleanup"""
+        if stream_id not in self._consumer_generator_states:
+            return
+
+        self._consumer_generator_states.pop(stream_id, None)
+        logger.debug(f"[C:{stream_id}] Cleaning up consumer generator...")
+
+        # Unsubscribe from data stream
+        await state.stream_subscription.unsubscribe()
+
+        # Clean up connection
+        await self._cleanup_consumer_connection(stream_id, state.dedicated_connection, state.control_subject)
+
+    async def _cleanup_consumer_connection(
+        self, stream_id: str, connection: RPCConnectionManager, control_subject: str | None
+    ) -> None:
+        """Consumer: Cleans up connection"""
+        logger.debug(f"[C:{stream_id}] Cleaning up consumer connection...")
+
+        # Send return signal if possible
+        if control_subject and not connection.is_closed():
+            with contextlib.suppress(Exception):
+                await connection.publish(control_subject, {"type": "return"})
+
+        # Disconnect
+        if not connection.is_closed():
+            try:
+                await connection.disconnect()
+            except Exception as error:
+                logger.debug(f"[C:{stream_id}] Error disconnecting consumer connection: {error}")
+
+    async def _cleanup_producer_generator(self, stream_id: str, state: ProducerGeneratorState) -> None:
+        """Producer: Initiates cleanup"""
+        if stream_id not in self._producer_generator_states:
+            return
+
+        self._producer_generator_states.pop(stream_id, None)
+        self._pending_ready_signals.pop(stream_id, None)
+        logger.debug(f"[P:{stream_id}] Cleaning up producer generator...")
+
+        # Close generator
+        with contextlib.suppress(Exception):
+            await state.generator.aclose()
+
+        # Clean up connection
+        await self._cleanup_producer_connection(state.dedicated_connection, state.control_subscription)
+
+    async def _cleanup_producer_connection(
+        self, connection: RPCConnectionManager, control_subscription: SubscriptionWrapper | None
+    ) -> None:
+        """Producer: Cleans up connection"""
+        conn_id = connection.options.get("metadata", {}).get("id", "unknown-producer")
+        logger.debug(f"[P:{conn_id}] Cleaning up producer connection...")
+
+        # Unsubscribe from control channel
+        if control_subscription:
+            await control_subscription.unsubscribe()
+
+        # Disconnect
+        if not connection.is_closed():
+            try:
+                await connection.disconnect()
+            except Exception as error:
+                logger.debug(f"[P:{conn_id}] Error disconnecting producer connection: {error}")

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

@@ -0,0 +1,96 @@
+from datetime import datetime
+from typing import Any, Final, Literal
+
+from .typings import ClientMetrics
+
+
+class SUBJECTS:
+    class HEALTH:
+        PING: Literal["health.ping"] = "health.ping"
+        PONG: Literal["health.pong"] = "health.pong"
+
+    class SERVER:
+        STATUS: Literal["server.status"] = "server.status"
+        BROADCAST: Literal["server.broadcast"] = "server.broadcast"
+
+    class PLUGIN:
+        REGISTER: Literal["plugin.register"] = "plugin.register"
+        UNREGISTER: Literal["plugin.unregister"] = "plugin.unregister"
+        STATUS: Literal["plugin.status"] = "plugin.status"
+
+    class SERVICE:
+        REGISTER: Literal["service.register"] = "service.register"
+        UNREGISTER: Literal["service.unregister"] = "service.unregister"
+        STATUS: Literal["service.status"] = "service.status"
+
+    class METRICS:
+        UPDATE: Literal["metrics.update"] = "metrics.update"
+
+
+class MESSAGE:
+    class TYPES:
+        REQUEST: Literal["request"] = "request"
+        RESPONSE: Literal["response"] = "response"
+        BROADCAST: Literal["broadcast"] = "broadcast"
+        RPC_REQUEST: Literal["rpcrequest"] = "rpcrequest"
+        RPC_RESPONSE: Literal["rpcresponse"] = "rpcresponse"
+        RPC_STREAM_REQUEST: Literal["rpcstreamrequest"] = "rpcstreamrequest"
+
+    class PRIORITIES:
+        HIGH: Literal["high"] = "high"
+        NORMAL: Literal["normal"] = "normal"
+        LOW: Literal["low"] = "low"
+
+    class HEADERS:
+        CORRELATION_ID: Literal["correlation-id"] = "correlation-id"
+        REQUEST_ID: Literal["request-id"] = "request-id"
+        TIMESTAMP: Literal["timestamp"] = "timestamp"
+        PRIORITY: Literal["priority"] = "priority"
+        TTL: Literal["ttl"] = "ttl"
+
+
+class DEFAULTS:
+    class TIMEOUTS:
+        CONNECTION: Final[int] = 5000  # 5 seconds
+        REQUEST: Final[int] = 5000  # 5 seconds
+        RPC: Final[int] = 5000  # 5 seconds
+
+    class INTERVALS:
+        HEARTBEAT: Final[int] = 15000  # 10 seconds
+        CLEANUP: Final[int] = 60000  # 1 minute
+        METRICS: Final[int] = 60000  # 1 minute
+
+    class RETRY:
+        MAX_RECONNECT_ATTEMPTS: Final[int] = -1  # Infinite retries
+        DELAY: Final[int] = 1000  # 1 second
+
+    class METRICS:
+        TTL: Final[int] = 60000  # 1 minute
+
+
+DEFAULT_CLIENT_METRICS: ClientMetrics = {
+    "timestamp": int(datetime.now().timestamp() * 1000),
+    "startTime": int(datetime.now().timestamp() * 1000),
+    "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},
+}
+
+BASE_METRICS: dict[str, Any] = {
+    "requests": {
+        "total": 0,
+        "active": 0,
+        "errors": 0,
+        "timings": {},
+        "in_window": {
+            "count": 0,
+            "errors": 0,
+            "response_times": [],
+            "start_time": int(datetime.now().timestamp() * 1000),
+        },
+    },
+    "messages": {"published": 0, "received": 0, "errors": 0},
+    "rpc": {"total": 0, "active": 0, "errors": 0},
+    "subscriptions": {"active": 0, "message_handlers": 0, "request_handlers": 0, "rpc_handlers": 0},
+}