@camera.ui/server 0.0.70 → 0.0.71

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

@@ -1,584 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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},
-}