tigrbl-runtime 0.4.4.dev8__py3-none-any.whl → 0.4.5.dev4__py3-none-any.whl

tigrbl_runtime/executors/ctx/context.py

@@ -16,11 +16,7 @@ from typing import (
     runtime_checkable,
 )
 
-try:
-    from sqlalchemy.ext.asyncio import AsyncSession
-    from sqlalchemy.orm import Session
-except Exception:  # pragma: no cover - optional ORM dependency for runtime typing
-    AsyncSession = Session = Any  # type: ignore[assignment]
+AsyncSession = Session = Any  # type: ignore[assignment]
 
 from tigrbl_atoms.types import BaseCtx
 from tigrbl_base._base import AttrDict

tigrbl_runtime/executors/ctx/hot_namespace_values.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from collections.abc import Mapping as ABCMapping
+from typing import Any, Mapping
+
+from .hot_state import (
+    HotCtx,
+    _ensure_hot_assembled_values_view,
+    _ensure_hot_in_values_view,
+    _ensure_hot_virtual_in_view,
+    _LAZY_MISSING,
+)
+
+
+def _coerce_optional_dict(value: Any) -> dict[str, Any] | None:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, ABCMapping):
+        return dict(value)
+    return None
+
+
+def _namespace_lazy_value(kind: str, hot: HotCtx, key: str) -> Any:
+    if kind == "route":
+        if key == "selector":
+            value = hot.route_selector
+            return value if value else _LAZY_MISSING
+        if key == "protocol":
+            value = hot.route_protocol
+            return value if value else _LAZY_MISSING
+        if key == "program_id":
+            value = (
+                hot.route_program_id if hot.route_program_id >= 0 else hot.program_id
+            )
+            return value if value >= 0 else _LAZY_MISSING
+        if key == "opmeta_index":
+            value = (
+                hot.route_opmeta_index
+                if hot.route_opmeta_index >= 0
+                else hot.route_program_id
+            )
+            return value if value >= 0 else _LAZY_MISSING
+        if key == "method_not_allowed":
+            return True if hot.route_method_not_allowed else _LAZY_MISSING
+        if key == "short_circuit":
+            return True if hot.route_short_circuit else _LAZY_MISSING
+        if key == "payload":
+            if hot.route_payload is not None:
+                return hot.route_payload
+            value = _ensure_hot_in_values_view(hot)
+            return value if value is not None else _LAZY_MISSING
+        if key == "path_params":
+            value = hot.route_path_params or hot.path_params
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc_envelope":
+            value = hot.route_rpc_envelope or hot.dispatch_rpc_envelope
+            return value if value is not None else _LAZY_MISSING
+        return _LAZY_MISSING
+    if kind == "dispatch":
+        if key == "binding_protocol":
+            value = hot.dispatch_binding_protocol
+            return value if value else _LAZY_MISSING
+        if key == "binding_selector":
+            value = hot.dispatch_binding_selector
+            return value if value else _LAZY_MISSING
+        if key == "channel_protocol":
+            value = hot.dispatch_channel_protocol
+            return value if value else _LAZY_MISSING
+        if key == "channel_selector":
+            value = hot.dispatch_channel_selector
+            return value if value else _LAZY_MISSING
+        if key in {"normalized_input", "parsed_payload"}:
+            value = _ensure_hot_in_values_view(hot)
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc":
+            value = hot.dispatch_rpc_envelope or hot.route_rpc_envelope
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc_method":
+            value = hot.dispatch_rpc_method
+            return value if value is not None else _LAZY_MISSING
+        return _LAZY_MISSING
+    if kind == "egress":
+        if key == "transport_response":
+            value = hot.egress_transport_response
+            return value if value is not None else _LAZY_MISSING
+        if key == "sent":
+            return True if hot.egress_sent else _LAZY_MISSING
+        return _LAZY_MISSING
+    return _LAZY_MISSING
+
+
+def _sync_hot_namespace_value(kind: str, hot: HotCtx, key: str, value: Any) -> None:
+    if kind == "route":
+        if key == "selector" and isinstance(value, str):
+            hot.route_selector = value
+        elif key == "protocol" and isinstance(value, str):
+            hot.route_protocol = value
+        elif key == "program_id" and isinstance(value, int):
+            hot.route_program_id = value
+            hot.program_id = value
+        elif key == "opmeta_index" and isinstance(value, int):
+            hot.route_opmeta_index = value
+            if hot.route_program_id < 0:
+                hot.route_program_id = value
+            if hot.program_id < 0:
+                hot.program_id = value
+        elif key == "method_not_allowed":
+            hot.route_method_not_allowed = bool(value)
+        elif key == "short_circuit":
+            hot.route_short_circuit = bool(value)
+        elif key == "payload":
+            hot.route_payload = _coerce_optional_dict(value)
+        elif key == "path_params":
+            path_params = _coerce_optional_dict(value)
+            hot.route_path_params = path_params
+            hot.path_params = path_params
+        elif key == "rpc_envelope":
+            envelope = _coerce_optional_dict(value)
+            hot.route_rpc_envelope = envelope
+            if envelope is not None:
+                hot.dispatch_jsonrpc_request_id = envelope.get("id")
+                method = envelope.get("method")
+                hot.dispatch_rpc_method = method if isinstance(method, str) else None
+    elif kind == "dispatch":
+        if key == "binding_protocol" and isinstance(value, str):
+            hot.dispatch_binding_protocol = value
+        elif key == "binding_selector" and isinstance(value, str):
+            hot.dispatch_binding_selector = value
+        elif key == "channel_protocol" and isinstance(value, str):
+            hot.dispatch_channel_protocol = value
+        elif key == "channel_selector" and isinstance(value, str):
+            hot.dispatch_channel_selector = value
+        elif key == "rpc":
+            envelope = _coerce_optional_dict(value)
+            hot.dispatch_rpc_envelope = envelope
+            if envelope is not None:
+                hot.dispatch_jsonrpc_request_id = envelope.get("id")
+                method = envelope.get("method")
+                hot.dispatch_rpc_method = method if isinstance(method, str) else None
+        elif key == "rpc_method":
+            hot.dispatch_rpc_method = value if isinstance(value, str) else None
+        elif key in {"normalized_input", "parsed_payload"}:
+            route_payload = _coerce_optional_dict(value)
+            if route_payload is not None:
+                hot.route_payload = route_payload
+        elif key == "jsonrpc_request_id":
+            hot.dispatch_jsonrpc_request_id = value
+    elif kind == "egress":
+        if key == "transport_response":
+            hot.egress_transport_response = _coerce_optional_dict(value)
+        elif key == "sent":
+            hot.egress_sent = bool(value)
+
+
+def _clear_hot_namespace_value(kind: str, hot: HotCtx, key: str) -> None:
+    if kind == "route":
+        if key == "selector":
+            hot.route_selector = ""
+        elif key == "protocol":
+            hot.route_protocol = ""
+        elif key == "program_id":
+            hot.route_program_id = -1
+        elif key == "opmeta_index":
+            hot.route_opmeta_index = -1
+        elif key == "method_not_allowed":
+            hot.route_method_not_allowed = False
+        elif key == "short_circuit":
+            hot.route_short_circuit = False
+        elif key == "payload":
+            hot.route_payload = None
+        elif key == "path_params":
+            hot.route_path_params = None
+            hot.path_params = None
+        elif key == "rpc_envelope":
+            hot.route_rpc_envelope = None
+            hot.dispatch_jsonrpc_request_id = None
+            hot.dispatch_rpc_method = None
+    elif kind == "dispatch":
+        if key == "binding_protocol":
+            hot.dispatch_binding_protocol = ""
+        elif key == "binding_selector":
+            hot.dispatch_binding_selector = ""
+        elif key == "channel_protocol":
+            hot.dispatch_channel_protocol = ""
+        elif key == "channel_selector":
+            hot.dispatch_channel_selector = ""
+        elif key == "rpc":
+            hot.dispatch_rpc_envelope = None
+            hot.dispatch_jsonrpc_request_id = None
+            hot.dispatch_rpc_method = None
+        elif key == "rpc_method":
+            hot.dispatch_rpc_method = None
+        elif key == "jsonrpc_request_id":
+            hot.dispatch_jsonrpc_request_id = None
+    elif kind == "egress":
+        if key == "transport_response":
+            hot.egress_transport_response = None
+        elif key == "sent":
+            hot.egress_sent = False
+

