Delete app.py

app.py

@@ -1,172 +0,0 @@
-# app.py — Space API FastAPI (Docker)
-from __future__ import annotations
-from typing import Dict, Any
-import os, json, uuid, threading, time, traceback
-from pathlib import Path
-import logging, requests
-
-from fastapi import FastAPI, HTTPException, Query
-from fastapi.responses import JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-# --- Remplace ces imports par ton vrai parseur/exports
-# from rfp_parser.prompting import build_chat_payload
-# from rfp_parser.exports_xls import build_xls_from_doc
-
-def build_chat_payload(text: str, model: str) -> Dict[str, Any]:
-    # TODO: branche ton vrai payload
-    return {
-        "model": model,
-        "max_tokens": 2048,
-        "messages": [{"role":"user","content": text}],
-        "temperature": 0.2,
-    }
-
-def build_xls_from_doc(doc: Dict[str, Any], out_path: str, baseline_kg: float = 100.0):
-    # TODO: branche ton vrai export XLSX
-    # Ici on crée juste un xlsx vide pour la démo
-    import pandas as pd
-    df = pd.DataFrame([{"baseline_kg": baseline_kg, "ok": True}])
-    df.to_excel(out_path, index=False)
-
-# ---------------- Config ----------------
-DEEPINFRA_API_KEY = os.environ.get("DEEPINFRA_API_KEY", "")
-MODEL_NAME        = os.environ.get("RFP_MODEL", "meta-llama/Meta-Llama-3.1-70B-Instruct")
-DEEPINFRA_URL     = os.environ.get("DEEPINFRA_URL", "https://api.deepinfra.com/v1/openai/chat/completions")
-RFP_DEBUG         = str(os.environ.get("RFP_DEBUG", "0")).lower() in {"1", "true", "yes"}
-BASE_TMP          = Path("/tmp/rfp_jobs"); BASE_TMP.mkdir(parents=True, exist_ok=True)
-
-logger = logging.getLogger("RFP_API")
-if not logger.handlers:
-    h = logging.StreamHandler()
-    h.setFormatter(logging.Formatter("[API] %(levelname)s: %(message)s"))
-    logger.addHandler(h)
-logger.setLevel(logging.DEBUG if RFP_DEBUG else logging.INFO)
-
-# -------------- Jobs en mémoire --------------
-JOBS: Dict[str, Dict[str, Any]] = {}
-JOBS_LOCK = threading.Lock()
-
-def new_job(text: str) -> str:
-    job_id = uuid.uuid4().hex[:12]
-    with JOBS_LOCK:
-        JOBS[job_id] = {
-            "status": "queued",
-            "error": None,
-            "xlsx_path": None,
-            "xlsx_url": None,
-            "started_at": time.time(),
-            "done_at": None,
-            "meta": {"model": MODEL_NAME, "length": len(text or "")},
-        }
-    return job_id
-
-def set_job_status(job_id: str, **updates):
-    with JOBS_LOCK:
-        if job_id in JOBS:
-            JOBS[job_id].update(**updates)
-
-# -------------- Cœur pipeline --------------
-def parse_with_deepinfra(text: str) -> Dict[str, Any]:
-    if not DEEPINFRA_API_KEY:
-        raise RuntimeError("DEEPINFRA_API_KEY non défini.")
-    payload = build_chat_payload(text, model=MODEL_NAME)
-    headers = {"Authorization": f"Bearer {DEEPINFRA_API_KEY}", "Content-Type": "application/json"}
-    logger.info("Appel DeepInfra model=%s max_tokens=%s", payload.get("model"), payload.get("max_tokens"))
-    r = requests.post(DEEPINFRA_URL, headers=headers, json=payload, timeout=120)
-    if r.status_code // 100 != 2:
-        raise RuntimeError(f"DeepInfra HTTP {r.status_code}: {r.text}")
-    data = r.json()
-    try:
-        content = data["choices"][0]["message"]["content"]
-    except Exception:
-        raise RuntimeError(f"Réponse inattendue DeepInfra: {json.dumps(data)[:400]}")
-    try:
-        doc = json.loads(content)
-    except Exception as e:
-        logger.warning("Échec json.loads(content); tentative strip. Err=%s", e)
-        doc = json.loads(content.strip().strip('`').strip())
-    if not isinstance(doc, dict):
-        raise RuntimeError("Le contenu renvoyé n'est pas un objet JSON.")
-    return doc
-
-def build_xlsx(doc: Dict[str, Any], job_dir: Path) -> str:
-    job_dir.mkdir(parents=True, exist_ok=True)
-    out_path = str(job_dir / "feuille_de_charge.xlsx")
-    baseline = (doc.get("assumptions") or {}).get("baseline_uop_kg") or 100.0
-    try:
-        baseline = float(baseline)
-    except Exception:
-        baseline = 100.0
-    build_xls_from_doc(doc, out_path, baseline_kg=baseline)
-    return out_path
-
-def run_job(job_id: str, text: str) -> None:
-    set_job_status(job_id, status="running")
-    job_dir = BASE_TMP / job_id
-    try:
-        doc = parse_with_deepinfra(text)
-        xlsx_path = build_xlsx(doc, job_dir)
-        xlsx_url = f"/results/{job_id}/feuille_de_charge.xlsx"   # pas de /api en Docker (c’est la racine)
-        set_job_status(job_id, status="done", xlsx_path=xlsx_path, xlsx_url=xlsx_url,
-                       done_at=time.time(), meta={**JOBS[job_id]["meta"], "assumptions": doc.get("assumptions")})
-        logger.info("Job %s terminé -> %s", job_id, xlsx_path)
-    except Exception as e:
-        logger.error("Job %s échoué: %s\n%s", job_id, e, traceback.format_exc())
-        set_job_status(job_id, status="error", error=str(e), done_at=time.time())
-
-# -------------- FastAPI app --------------
-app = FastAPI(title="RFP_MASTER API", version="1.0.0")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.get("/health")
-def health():
-    return {"ok": True, "ts": time.time(), "model": MODEL_NAME}
-
-@app.post("/submit")
-def submit(payload: Dict[str, Any]):
-    text = (payload or {}).get("text", "")
-    if not isinstance(text, str) or not text.strip():
-        raise HTTPException(400, "Champ 'text' manquant ou vide.")
-    job_id = new_job(text)
-    logger.info("Submit reçu job_id=%s len(text)=%d", job_id, len(text))
-    t = threading.Thread(target=run_job, args=(job_id, text), daemon=True)
-    t.start()
-    return JSONResponse({"job_id": job_id, "status": "queued"})
-
-@app.get("/status")
-def status(job_id: str = Query(..., description="Identifiant renvoyé par /submit")):
-    with JOBS_LOCK:
-        info = JOBS.get(job_id)
-    if not info:
-        raise HTTPException(404, f"job_id inconnu: {job_id}")
-    return JSONResponse({
-        "job_id": job_id,
-        "status": info.get("status"),
-        "xlsx_url": info.get("xlsx_url"),
-        "error": info.get("error"),
-        "meta": info.get("meta"),
-    })
-
-@app.get("/results/{job_id}/feuille_de_charge.xlsx")
-def download(job_id: str):
-    with JOBS_LOCK:
-        info = JOBS.get(job_id)
-    if not info:
-        raise HTTPException(404, f"job_id inconnu: {job_id}")
-    if info.get("status") != "done":
-        raise HTTPException(409, f"job {job_id} non prêt (status={info.get('status')})")
-    xlsx_path = info.get("xlsx_path")
-    if not xlsx_path or not Path(xlsx_path).exists():
-        raise HTTPException(404, "Fichier indisponible.")
-    return FileResponse(
-        xlsx_path,
-        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        filename="feuille_de_charge.xlsx",
-    )