apsimo-hostworker 0.2.0__py3-none-any.whl

apsimo_hostworker/__init__.py

@@ -0,0 +1,134 @@
+"""Stdlib-only core for governed Colony host workers.
+
+Phase A of the host-worker extraction: the wire contract, the governed tool
+catalog, ``HermesToolActionIntentV1`` validation, and the approval-gate
+invariant core.  Phase B: the loopback execution client, the dispatch
+admission, the :class:`~apsimo_hostworker.store.ActionStore` protocol with
+its documented transactional invariants, the reference SQLite store, the
+one-mutation worker, and the executable store conformance suite
+(:mod:`apsimo_hostworker.conformance`).  This distribution must never
+import FastAPI or ``apsimo`` — see the design rule in
+:mod:`apsimo_hostworker.contract`.
+"""
+
+from __future__ import annotations
+
+from .admission import (
+    DispatchAdmission,
+    DispatchAdmissionError,
+    FileDispatchAdmission,
+    sqlite_database_identity,
+)
+from .catalog import (
+    ACTION_TOOL_NAMES,
+    GRANT_AUTHORIZABLE_TOOL_NAMES,
+    NON_GRANTABLE_TOOL_NAMES,
+    TOOL_CATALOG,
+    ToolCatalogError,
+    ToolSpec,
+    validate_tool_args,
+)
+from .client import (
+    ClientCredential,
+    GovernedActionClient,
+    GovernedActionClientError,
+    WORKER_PRINCIPAL,
+    build_no_redirect_opener,
+)
+from .contract import (
+    GovernedContractError,
+    canonical_json_ascii,
+    canonical_json_utf8,
+    sha256_json_ascii,
+    sha256_json_utf8,
+)
+from .gate import (
+    BOUNDED_GRANT_SHAPE,
+    DEFAULT_REGISTRY,
+    GRANT_BINDING_METHOD,
+    GRANT_UNLIMITED_SENTINEL,
+    GateAuthorization,
+    MESSAGE_DELIVERY_SHAPE,
+    OwnerGateError,
+    ProvenanceShape,
+    ProvenanceShapeError,
+    ProvenanceShapeRegistry,
+    assert_dispatchable,
+    default_registry,
+    validate_owner_gate,
+)
+from .intent import HermesActionIntentError, HermesToolActionIntentV1
+from .sqlite_store import SqliteActionStore
+from .store import (
+    ActionIdempotencyConflict,
+    ActionLeaseConflict,
+    ActionNotFound,
+    ActionStore,
+    ActionStoreError,
+    ActionTransitionError,
+)
+from .worker import (
+    GovernedActionWorker,
+    GovernedActionWorkerError,
+    build_execution_request,
+    validate_execution_result,
+)
+
+try:  # single source of truth: the installed distribution metadata
+    from importlib.metadata import PackageNotFoundError, version as _dist_version
+    try:
+        __version__ = _dist_version("apsimo-hostworker")
+    except PackageNotFoundError:  # running from a source tree, not installed
+        __version__ = "0.2.0"
+except ImportError:  # pragma: no cover
+    __version__ = "0.2.0"
+
+__all__ = (
+    "ACTION_TOOL_NAMES",
+    "ActionIdempotencyConflict",
+    "ActionLeaseConflict",
+    "ActionNotFound",
+    "ActionStore",
+    "ActionStoreError",
+    "ActionTransitionError",
+    "BOUNDED_GRANT_SHAPE",
+    "ClientCredential",
+    "DEFAULT_REGISTRY",
+    "DispatchAdmission",
+    "DispatchAdmissionError",
+    "FileDispatchAdmission",
+    "GRANT_AUTHORIZABLE_TOOL_NAMES",
+    "GRANT_BINDING_METHOD",
+    "GRANT_UNLIMITED_SENTINEL",
+    "GateAuthorization",
+    "GovernedActionClient",
+    "GovernedActionClientError",
+    "GovernedActionWorker",
+    "GovernedActionWorkerError",
+    "GovernedContractError",
+    "HermesActionIntentError",
+    "HermesToolActionIntentV1",
+    "MESSAGE_DELIVERY_SHAPE",
+    "NON_GRANTABLE_TOOL_NAMES",
+    "OwnerGateError",
+    "ProvenanceShape",
+    "ProvenanceShapeError",
+    "ProvenanceShapeRegistry",
+    "SqliteActionStore",
+    "TOOL_CATALOG",
+    "ToolCatalogError",
+    "ToolSpec",
+    "WORKER_PRINCIPAL",
+    "assert_dispatchable",
+    "build_execution_request",
+    "build_no_redirect_opener",
+    "canonical_json_ascii",
+    "canonical_json_utf8",
+    "default_registry",
+    "sha256_json_ascii",
+    "sha256_json_utf8",
+    "sqlite_database_identity",
+    "validate_execution_result",
+    "validate_owner_gate",
+    "validate_tool_args",
+)

