aevum-store-postgres 0.2.0__tar.gz → 0.3.0__tar.gz

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/.gitignore

@@ -1,31 +1,31 @@
-# Python
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.venv/
-*.egg-info/
-
-# Build
-dist/
-build/
-
-# Tools
-.mypy_cache/
-.ruff_cache/
-.pytest_cache/
-.hypothesis/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Verify scripts (run locally, never commit)
-verify_phase*.py
-scripts/verify_phase*.py
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+*.egg-info/
+
+# Build
+dist/
+build/
+
+# Tools
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.hypothesis/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Verify scripts (run locally, never commit)
+verify_phase*.py
+scripts/verify_phase*.py

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aevum-store-postgres
-Version: 0.2.0
+Version: 0.3.0
 Summary: Aevum — PostgreSQL GraphStore + ConsentLedger backend (team deployments).
 Project-URL: Homepage, https://aevum.build
 Project-URL: Repository, https://github.com/aevum-labs/aevum

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/README.md

@@ -1,21 +1,21 @@
-# aevum-store-postgres
-
-PostgreSQL-backed graph store for Aevum. Suitable for team deployments with shared state, concurrent writers, and durable persistence.
-
-```bash
-pip install aevum-store-postgres
-```
-
-```python
-import psycopg
-from aevum.core import Engine
-from aevum.store.postgres import PostgresStore
-from aevum.store.postgres.store import initialize_schema
-
-conn = psycopg.connect("postgresql://user:pass@localhost/aevum")
-initialize_schema(conn)
-engine = Engine(graph_store=PostgresStore(conn))
-```
-
-For single-node deployments without PostgreSQL, use `aevum-store-oxigraph` instead.
-See the [main repository README](https://github.com/aevum-labs/aevum) for backend selection guidance.
+# aevum-store-postgres
+
+PostgreSQL-backed graph store for Aevum. Suitable for team deployments with shared state, concurrent writers, and durable persistence.
+
+```bash
+pip install aevum-store-postgres
+```
+
+```python
+import psycopg
+from aevum.core import Engine
+from aevum.store.postgres import PostgresStore
+from aevum.store.postgres.store import initialize_schema
+
+conn = psycopg.connect("postgresql://user:pass@localhost/aevum")
+initialize_schema(conn)
+engine = Engine(graph_store=PostgresStore(conn))
+```
+
+For single-node deployments without PostgreSQL, use `aevum-store-oxigraph` instead.
+See the [main repository README](https://github.com/aevum-labs/aevum) for backend selection guidance.

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/pyproject.toml

@@ -1,60 +1,60 @@
-[project]
-name = "aevum-store-postgres"
-version = "0.2.0"
-description = "Aevum — PostgreSQL GraphStore + ConsentLedger backend (team deployments)."
-readme = "README.md"
-requires-python = ">=3.11"
-license = { text = "Apache-2.0" }
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Typing :: Typed",
-]
-dependencies = [
-    "aevum-core",
-    "psycopg[binary]>=3.1,<4.0",
-]
-
-[project.scripts]
-aevum-store-migrate = "aevum.store.postgres.migrate:main"
-
-[project.urls]
-Homepage = "https://aevum.build"
-Repository = "https://github.com/aevum-labs/aevum"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/aevum"]
-
-[tool.uv.sources]
-aevum-core = { workspace = true }
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-asyncio_mode = "auto"
-addopts = "--tb=short"
-pythonpath = ["src", "tests"]
-
-[tool.mypy]
-strict = true
-python_version = "3.11"
-mypy_path = "src"
-explicit_package_bases = true
-ignore_missing_imports = true
-
-[tool.ruff]
-line-length = 130
-
-[tool.ruff.lint]
-select = ["E", "F", "UP", "B", "SIM", "I", "ANN"]
-ignore = ["ANN401"]
-
-[tool.ruff.lint.per-file-ignores]
-"tests/**" = ["ANN"]
+[project]
+name = "aevum-store-postgres"
+version = "0.3.0"
+description = "Aevum — PostgreSQL GraphStore + ConsentLedger backend (team deployments)."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aevum-core",
+    "psycopg[binary]>=3.1,<4.0",
+]
+
+[project.scripts]
+aevum-store-migrate = "aevum.store.postgres.migrate:main"
+
+[project.urls]
+Homepage = "https://aevum.build"
+Repository = "https://github.com/aevum-labs/aevum"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aevum"]
+
+[tool.uv.sources]
+aevum-core = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+addopts = "--tb=short"
+pythonpath = ["src", "tests"]
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+mypy_path = "src"
+explicit_package_bases = true
+ignore_missing_imports = true
+
+[tool.ruff]
+line-length = 130
+
+[tool.ruff.lint]
+select = ["E", "F", "UP", "B", "SIM", "I", "ANN"]
+ignore = ["ANN401"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["ANN"]

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/src/aevum/store/postgres/__init__.py

@@ -1,30 +1,30 @@
-"""
-aevum.store.postgres -- PostgreSQL backends for graph, consent, and ledger.
-
-Usage:
-    from aevum.store.postgres import PostgresStore, PostgresConsentLedger, PostgresLedger
-    from aevum.store.postgres.ledger import initialize_ledger_schema
-    import psycopg
-
-    conn = psycopg.connect("postgresql://user:pass@host/dbname")
-    initialize_schema(conn)           # graph + consent DDL
-    initialize_ledger_schema(conn)    # ledger DDL
-
-    store = PostgresStore(conn)
-    consent = PostgresConsentLedger(conn)
-    ledger = PostgresLedger(conn, sigchain)
-
-    engine = Engine(
-        graph_store=store,
-        consent_ledger=consent,
-        ledger=ledger,
-    )
-"""
-
-from aevum.store.postgres.consent import PostgresConsentLedger
-from aevum.store.postgres.ledger import PostgresLedger
-from aevum.store.postgres.store import PostgresStore
-
-__version__ = "0.1.0"
-
-__all__ = ["PostgresStore", "PostgresConsentLedger", "PostgresLedger"]
+"""
+aevum.store.postgres -- PostgreSQL backends for graph, consent, and ledger.
+
+Usage:
+    from aevum.store.postgres import PostgresStore, PostgresConsentLedger, PostgresLedger
+    from aevum.store.postgres.ledger import initialize_ledger_schema
+    import psycopg
+
+    conn = psycopg.connect("postgresql://user:pass@host/dbname")
+    initialize_schema(conn)           # graph + consent DDL
+    initialize_ledger_schema(conn)    # ledger DDL
+
+    store = PostgresStore(conn)
+    consent = PostgresConsentLedger(conn)
+    ledger = PostgresLedger(conn, sigchain)
+
+    engine = Engine(
+        graph_store=store,
+        consent_ledger=consent,
+        ledger=ledger,
+    )
+"""
+
+from aevum.store.postgres.consent import PostgresConsentLedger
+from aevum.store.postgres.ledger import PostgresLedger
+from aevum.store.postgres.store import PostgresStore
+
+__version__ = "0.1.0"
+
+__all__ = ["PostgresStore", "PostgresConsentLedger", "PostgresLedger"]

{aevum_store_postgres-0.2.0 → aevum_store_postgres-0.3.0}/src/aevum/store/postgres/consent.py

@@ -1,110 +1,110 @@
-"""
-PostgresConsentLedger — ConsentLedgerProtocol backed by PostgreSQL.
-
-Grants stored as JSONB in aevum_consent_grants.
-OR-Set semantics: revocation wins over concurrent grants.
-Expiration checked in Python (matching InMemoryConsentLedger behaviour).
-"""
-
-from __future__ import annotations
-
-import contextlib
-import json
-import threading
-from datetime import UTC, datetime
-from typing import Any
-
-from aevum.core.consent.models import ConsentGrant
-
-
-class PostgresConsentLedger:
-    """
-    ConsentLedgerProtocol implementation backed by PostgreSQL.
-
-    Args:
-        conn:  An open psycopg.Connection (autocommit=True recommended).
-        lock:  Optional shared Lock. Pass the same lock used by PostgresStore
-               when both share one connection.
-    """
-
-    def __init__(self, conn: Any, lock: threading.Lock | None = None) -> None:
-        self._conn = conn
-        self._lock = lock or threading.Lock()
-
-    # ── ConsentLedgerProtocol ──────────────────────────────────────────────────
-
-    def add_grant(self, grant: ConsentGrant) -> None:
-        """Upsert a consent grant. Replaces any prior record with the same grant_id."""
-        sql = """
-            INSERT INTO aevum_consent_grants (grant_id, grant_data)
-            VALUES (%s, %s::jsonb)
-            ON CONFLICT (grant_id) DO UPDATE SET grant_data = EXCLUDED.grant_data
-        """
-        with self._lock, self._conn.cursor() as cur:
-            cur.execute(sql, (grant.grant_id, json.dumps(grant.model_dump())))
-
-    def revoke_grant(self, grant_id: str) -> None:
-        """Mark a grant as revoked (immutable update via JSONB merge)."""
-        sql = """
-            UPDATE aevum_consent_grants
-            SET grant_data = jsonb_set(grant_data, '{revocation_status}', '"revoked"')
-            WHERE grant_id = %s
-        """
-        with self._lock, self._conn.cursor() as cur:
-            cur.execute(sql, (grant_id,))
-
-    def has_consent(
-        self,
-        *,
-        subject_id: str,
-        operation: str,
-        grantee_id: str,
-        purpose: str | None = None,
-    ) -> bool:
-        """
-        Return True if an active, unexpired grant covers this operation.
-
-        Mirrors InMemoryConsentLedger: loads candidates from DB, checks
-        expiration and operation in Python to stay consistent with the spec.
-        """
-        sql = """
-            SELECT grant_data
-            FROM aevum_consent_grants
-            WHERE grant_data->>'subject_id'       = %s
-              AND grant_data->>'grantee_id'        = %s
-              AND grant_data->>'revocation_status' = 'active'
-        """
-        with self._lock, self._conn.cursor() as cur:
-            cur.execute(sql, (subject_id, grantee_id))
-            rows = cur.fetchall()
-
-        now = datetime.now(UTC)
-        for row in rows:
-            raw = row[0]
-            d: dict[str, Any] = json.loads(raw) if isinstance(raw, str) else raw
-            if operation not in d.get("operations", []):
-                continue
-            try:
-                expires = datetime.fromisoformat(
-                    d["expires_at"].replace("Z", "+00:00")
-                )
-                if now > expires:
-                    continue
-            except (KeyError, ValueError):
-                continue
-            return True
-        return False
-
-    def all_grants(self) -> list[ConsentGrant]:
-        """Return all stored grants (active, revoked, and expired)."""
-        sql = "SELECT grant_data FROM aevum_consent_grants"
-        with self._lock, self._conn.cursor() as cur:
-            cur.execute(sql)
-            rows = cur.fetchall()
-        grants: list[ConsentGrant] = []
-        for row in rows:
-            raw = row[0]
-            d: dict[str, Any] = json.loads(raw) if isinstance(raw, str) else raw
-            with contextlib.suppress(Exception):
-                grants.append(ConsentGrant(**d))
-        return grants
+"""
+PostgresConsentLedger — ConsentLedgerProtocol backed by PostgreSQL.
+
+Grants stored as JSONB in aevum_consent_grants.
+OR-Set semantics: revocation wins over concurrent grants.
+Expiration checked in Python (matching InMemoryConsentLedger behaviour).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import threading
+from datetime import UTC, datetime
+from typing import Any
+
+from aevum.core.consent.models import ConsentGrant
+
+
+class PostgresConsentLedger:
+    """
+    ConsentLedgerProtocol implementation backed by PostgreSQL.
+
+    Args:
+        conn:  An open psycopg.Connection (autocommit=True recommended).
+        lock:  Optional shared Lock. Pass the same lock used by PostgresStore
+               when both share one connection.
+    """
+
+    def __init__(self, conn: Any, lock: threading.Lock | None = None) -> None:
+        self._conn = conn
+        self._lock = lock or threading.Lock()
+
+    # ── ConsentLedgerProtocol ──────────────────────────────────────────────────
+
+    def add_grant(self, grant: ConsentGrant) -> None:
+        """Upsert a consent grant. Replaces any prior record with the same grant_id."""
+        sql = """
+            INSERT INTO aevum_consent_grants (grant_id, grant_data)
+            VALUES (%s, %s::jsonb)
+            ON CONFLICT (grant_id) DO UPDATE SET grant_data = EXCLUDED.grant_data
+        """
+        with self._lock, self._conn.cursor() as cur:
+            cur.execute(sql, (grant.grant_id, json.dumps(grant.model_dump())))
+
+    def revoke_grant(self, grant_id: str) -> None:
+        """Mark a grant as revoked (immutable update via JSONB merge)."""
+        sql = """
+            UPDATE aevum_consent_grants
+            SET grant_data = jsonb_set(grant_data, '{revocation_status}', '"revoked"')
+            WHERE grant_id = %s
+        """
+        with self._lock, self._conn.cursor() as cur:
+            cur.execute(sql, (grant_id,))
+
+    def has_consent(
+        self,
+        *,
+        subject_id: str,
+        operation: str,
+        grantee_id: str,
+        purpose: str | None = None,
+    ) -> bool:
+        """
+        Return True if an active, unexpired grant covers this operation.
+
+        Mirrors InMemoryConsentLedger: loads candidates from DB, checks
+        expiration and operation in Python to stay consistent with the spec.
+        """
+        sql = """
+            SELECT grant_data
+            FROM aevum_consent_grants
+            WHERE grant_data->>'subject_id'       = %s
+              AND grant_data->>'grantee_id'        = %s
+              AND grant_data->>'revocation_status' = 'active'
+        """
+        with self._lock, self._conn.cursor() as cur:
+            cur.execute(sql, (subject_id, grantee_id))
+            rows = cur.fetchall()
+
+        now = datetime.now(UTC)
+        for row in rows:
+            raw = row[0]
+            d: dict[str, Any] = json.loads(raw) if isinstance(raw, str) else raw
+            if operation not in d.get("operations", []):
+                continue
+            try:
+                expires = datetime.fromisoformat(
+                    d["expires_at"].replace("Z", "+00:00")
+                )
+                if now > expires:
+                    continue
+            except (KeyError, ValueError):
+                continue
+            return True
+        return False
+
+    def all_grants(self) -> list[ConsentGrant]:
+        """Return all stored grants (active, revoked, and expired)."""
+        sql = "SELECT grant_data FROM aevum_consent_grants"
+        with self._lock, self._conn.cursor() as cur:
+            cur.execute(sql)
+            rows = cur.fetchall()
+        grants: list[ConsentGrant] = []
+        for row in rows:
+            raw = row[0]
+            d: dict[str, Any] = json.loads(raw) if isinstance(raw, str) else raw
+            with contextlib.suppress(Exception):
+                grants.append(ConsentGrant(**d))
+        return grants