tigrbl_runtime/executors/ctx/hot_namespaces.py

@@ -10,193 +10,12 @@ from .hot_state import (
     _ensure_hot_virtual_in_view,
     _LAZY_MISSING,
 )
-
-
-def _coerce_optional_dict(value: Any) -> dict[str, Any] | None:
-    if isinstance(value, dict):
-        return value
-    if isinstance(value, ABCMapping):
-        return dict(value)
-    return None
-
-
-def _namespace_lazy_value(kind: str, hot: HotCtx, key: str) -> Any:
-    if kind == "route":
-        if key == "selector":
-            value = hot.route_selector
-            return value if value else _LAZY_MISSING
-        if key == "protocol":
-            value = hot.route_protocol
-            return value if value else _LAZY_MISSING
-        if key == "program_id":
-            value = (
-                hot.route_program_id if hot.route_program_id >= 0 else hot.program_id
-            )
-            return value if value >= 0 else _LAZY_MISSING
-        if key == "opmeta_index":
-            value = (
-                hot.route_opmeta_index
-                if hot.route_opmeta_index >= 0
-                else hot.route_program_id
-            )
-            return value if value >= 0 else _LAZY_MISSING
-        if key == "method_not_allowed":
-            return True if hot.route_method_not_allowed else _LAZY_MISSING
-        if key == "short_circuit":
-            return True if hot.route_short_circuit else _LAZY_MISSING
-        if key == "payload":
-            if hot.route_payload is not None:
-                return hot.route_payload
-            value = _ensure_hot_in_values_view(hot)
-            return value if value is not None else _LAZY_MISSING
-        if key == "path_params":
-            value = hot.route_path_params or hot.path_params
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc_envelope":
-            value = hot.route_rpc_envelope or hot.dispatch_rpc_envelope
-            return value if value is not None else _LAZY_MISSING
-        return _LAZY_MISSING
-    if kind == "dispatch":
-        if key == "binding_protocol":
-            value = hot.dispatch_binding_protocol
-            return value if value else _LAZY_MISSING
-        if key == "binding_selector":
-            value = hot.dispatch_binding_selector
-            return value if value else _LAZY_MISSING
-        if key == "channel_protocol":
-            value = hot.dispatch_channel_protocol
-            return value if value else _LAZY_MISSING
-        if key == "channel_selector":
-            value = hot.dispatch_channel_selector
-            return value if value else _LAZY_MISSING
-        if key in {"normalized_input", "parsed_payload"}:
-            value = _ensure_hot_in_values_view(hot)
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc":
-            value = hot.dispatch_rpc_envelope or hot.route_rpc_envelope
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc_method":
-            value = hot.dispatch_rpc_method
-            return value if value is not None else _LAZY_MISSING
-        return _LAZY_MISSING
-    if kind == "egress":
-        if key == "transport_response":
-            value = hot.egress_transport_response
-            return value if value is not None else _LAZY_MISSING
-        if key == "sent":
-            return True if hot.egress_sent else _LAZY_MISSING
-        return _LAZY_MISSING
-    return _LAZY_MISSING
-
-
-def _sync_hot_namespace_value(kind: str, hot: HotCtx, key: str, value: Any) -> None:
-    if kind == "route":
-        if key == "selector" and isinstance(value, str):
-            hot.route_selector = value
-        elif key == "protocol" and isinstance(value, str):
-            hot.route_protocol = value
-        elif key == "program_id" and isinstance(value, int):
-            hot.route_program_id = value
-            hot.program_id = value
-        elif key == "opmeta_index" and isinstance(value, int):
-            hot.route_opmeta_index = value
-            if hot.route_program_id < 0:
-                hot.route_program_id = value
-            if hot.program_id < 0:
-                hot.program_id = value
-        elif key == "method_not_allowed":
-            hot.route_method_not_allowed = bool(value)
-        elif key == "short_circuit":
-            hot.route_short_circuit = bool(value)
-        elif key == "payload":
-            hot.route_payload = _coerce_optional_dict(value)
-        elif key == "path_params":
-            path_params = _coerce_optional_dict(value)
-            hot.route_path_params = path_params
-            hot.path_params = path_params
-        elif key == "rpc_envelope":
-            envelope = _coerce_optional_dict(value)
-            hot.route_rpc_envelope = envelope
-            if envelope is not None:
-                hot.dispatch_jsonrpc_request_id = envelope.get("id")
-                method = envelope.get("method")
-                hot.dispatch_rpc_method = method if isinstance(method, str) else None
-    elif kind == "dispatch":
-        if key == "binding_protocol" and isinstance(value, str):
-            hot.dispatch_binding_protocol = value
-        elif key == "binding_selector" and isinstance(value, str):
-            hot.dispatch_binding_selector = value
-        elif key == "channel_protocol" and isinstance(value, str):
-            hot.dispatch_channel_protocol = value
-        elif key == "channel_selector" and isinstance(value, str):
-            hot.dispatch_channel_selector = value
-        elif key == "rpc":
-            envelope = _coerce_optional_dict(value)
-            hot.dispatch_rpc_envelope = envelope
-            if envelope is not None:
-                hot.dispatch_jsonrpc_request_id = envelope.get("id")
-                method = envelope.get("method")
-                hot.dispatch_rpc_method = method if isinstance(method, str) else None
-        elif key == "rpc_method":
-            hot.dispatch_rpc_method = value if isinstance(value, str) else None
-        elif key in {"normalized_input", "parsed_payload"}:
-            route_payload = _coerce_optional_dict(value)
-            if route_payload is not None:
-                hot.route_payload = route_payload
-        elif key == "jsonrpc_request_id":
-            hot.dispatch_jsonrpc_request_id = value
-    elif kind == "egress":
-        if key == "transport_response":
-            hot.egress_transport_response = _coerce_optional_dict(value)
-        elif key == "sent":
-            hot.egress_sent = bool(value)
-
-
-def _clear_hot_namespace_value(kind: str, hot: HotCtx, key: str) -> None:
-    if kind == "route":
-        if key == "selector":
-            hot.route_selector = ""
-        elif key == "protocol":
-            hot.route_protocol = ""
-        elif key == "program_id":
-            hot.route_program_id = -1
-        elif key == "opmeta_index":
-            hot.route_opmeta_index = -1
-        elif key == "method_not_allowed":
-            hot.route_method_not_allowed = False
-        elif key == "short_circuit":
-            hot.route_short_circuit = False
-        elif key == "payload":
-            hot.route_payload = None
-        elif key == "path_params":
-            hot.route_path_params = None
-            hot.path_params = None
-        elif key == "rpc_envelope":
-            hot.route_rpc_envelope = None
-            hot.dispatch_jsonrpc_request_id = None
-            hot.dispatch_rpc_method = None
-    elif kind == "dispatch":
-        if key == "binding_protocol":
-            hot.dispatch_binding_protocol = ""
-        elif key == "binding_selector":
-            hot.dispatch_binding_selector = ""
-        elif key == "channel_protocol":
-            hot.dispatch_channel_protocol = ""
-        elif key == "channel_selector":
-            hot.dispatch_channel_selector = ""
-        elif key == "rpc":
-            hot.dispatch_rpc_envelope = None
-            hot.dispatch_jsonrpc_request_id = None
-            hot.dispatch_rpc_method = None
-        elif key == "rpc_method":
-            hot.dispatch_rpc_method = None
-        elif key == "jsonrpc_request_id":
-            hot.dispatch_jsonrpc_request_id = None
-    elif kind == "egress":
-        if key == "transport_response":
-            hot.egress_transport_response = None
-        elif key == "sent":
-            hot.egress_sent = False
+from .hot_namespace_values import (
+    _clear_hot_namespace_value,
+    _coerce_optional_dict,
+    _namespace_lazy_value,
+    _sync_hot_namespace_value,
+)
 
 
 class _HotNamespaceDict(dict[str, Any]):

