topos-node 1.3.6__tar.gz → 1.3.8__tar.gz

{topos_node-1.3.6/topos_node.egg-info → topos_node-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.6
+Version: 1.3.8
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.6 → topos_node-1.3.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.6"
+version = "1.3.8"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.6 → topos_node-1.3.8}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.6"
-__version_info__ = (1, 3, 6)
+__version__ = "1.3.8"
+__version_info__ = (1, 3, 8)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.6 → topos_node-1.3.8}/topos/analytics/messenger_communities.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional, Sequence
 import networkx as nx
 
 from .messenger_graph import extract_messenger_graph
+from ..storage.db.write_gate import batched_writes, commit_connection, with_db_write
 
 MESSENGER_SOCIAL_EDGES_TABLE = "messenger_social_edges"
 MESSENGER_PARTICIPANT_IMPORTANCE_TABLE = "messenger_participant_importance"
@@ -28,6 +29,14 @@ def _source_scope(source_ids: Optional[Sequence[str]]) -> str:
 
 def ensure_messenger_analytics_tables(conn: Any) -> None:
     """Create Sprint 02 derived messenger analytics tables."""
+    # DDL takes SQLite's write lock at execute time — gate it with the commit
+    # (write_gate lock-order inversion).
+    with with_db_write():
+        _create_messenger_analytics_tables(conn)
+        commit_connection(conn)
+
+
+def _create_messenger_analytics_tables(conn: Any) -> None:
     conn.execute(
         f"""
         CREATE TABLE IF NOT EXISTS {MESSENGER_SOCIAL_EDGES_TABLE} (
@@ -94,7 +103,6 @@ def ensure_messenger_analytics_tables(conn: Any) -> None:
         ON {MESSENGER_COMMUNITIES_TABLE}(dataset_id, period_key, source_scope)
         """
     )
-    conn.commit()
 
 
 def build_networkx_graph(period_payload: Dict[str, Any]) -> nx.Graph:
@@ -165,28 +173,6 @@ def _persist_period_results(
     communities: Dict[str, int],
 ) -> Dict[str, int]:
     now = _utc_now()
-    conn.execute(
-        f"""
-        DELETE FROM {MESSENGER_SOCIAL_EDGES_TABLE}
-        WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
-        """,
-        (dataset_id, period_key, source_scope),
-    )
-    conn.execute(
-        f"""
-        DELETE FROM {MESSENGER_PARTICIPANT_IMPORTANCE_TABLE}
-        WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
-        """,
-        (dataset_id, period_key, source_scope),
-    )
-    conn.execute(
-        f"""
-        DELETE FROM {MESSENGER_COMMUNITIES_TABLE}
-        WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
-        """,
-        (dataset_id, period_key, source_scope),
-    )
-
     edge_rows = []
     for edge in period_payload.get("edges", []):
         source_id = str(edge.get("source") or "").strip()
@@ -207,18 +193,6 @@ def _persist_period_results(
                 now,
             )
         )
-    if edge_rows:
-        conn.executemany(
-            f"""
-            INSERT INTO {MESSENGER_SOCIAL_EDGES_TABLE}
-            (
-                dataset_id, period_key, source_scope, source_id, target_id,
-                weight, edge_type, edge_type_counts_json, created_at, updated_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            edge_rows,
-        )
 
     importance_rows = []
     for participant_id, metrics in importance.items():
@@ -234,18 +208,6 @@ def _persist_period_results(
                 now,
             )
         )
-    if importance_rows:
-        conn.executemany(
-            f"""
-            INSERT INTO {MESSENGER_PARTICIPANT_IMPORTANCE_TABLE}
-            (
-                dataset_id, period_key, source_scope, participant_id,
-                centrality_degree, centrality_betweenness, created_at, updated_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            importance_rows,
-        )
 
     community_rows = []
     for participant_id, community_id in communities.items():
@@ -260,19 +222,66 @@ def _persist_period_results(
                 now,
             )
         )
