superlocalmemory 3.8.5 → 3.8.6

package/src/superlocalmemory/storage/database.py

@@ -218,9 +218,62 @@ class DatabaseManager:
         conn.execute("PRAGMA foreign_keys=ON")
         return conn
 
+    @contextmanager
+    def _bind_coordinator_connection(
+        self,
+        conn: sqlite3.Connection,
+        capability: Any,
+    ) -> Generator[None, None, None]:
+        """Reuse the coordinator's sole writable connection for one handler.
+
+        This deliberately stays internal: only ``WriteCoordinator`` can issue
+        a capability, and that capability is valid only for its worker thread
+        and the exact resolved database path.  While bound, ``transaction``
+        and ``raw_connection`` become no-op ownership scopes: they may yield
+        the connection, but they must never commit, rollback, or close it.
+        The coordinator owns the enclosing ``BEGIN IMMEDIATE`` and final
+        commit/rollback together with the command receipt.
+        """
+        from superlocalmemory.storage.write_coordinator import WriteCoordinatorError
+
+        if not isinstance(conn, sqlite3.Connection):
+            raise WriteCoordinatorError("coordinator binding requires a sqlite3 connection")
+        validate = getattr(capability, "_validate", None)
+        if not callable(validate):
+            raise WriteCoordinatorError("untrusted coordinator capability")
+        try:
+            validate(self.db_path.expanduser().resolve())
+        except Exception as exc:
+            # Import lazily so the storage manager retains its legacy import
+            # surface when the coordinator is not used.
+            if isinstance(exc, WriteCoordinatorError):
+                raise
+            raise WriteCoordinatorError("untrusted coordinator capability") from exc
+
+        attached = conn.execute("PRAGMA database_list").fetchall()
+        main_path = next((row[2] for row in attached if row[1] == "main"), "")
+        expected_path = self.db_path.expanduser().resolve()
+        if not main_path or Path(main_path).expanduser().resolve() != expected_path:
+            raise WriteCoordinatorError("coordinator connection targets a different database")
+        if getattr(self._txn_state, "conn", None) is not None:
+            raise WriteCoordinatorError("database manager is already bound to a transaction")
+
+        self._txn_state.conn = conn
+        self._txn_state.coordinator_bound = True
+        try:
+            yield
+        finally:
+            self._txn_state.conn = None
+            self._txn_state.coordinator_bound = False
+
     @contextmanager
     def transaction(self) -> Generator[None, None, None]:
         """Atomic transaction. All writes commit or rollback together."""
+        if getattr(self._txn_state, "coordinator_bound", False):
+            # The coordinator has already issued BEGIN IMMEDIATE.  Do not
+            # create a nested transaction or steal its commit/close lifecycle.
+            yield
+            return
         with self._lock:
             conn = self._connect()
             self._txn_state.conn = conn
@@ -243,6 +296,12 @@ class DatabaseManager:
         error, and always closes — mirroring transaction(). This is the public
         way to obtain a connection; there is no `.conn` attribute.
         """
+        coordinator_conn = getattr(self._txn_state, "conn", None)
+        if getattr(self._txn_state, "coordinator_bound", False):
+            if coordinator_conn is None:  # pragma: no cover - binding invariant
+                raise RuntimeError("coordinator binding has no active connection")
+            yield coordinator_conn
+            return
         with self._lock:
             conn = self._connect()
             self._txn_state.conn = conn

package/src/superlocalmemory/storage/deferred_writes.py

@@ -21,6 +21,7 @@ single-writer queue (see WRITE-QUEUE-PLAN.md).
 """
 from __future__ import annotations
 
+import atexit
 import queue
 import threading
 
@@ -40,11 +41,16 @@ _BG_MAXSIZE = 20000
 _bg_queue: "queue.Queue" = queue.Queue(maxsize=_BG_MAXSIZE)
 _bg_started = False
 _bg_start_lock = threading.Lock()
