topos-node 0.1.0__py3-none-any.whl

topos/api/filter_lab.py

@@ -0,0 +1,195 @@
+"""Filter Lab REST API (engine HTTP surface)."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+
+from ..auth import require_api_key
+from ..filter_lab import bundles as bundles_mod
+from ..filter_lab import store
+from ..filter_lab import service as lab_service
+
+logger = logging.getLogger("topos.api.filter_lab")
+
+router = APIRouter(tags=["filter-lab"])
+
+
+@router.get("/v1/filter-lab/bundles", dependencies=[Depends(require_api_key)])
+async def filter_lab_list_bundles() -> List[Dict[str, Any]]:
+    return bundles_mod.list_bundle_metadata()
+
+
+@router.get("/v1/filter-lab/bundles/{bundle_id}", dependencies=[Depends(require_api_key)])
+async def filter_lab_get_bundle(bundle_id: str) -> Dict[str, Any]:
+    data = bundles_mod.get_bundle_preview(bundle_id)
+    if not data:
+        raise HTTPException(status_code=404, detail="Bundle not found")
+    return data
+
+
+@router.post("/v1/filter-lab/job-groups", dependencies=[Depends(require_api_key)])
+async def filter_lab_create_job_group(body: Dict[str, Any] = Body(default_factory=dict)) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    try:
+        gid = lab_service.create_job_group(
+            filter_id=str(body.get("filter_id") or "").strip(),
+            bundle_id=str(body.get("bundle_id") or "").strip(),
+            models=list(body.get("models") or []),
+            options=body.get("options") if isinstance(body.get("options"), dict) else None,
+        )
+        return lab_service.serialize_job_group(conn, gid)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.get("/v1/filter-lab/job-groups", dependencies=[Depends(require_api_key)])
+async def filter_lab_list_job_groups(
+    filter_id: Optional[str] = Query(
+        None,
+        description="Omit to list all transforms; set to restrict history to one filter id.",
+    ),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    store.prune_old_groups(conn, max_age_days=30)
+    fid = (filter_id or "").strip()
+    if fid:
+        rows = store.list_groups_for_filter(conn, fid, limit=limit, offset=offset)
+    else:
+        rows = store.list_all_job_groups(conn, limit=limit, offset=offset)
+    groups = []
+    for row in rows:
+        g = dict(row)
+        g["baseline_models"] = json.loads(g.pop("baseline_models_json") or "[]")
+        g["pulled_models"] = json.loads(g.pop("pulled_models_json") or "[]")
+        opt_raw = g.pop("options_json", "{}")
+        try:
+            g["options"] = json.loads(opt_raw) if isinstance(opt_raw, str) else {}
+        except json.JSONDecodeError:
+            g["options"] = {}
+        groups.append(g)
+    lab_service.enrich_job_groups_list_with_run_summaries(conn, groups)
+    return {"groups": groups, "limit": limit, "offset": offset}
+
+
+@router.get("/v1/filter-lab/job-groups/{group_id}", dependencies=[Depends(require_api_key)])
+async def filter_lab_get_job_group(group_id: str) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    try:
+        return lab_service.serialize_job_group(conn, group_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Job group not found") from None
+
+
+@router.patch("/v1/filter-lab/job-groups/{group_id}", dependencies=[Depends(require_api_key)])
+async def filter_lab_patch_job_group(group_id: str, body: Dict[str, Any] = Body(default_factory=dict)) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    if not store.get_group(conn, group_id):
+        raise HTTPException(status_code=404, detail="Job group not found")
+    if "preferred_model_tag" in body:
+        p = body.get("preferred_model_tag")
+        store.patch_group(conn, group_id, preferred_model_tag=p if p is None else str(p).strip() or None)
+    if "group_notes" in body:
+        store.patch_group(conn, group_id, group_notes=body.get("group_notes"))
+    if "notes" in body:
+        store.patch_group(conn, group_id, notes=body.get("notes"))
+    return lab_service.serialize_job_group(conn, group_id)
+
+
+@router.patch("/v1/filter-lab/job-groups/{group_id}/runs/{run_id}", dependencies=[Depends(require_api_key)])
+async def filter_lab_patch_run(group_id: str, run_id: str, body: Dict[str, Any] = Body(default_factory=dict)) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    runs = store.list_runs(conn, group_id)
+    if not any(dict(r)["id"] == run_id for r in runs):
+        raise HTTPException(status_code=404, detail="Run not found")
+    rated = False
+    if "user_quality_score_0_10" in body:
+        v = body.get("user_quality_score_0_10")
+        if v is not None and (not isinstance(v, int) or v < 0 or v > 10):
+            raise HTTPException(status_code=400, detail="user_quality_score_0_10 must be 0–10 or null")
+        store.patch_run(conn, run_id, user_quality_score_0_10=v)
+        rated = True
+    if "user_liked" in body:
+        v = body.get("user_liked")
+        if v is None:
+            conn.execute("UPDATE filter_lab_run SET user_liked = NULL WHERE id = ?", (run_id,))
+            conn.commit()
+        else:
+            store.patch_run(conn, run_id, user_liked=bool(v))
+        rated = True
+    if "user_note" in body:
+        note = body.get("user_note")
+        store.patch_run(conn, run_id, user_note=None if note is None else str(note)[:2000])
+        rated = True
+    if rated:
+        conn.execute(
+            "UPDATE filter_lab_run SET rated_at = ? WHERE id = ?",
+            (store.utc_now_iso(), run_id),
+        )
+        conn.commit()
+    return lab_service.serialize_job_group(conn, group_id)
+
+
+@router.post("/v1/filter-lab/job-groups/{group_id}/apply-preferred", dependencies=[Depends(require_api_key)])
+async def filter_lab_apply_preferred(group_id: str) -> Dict[str, Any]:
+    try:
+        return lab_service.apply_preferred_model(group_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.delete("/v1/filter-lab/job-groups/{group_id}", dependencies=[Depends(require_api_key)])
+async def filter_lab_delete_job_group(group_id: str) -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    if not store.get_group(conn, group_id):
+        raise HTTPException(status_code=404, detail="Job group not found")
+    store.delete_group(conn, group_id)
+    return {"status": "ok", "group_id": group_id, "deleted": True}
+
+
+@router.delete("/v1/filter-lab/data", dependencies=[Depends(require_api_key)])
+async def filter_lab_clear_all() -> Dict[str, Any]:
+    from topos.core.state import get_db_connection
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    store.ensure_schema(conn)
+    conn.execute("DELETE FROM filter_lab_model_event")
+    conn.execute("DELETE FROM filter_lab_run")
+    conn.execute("DELETE FROM filter_lab_job_group")
+    conn.commit()
+    return {"status": "ok", "cleared": True}

topos/api/health.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from time import time
+
+from fastapi import Depends, APIRouter
+from fastapi.security import HTTPAuthorizationCredentials
+
+from ..__version__ import __version__
+from ..auth import bearer_scheme, require_api_key
+from ..core.api_models import HealthResponse
+from ..core import state
+
+router = APIRouter()
+
+
+@router.get("/healthcheck", response_model=HealthResponse)
+async def healthcheck(
+    credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
+) -> HealthResponse:
+    # Evaluate health auth dynamically instead of at import time so tests and
+    # runtime env changes do not get locked to stale settings.
+    from ..config.settings import settings as runtime_settings
+
+    if runtime_settings.enable_health_auth:
+        require_api_key(credentials)
+    cp_status = (
+        state.control_plane_client.get_connection_status()
+        if state.control_plane_client and hasattr(state.control_plane_client, "get_connection_status")
+        else None
+    )
+    sync_status = (
+        state.sync_client.get_connection_status()
+        if state.sync_client and hasattr(state.sync_client, "get_connection_status")
+        else None
+    )
+    cloud_connected = None
+    if cp_status is not None or sync_status is not None:
+        cloud_connected = bool(
+            (cp_status or {}).get("connected")
+            or (sync_status or {}).get("connected")
+        )
+    return HealthResponse(
+        status="ok",
+        time=time(),
+        cloud_connected=cloud_connected,
+        control_plane_connection=cp_status,
+        sync_connection=sync_status,
+    )
+
+
+@router.get("/version")
+async def get_version() -> dict:
+    return {
+        "version": __version__,
+        "name": "Topos Control Plane",
+    }
+
+
+@router.get("/")
+async def root() -> dict:
+    return {"status": "ok"}

topos/api/ingestion_api.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Body, Depends, Request
+
+from ..auth import require_api_key
+from .ingestion_sources import ingest_source
+
+router = APIRouter()
+
+
+@router.post("/ingestion/start")
+async def start_ingestion() -> dict:
+    return {"status": "stub"}
+
+
+@router.post("/ingestion/progress")
+async def report_progress() -> dict:
+    return {"status": "stub"}
+
+
+@router.post("/ingestion/upload", dependencies=[Depends(require_api_key)])
+async def upload_ingestion_file(request: Request) -> dict:
+    return await ingest_source("chatgpt_file_ingestion", request)
+
+
+@router.post("/ingestion/upload-local-path", dependencies=[Depends(require_api_key)])
+async def upload_ingestion_local_path(
+    request: Request, payload: dict = Body(default_factory=dict)
+) -> dict:
+    dataset_id = payload.get("dataset_id")
+    file_path = payload.get("file_path")
+    return await ingest_source(
+        "chatgpt_file_ingestion",
+        request,
+        dataset_id=dataset_id,
+        file_path=file_path,
+    )

topos/api/ingestion_compat.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Body, Depends, Request
+
+from ..auth import require_api_key
+from .ingestion_sources import ingest_source
+
+router = APIRouter()
+
+
+@router.post("/store_message", dependencies=[Depends(require_api_key)])
+async def store_message(
+    request: Request, payload: dict = Body(default_factory=dict)
+) -> dict:
+    dataset_id = payload.get("dataset_id")
+    return await ingest_source(
+        "chatgpt_ui_conversation",
+        request,
+        dataset_id=dataset_id,
+        payload=payload,
+    )