-    if community_rows:
-        conn.executemany(
+    # Rows are built above, outside the hold; only the deletes + inserts (one
+    # commit at exit) hold the gate.
+    with batched_writes(conn):
+        conn.execute(
             f"""
-            INSERT INTO {MESSENGER_COMMUNITIES_TABLE}
-            (
-                dataset_id, period_key, source_scope, participant_id,
-                community_id, created_at, updated_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?)
+            DELETE FROM {MESSENGER_SOCIAL_EDGES_TABLE}
+            WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
+            """,
+            (dataset_id, period_key, source_scope),
+        )
+        conn.execute(
+            f"""
+            DELETE FROM {MESSENGER_PARTICIPANT_IMPORTANCE_TABLE}
+            WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
+            """,
+            (dataset_id, period_key, source_scope),
+        )
+        conn.execute(
+            f"""
+            DELETE FROM {MESSENGER_COMMUNITIES_TABLE}
+            WHERE dataset_id = ? AND period_key = ? AND source_scope = ?
             """,
-            community_rows,
+            (dataset_id, period_key, source_scope),
         )
-    conn.commit()
+        if edge_rows:
+            conn.executemany(
+                f"""
+                INSERT INTO {MESSENGER_SOCIAL_EDGES_TABLE}
+                (
+                    dataset_id, period_key, source_scope, source_id, target_id,
+                    weight, edge_type, edge_type_counts_json, created_at, updated_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                edge_rows,
+            )
+        if importance_rows:
+            conn.executemany(
+                f"""
+                INSERT INTO {MESSENGER_PARTICIPANT_IMPORTANCE_TABLE}
+                (
+                    dataset_id, period_key, source_scope, participant_id,
+                    centrality_degree, centrality_betweenness, created_at, updated_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                importance_rows,
+            )
+        if community_rows:
+            conn.executemany(
+                f"""
+                INSERT INTO {MESSENGER_COMMUNITIES_TABLE}
+                (
+                    dataset_id, period_key, source_scope, participant_id,
+                    community_id, created_at, updated_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                community_rows,
+            )
     return {
         "edges_written": len(edge_rows),
         "importance_written": len(importance_rows),

{topos_node-1.3.6 → topos_node-1.3.8}/topos/api/compute_remote.py

@@ -14,6 +14,7 @@ from ..auth import require_api_key
 from ..core.state import get_db_connection
 from ..engine.engine import Engine
 from ..engine.tasks import ModelRequest, ProcessingTask
+from ..storage.db.write_gate import commit_connection, with_db_write
 
 router = APIRouter(tags=["compute-remote"])
 
@@ -23,32 +24,35 @@ def _now_iso() -> str:
 
 
 def _ensure_tables(conn) -> None:
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS remote_compute_results (
-            idempotency_key TEXT PRIMARY KEY,
-            compute_task_id TEXT NOT NULL,
-            response_json TEXT NOT NULL,
-            requested_tier TEXT NOT NULL,
-            correlation_id TEXT,
-            created_at TEXT NOT NULL
+    # DDL takes SQLite's write lock at execute time — gate it with the commit
+    # (write_gate lock-order inversion).
+    with with_db_write():
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS remote_compute_results (
+                idempotency_key TEXT PRIMARY KEY,
+                compute_task_id TEXT NOT NULL,
+                response_json TEXT NOT NULL,
+                requested_tier TEXT NOT NULL,
+                correlation_id TEXT,
+                created_at TEXT NOT NULL
+            )
+            """
         )
-        """
-    )
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS remote_compute_audit (
-            audit_id TEXT PRIMARY KEY,
-            compute_task_id TEXT NOT NULL,
-            idempotency_key TEXT,
-            principal TEXT NOT NULL,
-            requested_tier TEXT NOT NULL,
-            outcome TEXT NOT NULL,
-            created_at TEXT NOT NULL
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS remote_compute_audit (
+                audit_id TEXT PRIMARY KEY,
+                compute_task_id TEXT NOT NULL,
+                idempotency_key TEXT,
+                principal TEXT NOT NULL,
+                requested_tier TEXT NOT NULL,
+                outcome TEXT NOT NULL,
+                created_at TEXT NOT NULL
+            )
+            """
         )
-        """
-    )
-    conn.commit()
+        commit_connection(conn)
 
 
 class RemoteComputeTaskRequest(BaseModel):
@@ -76,23 +80,24 @@ async def remote_compute_run(body: RemoteComputeTaskRequest) -> Dict[str, Any]:
         ).fetchone()
         if row:
             cached = json.loads(str(row["response_json"]))
-            conn.execute(
-                """
-                INSERT INTO remote_compute_audit
-                (audit_id, compute_task_id, idempotency_key, principal, requested_tier, outcome, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    f"rca_{uuid.uuid4().hex}",
-                    body.compute_task_id,
-                    body.idempotency_key,
-                    principal,
-                    body.requested_tier,
-                    "idempotent_replay",
-                    _now_iso(),
-                ),
-            )
-            conn.commit()
+            with with_db_write():
+                conn.execute(
+                    """
+                    INSERT INTO remote_compute_audit
+                    (audit_id, compute_task_id, idempotency_key, principal, requested_tier, outcome, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        f"rca_{uuid.uuid4().hex}",
+                        body.compute_task_id,
+                        body.idempotency_key,
+                        principal,
+                        body.requested_tier,
+                        "idempotent_replay",
+                        _now_iso(),
+                    ),
+                )
+                commit_connection(conn)
             cached["idempotent_replay"] = True
             return cached
 
@@ -139,37 +144,38 @@ async def remote_compute_run(body: RemoteComputeTaskRequest) -> Dict[str, Any]:
             "idempotent_replay": False,
         }
 
-    if body.idempotency_key:
+    with with_db_write():
+        if body.idempotency_key:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO remote_compute_results
+                (idempotency_key, compute_task_id, response_json, requested_tier, correlation_id, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    body.idempotency_key,
+                    body.compute_task_id,
+                    json.dumps(response),
+                    body.requested_tier,
+                    body.correlation_id,
+                    _now_iso(),
+                ),
+            )
         conn.execute(
             """
-            INSERT OR REPLACE INTO remote_compute_results
-            (idempotency_key, compute_task_id, response_json, requested_tier, correlation_id, created_at)
-            VALUES (?, ?, ?, ?, ?, ?)
+            INSERT INTO remote_compute_audit
+            (audit_id, compute_task_id, idempotency_key, principal, requested_tier, outcome, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
             """,
             (
-                body.idempotency_key,
+                f"rca_{uuid.uuid4().hex}",
                 body.compute_task_id,
-                json.dumps(response),
+                body.idempotency_key,
+                principal,
                 body.requested_tier,
-                body.correlation_id,
+                str(response.get("status") or "unknown"),
                 _now_iso(),
             ),
         )
-    conn.execute(
-        """
-        INSERT INTO remote_compute_audit
-        (audit_id, compute_task_id, idempotency_key, principal, requested_tier, outcome, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            f"rca_{uuid.uuid4().hex}",
-            body.compute_task_id,
-            body.idempotency_key,
-            principal,
-            body.requested_tier,
-            str(response.get("status") or "unknown"),
-            _now_iso(),
-        ),
-    )
-    conn.commit()
+        commit_connection(conn)
     return response

{topos_node-1.3.6 → topos_node-1.3.8}/topos/api/conversation_context.py

@@ -13,6 +13,7 @@ from fastapi import APIRouter, Body, Depends, HTTPException
 from ..auth import require_api_key
 from ..core.state import get_db_connection
 from ..storage.db.migrations.conversation_context_v1 import CONTEXT_TAG_VALUES
+from ..storage.db.write_gate import commit_connection, with_db_write
 
 router = APIRouter()
 
@@ -56,12 +57,13 @@ def write_conversation_context(conn, conversation_id: str, dataset_id: str, raw_
         raise LookupError("Unknown conversation")
     # Owner decisions always win: stamped 'owner' even when clearing, so the
     # auto-classifier never refills a conversation the owner chose to untag.
-    conn.execute(
-        "UPDATE conversations SET context_tag=?, context_tag_source='owner', "
-        "updated_at=datetime('now') WHERE conversation_id=? AND dataset_id=?",
-        (tag, conversation_id, dataset_id),
-    )
-    conn.commit()
+    with with_db_write():
+        conn.execute(
+            "UPDATE conversations SET context_tag=?, context_tag_source='owner', "
+            "updated_at=datetime('now') WHERE conversation_id=? AND dataset_id=?",
+            (tag, conversation_id, dataset_id),
+        )
+        commit_connection(conn)
     return {
         "status": "ok",
         "conversation_id": conversation_id,

topos_node-1.3.8/topos/api/data_commit.py

@@ -0,0 +1,166 @@
+"""Phase B authoritative data-plane commit API."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection
+from ..storage.db.write_gate import commit_connection, with_db_write
+
+router = APIRouter(tags=["data-commit"])
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _ensure_tables(conn) -> None:
+    # DDL takes SQLite's write lock at execute time — gate it with the commit
+    # (write_gate lock-order inversion).
+    with with_db_write():
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS data_commit_artifacts (
+                commit_id TEXT PRIMARY KEY,
+                compute_task_id TEXT NOT NULL,
+                topos_id TEXT NOT NULL,
+                resource_id TEXT NOT NULL,
+                artifact_schema_version TEXT NOT NULL,
+                artifact_json TEXT NOT NULL,
+                idempotency_key TEXT UNIQUE,
+                correlation_id TEXT,
+                requested_by TEXT,
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS data_commit_audit (
+                audit_id TEXT PRIMARY KEY,
+                commit_id TEXT,
+                compute_task_id TEXT NOT NULL,
+                idempotency_key TEXT,
+                outcome TEXT NOT NULL,
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        commit_connection(conn)
+
+
+class CommitArtifactRequest(BaseModel):
+    compute_task_id: str = Field(..., min_length=1)
+    topos_id: str = Field(..., min_length=1)
+    resource_id: str = Field(..., min_length=1)
+    artifact: Dict[str, Any] = Field(default_factory=dict)
+    artifact_schema_version: str = Field(default="phase_b_v1", min_length=1)
+    idempotency_key: Optional[str] = Field(default=None, min_length=8, max_length=200)
+    correlation_id: Optional[str] = Field(default=None, min_length=8, max_length=200)
+    requested_by: Optional[str] = Field(default=None, min_length=1, max_length=200)
+
+
+@router.post("/v1/data/commit-artifact", dependencies=[Depends(require_api_key)])
+async def commit_artifact(body: CommitArtifactRequest) -> Dict[str, Any]:
+    if not isinstance(body.artifact, dict) or not body.artifact:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="artifact must be a non-empty object")
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database not available")
+    _ensure_tables(conn)
+    commit_id = f"commit_{uuid.uuid4().hex}"
+    now = _now_iso()
+    try:
+        # BEGIN IMMEDIATE takes SQLite's write lock at execute time — the whole
+        # transaction holds the gate with the commit (write_gate lock-order
+        # inversion). Rollback stays outside the hold.
+        with with_db_write():
+            conn.execute("BEGIN IMMEDIATE")
+            if body.idempotency_key:
+                existing = conn.execute(
+                    """
+                    SELECT commit_id, correlation_id FROM data_commit_artifacts
+                    WHERE idempotency_key = ?
+                    LIMIT 1
+                    """,
+                    (body.idempotency_key,),
+                ).fetchone()
+                if existing:
+                    existing_commit_id = str(existing["commit_id"])
+                    conn.execute(
+                        """
+                        INSERT INTO data_commit_audit
+                        (audit_id, commit_id, compute_task_id, idempotency_key, outcome, created_at)
+                        VALUES (?, ?, ?, ?, ?, ?)
+                        """,
+                        (
+                            f"dca_{uuid.uuid4().hex}",
+                            existing_commit_id,
+                            body.compute_task_id,
+                            body.idempotency_key,
+                            "idempotent_replay",
+                            now,
+                        ),
+                    )
+                    commit_connection(conn)
+                    return {
+                        "commit_id": existing_commit_id,
+                        "deduped": True,
+                        "compute_task_id": body.compute_task_id,
+                        "correlation_id": str(existing["correlation_id"] or body.correlation_id or ""),
+                    }
+
+            conn.execute(
+                """
+                INSERT INTO data_commit_artifacts
+                (commit_id, compute_task_id, topos_id, resource_id, artifact_schema_version, artifact_json, idempotency_key, correlation_id, requested_by, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    commit_id,
+                    body.compute_task_id,
+                    body.topos_id,
+                    body.resource_id,
+                    body.artifact_schema_version,
+                    json.dumps(body.artifact),
+                    body.idempotency_key,
+                    body.correlation_id,
+                    body.requested_by,
+                    now,
+                ),
+            )
+            conn.execute(
+                """
+                INSERT INTO data_commit_audit
+                (audit_id, commit_id, compute_task_id, idempotency_key, outcome, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    f"dca_{uuid.uuid4().hex}",
+                    commit_id,
+                    body.compute_task_id,
+                    body.idempotency_key,
+                    "committed",
+                    now,
+                ),
+            )
+            commit_connection(conn)
+    except Exception as exc:  # noqa: BLE001
+        conn.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"commit_failed:{exc}",
+        ) from exc
+    return {
+        "commit_id": commit_id,
+        "deduped": False,
+        "compute_task_id": body.compute_task_id,
+        "correlation_id": body.correlation_id,
+    }