quilt-spreadsheet 0.1.0__tar.gz

quilt_spreadsheet-0.1.0/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 Casey Digennaro / SuperInstance

quilt_spreadsheet-0.1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: quilt-spreadsheet
+Version: 0.1.0
+Summary: The Quilt IDE as spreadsheet substrate — cells as programs with hooks, double-entry bookkeeping, per-cell color namespaces, backend porting, distributed clocks
+Author: Casey / SuperInstance
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+Dynamic: requires-python
+
+# quilt-spreadsheet
+
+> **The Quilt IDE as spreadsheet substrate.**
+>
+> Front-end: rows × cols. Each cell is a runnable program with hooks.
+> Double-entry bookkeeping tracks every pull/push. Per-cell color
+> namespaces. Backend porting across scales. Distributed clocks with
+> skew tolerance.
+
+## What this is
+
+A runnable Python substrate where:
+
+1. **Front-end is a spreadsheet** — `QuiltSpreadsheet(rows, cols)`. Each cell is a `SheetCell`.
+2. **Each cell is a runnable program** with hooks (pulls wake it). No `main()`. Event-driven.
+3. **Double-entry bookkeeping** — every pull/push pair is recorded as a ledger pair. Same UUID, same timestamp.
+4. **Per-cell color namespaces** — cells can label anything anything. The substrate checks canonical agreement, not labels.
+5. **Backend porting** — different cells can use different scales/units. The backend converts at the boundary.
+6. **Distributed clocks with skew** — clocks can disagree. Time-between-events is the sync signal. Confidence rises with shared events.
+
+## Quick start
+
+```bash
+# Run the canonical demo
+python3 -m quilt_spreadsheet
+
+# Or with custom dimensions
+python3 -m quilt_spreadsheet --rows 4 --cols 4
+
+# Run individual demos
+PYTHONPATH=. python3 demos/demo_double_entry.py
+PYTHONPATH=. python3 demos/demo_color_independent.py
+PYTHONPATH=. python3 demos/demo_backend_conversion.py
+PYTHONPATH=. python3 demos/demo_clock_skew.py
+```
+
+## Quick example
+
+```python
+from quilt_spreadsheet.grid import QuiltSpreadsheet
+
+sheet = QuiltSpreadsheet(rows=4, cols=4)
+
+def adder(*, source, hook, value):
+    return (value or 0) + 1
+
+def doubler(*, source, hook, value):
+    return (value or 0) * 2
+
+# Place programs into cells
+sheet.place_cell(0, 0, adder)
+sheet.place_cell(0, 1, doubler)
+
+# Cell (0, 0) pulls from cell (0, 1) with value=5
+result = sheet.pull(0, 0, 0, 1, hook="double", value=5)
+
+print(result)
+# {'response': 10, 'pair_id': '...', 'timestamp_ns': ..., 'cell': (0, 1)}
+```
+
+## The 4 demos
+
+### 1. `demos/demo_double_entry.py`
+
+Demonstrates the load-bearing ledger. Pulls and pushes are paired by UUID
++ timestamp. Unbalanced pulls are flagged but not prevented.
+
+### 2. `demos/demo_color_independent.py`
+
+Two cells with different color labels (red/blue) for the same canonical
+(CRITICAL). The substrate verifies agreement at canonical level, not
+labels.
+
+### 3. `demos/demo_backend_conversion.py`
+
+Backend ports values between scales (celsius → fahrenheit). Gates values
+below threshold. Snaps approximations to discrete grid. Time is preserved
+in same units on both sides.
+
+### 4. `demos/demo_clock_skew.py`
+
+Two cells share 10 events. Confidence rises asymptotically from 0.5 to 0.91.
+Skew is observable but manageable.
+
+## Architecture
+
+```
+QuiltSpreadsheet (rows × cols)
+    ├── CellClock [per-cell, private]
+    ├── Ledger [double-entry pair ledger]
+    ├── Backend [conversions, gates, snaps]
+    └── SheetCell (rows × cols)
+        ├── program: Callable (no main, runs on pull)
+        ├── axioms: frozenset (DNA)
+        ├── dials: List[float] (16 mutable state slots)
+        ├── color: ColorNamespace (private labels)
+        ├── perception: Perception (own sort/group)
+        ├── witness_log: List[dict]
+        ├── pulls: Dict[cell, List[hook]]
+        └── pushes: Dict[cell, List[hook]]
+```
+
+## The 3 commands
+
+```python
+# 1. Place a program into a cell
+sheet.place_cell(row, col, program, axioms=None)
+
+# 2. Pull from another cell (cell A at (r0, c0) wakes cell at (r1, c1))
+sheet.pull(r0, c0, r1, c1, hook='name', value=...)
+
+# 3. Inspect state
+sheet.render()        # spreadsheet-shaped ascii view
+sheet.summary()       # substrate state dict
+sheet.ledger.summary()  # double-entry pair ledger
+```
+
+## Substrate transition
+
+This repo is the substrate transition FROM `quilt-egg` (single cell) TO
+`quilt-spreadsheet` (grid of cells with hooks). Same constants, same DNA.
+More dimensions.
+
+| quilt-egg | quilt-spreadsheet |
+|---|---|
+| 1 cell | rows × cols cells |
+| 1 tick loop | pull-triggered wake |
+| DNA + dials | DNA + dials + hooks + color + perception |
+| 18 tests | 21 tests |
+| 4 demos | 4 demos |
+
+## Layered navigation
+
+| Layer | Where |
+|---|---|
+| **CANON.md** | [CANON.md](CANON.md) — what this repo is, in 24 lines |
+| **README** | [README.md](README.md) — quick start, navigation |
+| **Spec** | [docs/SPEC.md](docs/SPEC.md) — half-canon, half-spec |
+| **Source** | [quilt_spreadsheet/](quilt_spreadsheet/) — `clock.py`, `ledger.py`, `color.py`, `backend.py`, `perception.py`, `cell.py`, `grid.py` |
+| **Demos** | [demos/](demos/) — 4 runnable demos |
+| **Tests** | [tests/](tests/) — 21 unit tests |
+| **Origin** | [quilt-egg](../quilt-egg/) — the prior substrate |
+
+## Polyformalism
+
+This substrate is canonically a polyformalism port. The canary
+`fnv1a-64("café Δ 日本語") = 0x024a555471370b18d` is verified on every
+Quilt port.
+
+## Tests
+
+```bash
+PYTHONPATH=. python3 -m unittest discover -s tests -v
+```
+
+21 tests covering:
+- Clock skew tolerance and pairwise confidence
+- Double-entry ledger pairing (and unbalanced-pull handling)
+- Per-cell color namespaces
+- Backend conversions, gates, snaps
+- Spreadsheet pull/push wiring
+- Perception sorting/grouping/filtering
+
+## License
+
+MIT — Casey / SuperInstance, Sept 23, 2026

