# 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", )