tigrbl_runtime/executors/packed/__init__.py

@@ -0,0 +1,4 @@
+from ._shared import _DirectWebSocketUnary
+from .executor import PackedPlanExecutor
+
+__all__ = ["PackedPlanExecutor"]

tigrbl_runtime/executors/packed/_shared.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Mapping
+from dataclasses import dataclass, fields, is_dataclass
+import inspect
+import json
+from importlib import import_module
+from typing import Any, ClassVar
+from operator import attrgetter
+from types import SimpleNamespace
+
+from tigrbl_atoms._ctx import _ctx_view
+from tigrbl_core.config.constants import __JSONRPC_DEFAULT_ENDPOINT_MAPPINGS__
+from tigrbl_atoms.types import build_error_ctx, error_phase_for, select_error_edge
+from tigrbl_atoms.atoms.wire.validate_in import _coerce_if_needed
+from tigrbl_atoms.atoms.transport.websocket_unary import (
+    DirectWebSocketUnary as _DirectWebSocketUnary,
+)
+from tigrbl_atoms.packed_inputs import (
+    DECODER_BOOL as _DECODER_BOOL,
+    DECODER_DATE as _DECODER_DATE,
+    DECODER_DATETIME as _DECODER_DATETIME,
+    DECODER_DECIMAL as _DECODER_DECIMAL,
+    DECODER_FLOAT as _DECODER_FLOAT,
+    DECODER_INT as _DECODER_INT,
+    DECODER_NONE as _DECODER_NONE,
+    DECODER_STR as _DECODER_STR,
+    DECODER_TIME as _DECODER_TIME,
+    DECODER_UUID as _DECODER_UUID,
+    DECODE_STRATEGY_BODY_ONLY_MAPPING as _DECODE_STRATEGY_BODY_ONLY_MAPPING,
+    DECODE_STRATEGY_BODY_ONLY_SINGLE_FIELD as _DECODE_STRATEGY_BODY_ONLY_SINGLE_FIELD,
+    DECODE_STRATEGY_GENERIC_HASHED as _DECODE_STRATEGY_GENERIC_HASHED,
+    PARAM_SOURCE_BODY as _PARAM_SOURCE_BODY,
+    PARAM_SOURCE_HEADER as _PARAM_SOURCE_HEADER,
+    PARAM_SOURCE_PATH as _PARAM_SOURCE_PATH,
+    PARAM_SOURCE_QUERY as _PARAM_SOURCE_QUERY,
+    QUERY_VALUE_HAS_PERCENT as _QUERY_VALUE_HAS_PERCENT,
+    QUERY_VALUE_HAS_PLUS as _QUERY_VALUE_HAS_PLUS,
+    body_hash_items as _atom_body_hash_items,
+    coerce_header_pairs as _atom_coerce_header_pairs,
+    compiled_lookup_name as _atom_compiled_lookup_name,
+    content_type_from_raw_headers as _atom_content_type_from_raw_headers,
+    decode_query_span_value as _atom_decode_query_span_value,
+    decode_scalar as _atom_decode_scalar,
+    ensure_body_bytes as _atom_ensure_body_bytes,
+    header_hash_pairs as _atom_header_hash_pairs,
+    lookup_hashed_mapping as _atom_lookup_hashed_mapping,
+    lookup_hashed_pairs as _atom_lookup_hashed_pairs,
+    lookup_query_value as _atom_lookup_query_value,
+    parse_query_spans as _atom_parse_query_spans,
+    path_hash_items as _atom_path_hash_items,
+    publish_compiled_slots as _atom_publish_compiled_slots,
+)
+from tigrbl_kernel.models import (
+    KernelPlan,
+    OpKey,
+    PackedHotSection,
+    PackedHotSectionDirectory,
+    PackedKernel,
+)
+from tigrbl_kernel.packed_access import (
+    DIRECT_INVOKE_RUN as _DIRECT_INVOKE_RUN,
+    DIRECT_INVOKE_RUN_WITH_DEP as _DIRECT_INVOKE_RUN_WITH_DEP,
+    DIRECT_INVOKE_RUN_WITH_NONE as _DIRECT_INVOKE_RUN_WITH_NONE,
+    DIRECT_INVOKE_STEP as _DIRECT_INVOKE_STEP,
+    HOT_RUNNER_COMPILED_PARAM as _HOT_RUNNER_COMPILED_PARAM,
+    HOT_RUNNER_GENERIC as _HOT_RUNNER_GENERIC,
+    HOT_RUNNER_LINEAR_DIRECT as _HOT_RUNNER_LINEAR_DIRECT,
+    HOT_RUNNER_WS_UNARY_TEXT as _HOT_RUNNER_WS_UNARY_TEXT,
+    HTTP_METHOD_ID_BY_NAME as _HTTP_METHOD_ID_BY_NAME,
+    TRANSPORT_KIND_CHANNEL as _TRANSPORT_KIND_CHANNEL,
+    TRANSPORT_KIND_GENERIC as _TRANSPORT_KIND_GENERIC,
+    TRANSPORT_KIND_JSONRPC as _TRANSPORT_KIND_JSONRPC,
+    TRANSPORT_KIND_REST as _TRANSPORT_KIND_REST,
+    hot_array as _kernel_hot_array,
+    hot_block_sections as _kernel_hot_block_sections,
+    hot_block_view as _kernel_hot_block_view,
+    hot_count as _kernel_hot_count,
+    hot_int_at as _kernel_hot_int_at,
+    hot_section as _kernel_hot_section,
+    http_method_id as _kernel_http_method_id,
+    resolve_program_hot_runner_id as _kernel_resolve_program_hot_runner_id,
+    stable_name_hash64 as _kernel_stable_name_hash64,
+)
+from tigrbl_kernel.packed_selectors import (
+    normalize_jsonrpc_mount_path as _kernel_normalize_jsonrpc_mount_path,
+    resolve_hot_exact_jsonrpc_routes as _kernel_resolve_hot_exact_jsonrpc_routes,
+    resolve_hot_exact_route_slices as _kernel_resolve_hot_exact_route_slices,
+    resolve_hot_exact_route_verify as _kernel_resolve_hot_exact_route_verify,
+    resolve_hot_exact_websocket_routes as _kernel_resolve_hot_exact_websocket_routes,
+    resolve_program_id_from_exact_route as _kernel_resolve_program_id_from_exact_route,
+    resolve_program_id_from_exact_websocket as _kernel_resolve_program_id_from_exact_websocket,
+)
+from tigrbl_typing.status.exceptions import HTTPException
+from tigrbl_typing.phases import canonicalize_phase_input as normalize_phase
+from tigrbl_typing.status.mappings import status as _status
+from tigrbl_atoms._request import Request
+
+from ..base import ExecutorBase
+from ..types import HotCtx, _Ctx
+
+_WRAPPER_KEYS = frozenset({"data", "payload", "body", "item"})
+_COMPAT_CONSTANTS = (
+    _DECODER_BOOL,
+    _DECODER_DATE,
+    _DECODER_DATETIME,
+    _DECODER_DECIMAL,
+    _DECODER_FLOAT,
+    _DECODER_INT,
+    _DECODER_NONE,
+    _DECODER_STR,
+    _DECODER_TIME,
+    _DECODER_UUID,
+    _QUERY_VALUE_HAS_PERCENT,
+    _QUERY_VALUE_HAS_PLUS,
+    _HTTP_METHOD_ID_BY_NAME,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _CompiledInputDescriptor:
+    slot_id: int
+    lookup_name: str
+    source_mask: int
+    decoder_id: int
+    max_length: int
+    lookup_hash: int
+    header_hash: int
+
+
+@dataclass(frozen=True, slots=True)
+class _CompiledFieldPlan:
+    slot_id: int
+    field_name: str
+    required: bool
+    nullable: bool | None
+    py_type: Any
+    coerce: bool
+    max_length: int
+    validator: Any
+    in_enabled: bool
+    is_virtual: bool
+    default_factory: Any
+
+
+@dataclass(frozen=True, slots=True)
+class _CompiledParamPlan:
+    field_names: tuple[str, ...]
+    field_index: Mapping[str, int]
+    field_plans: tuple[_CompiledFieldPlan, ...]
+    descriptor_plans: tuple[_CompiledInputDescriptor, ...]
+    strategy_kind: int
+    strategy_rows: tuple[tuple[int, str, int, int], ...]
+    assemble_order: tuple[int, ...]
+    body_lookup_names: frozenset[str]
+    reserved_input_keys: frozenset[str]
+    needs_query: bool
+    needs_header: bool
+    needs_path: bool
+
+
+__all__ = [
+    name
+    for name in globals()
+    if not name.startswith("__") or name == "__JSONRPC_DEFAULT_ENDPOINT_MAPPINGS__"
+]
+
+