quilt_spreadsheet-0.1.0/README.md

@@ -0,0 +1,166 @@
+# quilt-spreadsheet
+
+> **The Quilt IDE as spreadsheet substrate.**
+>
+> Front-end: rows × cols. Each cell is a runnable program with hooks.
+> Double-entry bookkeeping tracks every pull/push. Per-cell color
+> namespaces. Backend porting across scales. Distributed clocks with
+> skew tolerance.
+
+## What this is
+
+A runnable Python substrate where:
+
+1. **Front-end is a spreadsheet** — `QuiltSpreadsheet(rows, cols)`. Each cell is a `SheetCell`.
+2. **Each cell is a runnable program** with hooks (pulls wake it). No `main()`. Event-driven.
+3. **Double-entry bookkeeping** — every pull/push pair is recorded as a ledger pair. Same UUID, same timestamp.
+4. **Per-cell color namespaces** — cells can label anything anything. The substrate checks canonical agreement, not labels.
+5. **Backend porting** — different cells can use different scales/units. The backend converts at the boundary.
+6. **Distributed clocks with skew** — clocks can disagree. Time-between-events is the sync signal. Confidence rises with shared events.
+
+## Quick start
+
+```bash
+# Run the canonical demo
+python3 -m quilt_spreadsheet
+
+# Or with custom dimensions
+python3 -m quilt_spreadsheet --rows 4 --cols 4
+
+# Run individual demos
+PYTHONPATH=. python3 demos/demo_double_entry.py
+PYTHONPATH=. python3 demos/demo_color_independent.py
+PYTHONPATH=. python3 demos/demo_backend_conversion.py
+PYTHONPATH=. python3 demos/demo_clock_skew.py
+```
+
+## Quick example
+
+```python
+from quilt_spreadsheet.grid import QuiltSpreadsheet
+
+sheet = QuiltSpreadsheet(rows=4, cols=4)
+
+def adder(*, source, hook, value):
+    return (value or 0) + 1
+
+def doubler(*, source, hook, value):
+    return (value or 0) * 2
+
+# Place programs into cells
+sheet.place_cell(0, 0, adder)
+sheet.place_cell(0, 1, doubler)
+
+# Cell (0, 0) pulls from cell (0, 1) with value=5
+result = sheet.pull(0, 0, 0, 1, hook="double", value=5)
+
+print(result)
+# {'response': 10, 'pair_id': '...', 'timestamp_ns': ..., 'cell': (0, 1)}
+```
+
+## The 4 demos
+
+### 1. `demos/demo_double_entry.py`
+
+Demonstrates the load-bearing ledger. Pulls and pushes are paired by UUID
++ timestamp. Unbalanced pulls are flagged but not prevented.
+
+### 2. `demos/demo_color_independent.py`
+
+Two cells with different color labels (red/blue) for the same canonical
+(CRITICAL). The substrate verifies agreement at canonical level, not
+labels.
+
+### 3. `demos/demo_backend_conversion.py`
+
+Backend ports values between scales (celsius → fahrenheit). Gates values
+below threshold. Snaps approximations to discrete grid. Time is preserved
+in same units on both sides.
+
+### 4. `demos/demo_clock_skew.py`
+
+Two cells share 10 events. Confidence rises asymptotically from 0.5 to 0.91.
+Skew is observable but manageable.
+
+## Architecture
+
+```
+QuiltSpreadsheet (rows × cols)
+    ├── CellClock [per-cell, private]
+    ├── Ledger [double-entry pair ledger]
+    ├── Backend [conversions, gates, snaps]
+    └── SheetCell (rows × cols)
+        ├── program: Callable (no main, runs on pull)
+        ├── axioms: frozenset (DNA)
+        ├── dials: List[float] (16 mutable state slots)
+        ├── color: ColorNamespace (private labels)
+        ├── perception: Perception (own sort/group)
+        ├── witness_log: List[dict]
+        ├── pulls: Dict[cell, List[hook]]
+        └── pushes: Dict[cell, List[hook]]
+```
+
+## The 3 commands
+
+```python
+# 1. Place a program into a cell
+sheet.place_cell(row, col, program, axioms=None)
+
+# 2. Pull from another cell (cell A at (r0, c0) wakes cell at (r1, c1))
+sheet.pull(r0, c0, r1, c1, hook='name', value=...)
+
+# 3. Inspect state
+sheet.render()        # spreadsheet-shaped ascii view
+sheet.summary()       # substrate state dict
+sheet.ledger.summary()  # double-entry pair ledger
+```
+
+## Substrate transition
+
+This repo is the substrate transition FROM `quilt-egg` (single cell) TO
+`quilt-spreadsheet` (grid of cells with hooks). Same constants, same DNA.
+More dimensions.
+
+| quilt-egg | quilt-spreadsheet |
+|---|---|
+| 1 cell | rows × cols cells |
+| 1 tick loop | pull-triggered wake |
+| DNA + dials | DNA + dials + hooks + color + perception |
+| 18 tests | 21 tests |
+| 4 demos | 4 demos |
+
+## Layered navigation
+
+| Layer | Where |
+|---|---|
+| **CANON.md** | [CANON.md](CANON.md) — what this repo is, in 24 lines |
+| **README** | [README.md](README.md) — quick start, navigation |
+| **Spec** | [docs/SPEC.md](docs/SPEC.md) — half-canon, half-spec |
+| **Source** | [quilt_spreadsheet/](quilt_spreadsheet/) — `clock.py`, `ledger.py`, `color.py`, `backend.py`, `perception.py`, `cell.py`, `grid.py` |
+| **Demos** | [demos/](demos/) — 4 runnable demos |
+| **Tests** | [tests/](tests/) — 21 unit tests |
+| **Origin** | [quilt-egg](../quilt-egg/) — the prior substrate |
+
+## Polyformalism
+
+This substrate is canonically a polyformalism port. The canary
+`fnv1a-64("café Δ 日本語") = 0x024a555471370b18d` is verified on every
+Quilt port.
+
+## Tests
+
+```bash
+PYTHONPATH=. python3 -m unittest discover -s tests -v
+```
+
+21 tests covering:
+- Clock skew tolerance and pairwise confidence
+- Double-entry ledger pairing (and unbalanced-pull handling)
+- Per-cell color namespaces
+- Backend conversions, gates, snaps
+- Spreadsheet pull/push wiring
+- Perception sorting/grouping/filtering
+
+## License
+
+MIT — Casey / SuperInstance, Sept 23, 2026

