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

nl2data_semantic_catalog_postgres/fake_postgres/handlers_drafts.py

@@ -0,0 +1,84 @@
+"""Assembly-draft statement handlers for the fake pool."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .driver import _as_dt
+from .keys import _draft_key, _lock_or_fail
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_insert_assembly_draft(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, draft_id = params[0], params[1]
+    key = _draft_key(namespace, draft_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    if (namespace, draft_id) in pool.assembly_drafts:
+        return ([], 0)
+    conn._touch(key)
+    pool.assembly_drafts[(namespace, draft_id)] = {
+        "scope_namespace": namespace,
+        "draft_id": draft_id,
+        "bundle_id": params[2],
+        "source_id": params[3],
+        "draft_revision": params[4],
+        "state": params[5],
+        "schema_version": params[6],
+        "envelope": params[7],
+        "updated_at": _as_dt(params[8]),
+    }
+    return ([], 1)
+
+
+def _h_read_assembly_draft(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.assembly_drafts.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    return ([{
+        "envelope": row["envelope"],
+        "schema_version": row["schema_version"],
+        "draft_revision": row["draft_revision"],
+    }], 0)
+
+
+def _h_lock_assembly_draft(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.assembly_drafts.get((params[0], params[1]))
+    if row is None:
+        return ([], 0)
+    _lock_or_fail(pool, conn, _draft_key(params[0], params[1]), timeout)
+    return ([{
+        "envelope": row["envelope"],
+        "schema_version": row["schema_version"],
+        "draft_revision": row["draft_revision"],
+    }], 0)
+
+
+def _h_replace_assembly_draft(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, draft_id, expected_revision = params[7], params[8], params[9]
+    key = _draft_key(namespace, draft_id)
+    _lock_or_fail(pool, conn, key, timeout)
+    row = pool.assembly_drafts.get((namespace, draft_id))
+    if row is None or row["draft_revision"] != expected_revision:
+        return ([], 0)
+    conn._touch(key)
+    row.update(
+        bundle_id=params[0],
+        source_id=params[1],
+        draft_revision=params[2],
+        state=params[3],
+        schema_version=params[4],
+        envelope=params[5],
+        updated_at=_as_dt(params[6]),
+    )
+    return ([], 1)

nl2data_semantic_catalog_postgres/fake_postgres/handlers_maintenance.py

@@ -0,0 +1,263 @@
+"""Lifecycle-event and retention-cleanup statement handlers.
+
+The cleanup handlers mirror the real SQL's protection semantics: active
+pointer targets, history entries, and required dependencies are never
+removed, and removal happens in bounded ordered batches.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from .driver import _as_dt
+from .keys import (
+    _audit_entry_key,
+    _event_key,
+    _lock_or_fail,
+    _publication_key,
+    _snap_key,
+)
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_insert_event(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, event_id = params[0], params[1]
+    key = _event_key(namespace, event_id)
+    # Lock the key slot before checking existence so concurrent inserts of
+    # the same event serialize like the real unique index (second one no-ops).
+    _lock_or_fail(pool, conn, key, timeout)
+    if (namespace, event_id) in pool.events:
+        return ([], 0)
+    conn._touch(key)
+    pool.events[(namespace, event_id)] = {
+        "scope_namespace": namespace,
+        "event_id": event_id,
+        "kind": params[2],
+        "member_id": params[3],
+        "schema_version": params[4],
+        "payload": params[5],
+        "occurred_at": _as_dt(params[6]),
+    }
+    return ([], 1)
+
+
+def _active_bundle_fingerprints(
+    pool: FakePostgresPool, active: set[tuple[str, str, str]]
+) -> set[str]:
+    """Catalog/snapshot fingerprints referenced by active bundle envelopes.
+
+    Mirrors the SQL ``referenced_catalog_fingerprints`` CTE: descriptor
+    catalog fingerprints, source catalog fingerprints, and compatibility
+    fingerprints of publications currently selected by a bundle pointer.
+    """
+    referenced: set[str] = set()
+    for row in pool.publications.values():
+        if (
+            row["scope_namespace"], row["bundle_id"], row["model_version"]
+        ) not in active:
+            continue
+        try:
+            envelope = json.loads(row["envelope"])
+        except ValueError as error:
+            raise ValueError(
+                "invalid envelope json in bundle_publications"
+            ) from error
+        if envelope.get("kind") != "bundle":
+            continue
+        payload = envelope.get("payload") or {}
+        descriptor = payload.get("descriptor") or {}
+        fingerprint = descriptor.get("catalog_fingerprint")
+        if fingerprint:
+            referenced.add(fingerprint)
+        for source in payload.get("sources") or []:
+            fingerprint = source.get("catalog_fingerprint")
+            if fingerprint:
+                referenced.add(fingerprint)
+        compatibility = payload.get("compatibility") or {}
+        referenced.update(
+            compatibility.get("compatible_catalog_fingerprints") or []
+        )
+    return referenced
+
+
+def _snapshot_required_by(row: dict[str, Any], referenced: set[str]) -> bool:
+    """True when an active bundle references this snapshot row.
+
+    Bundles reference a snapshot either by the snapshot's own fingerprint
+    (``descriptor.catalog_fingerprint``) or by the source catalog
+    fingerprint the snapshot documents (``payload.source.catalog_fingerprint``).
+    A row without a source catalog fingerprint is conservatively retained,
+    mirroring the SQL ``NOT IN`` semantics that never match NULL.
+    """
+    try:
+        envelope = json.loads(row["envelope"])
+    except ValueError as error:
+        raise ValueError(
+            "invalid envelope json in metadata_snapshots"
+        ) from error
+    source = (envelope.get("payload") or {}).get("source") or {}
+    fingerprint = source.get("catalog_fingerprint")
+    return fingerprint is None or fingerprint in referenced
+
+
+def _h_delete_expired_snapshots(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    current = _as_dt(params[0])
+    limit = int(params[1])
+    pointed = {
+        row["snapshot_fingerprint"] for row in pool.snapshot_pointers.values()
+    }
+    active = {
+        (row["scope_namespace"], row["bundle_id"], row["model_version"])
+        for row in pool.bundle_pointers.values()
+    }
+    referenced = _active_bundle_fingerprints(pool, active)
+    candidates = [
+        ((row["retained_until"], fingerprint), (namespace, fingerprint))
+        for (namespace, fingerprint), row in pool.snapshots.items()
+        if row["retained_until"] is not None
+        and row["retained_until"] < current
+        and fingerprint not in pointed
+        and fingerprint not in referenced
+        and not _snapshot_required_by(row, referenced)
+    ]
+    removed = 0
+    for _, key in sorted(candidates)[:limit]:
+        _lock_or_fail(pool, conn, _snap_key(*key), timeout)
+        row = pool.snapshots.get(key)
+        if row is None:
+            continue
+        conn._touch(_snap_key(*key))
+        del pool.snapshots[key]
+        removed += 1
+    return ([], removed)
+
+
+def _h_delete_expired_publications(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    current = _as_dt(params[0])
+    limit = int(params[1])
+    protected = {
+        (row["scope_namespace"], row["bundle_id"], row["model_version"])
+        for row in pool.bundle_pointers.values()
+    } | {
+        (row["scope_namespace"], row["bundle_id"], row["model_version"])
+        for history in pool.bundle_history.values()
+        for row in history.values()
+    }
+    for pub_row in pool.publications.values():
+        try:
+            envelope = json.loads(pub_row["envelope"])
+        except ValueError as error:
+            raise ValueError(
+                "invalid envelope json in bundle_publications"
+            ) from error
+        if envelope.get("kind") != "bundle":
+            continue
+        for dependency in (envelope.get("payload") or {}).get(
+            "dependencies"
+        ) or []:
+            protected.add(
+                (
+                    pub_row["scope_namespace"],
+                    dependency.get("bundle_id"),
+                    dependency.get("version"),
+                )
+            )
+    candidates = [
+        (
+            (row["published_at"], bundle_id, version),
+            (namespace, bundle_id, version),
+        )
+        for (namespace, bundle_id, version), row in pool.publications.items()
+        if row["published_at"] < current
+        and (namespace, bundle_id, version) not in protected
+    ]
+    removed = 0
+    for _, key in sorted(candidates)[:limit]:
+        _lock_or_fail(pool, conn, _publication_key(*key), timeout)
+        row = pool.publications.get(key)
+        if row is None:
+            continue
+        conn._touch(_publication_key(*key))
+        del pool.publications[key]
+        removed += 1
+    return ([], removed)
+
+
+def _h_delete_expired_events(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    cutoff = _as_dt(params[0])
+    limit = int(params[1])
+    candidates = [
+        ((row["occurred_at"], event_id), (namespace, event_id))
+        for (namespace, event_id), row in pool.events.items()
+        if row["occurred_at"] < cutoff
+    ]
+    removed = 0
+    for _, key in sorted(candidates)[:limit]:
+        _lock_or_fail(pool, conn, _event_key(*key), timeout)
+        row = pool.events.get(key)
+        if row is None:
+            continue
+        conn._touch(_event_key(*key))
+        del pool.events[key]
+        removed += 1
+    return ([], removed)
+
+
+def _non_retired_audit_fingerprints(pool: FakePostgresPool) -> set[tuple[str, str]]:
+    """(namespace, fingerprint) pairs of non-retired published versions."""
+    return {
+        (row["scope_namespace"], row["bundle_fingerprint"])
+        for row in pool.published_versions.values()
+        if row["lifecycle_state"] != "retired"
+    }
+
+
+def _predecessors_of_protected(
+    pool: FakePostgresPool, protected: set[tuple[str, str]]
+) -> set[str]:
+    """Event ids referenced as predecessors by protected audit entries."""
+    ids: set[str] = set()
+    for (namespace, _event_id), row in pool.audit_entries.items():
+        if (namespace, row["bundle_fingerprint"]) not in protected:
+            continue
+        envelope = json.loads(row["envelope"])
+        ids.update((envelope.get("payload") or {}).get("predecessor_event_ids") or [])
+    return ids
+
+
+def _h_delete_expired_audit_entries(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    cutoff = _as_dt(params[0])
+    limit = int(params[1])
+    protected = _non_retired_audit_fingerprints(pool)
+    protected_ids = _predecessors_of_protected(pool, protected)
+    candidates = [
+        ((row["occurred_at"], event_id), (namespace, event_id))
+        for (namespace, event_id), row in pool.audit_entries.items()
+        if row["occurred_at"] < cutoff
+        and (namespace, row["bundle_fingerprint"]) not in protected
+        and event_id not in protected_ids
+    ]
+    removed = 0
+    for _, key in sorted(candidates)[:limit]:
+        _lock_or_fail(pool, conn, _audit_entry_key(*key), timeout)
+        row = pool.audit_entries.get(key)
+        if row is None:
+            continue
+        conn._touch(_audit_entry_key(*key))
+        del pool.audit_entries[key]
+        removed += 1
+    return ([], removed)

nl2data_semantic_catalog_postgres/fake_postgres/handlers_publications.py

@@ -0,0 +1,249 @@
+"""Publication, accepted-manifest, evidence, and audit statement handlers.
+
+Writers lock the key slot before checking existence so concurrent writers
+serialize like the real unique indexes (the second one no-ops or raises
+``UniqueViolation`` exactly where the real constraint would).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .driver import UniqueViolation, _as_dt
+from .keys import (
+    _audit_key,
+    _lock_or_fail,
+    _manifest_key,
+    _publication_key,
+    _verification_evidence_key,
+)
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_lock_publication_series(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    _lock_or_fail(pool, conn, ("publication_series", params[0], params[1]), timeout)
+    return ([{"pg_advisory_xact_lock": None}], 0)
+
+
+def _h_insert_publication(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id, version = params[0], params[1], params[2]
+    key = _publication_key(namespace, bundle_id, version)
+    # Lock the key slot before checking existence so concurrent publishes of
+    # the same version serialize like the real unique index (second one no-ops).
+    _lock_or_fail(pool, conn, key, timeout)
+    if (namespace, bundle_id, version) in pool.publications:
+        return ([], 0)
+    conn._touch(key)
+    pool.publications[(namespace, bundle_id, version)] = {
+        "scope_namespace": namespace,
+        "bundle_id": bundle_id,
+        "model_version": version,
+        "bundle_fingerprint": params[3],
+        "schema_version": params[4],
+        "envelope": params[5],
+        "published_at": _as_dt(params[6]),
+    }
+    return ([], 1)
+
+
+def _h_read_publication(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.publications.get((params[0], params[1], params[2]))
+    if row is None:
+        return ([], 0)
+    return (
+        [
+            {
+                "envelope": row["envelope"],
+                "schema_version": row["schema_version"],
+                "published_at": row["published_at"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_read_publication_fingerprint(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.publications.get((params[0], params[1], params[2]))
+    if row is None:
+        return ([], 0)
+    return ([{"bundle_fingerprint": row["bundle_fingerprint"]}], 0)
+
+
+def _h_read_publication_by_fingerprint(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id, fingerprint = params
+    for (scope, candidate_id, _version), row in pool.publications.items():
+        if (
+            scope == namespace
+            and candidate_id == bundle_id
+            and row["bundle_fingerprint"] == fingerprint
+        ):
+            return ([{
+                "envelope": row["envelope"],
+                "schema_version": row["schema_version"],
+                "published_at": row["published_at"],
+                "model_version": row["model_version"],
+            }], 0)
+    return ([], 0)
+
+
+def _h_list_publications(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, bundle_id = params[0], params[1]
+    items = [
+        (
+            row["published_at"],
+            row["model_version"],
+            row["schema_version"],
+            row["envelope"],
+        )
+        for (ns, bid, _version), row in pool.publications.items()
+        if ns == namespace and bid == bundle_id
+    ]
+    items.sort()  # ORDER BY published_at, model_version
+    rows = [
+        {
+            "envelope": envelope,
+            "model_version": model_version,
+            "schema_version": schema_version,
+        }
+        for _published_at, model_version, schema_version, envelope in items
+    ]
+    return (rows, len(rows))
+
+
+def _h_insert_accepted_manifest(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    key = _manifest_key(params[0], params[1], params[2])
+    _lock_or_fail(pool, conn, key, timeout)
+    if key[1:] in pool.accepted_manifests:
+        raise UniqueViolation("accepted manifest already exists")
+    conn._touch(key)
+    pool.accepted_manifests[key[1:]] = {
+        "scope_namespace": params[0],
+        "bundle_id": params[1],
+        "bundle_fingerprint": params[2],
+        "schema_version": params[3],
+        "envelope": params[4],
+        "created_at": _as_dt(params[5]),
+    }
+    return ([], 1)
+
+
+def _h_read_accepted_manifest(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.accepted_manifests.get(params)
+    if row is None:
+        return ([], 0)
+    return ([{"envelope": row["envelope"], "schema_version": row["schema_version"]}], 0)
+
+
+def _h_insert_verification_evidence(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    key = _verification_evidence_key(params[0], params[1], params[2])
+    _lock_or_fail(pool, conn, key, timeout)
+    if key[1:] in pool.verification_evidence:
+        raise UniqueViolation("verification evidence already exists")
+    if any(
+        row["scope_namespace"] == params[0]
+        and row["evidence_fingerprint"] == params[3]
+        for row in pool.verification_evidence.values()
+    ):
+        raise UniqueViolation("verification evidence fingerprint already exists")
+    conn._touch(key)
+    pool.verification_evidence[key[1:]] = {
+        "scope_namespace": params[0],
+        "bundle_id": params[1],
+        "bundle_fingerprint": params[2],
+        "evidence_fingerprint": params[3],
+        "schema_version": params[4],
+        "envelope": params[5],
+        "created_at": _as_dt(params[6]),
+    }
+    return ([], 1)
+
+
+def _h_read_verification_evidence(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.verification_evidence.get(params)
+    if row is None:
+        return ([], 0)
+    return (
+        [
+            {
+                "evidence_fingerprint": row["evidence_fingerprint"],
+                "envelope": row["envelope"],
+                "schema_version": row["schema_version"],
+            }
+        ],
+        0,
+    )
+
+
+def _h_insert_publish_audit(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    key = _audit_key(params[0], params[1], params[2])
+    _lock_or_fail(pool, conn, key, timeout)
+    if key[1:] in pool.publish_audits:
+        raise UniqueViolation("publish audit already exists")
+    if params[4] is not None and any(
+        row["scope_namespace"] == params[0]
+        and row["idempotency_key"] == params[4]
+        for row in pool.publish_audits.values()
+    ):
+        raise UniqueViolation("idempotency key already exists")
+    conn._touch(key)
+    pool.publish_audits[key[1:]] = {
+        "scope_namespace": params[0],
+        "bundle_id": params[1],
+        "bundle_fingerprint": params[2],
+        "audit_id": params[3],
+        "idempotency_key": params[4],
+        "schema_version": params[5],
+        "envelope": params[6],
+        "created_at": _as_dt(params[7]),
+    }
+    return ([], 1)
+
+
+def _h_read_publish_audit(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    row = pool.publish_audits.get(params)
+    if row is None:
+        return ([], 0)
+    return ([{"envelope": row["envelope"], "schema_version": row["schema_version"]}], 0)
+
+
+def _h_read_publish_by_idempotency_key(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    namespace, idempotency_key = params
+    for row in pool.publish_audits.values():
+        if (
+            row["scope_namespace"] == namespace
+            and row["idempotency_key"] == idempotency_key
+        ):
+            return ([{
+                "bundle_id": row["bundle_id"],
+                "bundle_fingerprint": row["bundle_fingerprint"],
+            }], 0)
+    return ([], 0)

nl2data_semantic_catalog_postgres/fake_postgres/handlers_schema.py

@@ -0,0 +1,23 @@
+"""Schema-version statement handlers for the fake pool."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .driver import _FakeConnection
+    from .pool import FakePostgresPool
+
+
+def _h_read_schema_version(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    value = pool.schema_metadata.get("schema_version")
+    return ([{"value": value}] if value is not None else [], 0)
+
+
+def _h_write_schema_version(
+    pool: FakePostgresPool, conn: _FakeConnection, params: tuple[Any, ...], timeout: float
+) -> tuple[list[dict[str, Any]], int]:
+    pool.schema_metadata["schema_version"] = str(params[0])
+    return ([], 1)