openbox-sdk-python 0.2.0__py3-none-any.whl

openbox_core/hooks/preflight.py

@@ -0,0 +1,292 @@
+"""HookRuntime — the SINGLE decision point for hook verdicts.
+
+One path only: wrapper -> hook runtime -> adapter. Wrappers never interpret
+verdicts; this runtime validates via the gate and delegates every native
+effect to the FrameworkAdapter:
+
+- started BLOCK/HALT  -> mark abort (+halt flag) -> ``adapter.raise_hook_blocked``
+- started REQUIRE_APPROVAL -> approval flow; rejected/unavailable -> blocked
+- completed verdicts  -> ``adapter.on_completed_hook_result`` + abort/halt
+  flags for FUTURE execution (the operation already ran; never undone)
+- prior abort         -> fail fast without another network call
+- no bound context    -> skip silently (not an error)
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping
+from typing import Any, NoReturn
+
+from ..approvals import ApprovalPoller
+from ..contracts.events import EventEnvelope
+from ..contracts.otel_spans import HookType, Stage
+from ..contracts.results import EvaluationResult, Verdict
+from ..errors import ContractError, GovernanceAPIError, GovernanceBlockedError
+from ..hooks.events import build_hook_event, resolve_context
+from ..runtime import OpenBoxRuntime
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["HookRuntime"]
+
+
+class HookRuntime:
+    """Drives preflight/completed hook evaluation for one OpenBoxRuntime."""
+
+    def __init__(self, runtime: OpenBoxRuntime):
+        self._runtime = runtime
+        self._store = runtime.context_store
+        self._gate = runtime.gate
+        self._adapter = runtime.adapter
+        # Decide ONCE whether the adapter's completed callback takes ``context``,
+        # by inspecting its signature — so a genuine TypeError raised inside the
+        # callback body is never mistaken for an arity mismatch and swallowed.
+        self._completed_accepts_context = self._adapter_accepts_context()
+        hitl = runtime.config.hitl
+        self._sync_poller: ApprovalPoller | None = None
+        if hitl.enabled:
+            self._sync_poller = ApprovalPoller(
+                runtime.client,
+                poll_interval_seconds=hitl.poll_interval_ms / 1000.0,
+                max_wait_seconds=(hitl.max_wait_ms / 1000.0) if hitl.max_wait_ms else None,
+            )
+
+    # ── Preflight (started stage) ─────────────────────────────────────────
+
+    def preflight(
+        self,
+        span: Any,
+        *,
+        hook_type: HookType,
+        identifier: str = "",
+        fields: Mapping[str, Any] | None = None,
+    ) -> bool:
+        """Evaluate BEFORE the real operation. True ⇒ proceed.
+
+        Blocking outcomes never return — the adapter raises. Skipped hooks
+        (disabled preflight / no context) return True.
+        """
+        event = self._pre_gate(span, hook_type, fields)
+        if event is None:
+            return True
+        try:
+            result = self._gate.preflight(event)
+        except (ContractError, GovernanceAPIError) as e:
+            self._fail_closed_started(e, span)
+        return self._decide_started(result, span, sync=True)
+
+    async def apreflight(
+        self,
+        span: Any,
+        *,
+        hook_type: HookType,
+        identifier: str = "",
+        fields: Mapping[str, Any] | None = None,
+    ) -> bool:
+        """Async :meth:`preflight` — approval delegates to the adapter."""
+        event = self._pre_gate(span, hook_type, fields)
+        if event is None:
+            return True
+        try:
+            result = await self._gate.apreflight(event)
+        except (ContractError, GovernanceAPIError) as e:
+            self._fail_closed_started(e, span)
+        return await self._adecide_started(result, span)
+
+    def _pre_gate(
+        self, span: Any, hook_type: HookType, fields: Mapping[str, Any] | None
+    ) -> EventEnvelope | None:
+        if not self._runtime.config.instrumentation.preflight_enabled:
+            return None
+        ctx = resolve_context(self._store, span)
+        if ctx is not None:
+            # Abort short-circuit: a prior hook already stopped this activity.
+            if self._store.is_activity_aborted(ctx.workflow_id, ctx.activity_id):
+                self._adapter.raise_hook_blocked(
+                    EvaluationResult(
+                        verdict=Verdict.BLOCK,
+                        reason="Activity aborted by a prior hook verdict",
+                    )
+                )
+        return build_hook_event(
+            self._store, span, stage=Stage.STARTED, hook_type=hook_type, fields=fields
+        )
+
+    def _fail_closed_started(self, error: Exception, span: Any) -> NoReturn:
+        """Map a started-hook evaluation failure to a framework-native HALT.
+
+        Reached only when the failure must stop the operation: the client
+        raises ``GovernanceAPIError`` solely under ``on_api_error=fail_closed``
+        (fail-open returns an allow-shaped fallback instead), and started-hook
+        ``ContractError``s always fail closed — a payload we cannot express to
+        Core must not let the operation run ungoverned. Raising the raw error
+        would leave frameworks treating it as a generic (often retryable)
+        failure; routing a HALT-shaped result through the adapter preserves
+        the non-retryable halt semantics.
+        """
+        halt = EvaluationResult(
+            verdict=Verdict.HALT,
+            reason=f"Governance evaluation failed closed: {error}",
+            fallback_used=True,
+            raw={"fail_closed_error": str(error), "error_type": type(error).__name__},
+        )
+        self._mark_stopped(halt, span)
+        self._adapter.raise_hook_blocked(halt)  # NoReturn by contract
+        raise GovernanceBlockedError(
+            halt.verdict, halt.reason or "Blocked (adapter returned)"
+        )
+
+    def _decide_started(self, result: EvaluationResult, span: Any, *, sync: bool) -> bool:
+        verdict = result.verdict
+        if verdict.should_stop():
+            self._mark_stopped(result, span)
+            self._adapter.raise_hook_blocked(result)  # NoReturn by contract
+            # Defense in depth: a misbehaving adapter that RETURNS from its
+            # NoReturn callback must not fall through to run the operation.
+            raise GovernanceBlockedError(
+                result.verdict, result.reason or "Blocked (adapter returned)"
+            )
+        if verdict.requires_approval():
+            return self._sync_approval(result, span)
+        return True
+
+    async def _adecide_started(self, result: EvaluationResult, span: Any) -> bool:
+        verdict = result.verdict
+        if verdict.should_stop():
+            self._mark_stopped(result, span)
+            self._adapter.raise_hook_blocked(result)  # NoReturn by contract
+            # Defense in depth: a misbehaving adapter that RETURNS from its
+            # NoReturn callback must not fall through to run the operation.
+            raise GovernanceBlockedError(
+                result.verdict, result.reason or "Blocked (adapter returned)"
+            )
+        if verdict.requires_approval():
+            # Adapter drives its native approval flow; returning ⇒ approved.
+            await self._adapter.handle_approval(result)
+            return True
+        return True
+
+    def _sync_approval(self, result: EvaluationResult, span: Any) -> bool:
+        """Sync approval: adapter-native flow first, core poller fallback.
+
+        An adapter exposing ``handle_approval_sync`` owns the flow. Returning
+        normally means approved. Without that seam, drive the core poller;
+        no poller / no approval_id ⇒ fail safe: blocked (the operation must
+        not run on an unresolved approval).
+        """
+        ctx = resolve_context(self._store, span)
+        adapter_sync = getattr(self._adapter, "handle_approval_sync", None)
+        if adapter_sync is not None:
+            # Pass the span-resolved context: ambient ContextVar lookup can
+            # miss in user-spawned threads, and the adapter needs the context
+            # for skip-HITL decisions and framework buffer correlation.
+            adapter_sync(result, context=ctx)
+            return True
+        if self._sync_poller is None or not result.approval_id or ctx is None:
+            self._mark_stopped(result, span)
+            self._adapter.raise_hook_blocked(result)  # NoReturn by contract
+            # Defense in depth: a misbehaving adapter that RETURNS from its
+            # NoReturn callback must not fall through to run the operation.
+            raise GovernanceBlockedError(
+                result.verdict, result.reason or "Blocked (adapter returned)"
+            )
+        approval = self._sync_poller.wait_for_decision(
+            ctx.workflow_id or "", ctx.run_id or "", ctx.activity_id or ""
+        )
+        if approval.allow_shaped:
+            return True
+        self._mark_stopped(result, span)
+        self._adapter.raise_hook_blocked(result)  # NoReturn by contract
+        raise GovernanceBlockedError(
+            result.verdict, result.reason or "Blocked (adapter returned)"
+        )
+
+    def _mark_stopped(self, result: EvaluationResult, span: Any) -> None:
+        ctx = resolve_context(self._store, span)
+        if ctx is not None:
+            self._store.mark_activity_aborted(ctx.workflow_id, ctx.activity_id)
+        if result.verdict is Verdict.HALT:
+            # Expose the halt request; the framework adapter decides how to
+            # stop future work.
+            self._store.request_halt()
+
+    # ── Completed (telemetry stage) ───────────────────────────────────────
+
+    def completed(
+        self,
+        span: Any,
+        *,
+        hook_type: HookType,
+        fields: Mapping[str, Any] | None = None,
+    ) -> None:
+        """Evaluate AFTER the operation ran. Never raises to the caller and
+        never undoes the operation — stop verdicts only mark FUTURE execution
+        blocked (abort/halt flags + adapter callback)."""
+        if not self._runtime.config.instrumentation.completed_telemetry_enabled:
+            return
+        event = build_hook_event(
+            self._store, span, stage=Stage.COMPLETED, hook_type=hook_type, fields=fields
+        )
+        if event is None:
+            return
+        try:
+            result = self._gate.completed(event)
+        except Exception:
+            logger.warning("completed-hook telemetry failed", exc_info=True)
+            return
+        self._after_completed(result, span)
+
+    async def acompleted(
+        self,
+        span: Any,
+        *,
+        hook_type: HookType,
+        fields: Mapping[str, Any] | None = None,
+    ) -> None:
+        """Async :meth:`completed`."""
+        if not self._runtime.config.instrumentation.completed_telemetry_enabled:
+            return
+        event = build_hook_event(
+            self._store, span, stage=Stage.COMPLETED, hook_type=hook_type, fields=fields
+        )
+        if event is None:
+            return
+        try:
+            result = await self._gate.acompleted(event)
+        except Exception:
+            logger.warning("completed-hook telemetry failed", exc_info=True)
+            return
+        self._after_completed(result, span)
+
+    def _adapter_accepts_context(self) -> bool:
+        """True when the adapter's ``on_completed_hook_result`` accepts a
+        ``context`` argument (checked once, by signature — not by catching a
+        TypeError from the call, which would mask real errors)."""
+        import inspect
+
+        callback = getattr(self._adapter, "on_completed_hook_result", None)
+        if callback is None:
+            return False
+        try:
+            params = inspect.signature(callback).parameters
+        except (TypeError, ValueError):
+            return False
+        # Accepts context via an explicit param or **kwargs.
+        return "context" in params or any(
+            p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values()
+        )
+
+    def _after_completed(self, result: EvaluationResult, span: Any) -> None:
+        if result.verdict.should_stop():
+            self._mark_stopped(result, span)  # future execution only
+        # Hand the span-resolved context so adapters can bridge a completed
+        # BLOCK/HALT to native effects on the correct run/activity.
+        ctx = resolve_context(self._store, span)
+        try:
+            if self._completed_accepts_context:
+                self._adapter.on_completed_hook_result(result, context=ctx)
+            else:
+                self._adapter.on_completed_hook_result(result)
+        except Exception:
+            logger.warning("adapter.on_completed_hook_result failed", exc_info=True)

openbox_core/hooks/wrappers.py

@@ -0,0 +1,105 @@
+"""Shared around-operation driver: preflight -> real op -> completed.
+
+Wrappers never interpret verdicts — a blocked preflight raises out of the
+hook runtime/adapter before the real operation is invoked. Completed
+telemetry always fires (success AND failure paths) with duration + error.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from ..contracts.otel_spans import HookType
+from .preflight import HookRuntime
+
+__all__ = ["run_governed_sync", "run_governed_async"]
+
+
+def _completed_fields(
+    base: Mapping[str, Any] | None,
+    extra: Mapping[str, Any] | None,
+    duration_ms: float,
+    error: str | None,
+) -> dict[str, Any]:
+    fields = dict(base or {})
+    fields.update(extra or {})
+    fields.setdefault("duration_ns", int(duration_ms * 1_000_000))
+    if error is not None:
+        fields["error"] = error
+    return fields
+
+
+def run_governed_sync(
+    hook_runtime: HookRuntime,
+    operation: Callable[..., Any],
+    args: tuple,
+    kwargs: dict,
+    *,
+    span: Any,
+    hook_type: HookType,
+    identifier: str = "",
+    started_fields: Mapping[str, Any] | None = None,
+    completed_fields: Callable[[Any], Mapping[str, Any] | None] | None = None,
+) -> Any:
+    """preflight -> operation -> completed (sync)."""
+    hook_runtime.preflight(
+        span, hook_type=hook_type, identifier=identifier, fields=started_fields
+    )
+    start = time.perf_counter()
+    try:
+        result = operation(*args, **kwargs)
+    except Exception as exc:
+        duration_ms = (time.perf_counter() - start) * 1000
+        hook_runtime.completed(
+            span,
+            hook_type=hook_type,
+            fields=_completed_fields(started_fields, None, duration_ms, str(exc)),
+        )
+        raise
+    duration_ms = (time.perf_counter() - start) * 1000
+    extra = completed_fields(result) if completed_fields else None
+    hook_runtime.completed(
+        span,
+        hook_type=hook_type,
+        fields=_completed_fields(started_fields, extra, duration_ms, None),
+    )
+    return result
+
+
+async def run_governed_async(
+    hook_runtime: HookRuntime,
+    operation: Callable[..., Any],
+    args: tuple,
+    kwargs: dict,
+    *,
+    span: Any,
+    hook_type: HookType,
+    identifier: str = "",
+    started_fields: Mapping[str, Any] | None = None,
+    completed_fields: Callable[[Any], Mapping[str, Any] | None] | None = None,
+) -> Any:
+    """preflight -> operation -> completed (async)."""
+    await hook_runtime.apreflight(
+        span, hook_type=hook_type, identifier=identifier, fields=started_fields
+    )
+    start = time.perf_counter()
+    try:
+        result = await operation(*args, **kwargs)
+    except Exception as exc:
+        duration_ms = (time.perf_counter() - start) * 1000
+        await hook_runtime.acompleted(
+            span,
+            hook_type=hook_type,
+            fields=_completed_fields(started_fields, None, duration_ms, str(exc)),
+        )
+        raise
+    duration_ms = (time.perf_counter() - start) * 1000
+    extra = completed_fields(result) if completed_fields else None
+    await hook_runtime.acompleted(
+        span,
+        hook_type=hook_type,
+        fields=_completed_fields(started_fields, extra, duration_ms, None),
+    )
+    return result