quilt_spreadsheet-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quilt-spreadsheet"
+version = "0.1.0"
+description = "The Quilt IDE as spreadsheet substrate — cells as programs with hooks, double-entry bookkeeping, per-cell color namespaces, backend porting, distributed clocks"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "Casey / SuperInstance"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[tool.setuptools]
+packages = ["quilt_spreadsheet"]

quilt_spreadsheet-0.1.0/quilt_spreadsheet/__init__.py

@@ -0,0 +1,50 @@
+"""
+quilt-spreadsheet — the IDE substrate.
+
+A spreadsheet-as-IDE where:
+  - front-end looks like a spreadsheet (rows x cols)
+  - each cell is a runnable program with hooks
+  - double-entry bookkeeping tracks every pull/push pair
+  - per-cell color namespaces (semantic heterogeneity is OK)
+  - backend porting handles scale/unit conversions
+  - distributed clocks allow skew; time-between-events converges
+
+This is the SUBSTRATE TRANSITION from quilt-egg (a single cell) to
+quilt-spreadsheet (a grid of cells with hooks).
+"""
+
+from .clock import (
+    CellClock, DistributedClock, get_default_clock, reset_default_clock
+)
+from .ledger import (
+    LedgerEntry, Ledger, get_default_ledger, reset_default_ledger
+)
+from .color import (
+    ColorNamespace, same_canonical, labels_matter
+)
+from .backend import (
+    Backend, get_default_backend, reset_default_backend,
+    convert, REGISTRY,
+)
+from .perception import Perception
+from .cell import (
+    SheetCell, DOCTRINE_AXIOMS, ACTION_AXIOMS,
+    register_cell, reset_registry, get_cell, all_cells,
+)
+from .grid import QuiltSpreadsheet, place_cell
+
+__all__ = [
+    "CellClock", "DistributedClock",
+    "get_default_clock", "reset_default_clock",
+    "LedgerEntry", "Ledger",
+    "get_default_ledger", "reset_default_ledger",
+    "ColorNamespace", "same_canonical", "labels_matter",
+    "Backend", "get_default_backend", "reset_default_backend",
+    "convert", "REGISTRY",
+    "Perception",
+    "SheetCell", "DOCTRINE_AXIOMS", "ACTION_AXIOMS",
+    "register_cell", "reset_registry", "get_cell", "all_cells",
+    "QuiltSpreadsheet", "place_cell",
+]
+
+__version__ = "0.1.0"

