app.py

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