+_bg_stop = threading.Event()
+_bg_thread: threading.Thread | None = None
 
 
-def _bg_run() -> None:
-    while True:
-        fn = _bg_queue.get()
+def _bg_run(work_queue: "queue.Queue", stop: threading.Event) -> None:
+    while not stop.is_set():
+        try:
+            fn = work_queue.get(timeout=0.1)
+        except queue.Empty:
+            continue
         try:
             fn()
         except Exception:
@@ -55,15 +61,21 @@ def _bg_run() -> None:
 
 
 def _ensure_bg_thread() -> None:
-    global _bg_started
-    if _bg_started:
+    global _bg_queue, _bg_started, _bg_stop, _bg_thread
+    if _bg_thread is not None and _bg_thread.is_alive():
         return
     with _bg_start_lock:
-        if _bg_started:
+        if _bg_thread is not None and _bg_thread.is_alive():
             return
-        threading.Thread(
-            target=_bg_run, name="slm-bg-writer", daemon=True
-        ).start()
+        _bg_queue = queue.Queue(maxsize=_BG_MAXSIZE)
+        _bg_stop = threading.Event()
+        _bg_thread = threading.Thread(
+            target=_bg_run,
+            args=(_bg_queue, _bg_stop),
+            name="slm-bg-writer",
+            daemon=True,
+        )
+        _bg_thread.start()
         _bg_started = True
 
 
@@ -81,6 +93,23 @@ def submit_background(fn) -> None:
         pass
 
 
+def _shutdown_background_writer(timeout: float) -> None:
+    """Stop the shared bookkeeping worker and wait for its thread to exit."""
+    global _bg_started, _bg_thread
+    with _bg_start_lock:
+        thread = _bg_thread
+        if thread is None:
+            return
+        _bg_stop.set()
+    if thread is not threading.current_thread():
+        thread.join(timeout=timeout)
+    if not thread.is_alive():
+        with _bg_start_lock:
+            if _bg_thread is thread:
+                _bg_thread = None
+                _bg_started = False
+
+
 class DeferredLastSeen:
     """Coalescing background flusher for canonical_entities.last_seen."""
 
@@ -90,6 +119,7 @@ class DeferredLastSeen:
         self._pending: dict[tuple[str, str], str] = {}
         self._lock = threading.Lock()
         self._stop = threading.Event()
+        self._stopped = False
         self._thread = threading.Thread(
             target=self._run, name="slm-deferred-lastseen", daemon=True
         )
@@ -126,9 +156,17 @@ class DeferredLastSeen:
         while not self._stop.wait(self._interval):
             self.flush()
 
-    def stop(self) -> None:
+    @property
+    def is_stopped(self) -> bool:
+        return self._stopped
+
+    def stop(self, timeout: float = 3.0) -> None:
+        """Flush then join the owner thread so it cannot outlive its database."""
         self._stop.set()
         self.flush()
+        if self._thread is not threading.current_thread():
+            self._thread.join(timeout=timeout)
+        self._stopped = not self._thread.is_alive()
 
 
 _registry: dict[int, DeferredLastSeen] = {}
@@ -140,14 +178,32 @@ def get_deferred_last_seen(db) -> DeferredLastSeen:
     key = id(db)
     with _registry_lock:
         writer = _registry.get(key)
-        if writer is None:
+        if writer is None or writer.is_stopped:
             writer = DeferredLastSeen(db)
             _registry[key] = writer
         return writer
 
 
+def shutdown_deferred_writes(timeout: float = 3.0) -> None:
+    """Stop every deferred-write worker owned by this process.
+
+    This is intentionally idempotent: service shutdown and pytest cleanup can
+    both call it, and a later caller can lazily create fresh workers.
+    """
+    with _registry_lock:
+        writers = list(_registry.values())
+        _registry.clear()
+    for writer in writers:
+        writer.stop(timeout=timeout)
+    _shutdown_background_writer(timeout)
+
+
+atexit.register(shutdown_deferred_writes)
+
+
 __all__ = [
     "DeferredLastSeen",
     "get_deferred_last_seen",
+    "shutdown_deferred_writes",
     "submit_background",
 ]

package/src/superlocalmemory/storage/memory_write.py

