nl2data-semantic-catalog-postgres 0.1.0__py3-none-any.whl

nl2data_semantic_catalog_postgres/fake_postgres/handlers_snapshots.py

@@ -0,0 +1,197 @@
+"""Snapshot, snapshot-pointer, and proposal-set statement handlers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .driver import _as_dt
+from .keys import _lock_or_fail, _pointer_key, _proposal_key, _snap_key
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_upsert_snapshot(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, fingerprint = params[0], params[1]
+    key = _snap_key(namespace, fingerprint)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.snapshots.get((namespace, fingerprint))
+    conn._touch(key)
+    if row is None:
+        pool.snapshots[(namespace, fingerprint)] = {
+            "scope_namespace": namespace,
+            "snapshot_fingerprint": fingerprint,
+            "source_id": params[2],
+            "state": params[3],
+            "schema_version": params[4],
+            "envelope": params[5],
+            "discovered_at": _as_dt(params[6]),
+            "retained_until": _as_dt(params[7]),
+            "activated_at": None,
+            "created_at": _as_dt(params[8]),
+        }
+    else:
+        # Mirrors ON CONFLICT DO UPDATE: state/created_at are preserved.
+        row.update(
+            source_id=params[2],
+            schema_version=params[4],
+            envelope=params[5],
+            discovered_at=_as_dt(params[6]),
+            retained_until=_as_dt(params[7]),
+        )
+    return ([], 1)
+
+
+def _h_read_snapshot_envelope(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.snapshots.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    return (
+        [
+            {
+                "envelope": row["envelope"],
+                "schema_version": row["schema_version"],
+                "discovered_at": row["discovered_at"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_lock_snapshot_row(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.snapshots.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    _lock_or_fail(pool, conn, _snap_key(params[0], params[1]), timeout)
+    return (
+        [
+            {
+                "source_id": row["source_id"],
+                "state": row["state"],
+                "retained_until": row["retained_until"],
+                "discovered_at": row["discovered_at"],
+                "envelope": row["envelope"],
+                "schema_version": row["schema_version"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_set_snapshot_state(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, fingerprint = params[2], params[3]
+    key = _snap_key(namespace, fingerprint)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.snapshots.get((namespace, fingerprint))
+    if row is None:
+        return ([], 0)
+    conn._touch(key)
+    row.update(state=params[0], activated_at=_as_dt(params[1]))
+    return ([], 1)
+
+
+def _h_snapshot_exists(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    if (params[0], params[1]) in pool.snapshots:
+        return ([{"exists": True}], 0)
+    return ([], 0)
+
+
+def _h_upsert_snapshot_pointer(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, source_id = params[0], params[1]
+    key = _pointer_key(namespace, source_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.snapshot_pointers.get((namespace, source_id))
+    conn._touch(key)
+    if row is None:
+        pool.snapshot_pointers[(namespace, source_id)] = {
+            "scope_namespace": namespace,
+            "source_id": source_id,
+            "snapshot_fingerprint": params[2],
+            "schema_version": params[3],
+            "activated_at": _as_dt(params[4]),
+        }
+    else:
+        row.update(
+            snapshot_fingerprint=params[2],
+            schema_version=params[3],
+            activated_at=_as_dt(params[4]),
+        )
+    return ([], 1)
+
+
+def _h_read_snapshot_pointer(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.snapshot_pointers.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    return (
+        [
+            {
+                "snapshot_fingerprint": row["snapshot_fingerprint"],
+                "schema_version": row["schema_version"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_list_snapshot_pointers(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    rows = [
+        {
+            "scope_namespace": namespace,
+            "source_id": source_id,
+            "snapshot_fingerprint": row["snapshot_fingerprint"],
+        }
+        for (namespace, source_id), row in sorted(pool.snapshot_pointers.items())
+    ]
+    return (rows, len(rows))
+
+
+def _h_upsert_proposal_set(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, fingerprint = params[0], params[1]
+    key = _proposal_key(namespace, fingerprint)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.proposal_sets.get((namespace, fingerprint))
+    conn._touch(key)
+    if row is None:
+        pool.proposal_sets[(namespace, fingerprint)] = {
+            "scope_namespace": namespace,
+            "snapshot_fingerprint": fingerprint,
+            "schema_version": params[2],
+            "envelope": params[3],
+            "saved_at": _as_dt(params[4]),
+        }
+    else:
+        row.update(
+            schema_version=params[2],
+            envelope=params[3],
+            saved_at=_as_dt(params[4]),
+        )
+    return ([], 1)
+
+
+def _h_read_proposal_set(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.proposal_sets.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    return ([{"envelope": row["envelope"], "schema_version": row["schema_version"]}], 0)

nl2data_semantic_catalog_postgres/fake_postgres/handlers_versions.py

@@ -0,0 +1,330 @@
+"""Published-version, supersession, pointer, and history statement handlers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .driver import UniqueViolation, _as_dt
+from .keys import (
+    _bundle_pointer_key,
+    _history_key,
+    _lock_or_fail,
+    _supersession_key,
+    _version_key,
+)
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_read_latest_version(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params
+    candidates = [
+        row
+        for (scope, candidate_id, _fingerprint), row in pool.published_versions.items()
+        if scope == namespace and candidate_id == bundle_id
+    ]
+    if not candidates:
+        return ([], 0)
+    row = max(candidates, key=lambda item: (item["published_at"], item["model_version"]))
+    _lock_or_fail(
+        pool,
+        conn,
+        _version_key(namespace, bundle_id, row["bundle_fingerprint"]),
+        timeout,
+    )
+    return ([{
+        "bundle_fingerprint": row["bundle_fingerprint"],
+        "lifecycle_state": row["lifecycle_state"],
+    }], 0)
+
+
+def _h_insert_published_version(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    key = _version_key(params[0], params[1], params[2])
+    _lock_or_fail(pool, conn, key, timeout)
+    if key[1:] in pool.published_versions or any(
+        scope == params[0]
+        and bundle_id == params[1]
+        and row["model_version"] == params[3]
+        for (scope, bundle_id, _fingerprint), row in pool.published_versions.items()
+    ):
+        raise UniqueViolation("published version already exists")
+    conn._touch(key)
+    pool.published_versions[key[1:]] = {
+        "scope_namespace": params[0],
+        "bundle_id": params[1],
+        "bundle_fingerprint": params[2],
+        "model_version": params[3],
+        "lifecycle_state": params[4],
+        "predecessor_fingerprint": params[5],
+        "successor_fingerprint": params[6],
+        "audit_id": params[7],
+        "published_at": _as_dt(params[8]),
+    }
+    return ([], 1)
+
+
+def _h_update_version_successor(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    successor, namespace, bundle_id, fingerprint = params
+    key = _version_key(namespace, bundle_id, fingerprint)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.published_versions.get(key[1:])
+    if row is None:
+        return ([], 0)
+    conn._touch(key)
+    row["successor_fingerprint"] = successor
+    if row["lifecycle_state"] != "active":
+        row["lifecycle_state"] = "superseded"
+    return ([], 1)
+
+
+def _h_insert_supersession_edge(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    key = _supersession_key(params[0], params[1], params[3])
+    _lock_or_fail(pool, conn, key, timeout)
+    if key[1:] in pool.supersession_edges:
+        raise UniqueViolation("supersession edge already exists")
+    conn._touch(key)
+    pool.supersession_edges[key[1:]] = {
+        "scope_namespace": params[0],
+        "bundle_id": params[1],
+        "predecessor_fingerprint": params[2],
+        "successor_fingerprint": params[3],
+        "created_at": _as_dt(params[4]),
+    }
+    return ([], 1)
+
+
+def _h_read_published_version(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.published_versions.get(params)
+    if row is None:
+        return ([], 0)
+    return ([dict(row)], 0)
+
+
+def _h_list_published_versions(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params
+    rows = [
+        dict(row)
+        for (scope, candidate_id, _fingerprint), row in pool.published_versions.items()
+        if scope == namespace and candidate_id == bundle_id
+    ]
+    rows.sort(key=lambda row: (row["published_at"], row["model_version"]))
+    return (rows, len(rows))
+
+
+def _h_set_published_version_state(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    state, namespace, bundle_id, fingerprint = params
+    key = _version_key(namespace, bundle_id, fingerprint)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.published_versions.get(key[1:])
+    if row is None:
+        return ([], 0)
+    conn._touch(key)
+    row["lifecycle_state"] = state
+    return ([], 1)
+
+
+def _h_upsert_bundle_pointer(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params[0], params[1]
+    key = _bundle_pointer_key(namespace, bundle_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.bundle_pointers.get((namespace, bundle_id))
+    conn._touch(key)
+    if row is None:
+        pool.bundle_pointers[(namespace, bundle_id)] = {
+            "scope_namespace": namespace,
+            "bundle_id": bundle_id,
+            "model_version": params[2],
+            "bundle_fingerprint": params[3],
+            "schema_version": params[4],
+            "activated_at": _as_dt(params[5]),
+            "activation_sequence": params[6],
+        }
+    else:
+        row.update(
+            model_version=params[2],
+            bundle_fingerprint=params[3],
+            schema_version=params[4],
+            activated_at=_as_dt(params[5]),
+            activation_sequence=params[6],
+        )
+    return ([], 1)
+
+
+def _h_read_bundle_pointer(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.bundle_pointers.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    return (
+        [
+            {
+                "model_version": row["model_version"],
+                "bundle_fingerprint": row["bundle_fingerprint"],
+                "schema_version": row["schema_version"],
+                "activation_sequence": row["activation_sequence"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_lock_bundle_pointer(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.bundle_pointers.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    _lock_or_fail(pool, conn, _bundle_pointer_key(params[0], params[1]), timeout)
+    return (
+        [
+            {
+                "model_version": row["model_version"],
+                "bundle_fingerprint": row["bundle_fingerprint"],
+                "schema_version": row["schema_version"],
+                "activation_sequence": row["activation_sequence"],
+                "activated_at": row["activated_at"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_next_history_position(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    history = pool.bundle_history.get((params[0], params[1]), {})
+    next_position = (max(history) if history else 0) + 1
+    return ([{"next_position": next_position}], 0)
+
+
+def _h_insert_history(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params[0], params[1]
+    key = _history_key(namespace, bundle_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    conn._touch(key)
+    history = pool.bundle_history.setdefault((namespace, bundle_id), {})
+    history[params[2]] = {
+        "scope_namespace": namespace,
+        "bundle_id": bundle_id,
+        "position": params[2],
+        "model_version": params[3],
+        "bundle_fingerprint": params[4],
+        "schema_version": params[5],
+        "activated_at": _as_dt(params[6]),
+        "deactivated_at": _as_dt(params[7]),
+    }
+    return ([], 1)
+
+
+def _h_read_history_top(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    history = pool.bundle_history.get((params[0], params[1]), {})
+    if not history:
+        return ([], 0)
+    position = max(history)
+    row = history[position]
+    return (
+        [
+            {
+                "position": row["position"],
+                "model_version": row["model_version"],
+                "bundle_fingerprint": row["bundle_fingerprint"],
+                "schema_version": row["schema_version"],
+                "activated_at": row["activated_at"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_delete_history_top(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id, position = params[0], params[1], params[2]
+    key = _history_key(namespace, bundle_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    history = pool.bundle_history.get((namespace, bundle_id))
+    if history is None or position not in history:
+        return ([], 0)
+    conn._touch(key)
+    del history[position]
+    if not history:
+        del pool.bundle_history[(namespace, bundle_id)]
+    return ([], 1)
+
+
+def _h_trim_history(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params[0], params[1]
+    trim_below = params[2]
+    key = _history_key(namespace, bundle_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    history = pool.bundle_history.get((namespace, bundle_id))
+    if not history:
+        return ([], 0)
+    conn._touch(key)
+    removed = sum(
+        1 for position in list(history) if position < trim_below
+    )
+    for position in list(history):
+        if position < trim_below:
+            del history[position]
+    if not history:
+        del pool.bundle_history[(namespace, bundle_id)]
+    return ([], removed)
+
+
+def _h_list_bundle_pointers(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    rows = [
+        {
+            "scope_namespace": namespace,
+            "bundle_id": bundle_id,
+            "model_version": row["model_version"],
+            "bundle_fingerprint": row["bundle_fingerprint"],
+        }
+        for (namespace, bundle_id), row in sorted(pool.bundle_pointers.items())
+    ]
+    return (rows, len(rows))
+
+
+def _h_list_orphan_active_versions(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    rows = [
+        {
+            "scope_namespace": scope,
+            "bundle_id": bundle_id,
+            "model_version": row["model_version"],
+        }
+        for (scope, bundle_id, _fingerprint), row in sorted(
+            pool.published_versions.items()
+        )
+        if row["lifecycle_state"] == "active"
+        and (scope, bundle_id) not in pool.bundle_pointers
+    ]
+    return (rows, len(rows))

nl2data_semantic_catalog_postgres/fake_postgres/keys.py

@@ -0,0 +1,99 @@
+"""Fake-pool table registry, row-key construction, and lock helpers.
+
+Tables are keyed by ``(namespace, fingerprint)`` / ``(namespace, id)``
+tuples (three-part keys for publications) so tenant-scoped and unscoped
+records stay isolated exactly as the real schema enforces.  Handlers lock
+a key slot before checking existence so concurrent writers serialize like
+the real unique indexes.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _snap_key(namespace: str, fingerprint: str) -> tuple[Any, ...]:
+    return ("snapshots", namespace, fingerprint)
+
+
+def _pointer_key(namespace: str, source_id: str) -> tuple[Any, ...]:
+    return ("snapshot_pointers", namespace, source_id)
+
+
+def _proposal_key(namespace: str, fingerprint: str) -> tuple[Any, ...]:
+    return ("proposal_sets", namespace, fingerprint)
+
+
+def _draft_key(namespace: str, draft_id: str) -> tuple[Any, ...]:
+    return ("assembly_drafts", namespace, draft_id)
+
+
+def _publication_key(
+    namespace: str, bundle_id: str, version: str
+) -> tuple[Any, ...]:
+    return ("publications", namespace, bundle_id, version)
+
+
+def _manifest_key(
+    namespace: str, bundle_id: str, fingerprint: str
+) -> tuple[Any, ...]:
+    return ("accepted_manifests", namespace, bundle_id, fingerprint)
+
+
+def _verification_evidence_key(
+    namespace: str, bundle_id: str, fingerprint: str
+) -> tuple[Any, ...]:
+    return ("verification_evidence", namespace, bundle_id, fingerprint)
+
+
+def _audit_key(
+    namespace: str, bundle_id: str, fingerprint: str
+) -> tuple[Any, ...]:
+    return ("publish_audits", namespace, bundle_id, fingerprint)
+
+
+def _version_key(
+    namespace: str, bundle_id: str, fingerprint: str
+) -> tuple[Any, ...]:
+    return ("published_versions", namespace, bundle_id, fingerprint)
+
+
+def _supersession_key(
+    namespace: str, bundle_id: str, successor: str
+) -> tuple[Any, ...]:
+    return ("supersession_edges", namespace, bundle_id, successor)
+
+
+def _bundle_pointer_key(namespace: str, bundle_id: str) -> tuple[Any, ...]:
+    return ("bundle_pointers", namespace, bundle_id)
+
+
+def _history_key(namespace: str, bundle_id: str) -> tuple[Any, ...]:
+    return ("bundle_history", namespace, bundle_id)
+
+
+def _event_key(namespace: str, event_id: str) -> tuple[Any, ...]:
+    return ("events", namespace, event_id)
+
+
+def _publication_audit_evidence_key(
+    namespace: str, bundle_id: str, fingerprint: str
+) -> tuple[Any, ...]:
+    return ("publication_audit_evidence", namespace, bundle_id, fingerprint)
+
+
+def _audit_entry_key(namespace: str, event_id: str) -> tuple[Any, ...]:
+    return ("audit_entries", namespace, event_id)
+
+
+def _lock_or_fail(
+    pool: FakePostgresPool,
+    connection: _FakeConnection,
+    key: tuple[Any, ...],
+    timeout: float,
+) -> None:
+    pool._lock(connection, key, timeout)