demo(A): local pdf storage + PUT/GET /api/pdf

backend/api.py

@@ -1,32 +1,20 @@
 from __future__ import annotations
 
-import json
-import re
 import os
-import socket
-import paramiko
-import concurrent.futures
-
+import time
 from pathlib import Path
-from typing import Any, Dict
+from typing import Dict, Optional
+from uuid import uuid4
+from collections import deque
+from dataclasses import dataclass, asdict
 
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException, Response, Header, Request
+from fastapi import FastAPI, HTTPException, Header, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
-
-
-# ------------------------------------------------------------------
-# App
-# ------------------------------------------------------------------
+from fastapi.responses import FileResponse, JSONResponse
+from pydantic import BaseModel
 
 app = FastAPI(title="PDF Trainer API", version="1.0")
 
-
-# ------------------------------------------------------------------
-# CORS
-# ------------------------------------------------------------------
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[
@@ -38,171 +26,76 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+WORKER_TOKEN = (os.getenv("WORKER_TOKEN") or "").strip()
+DATA_DIR = Path(os.getenv("DATA_DIR", "/app/data")).resolve()
+PDF_DIR = DATA_DIR / "pdfs"
+CFG_DIR = DATA_DIR / "configs"
 
-# ------------------------------------------------------------------
-# Paths & env
-# ------------------------------------------------------------------
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-BACKEND_DIR = REPO_ROOT / "backend"
-UPLOADS_DIR = BACKEND_DIR / "worker" / "uploads"
-
-UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
-
-load_dotenv(BACKEND_DIR / ".env", override=True)
-
-
-# ------------------------------------------------------------------
-# Helpers
-# ------------------------------------------------------------------
-
-def _require_env(key: str) -> str:
-    val = (os.environ.get(key) or "").strip()
-    if not val:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Server misconfigured: missing env var {key}",
-        )
-    return val
-
+PDF_DIR.mkdir(parents=True, exist_ok=True)
+CFG_DIR.mkdir(parents=True, exist_ok=True)
 
-def _gmail_client():
-    # LAZY IMPORT — do not move to top
-    from backend.worker.gmail_client import GmailClient
-
-    credentials_json = Path(
-        os.environ.get(
-            "GMAIL_CREDENTIALS_JSON",
-            BACKEND_DIR / "credentials.json",
-        )
-    )
-
-    token_json = Path(
-        os.environ.get(
-            "GMAIL_TOKEN_JSON",
-            BACKEND_DIR / "token.json",
-        )
-    )
-
-    return GmailClient(credentials_json, token_json)
-
-
-# ------------------------------------------------------------------
-# Health / root
-# ------------------------------------------------------------------
+def _require_worker_token(x_worker_token: Optional[str]):
+    if not WORKER_TOKEN:
+        raise HTTPException(status_code=500, detail="Server missing WORKER_TOKEN")
+    if not x_worker_token or x_worker_token != WORKER_TOKEN:
+        raise HTTPException(status_code=401, detail="Unauthorized worker")
 
 @app.get("/health")
 def health() -> Dict[str, bool]:
     return {"ok": True}
 
-
 @app.get("/")
 def root() -> Dict[str, str]:
     return {"service": "pdf-trainer-api", "status": "running"}
 