@@ -40,8 +40,9 @@ each commit quickly.
 Reads
 -----
 Use :func:`memory_read` for read-only access.  WAL allows concurrent readers
-without blocking the writer, so reads do NOT take the write lock — but they
-still get ``busy_timeout`` for robustness during the brief checkpoint window.
+without blocking the writer, so reads do NOT take the write lock.  The helper
+opens SQLite with ``mode=ro`` and ``PRAGMA query_only=ON``; it uses the
+3.8.6 read-path budget of at most 250ms during a brief checkpoint window.
 """
 from __future__ import annotations
 
@@ -51,6 +52,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Generator
 
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 from superlocalmemory.storage.write_lock import get_write_lock
 
 
@@ -100,20 +102,14 @@ def memory_write(db_path: str | Path) -> Generator[sqlite3.Connection, None, Non
 
 @contextmanager
 def memory_read(db_path: str | Path) -> Generator[sqlite3.Connection, None, None]:
-    """Yield a read-only-usage connection with ``busy_timeout`` (no write lock).
+    """Yield a physically read-only connection with no write lock.
 
     WAL permits concurrent readers, so this deliberately does NOT take the
-    write lock.  ``busy_timeout`` still applies so a read issued during the
-    brief WAL checkpoint window waits rather than erroring.
+    write lock.  A 250ms bounded wait protects the query path from a brief
+    checkpoint without converting a dashboard recall into a long hang.
     """
-    ms = _busy_timeout_ms()
-    conn = sqlite3.connect(str(db_path), timeout=ms / 1000.0)
-    try:
-        conn.execute(f"PRAGMA busy_timeout={ms}")
-        conn.row_factory = sqlite3.Row
+    with ReadConnectionFactory(db_path, timeout_ms=min(_busy_timeout_ms(), 250)).snapshot() as conn:
         yield conn
-    finally:
-        conn.close()
 
 
 __all__ = ["memory_write", "memory_read"]

package/src/superlocalmemory/storage/migration_runner.py

@@ -125,6 +125,9 @@ from superlocalmemory.storage.migrations import (
 from superlocalmemory.storage.migrations import (
     M031_dead_letter_operations as _M031,
 )
+from superlocalmemory.storage.migrations import (
+    M032_write_coordinator_admission as _M032,
+)
 
 # Map migration name → module (used for the optional ``verify(conn)`` hook
 # that lets the runner detect "already applied" state when an idempotent
@@ -160,6 +163,7 @@ _MODULES = {
     _M029.NAME: _M029,
     _M030.NAME: _M030,
     _M031.NAME: _M031,
+    _M032.NAME: _M032,
 }
 
 logger = logging.getLogger(__name__)
@@ -173,6 +177,12 @@ _KNOWN_EQUIVALENT_DDL_HASHES: dict[str, frozenset[str]] = {
         # v3.4.22 model_version-default variant shipped through 3.6.x.
         "d28666fa1dfa66e6514efd288e6748363513da2255a4cee95d80f233e6728ae7",
     }),
+    _M032.NAME: frozenset({
+        # Provisional 3.8.6 development ledger: global idempotency_key and
+        # operation_id uniqueness. Its standalone table is safely rebuilt by
+        # M032.repair() into the profile-scoped receipt contract.
+        "e45df41becba3d0c3342eca5ec3bd83aa899eef76943c819d2da73b4ca1625a7",
+    }),
 }
 
 
@@ -223,6 +233,9 @@ MIGRATIONS: list[Migration] = [
     # M031 creates dead_letter_operations — standalone table, no FK to engine-
     # bootstrapped tables, so it can run during apply_all (before engine init).
     Migration(name=_M031.NAME, db_target="memory", ddl=_M031.DDL),
+    # M032 is standalone and must precede daemon readiness: typed writes use
+    # this append-only receipt ledger for durable idempotency.
+    Migration(name=_M032.NAME, db_target="memory", ddl=_M032.DDL),
     # M006 + M011 are deliberately NOT here — see DEFERRED_MIGRATIONS below.
 ]
 