apsimo_hostworker/_private_io.py

@@ -0,0 +1,267 @@
+"""Owner-only file and loopback-origin primitives for host workers.
+
+Everything here is stdlib-only, side-effect-free beyond reading the named
+file, and deliberately paranoid: these primitives sit under the credential
+loader (:mod:`apsimo_hostworker.client`) and the dispatch-admission check
+(:mod:`apsimo_hostworker.admission`), where a symlink race, a
+group-readable secret, or an over-large document must fail closed rather
+than degrade.
+
+The bounded JSON reader is also the only JSON decoder the client uses for
+network responses: it refuses duplicate object keys, non-finite numbers,
+oversized integers, control characters, and unbounded nesting before any
+value reaches a validator.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import json
+import math
+import os
+import stat
+import urllib.parse
+from pathlib import Path
+from typing import Any, Mapping
+
+PRIVATE_DOCUMENT_MAX_BYTES = 16 * 1024
+
+
+class PrivateIOError(RuntimeError):
+    """An owner-only file or origin failed its safety contract."""
+
+
+def strict_json_bytes(raw: bytes, *, maximum: int, error=PrivateIOError) -> Any:
+    """Decode one bounded finite JSON value without duplicate object keys."""
+
+    if not isinstance(raw, bytes) or len(raw) > maximum:
+        raise error("JSON document exceeds its safety bound")
+
+    def pairs(values):
+        result = {}
+        for key, value in values:
+            if key in result:
+                raise error("JSON object keys must be unique")
+            result[key] = value
+        return result
+
+    def constant(_value):
+        raise error("JSON numbers must be finite")
+
+    def integer(value):
+        if len(value.lstrip("-")) > 19:
+            raise error("JSON integer exceeds its safety bound")
+        parsed = int(value)
+        if abs(parsed) > (1 << 63) - 1:
+            raise error("JSON integer exceeds its safety bound")
+        return parsed
+
+    def floating(value):
+        parsed = float(value)
+        if not math.isfinite(parsed):
+            raise error("JSON numbers must be finite")
+        return parsed
+
+    try:
+        value = json.loads(
+            raw.decode("utf-8", errors="strict"),
+            object_pairs_hook=pairs,
+            parse_constant=constant,
+            parse_int=integer,
+            parse_float=floating,
+        )
+    except error:
+        raise
+    except (UnicodeError, ValueError, TypeError, OverflowError, RecursionError) as exc:
+        raise error("JSON document is malformed") from exc
+
+    stack = [(value, 0)]
+    count = 0
+    while stack:
+        item, depth = stack.pop()
+        count += 1
+        if count > 1024 or depth > 16:
+            raise error("JSON document is too complex")
+        if isinstance(item, str):
+            if len(item) > 8192 or any(
+                ord(character) < 0x20 or ord(character) == 0x7F
+                for character in item
+            ):
+                raise error("JSON text is unsafe")
+            try:
+                item.encode("utf-8")
+            except UnicodeError as exc:
+                raise error("JSON text is not UTF-8") from exc
+        elif isinstance(item, Mapping):
+            stack.extend((key, depth + 1) for key in item)
+            stack.extend((child, depth + 1) for child in item.values())
+        elif isinstance(item, list):
+            stack.extend((child, depth + 1) for child in item)
+        elif item is not None and not isinstance(item, (bool, int, float)):
+            raise error("JSON document contains an unsafe value")
+    return value
+
+
+def safe_ancestry(
+    path: Path, *, label: str, error=PrivateIOError
+) -> tuple[tuple[int, int, int], ...]:
+    """Attest every existing ancestor without resolving through a symlink."""
+
+    chain = []
+    cursor = path
+    while True:
+        chain.append(cursor)
+        if cursor.parent == cursor:
+            break
+        cursor = cursor.parent
+    identities = []
+    try:
+        for candidate in reversed(chain):
+            info = candidate.lstat()
+            if stat.S_ISLNK(info.st_mode) or not stat.S_ISDIR(info.st_mode):
+                raise error("%s path ancestry is unsafe" % label)
+            identities.append((info.st_dev, info.st_ino, info.st_mode))
+    except error:
+        raise
+    except OSError as exc:
+        raise error("%s path ancestry is unavailable" % label) from exc
+    return tuple(identities)
+
+
+def read_private_json(
+    path: str, *, label: str, error=PrivateIOError
+) -> tuple[Path, bytes, Any]:
+    """Read an owner-only mode-0600 regular file without racing a symlink.
+
+    The file must be a regular file owned by the calling user with mode
+    exactly ``0600``, at most :data:`PRIVATE_DOCUMENT_MAX_BYTES` long, whose
+    identity (device, inode, size, mtime) and whole directory ancestry are
+    unchanged across the read.  Anything else fails closed.
+    """
+
+    configured = str(path or "").strip()
+    if not configured:
+        raise error("%s file is not configured" % label)
+    target = Path(os.path.abspath(os.path.expanduser(configured)))
+    if not hasattr(os, "O_NOFOLLOW") or not hasattr(os, "O_CLOEXEC"):
+        raise error("private file loading is unsupported")
+    descriptor = None
+    try:
+        ancestry_before = safe_ancestry(target.parent, label=label, error=error)
+        initial = target.lstat()
+        if stat.S_ISLNK(initial.st_mode):
+            raise error("%s must not be a symlink" % label)
+        descriptor = os.open(target, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
+        before = os.fstat(descriptor)
+        if (
+            not stat.S_ISREG(before.st_mode)
+            or stat.S_IMODE(before.st_mode) != 0o600
+            or (hasattr(os, "geteuid") and before.st_uid != os.geteuid())
+            or before.st_size < 0
+            or before.st_size > PRIVATE_DOCUMENT_MAX_BYTES
+            or (initial.st_dev, initial.st_ino) != (before.st_dev, before.st_ino)
+        ):
+            raise error("%s must be an owned mode-0600 regular file" % label)
+        collected = bytearray()
+        while len(collected) <= PRIVATE_DOCUMENT_MAX_BYTES:
+            chunk = os.read(
+                descriptor,
+                min(4096, PRIVATE_DOCUMENT_MAX_BYTES + 1 - len(collected)),
+            )
+            if not chunk:
+                break
+            collected.extend(chunk)
+        after = os.fstat(descriptor)
+        current = target.lstat()
+        ancestry_after = safe_ancestry(target.parent, label=label, error=error)
+        stable = (
+            before.st_dev,
+            before.st_ino,
+            before.st_uid,
+            before.st_mode,
+            before.st_size,
+            before.st_mtime_ns,
+        ) == (
+            after.st_dev,
+            after.st_ino,
+            after.st_uid,
+            after.st_mode,
+            after.st_size,
+            after.st_mtime_ns,
+        )
+        if (
+            len(collected) > PRIVATE_DOCUMENT_MAX_BYTES
+            or len(collected) != before.st_size
+            or not stable
+            or ancestry_before != ancestry_after
+            or (current.st_dev, current.st_ino) != (before.st_dev, before.st_ino)
+        ):
+            raise error("%s changed while being read" % label)
+        raw = bytes(collected)
+    except error:
+        raise
+    except OSError as exc:
+        raise error("%s file is unavailable" % label) from exc
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+    return (
+        target,
+        raw,
+        strict_json_bytes(raw, maximum=PRIVATE_DOCUMENT_MAX_BYTES, error=error),
+    )
+
+
+def loopback_origin(value: str, *, error=PrivateIOError) -> str:
+    """Return ``value`` iff it is one canonical loopback HTTP(S) origin.
+
+    Exactly ``scheme://host[:port]`` with a loopback host: no path, query,
+    fragment, userinfo, whitespace, or non-printable bytes.  Everything a
+    governed-action client or admission may talk to must pass this, so a
+    configuration mistake can never point owner-authorized mutations at a
+    remote host.
+    """
+
+    raw = str(value or "")
+    if (
+        not raw
+        or raw != raw.strip()
+        or any(ord(character) < 0x21 or ord(character) > 0x7E for character in raw)
+    ):
+        raise error("service origin is invalid")
+    try:
+        parsed = urllib.parse.urlsplit(raw)
+        port = parsed.port
+    except ValueError as exc:
+        raise error("service origin is invalid") from exc
+    if (
+        parsed.scheme not in ("http", "https")
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.path
+        or parsed.query
+        or parsed.fragment
+        or not parsed.netloc
+    ):
+        raise error("service origin must be one loopback origin")
+    hostname = parsed.hostname.lower()
+    try:
+        loopback = ipaddress.ip_address(hostname).is_loopback
+    except ValueError:
+        loopback = hostname == "localhost"
+    if not loopback or (port is not None and not 1 <= port <= 65535):
+        raise error("service origin must be loopback")
+    if urllib.parse.urlunsplit((parsed.scheme, parsed.netloc, "", "", "")) != raw:
+        raise error("service origin must be canonical")
+    return raw
+
+
+__all__ = (
+    "PRIVATE_DOCUMENT_MAX_BYTES",
+    "PrivateIOError",
+    "loopback_origin",
+    "read_private_json",
+    "safe_ancestry",
+    "strict_json_bytes",
+)

apsimo_hostworker/admission.py

@@ -0,0 +1,297 @@
+"""Dispatch admission: an operator kill-switch checked before every mutation.
+
+THE PROTOCOL
+============
+A :class:`DispatchAdmission` answers exactly one question at exactly one
+moment: "may this process attempt a mutation RIGHT NOW?"  The worker calls
+``assert_live()`` immediately before every owner-authorized dispatch (the
+transition that consumes the approval gate and precedes the one PUT).
+``assert_live()`` MUST:
+
+* re-read its authority from durable or ambient state at call time — never
+  cache a yes;
+* raise :class:`DispatchAdmissionError` to refuse, in which case the worker
+  defers the leased action WITHOUT consuming the gate or counting an
+  attempt; and
+* return ``None`` only when a mutation is admitted for immediate dispatch.
+
+Admission is deliberately NOT authorization.  The owner approval gate binds
+one action; admission binds the deployment (this binary, this store, this
+endpoint, these tools, this time window).  Deleting or expiring the
+admission halts all mutations without touching any durable action state.
+
+THE REFERENCE IMPLEMENTATION
+============================
+:class:`FileDispatchAdmission` reads an owner-only mode-0600 canonical-JSON
+file on every check.  The private deployment this generalizes pinned its
+SQLite store by device/inode and its release by commit SHA inside the
+admission document; those are host-deployment details, so here they become
+one optional ``identity_probe`` hook: a host callable returning any
+JSON-serializable identity document (a device/inode pair, a release SHA, a
+container digest, ...).  The probe result is captured at construction,
+required to match the admission file's ``binding_identity`` field, and
+re-probed on EVERY ``assert_live()`` — so the resource the admission was
+issued for cannot be swapped underneath a live worker.  A host that
+configures no probe gets a file whose ``binding_identity`` must be ``null``;
+the probe is optional, the field is not.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import stat
+from pathlib import Path
+from typing import Any, Callable, Iterable, Mapping, Protocol, runtime_checkable
+
+from ._private_io import loopback_origin, read_private_json, safe_ancestry
+from .catalog import ACTION_TOOL_NAMES
+from .contract import GATE_CLOCK_SKEW_SECONDS, canonical_json_utf8
+
+
+class DispatchAdmissionError(RuntimeError):
+    """The deployment is not admitted to attempt a mutation right now."""
+
+
+@runtime_checkable
+class DispatchAdmission(Protocol):
+    """See the module docstring for the full ``assert_live`` contract."""
+
+    def assert_live(self) -> None:
+        """Raise :class:`DispatchAdmissionError` unless a mutation may be
+        attempted immediately; never cache a previous answer."""
+        ...
+
+
+ADMISSION_SCHEMA = "ColonyHostWorkerAdmissionV1"
+ADMISSION_FIELDS = frozenset(
+    {
+        "schema",
+        "version",
+        "authorized",
+        "authorization_id",
+        "colony_origin",
+        "enabled_tools",
+        "binding_identity",
+        "created_at",
+        "expires_at",
+    }
+)
+ADMISSION_MAX_LIFETIME_SECONDS = 30 * 24 * 60 * 60
+
+AUTHORIZATION_ID_RE = re.compile(r"^[0-9a-f]{32}$")
+
+
+def sqlite_database_identity(path: str | Path) -> dict[str, Any]:
+    """Reference ``identity_probe`` for a host whose store is local SQLite.
+
+    Returns the database file's device/inode identity after asserting that
+    the file, its mutable WAL/journal siblings, and its whole directory
+    ancestry are private to the calling user and free of symlinks.  This is
+    the generalized form of the private deployment's store pinning; hosts
+    with a different store supply their own probe (or none).
+    """
+
+    target = Path(os.path.abspath(os.path.expanduser(str(path))))
+    safe_ancestry(target.parent, label="action store", error=DispatchAdmissionError)
+    try:
+        info = target.lstat()
+    except OSError as error:
+        raise DispatchAdmissionError("action store file is unavailable") from error
+    if (
+        stat.S_ISLNK(info.st_mode)
+        or not stat.S_ISREG(info.st_mode)
+        or stat.S_IMODE(info.st_mode) & 0o077
+        or (hasattr(os, "geteuid") and info.st_uid != os.geteuid())
+    ):
+        raise DispatchAdmissionError("action store file is unsafe")
+    for suffix in ("-wal", "-shm", "-journal"):
+        sibling = Path(str(target) + suffix)
+        if not os.path.lexists(sibling):
+            continue
+        try:
+            sibling_info = sibling.lstat()
+        except OSError as error:
+            raise DispatchAdmissionError(
+                "action store journal is unavailable"
+            ) from error
+        if (
+            stat.S_ISLNK(sibling_info.st_mode)
+            or not stat.S_ISREG(sibling_info.st_mode)
+            or stat.S_IMODE(sibling_info.st_mode) & 0o077
+            or (
+                hasattr(os, "geteuid")
+                and sibling_info.st_uid != os.geteuid()
+            )
+        ):
+            raise DispatchAdmissionError("action store journal is unsafe")
+    return {"path": str(target), "device": info.st_dev, "inode": info.st_ino}
+
+
+class FileDispatchAdmission:
+    """File-based reference :class:`DispatchAdmission`.
+
+    The admission file must be the exact canonical UTF-8 JSON encoding of an
+    :data:`ADMISSION_SCHEMA` document plus one trailing newline, mode 0600,
+    owned by the calling user.  Every field the file carries is pinned
+    against this process's configuration; a mismatch anywhere fails closed.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        *,
+        colony_origin: str,
+        enabled_tools: Iterable[str],
+        clock: Callable[[], float],
+        identity_probe: Callable[[], Any] | None = None,
+    ) -> None:
+        configured = str(path or "")
+        if not configured or not os.path.isabs(configured):
+            raise DispatchAdmissionError("admission path must be absolute")
+        try:
+            tools = frozenset(enabled_tools)
+        except TypeError as error:
+            raise DispatchAdmissionError("admitted tools are invalid") from error
+        if (
+            not tools
+            or any(not isinstance(tool, str) for tool in tools)
+            or tools - ACTION_TOOL_NAMES
+        ):
+            raise DispatchAdmissionError("admitted tools are invalid")
+        if not callable(clock):
+            raise DispatchAdmissionError("admission clock is invalid")
+        if identity_probe is not None and not callable(identity_probe):
+            raise DispatchAdmissionError("admission identity probe is invalid")
+        self.path = configured
+        self.colony_origin = loopback_origin(
+            colony_origin, error=DispatchAdmissionError
+        )
+        self.enabled_tools = tools
+        self.clock = clock
+        self.identity_probe = identity_probe
+        # Capture the identity ONCE at construction; assert_live() then
+        # requires probe-now == probe-at-construction == file value, so the
+        # bound resource cannot be swapped underneath a live worker.
+        self.pinned_identity = self._probe_identity()
+
+    def _probe_identity(self) -> str | None:
+        if self.identity_probe is None:
+            return None
+        try:
+            observed = self.identity_probe()
+        except DispatchAdmissionError:
+            raise
+        except Exception as error:
+            raise DispatchAdmissionError("admission identity probe failed") from error
+        try:
+            return canonical_json_utf8(observed)
+        except Exception as error:
+            raise DispatchAdmissionError(
+                "admission identity is not canonical JSON"
+            ) from error
+
+    def fence(self) -> dict[str, Any]:
+        """Secret-free deployment identity for observability."""
+
+        return {
+            "schema": "ColonyHostWorkerAdmissionFenceV1",
+            "admission_file": self.path,
+            "colony_origin": self.colony_origin,
+            "enabled_tools": sorted(self.enabled_tools),
+            "binding_identity": self.pinned_identity,
+        }
+
+    def assert_live(self) -> None:
+        _target, raw, document = read_private_json(
+            self.path,
+            label="host worker admission",
+            error=DispatchAdmissionError,
+        )
+        if not isinstance(document, Mapping) or set(document) != ADMISSION_FIELDS:
+            raise DispatchAdmissionError("admission fields are invalid")
+        try:
+            canonical = (canonical_json_utf8(dict(document)) + "\n").encode("utf-8")
+        except (
+            TypeError,
+            ValueError,
+            UnicodeError,
+            OverflowError,
+            RecursionError,
+        ) as error:
+            raise DispatchAdmissionError("admission is not canonical") from error
+        if raw != canonical:
+            raise DispatchAdmissionError("admission must be canonical JSON")
+        version = document.get("version")
+        authorized = document.get("authorized")
+        created_at = document.get("created_at")
+        expires_at = document.get("expires_at")
+        admitted_tools = document.get("enabled_tools")
+        binding_identity = document.get("binding_identity")
+        if (
+            document.get("schema") != ADMISSION_SCHEMA
+            or isinstance(version, bool)
+            or version != 1
+            or authorized is not True
+            or not isinstance(document.get("authorization_id"), str)
+            or not AUTHORIZATION_ID_RE.fullmatch(document["authorization_id"])
+            or document.get("colony_origin") != self.colony_origin
+            or not isinstance(admitted_tools, list)
+            or admitted_tools != sorted(self.enabled_tools)
+            or len(admitted_tools) != len(self.enabled_tools)
+            or isinstance(created_at, bool)
+            or not isinstance(created_at, (int, float))
+            or isinstance(expires_at, bool)
+            or not isinstance(expires_at, (int, float))
+        ):
+            raise DispatchAdmissionError("admission does not bind this process")
+        if self.identity_probe is None:
+            if binding_identity is not None:
+                raise DispatchAdmissionError(
+                    "admission does not bind this process"
+                )
+        else:
+            try:
+                observed_file = canonical_json_utf8(binding_identity)
+            except Exception as error:
+                raise DispatchAdmissionError(
+                    "admission does not bind this process"
+                ) from error
+            observed_now = self._probe_identity()
+            if (
+                binding_identity is None
+                or observed_file != self.pinned_identity
+                or observed_now != self.pinned_identity
+            ):
+                raise DispatchAdmissionError("admission binding identity changed")
+        created = float(created_at)
+        expires = float(expires_at)
+        try:
+            now = float(self.clock())
+        except (TypeError, ValueError, OverflowError) as error:
+            raise DispatchAdmissionError("admission clock failed") from error
+        if (
+            not math.isfinite(now)
+            or not math.isfinite(created)
+            or not math.isfinite(expires)
+            or now <= 0
+            or created <= 0
+            or created > now + GATE_CLOCK_SKEW_SECONDS
+            or expires <= created
+            or expires - created > ADMISSION_MAX_LIFETIME_SECONDS
+            or expires <= now
+        ):
+            raise DispatchAdmissionError("admission is not live")
+
+
+__all__ = (
+    "ADMISSION_FIELDS",
+    "ADMISSION_MAX_LIFETIME_SECONDS",
+    "ADMISSION_SCHEMA",
+    "AUTHORIZATION_ID_RE",
+    "DispatchAdmission",
+    "DispatchAdmissionError",
+    "FileDispatchAdmission",
+    "sqlite_database_identity",
+)