-
-# ------------------------------------------------------------------
-# API endpoints
-# ------------------------------------------------------------------
-
-# ------------------------------------------------------------------
-# PDF storage (local to API container)
-# Worker uploads PDFs here. UI fetches from here.
-# ------------------------------------------------------------------
-
-PDF_STORE_DIR = Path(os.getenv("PDF_STORE_DIR", "/app/data/pdfs")).resolve()
-PDF_STORE_DIR.mkdir(parents=True, exist_ok=True)
-
-def _require_worker_token(x_worker_token: Optional[str]):
-    # reuse global WORKER_TOKEN if you already have it later in the file
-    token = os.getenv("WORKER_TOKEN", "").strip()
-    if not token:
-        raise HTTPException(status_code=500, detail="Server missing WORKER_TOKEN")
-    if not x_worker_token or x_worker_token != token:
-        raise HTTPException(status_code=401, detail="Unauthorized worker")
-
-def _safe_id(s: str) -> str:
-    # keep it simple: allow only safe filename chars
-    return re.sub(r"[^a-zA-Z0-9_.-]+", "_", s)
-
-@app.post("/api/pdf/{pdf_id}")
-async def put_pdf(pdf_id: str, request: Request, x_worker_token: Optional[str] = Header(default=None)):
+def _pdf_path(pdf_id: str) -> Path:
+    safe = pdf_id.strip().replace("/", "_")
+    if not safe:
+        raise HTTPException(status_code=400, detail="Missing pdf_id")
+    if not safe.lower().endswith(".pdf"):
+        safe = safe + ".pdf"
+    return PDF_DIR / safe
+
+@app.put("/api/pdf/{pdf_id}")
+async def put_pdf(
+    pdf_id: str,
+    request: Request,
+    x_worker_token: Optional[str] = Header(default=None),
+):
     _require_worker_token(x_worker_token)
-    pid = _safe_id(pdf_id)
-    data = await request.body()
-    if not data:
+    body = await request.body()
+    if not body:
         raise HTTPException(status_code=400, detail="Empty body")
-    if len(data) > 50 * 1024 * 1024:
-        raise HTTPException(status_code=413, detail="PDF too large")
-    out = PDF_STORE_DIR / (pid if pid.lower().endswith(".pdf") else pid + ".pdf")
-    out.write_bytes(data)
-    return {"ok": True, "pdf_id": pid, "bytes": len(data)}
+    p = _pdf_path(pdf_id)
+    p.write_bytes(body)
+    return {"ok": True, "pdf_id": p.stem, "bytes": len(body)}
 
 @app.get("/api/pdf/{pdf_id}")
 def get_pdf(pdf_id: str):
-    pid = _safe_id(pdf_id)
-    f = PDF_STORE_DIR / (pid if pid.lower().endswith(".pdf") else pid + ".pdf")
-    if not f.exists():
+    p = _pdf_path(pdf_id)
+    if not p.exists():
         raise HTTPException(status_code=404, detail="PDF not found")
-    data = f.read_bytes()
-    return Response(content=data, media_type="application/pdf")
+    return FileResponse(str(p), media_type="application/pdf", filename=p.name)
 
 @app.post("/api/send-config")
-def send_config(payload: Dict[str, Any]):
-    # Expect payload to include at least: pdf_id, template_id, config
+async def send_config(payload: dict):
     pdf_id = str(payload.get("pdf_id", "")).strip()
     template_id = str(payload.get("template_id", "")).strip()
     config = payload.get("config")
-
     if not pdf_id or not template_id or config is None:
         raise HTTPException(status_code=400, detail="Missing pdf_id/template_id/config")
-
-    store = SFTPStore()
-    remote_json = f"configs/{pdf_id}_{template_id}.json"
-    store.put_bytes(remote_json, json.dumps(payload, indent=2).encode("utf-8"))
-
-    return {"ok": True, "stored": remote_json}
-
-
-@app.post("/api/notify-unknown")
-def notify_unknown(payload: Dict[str, Any]):
-    client = _gmail_client()
-
-    client.send_email(
-        to=_require_env("ALERT_EMAIL"),
-        subject="PDF Trainer: Unknown document",
-        body=json.dumps(payload, indent=2),
-    )
-
-    return {"ok": True}
-
-# ------------------------------------------------------------------
-# Worker job queue (in-memory, Phase 2)
-# ------------------------------------------------------------------
-
-from collections import deque
-from dataclasses import dataclass, asdict
-from typing import Optional
-from uuid import uuid4
-import time
-from fastapi import Header
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-
-WORKER_TOKEN = os.getenv("WORKER_TOKEN", "")
-
-def _require_worker_token(x_worker_token: Optional[str]):
-    if not WORKER_TOKEN:
-        raise HTTPException(status_code=500, detail="Server missing WORKER_TOKEN")
-    if not x_worker_token or x_worker_token != WORKER_TOKEN:
-        raise HTTPException(status_code=401, detail="Unauthorized worker")
+    cfg_name = f"{pdf_id}_{template_id}_{uuid4().hex}.json"
+    out = CFG_DIR / cfg_name
+    import json
+    out.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return {"ok": True, "saved": cfg_name}
 
 @dataclass
 class Job:
     id: str
     payload: dict
     created_at: float