quilt_spreadsheet-0.1.0/quilt_spreadsheet/__main__.py

@@ -0,0 +1,71 @@
+"""
+__main__.py — `python -m quilt_spreadsheet` runs a demo spreadsheet.
+"""
+
+import argparse
+import sys
+
+from .grid import QuiltSpreadsheet, reset_all
+
+
+def demo_spreadsheet():
+    """Build a 4×4 substrate with 4 programs that respond to pulls."""
+    reset_all()
+    sheet = QuiltSpreadsheet(rows=4, cols=4, name="canonical_demo")
+
+    def adder(*, source, hook, value):
+        # Cell that adds 1 to whatever is pulled
+        return (value or 0) + 1
+
+    def doubler(*, source, hook, value):
+        return (value or 0) * 2
+
+    def labeler(*, source, hook, value):
+        # Cell that translates a label
+        return "doubled" if hook == "double" else "added"
+
+    def tally(*, source, hook, value):
+        # Counts how many times it has been pulled
+        return f"tally:{value}"
+
+    # Place four programs
+    sheet.place_cell(0, 0, adder)
+    sheet.place_cell(0, 1, doubler)
+    sheet.place_cell(1, 0, labeler)
+    sheet.place_cell(1, 1, tally)
+
+    # Wire a workflow: cell at (2, 2) pulls adder, then doubler
+    def workflow(*, source, hook, value):
+        return f"workflow[{hook}]={value}"
+
+    sheet.place_cell(2, 2, workflow)
+    # Pull adder
+    sheet.pull(2, 2, 0, 0, hook="step1", value=5)
+    # Pull doubler — note this uses ledger.record_pair
+    sheet.pull(0, 0, 0, 1, hook="double", value=5)
+
+    print(sheet.render())
+    print()
+    print("Summary:")
+    for k, v in sheet.summary().items():
+        print(f"  {k}: {v}")
+    print()
+    print("Pulls and pushes recorded in the ledger (double-entry pairs).")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="quilt_spreadsheet",
+        description="The Quilt spreadsheet IDE substrate — double-entry bookkeeping, distributed clocks, per-cell color namespaces, backend porting.",
+    )
+    parser.add_argument("--rows", type=int, default=4, help="Spreadsheet rows (default: 4)")
+    parser.add_argument("--cols", type=int, default=4, help="Spreadsheet cols (default: 4)")
+    parser.add_argument("--demo", choices=["canonical"], default="canonical", help="Demo to run")
+    args = parser.parse_args()
+    if args.demo == "canonical":
+        demo_spreadsheet()
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

