topos-node 0.1.0__py3-none-any.whl

topos/api/compute_remote.py

@@ -0,0 +1,175 @@
+"""Phase B remote compute transport endpoint."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Literal, 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 ..engine.engine import Engine
+from ..engine.tasks import ModelRequest, ProcessingTask
+
+router = APIRouter(tags=["compute-remote"])
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+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
+        )
+        """
+    )
+    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()
+
+
+class RemoteComputeTaskRequest(BaseModel):
+    compute_task_id: str = Field(..., min_length=1)
+    topos_id: str = Field(..., min_length=1)
+    resource_id: str = Field(..., min_length=1)
+    operation: str = Field(..., min_length=1)
+    payload: Dict[str, Any] = Field(default_factory=dict)
+    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_tier: Literal["basic", "pro", "premium"] = "basic"
+
+
+@router.post("/v1/compute/run", dependencies=[Depends(require_api_key)])
+async def remote_compute_run(body: RemoteComputeTaskRequest) -> Dict[str, Any]:
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database not available")
+    _ensure_tables(conn)
+    principal = "control-plane"
+    if body.idempotency_key:
+        row = conn.execute(
+            "SELECT response_json FROM remote_compute_results WHERE idempotency_key = ?",
+            (body.idempotency_key,),
+        ).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()
+            cached["idempotent_replay"] = True
+            return cached
+
+    try:
+        if body.operation == "healthcheck":
+            response = {
+                "compute_task_id": body.compute_task_id,
+                "status": "completed",
+                "result": {"status": "ok"},
+                "error_class": None,
+                "requested_tier": body.requested_tier,
+                "correlation_id": body.correlation_id,
+                "idempotent_replay": False,
+            }
+        else:
+            task = ProcessingTask(
+                id=body.compute_task_id,
+                type=body.operation,
+                input=body.payload,
+                model_request=ModelRequest(
+                    provider=str(body.payload.get("provider") or "huggingface"),
+                    model=str(body.payload.get("model") or "") or None,
+                ),
+            )
+            result = Engine().run(task)
+            response = {
+                "compute_task_id": body.compute_task_id,
+                "status": result.status,
+                "result": result.model_dump(mode="json"),
+                "error_class": None if result.status == "completed" else "runtime_failure",
+                "requested_tier": body.requested_tier,
+                "correlation_id": body.correlation_id,
+                "idempotent_replay": False,
+            }
+    except Exception as exc:  # noqa: BLE001
+        response = {
+            "compute_task_id": body.compute_task_id,
+            "status": "failed",
+            "result": {},
+            "error_class": "runtime_failure",
+            "error_message": str(exc),
+            "requested_tier": body.requested_tier,
+            "correlation_id": body.correlation_id,
+            "idempotent_replay": False,
+        }
+
+    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 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()
+    return response

topos/api/data_commit.py

@@ -0,0 +1,158 @@
+"""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
+
+router = APIRouter(tags=["data-commit"])
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _ensure_tables(conn) -> None:
+    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
+        )
+        """
+    )
+    conn.commit()
+
+
+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:
+        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,
+                    ),
+                )
+                conn.commit()
+                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,
+            ),
+        )
+        conn.commit()
+    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,
+    }

topos/api/data_explorer_table_prefs.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection
+from ..data_explorer_table_prefs import (
+    delete_table_prefs,
+    get_table_prefs,
+    put_table_prefs,
+)
+
+router = APIRouter(tags=["data-explorer-table-prefs"])
+
+
+def _map_validation_error(err: ValueError) -> HTTPException:
+    code = str(err)
+    mapping = {
+        "INVALID_PREFS": (status.HTTP_400_BAD_REQUEST, "Invalid table preferences payload."),
+        "INVALID_SORT": (status.HTTP_400_BAD_REQUEST, "Invalid sort state."),
+        "INVALID_TABLE_NAME": (status.HTTP_400_BAD_REQUEST, "Invalid table name."),
+        "INVALID_USER_ID": (status.HTTP_400_BAD_REQUEST, "Invalid user id."),
+        "PREFS_TOO_LARGE": (status.HTTP_400_BAD_REQUEST, "Table preferences exceed maximum size."),
+    }
+    status_code, message = mapping.get(code, (status.HTTP_400_BAD_REQUEST, "Invalid request."))
+    return HTTPException(status_code=status_code, detail={"error": message, "code": code})
+
+
+@router.get("/v1/data-explorer/table-prefs/{table_name}", dependencies=[Depends(require_api_key)])
+async def read_data_explorer_table_prefs(
+    table_name: str,
+    user_id: str = Query(..., min_length=1),
+) -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database not available")
+    try:
+        prefs = get_table_prefs(conn, user_id=user_id, table_name=table_name)
+    except ValueError as exc:
+        raise _map_validation_error(exc) from exc
+    return {"status": "ok", "prefs": prefs}
+
+
+@router.put("/v1/data-explorer/table-prefs/{table_name}", dependencies=[Depends(require_api_key)])
+async def write_data_explorer_table_prefs(
+    table_name: str,
+    body: dict[str, Any] = Body(default=None),
+) -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database not available")
+    payload = body or {}
+    user_id = str(payload.get("user_id") or "").strip()
+    prefs = payload.get("prefs")
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={"error": "user_id is required", "code": "INVALID_USER_ID"},
+        )
+    try:
+        saved = put_table_prefs(conn, user_id=user_id, table_name=table_name, prefs=prefs or {})
+    except ValueError as exc:
+        raise _map_validation_error(exc) from exc
+    return {"status": "ok", "prefs": saved}
+
+
+@router.delete("/v1/data-explorer/table-prefs/{table_name}", dependencies=[Depends(require_api_key)])
+async def remove_data_explorer_table_prefs(
+    table_name: str,
+    user_id: str = Query(..., min_length=1),
+) -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database not available")
+    try:
+        deleted = delete_table_prefs(conn, user_id=user_id, table_name=table_name)
+    except ValueError as exc:
+        raise _map_validation_error(exc) from exc
+    return {"status": "ok", "deleted": deleted}

topos/api/db.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/db/status")
+async def db_status() -> dict:
+    return {"status": "stub", "database": "unknown"}

topos/api/device.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+
+from ..auth import require_api_key
+from ..core.api_models import DeviceInfoResponse, DeviceNameRequest, DeviceNameResponse
+from ..services.container import Services, get_services
+
+
+router = APIRouter()
+
+
+@router.get("/device/info", response_model=DeviceInfoResponse, dependencies=[Depends(require_api_key)])
+async def get_device_info(services: Services = Depends(get_services)):
+    return await services.device.get_device_info()
+
+
+@router.get("/device_info", response_model=DeviceInfoResponse, dependencies=[Depends(require_api_key)])
+async def get_device_info_alias(services: Services = Depends(get_services)):
+    return await services.device.get_device_info()
+
+
+@router.post("/device_name", response_model=DeviceNameResponse, dependencies=[Depends(require_api_key)])
+async def set_device_name(body: DeviceNameRequest, services: Services = Depends(get_services)):
+    return await services.device.set_device_name(body.device_name)