openbox_core/identity.py

@@ -0,0 +1,231 @@
+"""AgentIdentity — AIP DID validation and Ed25519 request signing.
+
+Implements the Core signed-request contract. The canonical string (must match
+Core ``agent.go:93``)::
+
+    UPPER(METHOD)\nPATH\nTIMESTAMP\nNONCE\nBODY_SHA256_HEX
+
+Contract invariants:
+
+- The signing TIMESTAMP is ``datetime.now(timezone.utc).isoformat()`` —
+  it KEEPS ``+00:00`` and never uses ``Z``. The event-payload timestamp is a
+  different field with a different format.
+- NONCE is ``secrets.token_urlsafe(24)``.
+- Signature is standard padded base64 of the Ed25519 signature over the
+  canonical string, ASCII-decoded.
+- PATH includes the ``/api/v1`` prefix; no host, no query.
+- Body bytes are produced ONCE by ``serialization.serialize_body`` and sent
+  verbatim via ``content=body_bytes`` — NEVER ``json=``.
+
+SANDBOX SAFETY: ``cryptography`` is imported lazily inside functions. This
+module must never be imported from constrained framework paths; signing
+happens only in client/runtime code.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+import uuid
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any
+
+from .errors import OpenBoxConfigError
+from .sdk_version import (
+    DEFAULT_SDK_ENGINE,
+    DEFAULT_SDK_LANGUAGE,
+    build_sdk_identifier,
+)
+from .serialization import serialize_body
+
+__all__ = [
+    "AGENT_DID_PREFIX",
+    "EMPTY_BODY_SHA256",
+    "HEADER_DID",
+    "HEADER_TIMESTAMP",
+    "HEADER_NONCE",
+    "HEADER_SIGNATURE",
+    "HEADER_BODY_SHA256",
+    "validate_agent_did",
+    "load_ed25519_seed",
+    "AgentIdentity",
+    "build_canonical_string",
+    "build_auth_headers",
+    "prepare_signed_request",
+]
+
+# Agent DID prefix; the suffix must be a parseable UUID (validated via
+# uuid.UUID, matching Core's UUID parser rather than a loose regex).
+AGENT_DID_PREFIX = "did:aip:"
+
+# SHA-256 of empty bytes — body hash for GET / empty-body requests.
+EMPTY_BODY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+
+# AIP signed-request header names (Core agent.go:26-30).
+HEADER_DID = "X-OpenBox-Agent-DID"
+HEADER_TIMESTAMP = "X-OpenBox-Agent-Timestamp"
+HEADER_NONCE = "X-OpenBox-Agent-Nonce"
+HEADER_SIGNATURE = "X-OpenBox-Agent-Signature"
+HEADER_BODY_SHA256 = "X-OpenBox-Body-SHA256"
+
+
+def validate_agent_did(agent_did: str) -> None:
+    """Validate agent DID format (``did:aip:<uuid>``).
+
+    Parses the suffix with uuid.UUID so malformed UUID layouts fail locally at
+    init (matching Core's parser) rather than slipping through to a Core 4xx.
+
+    Raises OpenBoxConfigError on mismatch.
+    """
+    if not isinstance(agent_did, str) or not agent_did.startswith(AGENT_DID_PREFIX):
+        raise OpenBoxConfigError(
+            f"Invalid agent DID format. Expected 'did:aip:<uuid>', "
+            f"got: '{str(agent_did)[:24]}...' (showing first 24 chars)"
+        )
+    suffix = agent_did[len(AGENT_DID_PREFIX):]
+    try:
+        uuid.UUID(suffix)
+    except (ValueError, AttributeError):
+        raise OpenBoxConfigError(
+            f"Invalid agent DID: '{agent_did[:24]}...' — the part after "
+            f"'{AGENT_DID_PREFIX}' is not a valid UUID."
+        ) from None
+
+
+def load_ed25519_seed(agent_private_key: str) -> Any:
+    """Decode a base64 raw 32-byte Ed25519 seed and load a private key object.
+
+    The provisioned key is a raw 32-byte seed (base64), NOT PKCS8. Returns a
+    cryptography Ed25519PrivateKey. Never echoes key bytes in error messages —
+    the seed is non-repudiation material.
+
+    Raises OpenBoxConfigError on any failure (bad base64, wrong length, load error).
+    """
+    # cryptography imported lazily — keeps it off any eager import path.
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    try:
+        seed = base64.b64decode(agent_private_key, validate=True)
+    except Exception:
+        raise OpenBoxConfigError(
+            "Invalid agent private key: not valid base64 (key bytes not shown)."
+        ) from None
+
+    if len(seed) != 32:
+        raise OpenBoxConfigError(
+            f"Invalid agent private key: expected a 32-byte Ed25519 seed, "
+            f"got {len(seed)} bytes (key bytes not shown)."
+        )
+
+    try:
+        return Ed25519PrivateKey.from_private_bytes(seed)
+    except Exception:
+        raise OpenBoxConfigError(
+            "Invalid agent private key: could not load Ed25519 key (key bytes not shown)."
+        ) from None
+
+
+@dataclass
+class AgentIdentity:
+    """A validated agent DID plus its loaded Ed25519 signer.
+
+    Stores the loaded key OBJECT — never raw seed bytes/strings after init.
+    Construct via :meth:`from_private_key` for validation.
+    """
+
+    agent_did: str
+    signer: Any = field(repr=False)  # Ed25519PrivateKey; excluded from repr
+
+    @classmethod
+    def from_private_key(cls, agent_did: str, agent_private_key: str) -> AgentIdentity:
+        """Validate the DID, decode + load the seed, return a ready identity."""
+        validate_agent_did(agent_did)
+        return cls(agent_did=agent_did, signer=load_ed25519_seed(agent_private_key))
+
+    def sign(self, canonical: str) -> str:
+        """Sign a canonical string; return standard padded base64 (ASCII)."""
+        return base64.b64encode(self.signer.sign(canonical.encode("utf-8"))).decode("ascii")
+
+    def __repr__(self) -> str:  # never leak key material
+        return f"AgentIdentity(agent_did={self.agent_did!r}, signer=<loaded>)"
+
+
+def build_canonical_string(
+    method: str, path: str, timestamp: str, nonce: str, body_sha256: str
+) -> str:
+    """The exact canonical string Core verifies (``agent.go:93``)."""
+    return "\n".join([method.upper(), path, timestamp, nonce, body_sha256])
+
+
+def build_auth_headers(
+    api_key: str,
+    sdk_version: str | None = None,
+    *,
+    sdk_engine: str = DEFAULT_SDK_ENGINE,
+    sdk_language: str = DEFAULT_SDK_LANGUAGE,
+) -> dict[str, str]:
+    """Standard bearer auth headers for governance API calls."""
+    sdk_identifier = build_sdk_identifier(
+        engine=sdk_engine,
+        language=sdk_language,
+        version=sdk_version,
+    )
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "User-Agent": f"OpenBox-SDK/{sdk_identifier}",
+        "X-OpenBox-SDK-Version": sdk_identifier,
+    }
+
+
+def prepare_signed_request(
+    method: str,
+    path: str,
+    payload: dict | None,
+    *,
+    api_key: str,
+    identity: AgentIdentity | None,
+    sdk_version: str | None = None,
+    sdk_engine: str = DEFAULT_SDK_ENGINE,
+    sdk_language: str = DEFAULT_SDK_LANGUAGE,
+    _timestamp: str | None = None,
+    _nonce: str | None = None,
+) -> tuple[dict[str, str], bytes]:
+    """Build request headers + exact body bytes — the single source of truth.
+
+    Args:
+        method: HTTP method (case-insensitive; upper-cased into the canonical string).
+        path: URL path only, no host/query — INCLUDES the ``/api/v1`` prefix.
+        payload: JSON-serializable body, or ``None`` for empty-body (GET) requests.
+        api_key: Bearer API key for the base auth headers.
+        identity: Loaded AgentIdentity, or ``None`` for unsigned mode.
+        _timestamp/_nonce: Deterministic injection points for golden-fixture
+            tests ONLY. Production callers must not pass them — a reused nonce
+            is rejected by Core (nonce_replayed).
+
+    Returns:
+        ``(headers, body_bytes)``. Callers MUST send ``content=body_bytes`` —
+        never ``json=`` — so the transmitted bytes match the hashed bytes.
+    """
+    body_bytes = serialize_body(payload)
+    headers = build_auth_headers(
+        api_key,
+        sdk_version,
+        sdk_engine=sdk_engine,
+        sdk_language=sdk_language,
+    )
+
+    if identity is not None:
+        body_sha256 = hashlib.sha256(body_bytes).hexdigest()
+        # Signing timestamp KEEPS +00:00 (never Z) — Core verifies these bytes.
+        timestamp = _timestamp if _timestamp is not None else datetime.now(UTC).isoformat()
+        nonce = _nonce if _nonce is not None else secrets.token_urlsafe(24)
+        canonical = build_canonical_string(method, path, timestamp, nonce, body_sha256)
+        headers[HEADER_DID] = identity.agent_did
+        headers[HEADER_TIMESTAMP] = timestamp
+        headers[HEADER_NONCE] = nonce
+        headers[HEADER_SIGNATURE] = identity.sign(canonical)
+        headers[HEADER_BODY_SHA256] = body_sha256
+
+    return headers, body_bytes

openbox_core/instrumentation/__init__.py

@@ -0,0 +1,3 @@
+"""Generic operation instrumentation (HTTP/DB/file/function/LLM)."""
+
+__all__: list[str] = []