topos-node 1.3.5__tar.gz → 1.3.7__tar.gz

{topos_node-1.3.5/topos_node.egg-info → topos_node-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.5
+Version: 1.3.7
 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.5 → topos_node-1.3.7}/pyproject.toml

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

topos_node-1.3.7/tests/test_prewarm_first_run.py

@@ -0,0 +1,61 @@
+"""first_run decides whether the UI says "downloading" or "preparing".
+
+Getting it wrong is a lie in the copy: a node that reports first_run=False shows
+"preparing its language models… should only take a moment" while it fetches 2.9GB.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from topos.sanitization import prewarm
+
+
+@pytest.fixture
+def cache_root(tmp_path, monkeypatch):
+    monkeypatch.setattr(prewarm, "_hf_cache_root", lambda: str(tmp_path))
+    return tmp_path
+
+
+def _write_blobs(cache_root, repo_id: str, names: list[str]) -> None:
+    blobs = os.path.join(prewarm._repo_dir(str(cache_root), repo_id), "blobs")
+    os.makedirs(blobs, exist_ok=True)
+    for name in names:
+        open(os.path.join(blobs, name), "w").close()
+
+
+REPO = prewarm.PRIVACY_FILTER_REPO
+
+
+def test_absent_repo_is_not_present(cache_root):
+    assert prewarm._repo_present(REPO) is False
+
+
+def test_started_but_empty_is_not_present(cache_root):
+    """The first instant of a first download — the directory exists, nothing is in it."""
+    _write_blobs(cache_root, REPO, [])
+    assert prewarm._repo_present(REPO) is False
+
+
+def test_interrupted_download_is_not_present(cache_root):
+    """The case that made this a bug: a killed first run leaves .incomplete blobs
+    behind, and directory-existence alone would call that done."""
+    _write_blobs(cache_root, REPO, ["abc123.incomplete"])
+    assert prewarm._repo_present(REPO) is False
+
+
+def test_partially_resumed_download_is_not_present(cache_root):
+    _write_blobs(cache_root, REPO, ["abc123", "def456.incomplete"])
+    assert prewarm._repo_present(REPO) is False
+
+
+def test_complete_download_is_present(cache_root):
+    _write_blobs(cache_root, REPO, ["abc123", "def456"])
+    assert prewarm._repo_present(REPO) is True
+
+
+def test_no_cache_root_is_not_present(monkeypatch):
+    monkeypatch.setattr(prewarm, "_hf_cache_root", lambda: None)
+    assert prewarm._repo_present(REPO) is False

topos_node-1.3.7/tests/test_system_computer_name.py

@@ -0,0 +1,113 @@
+"""The machine name a Mac owner recognises, reported alongside the hostname.
+
+`platform.node()` returns the network hostname, which on macOS is either a
+mangled form of the computer name ("jonnys-macbook-pro.local") or something
+meaningless from DHCP ("mac.lan" on the machine this was written on). The
+frontend names a new self-hosted Topos after this, so a bad answer here shows up
+as a Topos called "mac.lan".
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+
+from topos.core import state
+
+
+@pytest.fixture(autouse=True)
+def _clear_cache():
+    state._computer_name_cache = state._UNRESOLVED
+    yield
+    state._computer_name_cache = state._UNRESOLVED
+
+
+def _fake_run(stdout: str):
+    def run(_cmd, **_kwargs):
+        return subprocess.CompletedProcess(args=_cmd, returncode=0, stdout=stdout, stderr="")
+
+    return run
+
+
+def test_reports_the_computer_name_on_macos(monkeypatch):
+    monkeypatch.setattr(state.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(state.subprocess, "run", _fake_run("Jonny's MacBook Pro\n"))
+
+    assert state._macos_computer_name() == "Jonny's MacBook Pro"
+
+
+def test_absent_off_macos(monkeypatch):
+    monkeypatch.setattr(state.platform, "system", lambda: "Linux")
+
+    def explode(*_a, **_k):  # pragma: no cover - must never be reached
+        raise AssertionError("scutil is macOS-only and must not be spawned elsewhere")
+
+    monkeypatch.setattr(state.subprocess, "run", explode)
+    assert state._macos_computer_name() is None
+
+
+@pytest.mark.parametrize("stdout", ["", "   \n"])
+def test_blank_output_is_no_name(monkeypatch, stdout):
+    monkeypatch.setattr(state.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(state.subprocess, "run", _fake_run(stdout))
+
+    assert state._macos_computer_name() is None
+
+
+def test_failure_is_swallowed_and_never_retried(monkeypatch):
+    """A nicer label is never worth a startup failure — nor a stall on every request.
+
+    get_system_info runs inside async handlers, so an uncached spawn blocks the
+    event loop for the full timeout. On a Mac with no ComputerName that would be
+    a permanent per-request stall, so a miss is cached exactly like a hit and the
+    node falls back to the hostname for the rest of its life.
+    """
+    monkeypatch.setattr(state.platform, "system", lambda: "Darwin")
+    calls = {"n": 0}
+
+    def always_times_out(_cmd, **_kwargs):
+        calls["n"] += 1
+        raise subprocess.TimeoutExpired(cmd=_cmd, timeout=2.0)
+
+    monkeypatch.setattr(state.subprocess, "run", always_times_out)
+
+    assert state._macos_computer_name() is None
+    assert state._macos_computer_name() is None
+    assert state._macos_computer_name() is None
+    assert calls["n"] == 1
+
+
+def test_non_macos_never_spawns_twice(monkeypatch):
+    monkeypatch.setattr(state.platform, "system", lambda: "Linux")
+    assert state._macos_computer_name() is None
+    # Cached, so a Linux node does not re-check platform on every request either.
+    assert state._computer_name_cache is None
+
+
+def test_spawns_once_per_process(monkeypatch):
+    """get_device_info calls get_system_info twice, and the CP hits it on every connect."""
+    monkeypatch.setattr(state.platform, "system", lambda: "Darwin")
+    calls = {"n": 0}
+
+    def counting(_cmd, **_kwargs):
+        calls["n"] += 1
+        return subprocess.CompletedProcess(args=_cmd, returncode=0, stdout="q4\n", stderr="")
+
+    monkeypatch.setattr(state.subprocess, "run", counting)
+
+    for _ in range(5):
+        state._macos_computer_name()
+
+    assert calls["n"] == 1
+
+
+def test_system_info_carries_computer_name_beside_hostname(monkeypatch):
+    """The dict is free-form and the control plane forwards it verbatim, so this
+    key is the entire wire contract — it lands as system_info.computer_name."""
+    monkeypatch.setattr(state, "_macos_computer_name", lambda: "Jonny's MacBook Pro")
+
+    info = state.get_system_info()
+
+    assert info["computer_name"] == "Jonny's MacBook Pro"
+    assert "hostname" in info

{topos_node-1.3.5 → topos_node-1.3.7}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.5"
-__version_info__ = (1, 3, 5)
+__version__ = "1.3.7"
+__version_info__ = (1, 3, 7)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.5 → topos_node-1.3.7}/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.5 → topos_node-1.3.7}/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.5 → topos_node-1.3.7}/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,