caddforge-gui 0.6.0__py3-none-any.whl

caddforge_gui/__init__.py

@@ -0,0 +1,3 @@
+"""CADDForge GUI server package."""
+
+__all__ = ["app"]

caddforge_gui/app.py

@@ -0,0 +1,644 @@
+"""FastAPI app for the CADDForge GUI."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, AsyncGenerator, Iterable
+
+from fastapi import Depends, FastAPI, HTTPException, Query, Request, Response
+import typer
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from caddforge.cli.main import _restart_recorded_job
+from caddforge.core.job import Job, JobStatus
+from caddforge.core.backends.slurm import SlurmBackend, SlurmJobHandle
+from caddforge.core.job_registry import get_job, initialize_registry, list_jobs, record_job
+from caddforge.core.status_refresh import refresh_job_status
+
+try:  # Backward-compatible import if core doesn't have delete_job yet.
+    from caddforge.core.job_registry import delete_job
+except ImportError:  # pragma: no cover - for older core installs
+    def delete_job(job_id: str, registry_path: Path | None = None) -> None:
+        import sqlite3
+
+        registry = registry_path or Path("runs") / "job_registry.sqlite"
+        with sqlite3.connect(registry) as conn:
+            conn.execute("DELETE FROM jobs WHERE job_id = ?", (job_id,))
+            conn.commit()
+from caddforge.gui import discover_gui_extensions
+
+from .artifacts import collect_artifacts, resolve_artifact_path, stream_log_events
+from .config import GuiConfig, apply_env_overrides, load_config
+
+MAX_INLINE_RESULTS_BYTES = 5 * 1024 * 1024
+
+
+def build_config(
+    *,
+    config_path: Path | None = None,
+    host: str | None = None,
+    port: int | None = None,
+    base_path: str | None = None,
+    cors_origins: list[str] | None = None,
+    auth_mode: str | None = None,
+    auth_token: str | None = None,
+    runs_root: Path | None = None,
+    registry_path: Path | None = None,
+) -> GuiConfig:
+    config = load_config(config_path)
+    config = apply_env_overrides(config)
+    if runs_root and registry_path is None:
+        registry_path = Path(runs_root) / "job_registry.sqlite"
+    return config.with_overrides(
+        host=host,
+        port=port,
+        base_path=base_path,
+        cors_origins=cors_origins if cors_origins else None,
+        auth_mode=auth_mode,
+        auth_token=auth_token,
+        runs_root=runs_root,
+        registry_path=registry_path,
+    )
+
+
+def _auth_dependency(config: GuiConfig):
+    def _check(request: Request) -> None:
+        if config.auth_mode == "none":
+            return
+        if config.auth_mode == "token":
+            token = (request.headers.get("Authorization") or "").replace("Bearer ", "")
+            if not token or token != config.auth_token:
+                raise HTTPException(status_code=401, detail="Unauthorized")
+            return
+        raise HTTPException(status_code=500, detail="Unsupported auth mode.")
+
+    return _check
+
+
+def _job_to_summary(job: Job) -> dict[str, Any]:
+    job_name = (job.metadata or {}).get("job_name") if job.metadata else None
+    return {
+        "job_id": job.id,
+        "job_name": job_name,
+        "tool_name": job.tool_name,
+        "plugin_section": job.metadata.get("section") if job.metadata else None,
+        "backend": job.backend,
+        "status": job.status.value,
+        "created_at": job.created_at.isoformat(),
+        "started_at": job.started_at.isoformat() if job.started_at else None,
+        "finished_at": job.finished_at.isoformat() if job.finished_at else None,
+        "run_directory": str(job.run_directory) if job.run_directory else None,
+        "metadata": job.metadata,
+    }
+
+
+def _load_results(run_directory: Path | None) -> dict[str, Any] | None:
+    if not run_directory:
+        return None
+    results_path = run_directory / "results" / "results.json"
+    if not results_path.exists():
+        return None
+    if results_path.stat().st_size > MAX_INLINE_RESULTS_BYTES:
+        return None
+    try:
+        return json.loads(results_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return None
+
+
+def _results_metadata(run_directory: Path | None) -> dict[str, Any]:
+    if not run_directory:
+        return {"available": False, "size_bytes": 0, "inline_loaded": False}
+    results_path = run_directory / "results" / "results.json"
+    if not results_path.exists():
+        return {"available": False, "size_bytes": 0, "inline_loaded": False}
+    size_bytes = results_path.stat().st_size
+    return {
+        "available": True,
+        "size_bytes": size_bytes,
+        "inline_loaded": size_bytes <= MAX_INLINE_RESULTS_BYTES,
+    }
+
+
+def _build_artifact_payload(job_id: str, run_directory: Path | None) -> list[dict[str, Any]]:
+    return _build_artifact_payload_limited(job_id, run_directory, include_tool_specific=True)
+
+
+def _build_artifact_payload_limited(
+    job_id: str,
+    run_directory: Path | None,
+    *,
+    include_tool_specific: bool,
+    max_tool_specific_files: int = 200,
+) -> list[dict[str, Any]]:
+    if not run_directory:
+        return []
+    artifacts = collect_artifacts(
+        run_directory,
+        include_tool_specific=include_tool_specific,
+        max_tool_specific_files=max_tool_specific_files,
+    )
+    return [artifact.to_dict(job_id) for artifact in artifacts]
+
+
+def _resolve_run_directory(job: Job, runs_root: Path) -> Path | None:
+    if job.run_directory:
+        return Path(job.run_directory)
+    if not runs_root.exists():
+        return None
+    matches = list(runs_root.glob(f"*/{job.id}"))
+    if matches:
+        return matches[0]
+    return None
+
+
+def _delete_run_directory(run_directory: Path | None) -> None:
+    if not run_directory or not run_directory.exists():
+        return
+    import shutil
+
+    shutil.rmtree(run_directory)
+
+
+def _submission_cwd_from_job(job: Job) -> Path | None:
+    if not job.metadata:
+        return None
+    submission_cwd = job.metadata.get("submission_cwd")
+    if not isinstance(submission_cwd, str) or not submission_cwd.strip():
+        return None
+    return Path(submission_cwd).expanduser().resolve()
+
+
+def _list_jobs(registry_path: Path, statuses: list[JobStatus] | None) -> list[Job]:
+    initialize_registry(registry_path)
+    return list(list_jobs(registry_path=registry_path, statuses=statuses))
+
+
+def _filter_jobs(
+    jobs: Iterable[Job], *, search: str | None, status: list[str] | None
+) -> list[Job]:
+    filtered = []
+    for job in jobs:
+        if status and job.status.value not in status:
+            continue
+        if search:
+            metadata = job.metadata or {}
+            haystack = " ".join(
+                str(value or "")
+                for value in (
+                    job.id,
+                    metadata.get("job_name"),
+                    job.tool_name,
+                    metadata.get("section"),
+                    job.backend,
+                )
+            ).lower()
+            if search.lower() not in haystack:
+                continue
+        filtered.append(job)
+    return filtered
+
+
+def _jobs_response(
+    registry_path: Path,
+    *,
+    status: list[str] | None,
+    search: str | None,
+    limit: int,
+    offset: int,
+) -> dict[str, Any]:
+    items = _filter_jobs(_list_jobs(registry_path, None), search=search, status=status)
+    total = len(items)
+    sliced = items[offset : offset + limit]
+    return {
+        "items": [_job_to_summary(job) for job in sliced],
+        "total": total,
+        "limit": limit,
+        "offset": offset,
+    }
+
+
+def _dashboard_totals(jobs: list[Job]) -> dict[str, int]:
+    now = datetime.now().astimezone()
+    today = now.date()
+    last_24h = now - timedelta(hours=24)
+
+    active_statuses = {JobStatus.PENDING, JobStatus.RUNNING}
+    return {
+        "total_jobs": len(jobs),
+        "active_jobs": sum(1 for job in jobs if job.status in active_statuses),
+        "running_jobs": sum(1 for job in jobs if job.status == JobStatus.RUNNING),
+        "pending_jobs": sum(1 for job in jobs if job.status == JobStatus.PENDING),
+        "completed_today": sum(
+            1
+            for job in jobs
+            if job.status == JobStatus.COMPLETED
+            and job.finished_at
+            and job.finished_at.astimezone().date() == today
+        ),
+        "failed_today": sum(
+            1
+            for job in jobs
+            if job.status == JobStatus.FAILED
+            and (job.finished_at or job.created_at).astimezone().date() == today
+        ),
+        "created_last_24h": sum(1 for job in jobs if job.created_at >= last_24h),
+        "tools_seen": len({job.tool_name for job in jobs}),
+        "backends_seen": len({job.backend for job in jobs}),
+    }
+
+
+def _dashboard_summary(jobs: list[Job]) -> dict[str, Any]:
+    by_status: dict[str, int] = {}
+    by_backend: dict[str, int] = {}
+    by_tool: dict[str, int] = {}
+    for job in jobs:
+        by_status[job.status.value] = by_status.get(job.status.value, 0) + 1
+        by_backend[job.backend] = by_backend.get(job.backend, 0) + 1
+        by_tool[job.tool_name] = by_tool.get(job.tool_name, 0) + 1
+
+    active_statuses = {JobStatus.PENDING, JobStatus.RUNNING}
+    active_jobs = [job for job in jobs if job.status in active_statuses][:6]
+    recent_failures = [job for job in jobs if job.status == JobStatus.FAILED][:5]
+
+    return {
+        "updated_at": datetime.now().astimezone().isoformat(),
+        "totals": _dashboard_totals(jobs),
+        "status": by_status,
+        "backend": by_backend,
+        "tool": by_tool,
+        "active_jobs": [_job_to_summary(job) for job in active_jobs],
+        "recent_jobs": [_job_to_summary(job) for job in jobs[:8]],
+        "recent_failures": [_job_to_summary(job) for job in recent_failures],
+    }
+
+
+async def _status_stream(registry_path: Path, interval: float) -> AsyncGenerator[str, None]:
+    last_payload: dict[str, str] = {}
+    while True:
+        jobs = list_jobs(registry_path=registry_path)
+        payload = {job.id: job.status.value for job in jobs}
+        if payload != last_payload:
+            last_payload = payload
+            message = {"updated_at": datetime.now().astimezone().isoformat(), "jobs": payload}
+            yield f"data: {json.dumps(message)}\n\n"
+        await asyncio.sleep(interval)
+
+
+def create_app(config: GuiConfig) -> FastAPI:
+    app = FastAPI(title="CADDForge GUI", root_path=config.base_path)
+
+    if config.cors_origins:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=config.cors_origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    auth_dependency = Depends(_auth_dependency(config))
+
+    extensions = discover_gui_extensions()
+    for ext in extensions:
+        if ext.router is not None:
+            app.include_router(ext.router, prefix=f"/api/v1/ext/{ext.plugin_id}")
+        if ext.frontend_dir:
+            app.mount(
+                f"/static/ext/{ext.plugin_id}",
+                StaticFiles(directory=ext.frontend_dir),
+                name=f"ext-{ext.plugin_id}",
+            )
+
+    static_root = Path(__file__).parent / "static"
+    app.mount("/static", StaticFiles(directory=static_root), name="static")
+
+    @app.get("/api/v1/health", dependencies=[auth_dependency])
+    def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.get("/api/v1/jobs", dependencies=[auth_dependency])
+    def jobs(
+        status: list[str] | None = Query(None),
+        search: str | None = None,
+        limit: int = Query(200, ge=1, le=500),
+        offset: int = Query(0, ge=0),
+    ) -> dict[str, Any]:
+        return _jobs_response(
+            config.registry_path,
+            status=status,
+            search=search,
+            limit=limit,
+            offset=offset,
+        )
+
+    @app.get("/api/v1/jobs-stream", dependencies=[auth_dependency])
+    async def job_stream(interval: float = 2.0) -> StreamingResponse:
+        return StreamingResponse(_status_stream(config.registry_path, interval), media_type="text/event-stream")
+
+    @app.get("/api/v1/jobs/{job_id}", dependencies=[auth_dependency])
+    def job_detail(
+        job_id: str,
+        include_tool_specific_artifacts: bool = False,
+    ) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        payload = _job_to_summary(job)
+        payload["run_directory"] = str(run_directory) if run_directory else None
+        payload["artifacts"] = _build_artifact_payload_limited(
+            job_id,
+            run_directory,
+            include_tool_specific=include_tool_specific_artifacts,
+        )
+        payload["results"] = _load_results(run_directory)
+        payload["results_meta"] = _results_metadata(run_directory)
+        return payload
+
+    @app.post("/api/v1/jobs/{job_id}/refresh-status", dependencies=[auth_dependency])
+    def job_refresh_status(job_id: str) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        previous_status = job.status
+        refresh_job_status(job, registry_path=config.registry_path)
+        refreshed = get_job(job_id, registry_path=config.registry_path) or job
+        return {
+            "item": _job_to_summary(refreshed),
+            "changed": previous_status != refreshed.status,
+        }
+
+    @app.post("/api/v1/jobs/refresh-status", dependencies=[auth_dependency])
+    def jobs_refresh_status(
+        status: list[str] | None = None,
+        only_active: bool = True,
+        limit: int = 500,
+    ) -> dict[str, Any]:
+        jobs = _list_jobs(config.registry_path, None)
+        if status:
+            allowed = {value.upper() for value in status}
+            jobs = [job for job in jobs if job.status.value in allowed]
+        elif only_active:
+            jobs = [job for job in jobs if job.status in {JobStatus.PENDING, JobStatus.RUNNING}]
+
+        if limit > 0:
+            jobs = jobs[:limit]
+
+        changed = 0
+        errors: list[dict[str, str]] = []
+        refreshed_items: list[dict[str, Any]] = []
+        for job in jobs:
+            before = job.status
+            try:
+                refresh_job_status(job, registry_path=config.registry_path)
+                refreshed = get_job(job.id, registry_path=config.registry_path) or job
+                if refreshed.status != before:
+                    changed += 1
+                refreshed_items.append(_job_to_summary(refreshed))
+            except Exception as exc:  # pragma: no cover - defensive
+                errors.append({"job_id": job.id, "error": str(exc)})
+
+        return {
+            "total": len(jobs),
+            "changed": changed,
+            "errors": errors,
+            "items": refreshed_items,
+        }
+
+    @app.get("/api/v1/jobs/{job_id}/artifacts", dependencies=[auth_dependency])
+    def job_artifacts(job_id: str, include_tool_specific: bool = True) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        if not run_directory:
+            raise HTTPException(status_code=404, detail="Run directory not found")
+        return {
+            "items": _build_artifact_payload_limited(
+                job_id,
+                run_directory,
+                include_tool_specific=include_tool_specific,
+            )
+        }
+
+    @app.get("/api/v1/jobs/{job_id}/artifacts/{artifact_id}", dependencies=[auth_dependency])
+    def job_artifact_download(job_id: str, artifact_id: str) -> Response:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        if not run_directory:
+            raise HTTPException(status_code=404, detail="Run directory not found")
+        try:
+            path = resolve_artifact_path(run_directory, artifact_id)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        if not path.exists():
+            raise HTTPException(status_code=404, detail="Artifact not found")
+        return FileResponse(path)
+
+    @app.get("/api/v1/jobs/{job_id}/results", dependencies=[auth_dependency])
+    def job_results(job_id: str) -> Response:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        if not run_directory:
+            raise HTTPException(status_code=404, detail="Run directory not found")
+        results = _load_results(run_directory)
+        if results is None:
+            raise HTTPException(status_code=404, detail="Results not available")
+        return JSONResponse(results)
+
+    @app.post("/api/v1/jobs/{job_id}/restart", dependencies=[auth_dependency])
+    def job_restart(job_id: str) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        if job.status != JobStatus.FAILED:
+            raise HTTPException(status_code=400, detail="Only failed jobs can be restarted.")
+        try:
+            restarted = _restart_recorded_job(
+                job,
+                registry_path_override=config.registry_path,
+                backend_override=job.backend,
+                runs_root_override=config.runs_root,
+                submission_cwd=_submission_cwd_from_job(job),
+                emit=None,
+                local_async=job.backend == "local",
+            )
+        except (LookupError, FileNotFoundError, typer.BadParameter, ValueError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"item": _job_to_summary(restarted)}
+
+
+    @app.post("/api/v1/jobs/{job_id}/cancel", dependencies=[auth_dependency])
+    def job_cancel(job_id: str) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        if job.status in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+            raise HTTPException(status_code=400, detail="Job is not running or pending.")
+        if job.backend == "slurm":
+            slurm_job_id = None
+            if job.metadata:
+                slurm_job_id = job.metadata.get("slurm_job_id")
+            if not slurm_job_id:
+                raise HTTPException(status_code=400, detail="Missing Slurm job id.")
+            backend = SlurmBackend(
+                runs_root=config.runs_root,
+                registry_path=config.registry_path,
+            )
+            backend.cancel(SlurmJobHandle(job.id, slurm_job_id))
+            return {"cancelled": True, "job_id": job.id}
+        if job.backend == "local":
+            pid = None
+            if job.metadata:
+                pid = job.metadata.get("local_pid")
+            if not pid:
+                raise HTTPException(status_code=400, detail="Missing local process id.")
+            import os
+            import signal
+            from datetime import datetime
+            from caddforge.core.job_registry import update_status
+
+            try:
+                os.killpg(os.getpgid(pid), signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+            run_directory = _resolve_run_directory(job, config.runs_root)
+            if run_directory:
+                job.run_directory = Path(run_directory)
+            job.status = JobStatus.CANCELLED
+            job.finished_at = datetime.now().astimezone()
+            if run_directory:
+                job.save_metadata(Path(run_directory) / "metadata.json")
+                results_dir = Path(run_directory) / "results"
+                results_dir.mkdir(parents=True, exist_ok=True)
+                from caddforge.core.result import Result
+
+                Result(
+                    job_id=job.id,
+                    tool_name=job.tool_name,
+                    status=JobStatus.CANCELLED,
+                    metrics={},
+                    paths={},
+                    extra={"cancelled": True},
+                ).save(results_dir / "results.json")
+            update_status(job.id, JobStatus.CANCELLED, finished_at=job.finished_at, registry_path=config.registry_path)
+            record_job(job, registry_path=config.registry_path)
+            return {"cancelled": True, "job_id": job.id}
+        raise HTTPException(status_code=400, detail="Backend does not support cancellation.")
+
+    @app.delete("/api/v1/jobs/{job_id}", dependencies=[auth_dependency])
+    def job_delete(job_id: str) -> dict[str, Any]:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        _delete_run_directory(run_directory)
+        delete_job(job_id, registry_path=config.registry_path)
+        return {"deleted": True, "job_id": job_id}
+
+    @app.get("/api/v1/jobs/{job_id}/logs/{stream}", dependencies=[auth_dependency])
+    async def job_logs(
+        request: Request,
+        job_id: str,
+        stream: str,
+        interval: float = 0.5,
+        tail_kb: int = 256,
+    ) -> StreamingResponse:
+        job = get_job(job_id, registry_path=config.registry_path)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        run_directory = _resolve_run_directory(job, config.runs_root)
+        if not run_directory:
+            raise HTTPException(status_code=404, detail="Run directory not found")
+        if stream not in {"stdout", "stderr"}:
+            raise HTTPException(status_code=400, detail="stream must be stdout or stderr")
+        path = Path(run_directory) / f"{stream}.log"
+        clamped_tail_kb = max(0, min(tail_kb, 4096))
+        async def _stream() -> AsyncGenerator[str, None]:
+            async for event in stream_log_events(path, interval, initial_tail_bytes=clamped_tail_kb * 1024):
+                if await request.is_disconnected():
+                    break
+                yield event
+
+        return StreamingResponse(_stream(), media_type="text/event-stream")
+
+    @app.get("/api/v1/dashboard", dependencies=[auth_dependency])
+    def dashboard() -> dict[str, Any]:
+        jobs = _list_jobs(config.registry_path, None)
+        return _dashboard_summary(jobs)
+
+    @app.get("/api/v1/gui/extensions", dependencies=[auth_dependency])
+    def gui_extensions() -> dict[str, Any]:
+        manifest = []
+        for ext in extensions:
+            remote_entry = None
+            if ext.frontend_dir and ext.remote_entry:
+                remote_entry = f"{config.base_path}/static/ext/{ext.plugin_id}/{ext.remote_entry}"
+            manifest.append(
+                {
+                    "plugin_id": ext.plugin_id,
+                    "display_name": ext.display_name,
+                    "api_version": ext.api_version,
+                    "ui_compat_version": ext.ui_compat_version,
+                    "nav_items": [
+                        {
+                            "path": item.path,
+                            "label": item.label,
+                            "module": item.module,
+                            "export": item.export,
+                            "icon": item.icon,
+                            "order": item.order,
+                        }
+                        for item in ext.nav_items
+                    ],
+                    "remote_entry": remote_entry,
+                    "remote_modules": [
+                        {"module": module.module, "export": module.export}
+                        for module in ext.remote_modules
+                    ],
+                }
+            )
+        return {"items": manifest}
+
+    def _index_html() -> str:
+        index_path = static_root / "index.html"
+        html = index_path.read_text(encoding="utf-8")
+        if config.base_path:
+            html = html.replace('href="/static/', f'href="{config.base_path}/static/')
+            html = html.replace('src="/static/', f'src="{config.base_path}/static/')
+            html = html.replace('window.__BASE_PATH__ = "";', f'window.__BASE_PATH__ = "{config.base_path}";')
+        return html
+
+    @app.get("/", response_class=HTMLResponse)
+    def index() -> HTMLResponse:
+        return HTMLResponse(_index_html())
+
+    @app.get("/{path:path}", response_class=HTMLResponse)
+    def spa_fallback(path: str) -> HTMLResponse:
+        if path.startswith("api") or path.startswith("static"):
+            raise HTTPException(status_code=404, detail="Not found")
+        return HTMLResponse(_index_html())
+
+    return app
+
+
+def run_gui(config: GuiConfig) -> None:
+    import uvicorn
+
+    app = create_app(config)
+    uvicorn.run(app, host=config.host, port=config.port)
+
+
+def main() -> None:
+    config = build_config()
+    run_gui(config)