@@ -422,6 +435,30 @@ def _apply_single(
                             )
                     except sqlite3.Error:  # pragma: no cover
                         pass
+                    if dry_run:
+                        return (
+                            "skipped",
+                            "dry-run: would repair allowlisted historical schema",
+                        )
+                    repair_fn = getattr(mod, "repair", None) if mod is not None else None
+                    if callable(repair_fn):
+                        try:
+                            repair_fn(conn)
+                            if not bool(verify_fn(conn)):
+                                return (
+                                    "failed",
+                                    f"safe repair did not restore {migration.name}",
+                                )
+                            _upsert_log(conn, migration.name, ddl_hash, "complete")
+                            return (
+                                "applied",
+                                "allowlisted historical schema repaired safely",
+                            )
+                        except sqlite3.Error as exc:
+                            return (
+                                "failed",
+                                f"safe repair failed for {migration.name}: {exc}",
+                            )
                 detail = (
                     f"DDL drift detected for {migration.name}: "
                     f"logged={logged_hash[:8]}... current={ddl_hash[:8]}..."

package/src/superlocalmemory/storage/migrations/M032_write_coordinator_admission.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""M032 — durable, append-only receipts for canonical write commands.
+
+The receipt ledger is profile-isolated at the client idempotency boundary.
+``command_id`` and ``journal_id`` remain globally durable identifiers; a
+client-supplied idempotency key is unique only with its target profile.  An
+operation id is a projection label (for example, ``update:<fact_id>``), not a
+durable command identifier, so it is deliberately indexed but not unique.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M032_write_coordinator_admission"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS write_commits (
+    commit_sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    command_id      TEXT NOT NULL UNIQUE,
+    journal_id      TEXT NOT NULL UNIQUE,
+    command_kind    TEXT NOT NULL,
+    request_hash    TEXT NOT NULL,
+    profile_id      TEXT NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    operation_id    TEXT NOT NULL,
+    receipt_json    TEXT NOT NULL,
+    committed_at    REAL NOT NULL,
+    UNIQUE(profile_id, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS idx_write_commits_committed_at
+    ON write_commits (committed_at);
+CREATE INDEX IF NOT EXISTS idx_write_commits_operation_id
+    ON write_commits (operation_id);
+CREATE TRIGGER IF NOT EXISTS trg_write_commits_immutable_update
+BEFORE UPDATE ON write_commits
+BEGIN
+    SELECT RAISE(ABORT, 'write_commits receipts are immutable');
+END;
+CREATE TRIGGER IF NOT EXISTS trg_write_commits_immutable_delete
+BEFORE DELETE ON write_commits
+BEGIN
+    SELECT RAISE(ABORT, 'write_commits receipts are immutable');
+END;
+"""
+
+_CREATE_TABLE = DDL.split(";", 1)[0]
+_CREATE_COMMITTED_AT_INDEX = (
+    "CREATE INDEX IF NOT EXISTS idx_write_commits_committed_at "
+    "ON write_commits (committed_at)"
+)
+_CREATE_OPERATION_ID_INDEX = (
+    "CREATE INDEX IF NOT EXISTS idx_write_commits_operation_id "
+    "ON write_commits (operation_id)"
+)
+_CREATE_UPDATE_TRIGGER = """
+CREATE TRIGGER IF NOT EXISTS trg_write_commits_immutable_update
+BEFORE UPDATE ON write_commits
+BEGIN
+    SELECT RAISE(ABORT, 'write_commits receipts are immutable');
+END
+"""
+_CREATE_DELETE_TRIGGER = """
+CREATE TRIGGER IF NOT EXISTS trg_write_commits_immutable_delete
+BEFORE DELETE ON write_commits
+BEGIN
+    SELECT RAISE(ABORT, 'write_commits receipts are immutable');
+END
+"""
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Create or safely upgrade the profile-scoped append-only receipt ledger."""
+    if verify(conn):
+        return
+    if not _table_exists(conn):
+        _create_current_schema(conn)
+        return
+    _rebuild_legacy_schema(conn)
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Repair a completed provisional M032 in developer/test databases."""
+    apply(conn)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Return true only when the full profile-safe ledger contract exists."""
+    if not _table_exists(conn):
+        return False
+    columns = {row[1] for row in conn.execute("PRAGMA table_info(write_commits)").fetchall()}
+    required = {
+        "commit_sequence",
+        "command_id",
+        "journal_id",
+        "command_kind",
+        "request_hash",
+        "profile_id",
+        "idempotency_key",
+        "operation_id",
+        "receipt_json",
+        "committed_at",
+    }
+    if not required <= columns:
+        return False
+    if not _has_unique_index(conn, ("command_id",)):
+        return False
+    if not _has_unique_index(conn, ("journal_id",)):
+        return False
+    if not _has_unique_index(conn, ("profile_id", "idempotency_key")):
+        return False
+    if _has_unique_index(conn, ("idempotency_key",)):
+        return False
+    if _has_unique_index(conn, ("operation_id",)):
+        return False
+    object_names = {
+        row[0]
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE name IN (?, ?, ?, ?)",
+            (
+                "idx_write_commits_committed_at",
+                "idx_write_commits_operation_id",
+                "trg_write_commits_immutable_update",
+                "trg_write_commits_immutable_delete",
+            ),
+        ).fetchall()
+    }
+    return object_names == {
+        "idx_write_commits_committed_at",
+        "idx_write_commits_operation_id",
+        "trg_write_commits_immutable_update",
+        "trg_write_commits_immutable_delete",
+    }
+
+
+def _table_exists(conn: sqlite3.Connection) -> bool:
+    return conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='write_commits'"
+    ).fetchone() is not None
+
+
+def _has_unique_index(conn: sqlite3.Connection, columns: tuple[str, ...]) -> bool:
+    for index in conn.execute("PRAGMA index_list(write_commits)").fetchall():
+        if not index[2]:
+            continue
+        index_columns = tuple(
+            row[2] for row in conn.execute(f"PRAGMA index_info({index[1]})").fetchall()
+        )
+        if index_columns == columns:
+            return True
+    return False
+
+
+def _create_current_schema(conn: sqlite3.Connection) -> None:
+    conn.execute(_CREATE_TABLE)
+    conn.execute(_CREATE_COMMITTED_AT_INDEX)
+    conn.execute(_CREATE_OPERATION_ID_INDEX)
+    conn.execute(_CREATE_UPDATE_TRIGGER)
+    conn.execute(_CREATE_DELETE_TRIGGER)
+
+
+def _rebuild_legacy_schema(conn: sqlite3.Connection) -> None:
+    """Rebuild only M032's own standalone table under one savepoint."""
+    conn.execute("SAVEPOINT m032_profile_scoped_idempotency")
+    try:
+        conn.execute("DROP TRIGGER IF EXISTS trg_write_commits_immutable_update")
+        conn.execute("DROP TRIGGER IF EXISTS trg_write_commits_immutable_delete")
+        conn.execute("ALTER TABLE write_commits RENAME TO write_commits_legacy")
+        conn.execute("DROP INDEX IF EXISTS idx_write_commits_committed_at")
+        conn.execute("DROP INDEX IF EXISTS idx_write_commits_operation_id")
+        _create_current_schema(conn)
+        conn.execute(
+            "INSERT INTO write_commits("
+            "commit_sequence, command_id, journal_id, command_kind, request_hash, "
+            "profile_id, idempotency_key, operation_id, receipt_json, committed_at"
+            ") SELECT commit_sequence, command_id, journal_id, command_kind, request_hash, "
+            "profile_id, idempotency_key, operation_id, receipt_json, committed_at "
+            "FROM write_commits_legacy"
+        )
+        conn.execute("DROP TABLE write_commits_legacy")
+    except BaseException:
+        conn.execute("ROLLBACK TO m032_profile_scoped_idempotency")
+        conn.execute("RELEASE m032_profile_scoped_idempotency")
+        raise
+    conn.execute("RELEASE m032_profile_scoped_idempotency")