quilt_spreadsheet-0.1.0/quilt_spreadsheet/backend.py

@@ -0,0 +1,183 @@
+"""
+backend.py — the porting, conversion, gating, and snapping layer.
+
+Casey: "the true backend is the actual porting and conversions. one cell
+might be using a different scale than another but if the backend can convert
+so their equal exchange for their applications, it doesn't matter. the
+backend can gate variables or convert approximations to snaps but the time
+is in the same units on both sides."
+
+This is the polyformalism-port layer at the substrate level. Different
+cells may use:
+  - different scales (celsius vs fahrenheit)
+  - different units (ns vs ms)
+  - different precision (continuous vs snapped)
+  - different visibility (some variables are gated)
+
+The backend DOES NOT enforce agreement. The backend PROVIDES porting
+for when cells need to exchange data.
+"""
+
+from typing import Any, Tuple
+import math
+
+
+#: The canonical conversions registry — extensible.
+#: Each entry: name -> callable(value, from_unit, to_unit)
+#: Time is preserved in the SAME units on both sides (per Casey).
+REGISTRY = {}
+
+
+def convert(name: str):
+    """Decorator to register a backend conversion."""
+    def deco(fn):
+        REGISTRY[name] = fn
+        return fn
+    return deco
+
+
+@convert("temperature")
+def convert_temperature(value: float, from_unit: str, to_unit: str) -> float:
+    """Convert temperature scales."""
+    if from_unit == to_unit:
+        return value
+    if from_unit == 'celsius' and to_unit == 'fahrenheit':
+        return value * 9/5 + 32
+    if from_unit == 'fahrenheit' and to_unit == 'celsius':
+        return (value - 32) * 5/9
+    if from_unit == 'celsius' and to_unit == 'kelvin':
+        return value + 273.15
+    raise ValueError(f"unsupported temperature conversion: {from_unit} -> {to_unit}")
+
+
+@convert("time")
+def convert_time(value: float, from_unit: str, to_unit: str) -> float:
+    """Time is preserved in the SAME units on both sides (per Casey).
+
+    Per Casey's directive: 'time is in the same units on both sides'.
+    This converter refuses to convert across units — it normalizes to
+    nanoseconds (canonical) and back.
+
+    Use ms and ns. The substrate does not negotiate time across calendars.
+    """
+    if from_unit == to_unit:
+        return value
+    if from_unit not in ('ns', 'ms', 's') or to_unit not in ('ns', 'ms', 's'):
+        raise ValueError(f"time must be in same units: {from_unit} vs {to_unit}")
+    # Casey: convert for compatibility but it's a unit-preserving op
+    if from_unit == 'ns' and to_unit == 'ms':
+        return value / 1e6
+    if from_unit == 'ms' and to_unit == 'ns':
+        return value * 1e6
+    if from_unit == 'ns' and to_unit == 's':
+        return value / 1e9
+    if from_unit == 's' and to_unit == 'ns':
+        return value * 1e9
+    return value
+
+
+@convert("distance")
+def convert_distance(value: float, from_unit: str, to_unit: str) -> float:
+    """Distance scaling."""
+    if from_unit == to_unit:
+        return value
+    if from_unit == 'm' and to_unit == 'cm':
+        return value * 100
+    if from_unit == 'cm' and to_unit == 'm':
+        return value / 100
+    raise ValueError(f"unsupported distance conversion: {from_unit} -> {to_unit}")
+
+
+@convert("ratio")
+def convert_ratio(value: float, from_unit: str, to_unit: str) -> float:
+    """Ratios are unitless — convert between percent, decimal, ppm."""
+    if from_unit == to_unit:
+        return value
+    if from_unit == 'decimal' and to_unit == 'percent':
+        return value * 100
+    if from_unit == 'percent' and to_unit == 'decimal':
+        return value / 100
+    if from_unit == 'ppm' and to_unit == 'decimal':
+        return value / 1e6
+    raise ValueError(f"unsupported ratio conversion: {from_unit} -> {to_unit}")
+
+
+class Backend:
+    """The porting backend — applied at cell boundaries.
+
+    Functions: convert, gate, snap, time-aware porting.
+    """
+
+    def __init__(self):
+        self.conversions_run: int = 0
+
+    def port(self, value: Any, from_unit: str, to_unit: str,
+             domain: str = "ratio") -> Any:
+        """Port a value across scales/units in the same domain.
+
+        Default domain is 'ratio' (unitless). For physical conversions
+        pass domain='temperature' or 'distance'.
+        """
+        if from_unit == to_unit:
+            return value
+        if domain not in REGISTRY:
+            raise ValueError(f"unknown backend domain: {domain}")
+        self.conversions_run += 1
+        return REGISTRY[domain](value, from_unit, to_unit)
+
+    def gate(self, value: Any, predicate) -> Any:
+        """Backend 'gate' — release a value only if predicate is satisfied.
+
+        Casey: 'the backend can gate variables or convert approximations
+        to snaps'. The gate is controlled release/transformation.
+
+        Returns None if predicate fails. The cell receives None and can
+        decide what to do (default action: skip).
+        """
+        if not predicate(value):
+            return None
+        return value
+
+    def gate_below(self, value: float, threshold: float) -> Any:
+        """Common gate: block values below threshold."""
+        if value < threshold:
+            return None
+        return value
+
+    def snap(self, value: float, granularity: float) -> float:
+        """Approximation snap — snap to discrete grid.
+
+        Casey: 'the backend can gate variables or convert approximations
+        to snaps'. A snap rounds the value to the nearest multiple of
+        granularity.
+
+        e.g. snap(3.7, 0.5) = 3.5 (or 4.0, depending on tie-break)
+        """
+        if granularity <= 0:
+            return value
+        return round(value / granularity) * granularity
+
+    def port_time(self, value: float, from_unit: str, to_unit: str) -> float:
+        """Time porting — preserves same units on both sides (per Casey)."""
+        return REGISTRY["time"](value, from_unit, to_unit)
+
+    def stats(self) -> dict:
+        return {
+            "conversions_run": self.conversions_run,
+            "available_conversions": sorted(REGISTRY.keys()),
+        }
+
+
+_default_backend = None
+
+
+def get_default_backend() -> Backend:
+    global _default_backend
+    if _default_backend is None:
+        _default_backend = Backend()
+    return _default_backend
+
+
+def reset_default_backend() -> None:
+    global _default_backend
+    _default_backend = None