afferent 0.1.0__tar.gz

afferent-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,66 @@
+name: Publish to PyPI
+
+# Publishes afferent automatically on every push to main — but only when the
+# version in afferent/__init__.py is one that isn't already on PyPI. So:
+#   - push without bumping __version__  → build/publish steps skip (green no-op)
+#   - push that bumps __version__        → build, test, and publish to PyPI
+#
+# Uses PyPI Trusted Publishing (OIDC) — NO API token stored anywhere.
+# ONE-TIME setup on PyPI (https://pypi.org/manage/account/publishing/):
+#   "Add a pending publisher"
+#     PyPI Project Name:  afferent
+#     Owner:              andrasfe
+#     Repository name:    spinalcord        # the GitHub repo (unchanged)
+#     Workflow name:      publish.yml
+#     Environment:        (leave blank)
+# That's the whole setup. (If you'd rather use a token instead of trusted
+# publishing, add a repo secret PYPI_API_TOKEN and give the publish step
+# `with: { password: ${{ secrets.PYPI_API_TOKEN }} }`.)
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:        # allow manual runs from the Actions tab
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write       # required for Trusted Publishing (OIDC)
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Read package version
+        id: ver
+        run: |
+          V=$(grep -oE '__version__ = "[^"]+"' afferent/__init__.py | cut -d'"' -f2)
+          echo "version=$V" >> "$GITHUB_OUTPUT"
+          echo "afferent version: $V"
+
+      - name: Is this version already on PyPI?
+        id: gate
+        run: |
+          if curl -sf "https://pypi.org/pypi/afferent/${{ steps.ver.outputs.version }}/json" > /dev/null; then
+            echo "publish=false" >> "$GITHUB_OUTPUT"
+            echo "::notice::afferent ${{ steps.ver.outputs.version }} already on PyPI — nothing to publish."
+          else
+            echo "publish=true" >> "$GITHUB_OUTPUT"
+            echo "::notice::afferent ${{ steps.ver.outputs.version }} is new — building and publishing."
+          fi
+
+      - name: Build + test
+        if: steps.gate.outputs.publish == 'true'
+        run: |
+          python -m pip install --upgrade build twine
+          python -m unittest discover -s tests -p 'test_*.py' -t .
+          python -m build
+          python -m twine check dist/*
+
+      - name: Publish to PyPI
+        if: steps.gate.outputs.publish == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1

afferent-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# os / editor
+.DS_Store
+*.swp
+.idea/
+.vscode/

afferent-0.1.0/CLAUDE.md

@@ -0,0 +1,106 @@
+# CLAUDE.md
+
+Guidance for AI agents (and humans) working in this repository.
+**This file is yours to edit** — keep it current as the code changes. If you
+add a backend, change the protocol, or alter the release flow, update the
+relevant section here in the same change.
+
+## What this is
+
+`afferent` is a **backend-agnostic sensorimotor protocol**: the typed,
+safety-gated seam between a cognitive layer ("brain", the planner) and an
+embodiment layer ("body", the backend). Afferent signals go up (eyes:
+`observe` / `locate` / `verify` / `read_text`); efferent signals go down
+(hands: `click` / `type_text` / `key` / `scroll`).
+
+It is a standalone library — no ties to any particular body or planner. The
+package is **stdlib-only** (zero runtime dependencies). It is published to
+PyPI as `afferent`.
+
+## Design rules (load-bearing — don't break these)
+
+1. **Core stays dependency-free.** `afferent/types.py`, `safety.py`,
+   `embodiment.py`, `backends/base.py`, `backends/fake.py`, and the package
+   `__init__` must import with **stdlib only**. A real-body backend may need
+   third-party packages (httpx, a CV stack, pyautogui, …) — put those behind
+   an optional extra and import them lazily/inside the backend module, never
+   at package import time.
+2. **Backends answer "how", the gate answers "should".** A `Backend`
+   implements raw primitives (`observe`, `do_click_at`, …) and never gates
+   itself for policy reasons. `Embodiment` applies the `SafetyGate` and the
+   post-action observation. Keep that split.
+3. **Eyes are never gated.** Observation has no blast radius; only efferent
+   (`do_*`) actions pass through the gate.
+4. **`read_only=True` is the default.** Hands refuse until a consumer opts in.
+   Don't change the default.
+5. **Coordinates are `pct`** — fractions in `[0,1]`, top-left origin,
+   resolution-independent. All backends and results use this.
+6. **`Observation.render_text()` must stay deterministic** — same observation
+   → byte-identical string. Consumers embed it and use it as a world-model
+   key. If you change the format, keep it stable and update the test.
+7. **`do_*` methods don't raise for ordinary failures** — return
+   `ActionResult(ok=False, reason=...)`. They may raise `BackendUnavailable`
+   when the transport/device is unreachable.
+
+## Layout
+
+```
+afferent/
+  __init__.py          # public surface + __version__ (single source of truth)
+  types.py             # Frame, VisualElement, Observation, LocateResult,
+                       #   VerifyResult, ActionResult  (the protocol)
+  safety.py            # SafetyGate (read_only, confirm, allowed_apps, rate, panic)
+  embodiment.py        # Embodiment facade — wraps a Backend with the gate
+  backends/
+    base.py            # Backend ABC + BackendUnavailable
+    fake.py            # FakeBackend — scripted, hardware-free reference impl
+tests/                 # unittest, fully offline (no deps, no network)
+scripts/release.sh     # build + publish to PyPI / TestPyPI
+.github/workflows/publish.yml   # Trusted-Publishing release workflow
+pyproject.toml         # hatchling; version is dynamic from __init__.py
+```
+
+## Adding a backend
+
+Subclass `Backend`. Required: `capabilities()`, `observe()`, `do_click_at`,
+`do_type_text`, `do_key`. Optional (sensible defaults provided): `health`,
+`frontmost_app`, `screenshot`, `locate`, `verify`, `read_text`, `do_move_to`,
+`do_scroll`, `close`. `FakeBackend` is the worked example. If the backend
+needs third-party deps, add an extra in `pyproject.toml`
+(`[project.optional-dependencies]`) and import them inside the backend module
+so the core import stays clean. Add it to `backends/__init__.py` only if it's
+dependency-free; otherwise document the import path.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -p 'test_*.py' -t .   # offline, no deps
+# or, with dev extras: pytest
+```
+
+Every test must run offline with zero third-party deps. Drive new behavior
+through `FakeBackend`. When you add a public method or a protocol field, add a
+test for it.
+
+## Releasing
+
+Version is single-sourced from `__version__` in `afferent/__init__.py`
+(hatchling reads it; `pyproject.toml` declares `dynamic = ["version"]`).
+
+- **CI (primary):** bump `__version__`, commit, push to `main`.
+  `.github/workflows/publish.yml` runs on every push to main, but only
+  builds+publishes when the version isn't already on PyPI (it queries the PyPI
+  JSON API and skips otherwise). Publishes via Trusted Publishing — no tokens.
+  One-time PyPI "pending publisher" config is documented in the workflow
+  header. **So: a version bump is the release trigger; ordinary pushes are
+  no-ops.**
+- **Local / TestPyPI:** `scripts/release.sh --test` then `scripts/release.sh`.
+  `--tag` pushes a `vX.Y.Z` git tag after a real upload.
+
+## Conventions
+
+- Keep public surface in `afferent/__init__.py:__all__` current.
+- Docstrings explain *why*; code says *what*. No emojis in code.
+- `from __future__ import annotations` in every module (supports Python 3.9).
+- Target Python ≥ 3.9; avoid 3.10+ runtime syntax (no `match`, no runtime
+  `X | Y` in `isinstance`, etc.).

afferent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andras Ferenczi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

afferent-0.1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: afferent
+Version: 0.1.0
+Summary: A backend-agnostic sensorimotor protocol — eyes and hands for cognitive agents driving a computer.
+Project-URL: Homepage, https://github.com/andrasfe/spinalcord
+Project-URL: Repository, https://github.com/andrasfe/spinalcord
+Project-URL: Issues, https://github.com/andrasfe/spinalcord/issues
+Author-email: Andras Ferenczi <andrasf94@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agent,automation,computer-use,embodiment,gui-automation,llm,sensorimotor
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# afferent
+
+**A backend-agnostic sensorimotor protocol — eyes and hands for cognitive agents driving a computer.**
+
+A cognitive layer (a *brain*) plans; an embodiment layer (a *body*) acts.
+`afferent` is the conduit between them. It carries **afferent** signals up
+(eyes — `observe` / `locate` / `verify` / `read_text`) and **efferent**
+signals down (hands — `click` / `type_text` / `key` / `scroll`), as typed,
+safety-gated calls over a **pluggable backend**.
+
+```
+   ┌─────────┐   afferent (eyes) ↑    ┌────────────┐   actions   ┌──────────┐
+   │  brain  │ ◀───────────────────── │  afferent  │ ──────────▶ │   body   │
+   │ (plans) │ ──────────────────────▶│ (protocol) │ ◀────────── │ (backend)│
+   └─────────┘   efferent (hands) ↓    └────────────┘  observations└──────────┘
+```
+
+The package is **dependency-free** (stdlib only). It ships one working
+backend — `FakeBackend` (scripted, hardware-free) — and a `Backend` ABC you
+subclass to drive a real body: browser automation (Playwright/Selenium), OS
+automation (pyautogui / accessibility APIs), a VM driver, a remote HID bridge,
+or a test harness. The protocol doesn't care which.
+
+## Why it exists
+
+Most computer-use agents fuse perception, planning, and action into one
+monolith. `afferent` deliberately splits the *body* from the *mind* with a
+narrow, typed seam, so:
+
+- the planner stays free to be anything (an LLM loop, a cognitive
+  architecture, a script);
+- the body stays free to be anything (a real desktop, a browser, a VM, a
+  fake);
+- and the whole loop is **unit-testable offline** via the scripted fake
+  backend — no hardware, no network, no API keys.
+
+## Install
+
+```bash
+pip install afferent
+```
+
+That's it — no dependencies. (Dev tooling: `pip install afferent[dev]`.)
+
+## Quickstart — offline, scripted body (works immediately)
+
+```python
+from afferent import Embodiment
+from afferent.types import Observation, VisualElement
+
+screen0 = Observation(
+    ts=0.0, frontmost_app="Firefox",
+    elements=[VisualElement("Run", (0.80, 0.20, 0.10, 0.04), kind="button")],
+)
+screen1 = Observation(ts=1.0, frontmost_app="Firefox", ocr_text="running…")
+
+em = Embodiment.fake(script=[screen0, screen1])     # read_only=False for the demo
+
+print(em.observe().render_text())                   # afferent: see the screen
+res = em.click("Run")                               # efferent: locate + click
+print(res.ok, res.steps, res.state_after.ocr_text)  # grounded outcome
+```
+
+## The protocol
+
+All coordinates are `pct` — fractions in `[0, 1]`, top-left origin,
+resolution-independent (so they're stable world-model keys across machines).
+
+Typed results (`afferent.types`): `Frame`, `VisualElement`, `Observation`,
+`LocateResult`, `VerifyResult`, `ActionResult`.
+
+`Observation.render_text()` is a **stable, compact, embeddable** one-screen
+string — feed it to an embedding model and use it as a key in a learned world
+model. Determinism is guaranteed (same observation → byte-identical string).
+
+`ActionResult` carries **grounding** for predictive-coding / world-model
+consumers: `steps` (e.g. visual-servo iterations), `duration_ms`,
+`final_cursor_pct`, `frame_before` / `frame_after`, and a `state_after`
+observation bracketing the action.
+
+## Safety
+
+`SafetyGate` sits in front of every efferent action (eyes are never gated):
+
+- `read_only=True` is the **default** — hands refuse until you opt in.
+- `confirm(desc) -> bool` — a per-action veto your planner drives.
+- `allowed_apps` — refuse when the frontmost app isn't allowed.
+- `max_actions_per_min` — rate limit against runaway loops.
+- `panic()` — latch into a permanent refusing state.
+
+This is *additive* to whatever gates a backend enforces internally. Both must
+pass.
+
+## Writing a backend
+
+Subclass `afferent.Backend`, implement the eyes (`observe`, optionally
+`locate` / `verify` / `read_text`) and the raw hands (`do_click_at`,
+`do_type_text`, `do_key`, optionally `do_move_to` / `do_scroll`), and declare
+`capabilities()`. `Embodiment` applies the `SafetyGate` and the post-action
+observation for you — a backend only answers "how do I see / move", never
+"should I".
+
+```python
+from afferent import Backend, Embodiment
+from afferent.types import Observation, ActionResult
+
+class MyBackend(Backend):
+    name = "mybody"
+    def capabilities(self):
+        return {"pixels", "click", "type", "key"}
+    def observe(self, *, ocr=False, locate=None) -> Observation:
+        ...   # capture your screen → Observation
+    def do_click_at(self, x_pct, y_pct, button, count) -> ActionResult:
+        ...   # drive your mouse; return ActionResult(ok=True, ...)
+    def do_type_text(self, text, secret, append_enter) -> ActionResult:
+        ...
+    def do_key(self, combo) -> ActionResult:
+        ...
+
+em = Embodiment(MyBackend(), read_only=False)
+```
+
+`FakeBackend` (in `afferent/backends/fake.py`) is a complete, readable
+reference implementation of the contract.
+
+## Develop
+
+```bash
+pip install -e ".[dev]"
+python -m unittest discover -s tests -v     # fully offline, no deps
+# or: pytest
+```
+
+## Releasing
+
+Publishing is automatic. Bump `__version__` in `afferent/__init__.py`,
+commit, and **push to `main`** — `.github/workflows/publish.yml` builds, tests,
+and publishes to PyPI via Trusted Publishing (no tokens). Pushes that don't
+change the version are a no-op (the workflow checks PyPI and skips).
+
+One-time setup is in the workflow header (add a "pending publisher" on PyPI).
+
+For a manual / TestPyPI publish, use the local script:
+
+```bash
+scripts/release.sh --test     # TestPyPI
+scripts/release.sh            # PyPI
+```
+
+## License
+
+MIT.

afferent-0.1.0/README.md

@@ -0,0 +1,152 @@
+# afferent
+
+**A backend-agnostic sensorimotor protocol — eyes and hands for cognitive agents driving a computer.**
+
+A cognitive layer (a *brain*) plans; an embodiment layer (a *body*) acts.
+`afferent` is the conduit between them. It carries **afferent** signals up
+(eyes — `observe` / `locate` / `verify` / `read_text`) and **efferent**
+signals down (hands — `click` / `type_text` / `key` / `scroll`), as typed,
+safety-gated calls over a **pluggable backend**.
+
+```
+   ┌─────────┐   afferent (eyes) ↑    ┌────────────┐   actions   ┌──────────┐
+   │  brain  │ ◀───────────────────── │  afferent  │ ──────────▶ │   body   │
+   │ (plans) │ ──────────────────────▶│ (protocol) │ ◀────────── │ (backend)│
+   └─────────┘   efferent (hands) ↓    └────────────┘  observations└──────────┘
+```
+
+The package is **dependency-free** (stdlib only). It ships one working
+backend — `FakeBackend` (scripted, hardware-free) — and a `Backend` ABC you
+subclass to drive a real body: browser automation (Playwright/Selenium), OS
+automation (pyautogui / accessibility APIs), a VM driver, a remote HID bridge,
+or a test harness. The protocol doesn't care which.
+
+## Why it exists
+
+Most computer-use agents fuse perception, planning, and action into one
+monolith. `afferent` deliberately splits the *body* from the *mind* with a
+narrow, typed seam, so:
+
+- the planner stays free to be anything (an LLM loop, a cognitive
+  architecture, a script);
+- the body stays free to be anything (a real desktop, a browser, a VM, a
+  fake);
+- and the whole loop is **unit-testable offline** via the scripted fake
+  backend — no hardware, no network, no API keys.
+
+## Install
+
+```bash
+pip install afferent
+```
+
+That's it — no dependencies. (Dev tooling: `pip install afferent[dev]`.)
+
+## Quickstart — offline, scripted body (works immediately)
+
+```python
+from afferent import Embodiment
+from afferent.types import Observation, VisualElement
+
+screen0 = Observation(
+    ts=0.0, frontmost_app="Firefox",
+    elements=[VisualElement("Run", (0.80, 0.20, 0.10, 0.04), kind="button")],
+)
+screen1 = Observation(ts=1.0, frontmost_app="Firefox", ocr_text="running…")
+
+em = Embodiment.fake(script=[screen0, screen1])     # read_only=False for the demo
+
+print(em.observe().render_text())                   # afferent: see the screen
+res = em.click("Run")                               # efferent: locate + click
+print(res.ok, res.steps, res.state_after.ocr_text)  # grounded outcome
+```
+
+## The protocol
+
+All coordinates are `pct` — fractions in `[0, 1]`, top-left origin,
+resolution-independent (so they're stable world-model keys across machines).
+
+Typed results (`afferent.types`): `Frame`, `VisualElement`, `Observation`,
+`LocateResult`, `VerifyResult`, `ActionResult`.
+
+`Observation.render_text()` is a **stable, compact, embeddable** one-screen
+string — feed it to an embedding model and use it as a key in a learned world
+model. Determinism is guaranteed (same observation → byte-identical string).
+
+`ActionResult` carries **grounding** for predictive-coding / world-model
+consumers: `steps` (e.g. visual-servo iterations), `duration_ms`,
+`final_cursor_pct`, `frame_before` / `frame_after`, and a `state_after`
+observation bracketing the action.
+
+## Safety
+
+`SafetyGate` sits in front of every efferent action (eyes are never gated):
+
+- `read_only=True` is the **default** — hands refuse until you opt in.
+- `confirm(desc) -> bool` — a per-action veto your planner drives.
+- `allowed_apps` — refuse when the frontmost app isn't allowed.
+- `max_actions_per_min` — rate limit against runaway loops.
+- `panic()` — latch into a permanent refusing state.
+
+This is *additive* to whatever gates a backend enforces internally. Both must
+pass.
+
+## Writing a backend
+
+Subclass `afferent.Backend`, implement the eyes (`observe`, optionally
+`locate` / `verify` / `read_text`) and the raw hands (`do_click_at`,
+`do_type_text`, `do_key`, optionally `do_move_to` / `do_scroll`), and declare
+`capabilities()`. `Embodiment` applies the `SafetyGate` and the post-action
+observation for you — a backend only answers "how do I see / move", never
+"should I".
+
+```python
+from afferent import Backend, Embodiment
+from afferent.types import Observation, ActionResult
+
+class MyBackend(Backend):
+    name = "mybody"
+    def capabilities(self):
+        return {"pixels", "click", "type", "key"}
+    def observe(self, *, ocr=False, locate=None) -> Observation:
+        ...   # capture your screen → Observation
+    def do_click_at(self, x_pct, y_pct, button, count) -> ActionResult:
+        ...   # drive your mouse; return ActionResult(ok=True, ...)
+    def do_type_text(self, text, secret, append_enter) -> ActionResult:
+        ...
+    def do_key(self, combo) -> ActionResult:
+        ...
+
+em = Embodiment(MyBackend(), read_only=False)
+```
+
+`FakeBackend` (in `afferent/backends/fake.py`) is a complete, readable
+reference implementation of the contract.
+
+## Develop
+
+```bash
+pip install -e ".[dev]"
+python -m unittest discover -s tests -v     # fully offline, no deps
+# or: pytest
+```
+
+## Releasing
+
+Publishing is automatic. Bump `__version__` in `afferent/__init__.py`,
+commit, and **push to `main`** — `.github/workflows/publish.yml` builds, tests,
+and publishes to PyPI via Trusted Publishing (no tokens). Pushes that don't
+change the version are a no-op (the workflow checks PyPI and skips).
+
+One-time setup is in the workflow header (add a "pending publisher" on PyPI).
+
+For a manual / TestPyPI publish, use the local script:
+
+```bash
+scripts/release.sh --test     # TestPyPI
+scripts/release.sh            # PyPI
+```
+
+## License
+
+MIT.

afferent-0.1.0/afferent/__init__.py

@@ -0,0 +1,43 @@
+"""afferent — a backend-agnostic sensorimotor protocol for cognitive agents.
+
+A cognitive layer (a "brain") plans; an embodiment layer (a "body") acts.
+``afferent`` is the conduit between them: it carries **afferent** signals
+up (eyes — observe / locate / verify / read) and **efferent** signals down
+(hands — click / type / key / scroll), as typed, safety-gated calls over a
+pluggable `Backend`.
+
+The package is **dependency-free** (stdlib only). It ships one working
+backend — `FakeBackend` (scripted, hardware-free) — and a `Backend` ABC you
+subclass to drive a real body (browser automation, OS automation, a VM
+driver, a remote HID bridge, a test harness, …). `Embodiment` wraps any
+backend with a `SafetyGate` and post-action observation.
+"""
+from __future__ import annotations
+
+from .backends.base import Backend
+from .backends.fake import FakeBackend
+from .embodiment import Embodiment
+from .safety import SafetyGate
+from .types import (
+    ActionResult,
+    Frame,
+    LocateResult,
+    Observation,
+    VerifyResult,
+    VisualElement,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Embodiment",
+    "Backend",
+    "FakeBackend",
+    "SafetyGate",
+    "Frame",
+    "VisualElement",
+    "Observation",
+    "LocateResult",
+    "VerifyResult",
+    "ActionResult",
+]

afferent-0.1.0/afferent/backends/__init__.py

@@ -0,0 +1,12 @@
+"""Backends — pluggable embodiment implementations.
+
+`Backend` is the ABC you subclass to drive a real body. `FakeBackend` is a
+scripted, hardware-free reference implementation (stdlib only) used for tests
+and as a worked example of the contract.
+"""
+from __future__ import annotations
+
+from .base import Backend
+from .fake import FakeBackend
+
+__all__ = ["Backend", "FakeBackend"]