package/src/superlocalmemory/storage/read_connection.py

@@ -0,0 +1,115 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com
+
+"""Physically read-only SQLite snapshots for canonical ``memory.db``.
+
+The factory is deliberately small: a query path must receive a connection
+which SQLite itself refuses to mutate.  This is the storage half of the
+Command-Query Separation contract; higher layers must not use it to perform
+telemetry, access tracking, or any other side effect.
+"""
+from __future__ import annotations
+
+import sqlite3
+from contextlib import AbstractContextManager, contextmanager
+from pathlib import Path
+from typing import Iterator
+
+
+class ReadConnectionError(RuntimeError):
+    """Raised when a read snapshot cannot be opened safely."""
+
+
+class ReadConnectionFactory:
+    """Open short-lived query-only snapshots of one canonical database path."""
+
+    def __init__(self, memory_db: str | Path, timeout_ms: int = 250) -> None:
+        if timeout_ms < 0:
+            raise ValueError("timeout_ms must be greater than or equal to zero")
+        self._memory_db = Path(memory_db).expanduser().resolve()
+        self._timeout_ms = timeout_ms
+
+    @property
+    def memory_db(self) -> Path:
+        """Return the resolved canonical database path."""
+        return self._memory_db
+
+    @contextmanager
+    def snapshot(self) -> Iterator[sqlite3.Connection]:
+        """Yield a SQLite connection that cannot issue a write statement.
+
+        ``immutable=1`` is intentionally not used: a live WAL database may
+        have valid state in its WAL file.  ``mode=ro`` retains normal WAL
+        visibility while prohibiting a writable open, and ``query_only`` is a
+        second SQLite-enforced guard against accidental DML or DDL.
+        """
+        if not self._memory_db.exists():
+            raise ReadConnectionError(f"canonical database does not exist: {self._memory_db}")
+
+        uri = f"{self._memory_db.as_uri()}?mode=ro"
+        try:
+            conn = sqlite3.connect(
+                uri,
+                uri=True,
+                timeout=self._timeout_ms / 1000.0,
+            )
+        except sqlite3.Error as exc:
+            raise ReadConnectionError(
+                f"could not open read-only snapshot for {self._memory_db}"
+            ) from exc
+
+        try:
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA query_only=ON")
+            conn.execute("PRAGMA foreign_keys=ON")
+            conn.execute(f"PRAGMA busy_timeout={self._timeout_ms}")
+            yield conn
+        finally:
+            conn.close()
+
+    def open(self) -> "ReadConnectionLease":
+        """Return a manually-closeable read-only lease for legacy query code.
+
+        New code should use :meth:`snapshot`; the lease is a small compatibility
+        bridge for client paths that still use ``try/finally: conn.close()``.
+        Closing it exits this same context manager, preserving both ``mode=ro``
+        and ``PRAGMA query_only`` rather than reopening SQLite directly.
+        """
+        return ReadConnectionLease(self.snapshot())
+
+
+class ReadConnectionLease:
+    """A legacy-compatible facade around one read-only snapshot."""
+
+    def __init__(self, snapshot: AbstractContextManager[sqlite3.Connection]) -> None:
+        object.__setattr__(self, "_snapshot", snapshot)
+        object.__setattr__(self, "_connection", snapshot.__enter__())
+        object.__setattr__(self, "_closed", False)
+
+    def __getattr__(self, name: str):
+        return getattr(self._connection, name)
+
+    def __setattr__(self, name: str, value: object) -> None:
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._connection, name, value)
+
+    def __enter__(self) -> sqlite3.Connection:
+        return self._connection
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        self._close(exc_type, exc, traceback)
+
+    def close(self) -> None:
+        """Close this lease once, including its context-manager cleanup."""
+        self._close(None, None, None)
+
+    def _close(self, exc_type, exc, traceback) -> None:
+        if not self._closed:
+            object.__setattr__(self, "_closed", True)
+            self._snapshot.__exit__(exc_type, exc, traceback)
+
+
+__all__ = ["ReadConnectionError", "ReadConnectionFactory", "ReadConnectionLease"]