-    status: str = "queued"  # queued|running|done|failed
+    status: str = "queued"
     message: str = ""
 
 JOBQ: deque[Job] = deque()
@@ -227,10 +120,10 @@ def jobs_next(x_worker_token: Optional[str] = Header(default=None)):
         if job.status == "queued":
             job.status = "running"
             return asdict(job)
-    return Response(status_code=204)
+    return JSONResponse(status_code=204, content=None)
 
 class StatusReq(BaseModel):
-    status: str  # running|done|failed
+    status: str
     message: str = ""
 
 @app.post("/api/jobs/{job_id}/status")
@@ -244,60 +137,3 @@ def jobs_status(job_id: str, req: StatusReq, x_worker_token: Optional[str] = Hea
     job.status = req.status
     job.message = req.message
     return {"ok": True, "job_id": job_id, "status": job.status}
-
-@app.get("/api/sftp-test")
-def api_sftp_test():
-    host = (os.getenv("SFTP_HOST") or "").strip()
-    port = int((os.getenv("SFTP_PORT") or "2222").strip())
-    user = (os.getenv("SFTP_USER") or "").strip()
-    pw   = (os.getenv("SFTP_PASS") or "").strip()
-    root = (os.getenv("SFTP_ROOT") or ".").strip() or "."
-    timeout = float((os.getenv("SFTP_TIMEOUT_SECONDS") or "8").strip())
-
-    if not host or not user or not pw:
-        raise HTTPException(status_code=500, detail="Missing SFTP secrets: SFTP_HOST/SFTP_USER/SFTP_PASS")
-
-    t0 = time.time()
-    # HARD socket timeout
-    try:
-        sock = socket.create_connection((host, port), timeout=timeout)
-    except Exception as e:
-        return JSONResponse({"ok": False, "stage": "connect", "error": str(e), "host": host, "port": port, "timeout": timeout}, status_code=502)
-    t_sock = time.time()
-
-    tr = paramiko.Transport(sock)
-    tr.banner_timeout = timeout
-    tr.auth_timeout = timeout
-
-    tr.connect(username=user, password=pw)
-    t_auth = time.time()
-
-    sftp = paramiko.SFTPClient.from_transport(tr)
-
-    out = {
-        "ok": False,
-        "host": host,
-        "port": port,
-        "user": user,
-        "root": root,
-        "timeout": timeout,
-        "t_sock_ms": int((t_sock - t0) * 1000),
-        "t_auth_ms": int((t_auth - t_sock) * 1000),
-    }
-
-    try:
-        sftp.chdir(root)
-        out["listdir_root"] = sftp.listdir(".")[:50]
-        try:
-            st = sftp.stat("pdfs/demo_test_003.pdf")
-            out["stat_demo_test_003"] = {"size": st.st_size}
-        except Exception as e:
-            out["stat_demo_test_003_error"] = str(e)
-        out["ok"] = True
-        return JSONResponse(out)
-    finally:
-        try:
-            sftp.close()
-        finally:
-            tr.close()
-

requirements.txt

@@ -1,4 +1,4 @@
 fastapi
-uvicorn
+uvicorn[standard]
 python-dotenv
-paramiko
+pydantic