Update server.py

server.py

@@ -2,11 +2,16 @@
 import numpy as np
 import pandas as pd
 import cloudpickle as cp
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import traceback
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(
     title="Incassi API",
@@ -16,103 +21,197 @@ app = FastAPI(
     redoc_url="/redoc",
 )
 
-# CORS: inizia permissivo, poi restringi al dominio Lovable
+# CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # poi metti ["https://<tuo-dominio-lovable>"]
+    allow_origins=["*"],  
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Carica l'artefatto con cloudpickle
-with open("incassi_model.pkl", "rb") as f:
-    mdl = cp.load(f)
-
-
-
-
+# Carica il modello con debug dettagliato
+try:
+    logger.info("🔧 Caricamento modello in corso...")
+    with open("incassi_model.pkl", "rb") as f:
+        mdl = cp.load(f)
+    logger.info(f"✅ Modello caricato - Versione: {getattr(mdl, 'model_version', 'unknown')}")
+    
+    # Test rapido del modello
+    test_df = pd.DataFrame([{
+        "Debitore_cluster": "A", 
+        "Importo iniziale outstanding": 10000.0,
+        "giorni_da_iscrizione": 100,
+        "giorni_da_cessione": 50
+    }])
+    test_result = mdl.predict(test_df)
+    logger.info(f"🎯 Test modello riuscito - yhat: {test_result[2]:.2f}")
+    
+except Exception as e:
+    logger.error(f"❌ ERRORE CRITICO nel caricamento modello: {e}")
+    traceback.print_exc()
+    raise e
 
+# ===== PYDANTIC MODELS CON VALIDAZIONE MIGLIORATA =====
 class PredictIn(BaseModel):
-    Debitore_cluster: str | None = None
-    Stato_Giudizio: str | None = None
-    Cedente: str | None = None
-    Importo_iniziale_outstanding: float | None = None
-    Decreto_sospeso: str | int | None = None
-    Notifica_Decreto: str | int | None = None
-    Opposizione_al_decreto_ingiuntivo: str | int | None = None
-    Ricorso_al_TAR: str | int | None = None
-    Sentenza_TAR: str | int | None = None
-    Atto_di_Precetto: str | int | None = None
-    Decreto_Ingiuntivo: str | int | None = None
-    Sentenza_giudizio_opposizione: str | int | None = None
-    giorni_da_iscrizione: int | None = None
-    giorni_da_cessione: int | None = None
-    Zona: str | None = None
+    # Usa Field con alias per gestire nomi diversi
+    Debitore_cluster: str | None = Field(default=None, description="Cluster del debitore")
+    Stato_Giudizio: str | None = Field(default=None, description="Stato del giudizio")
+    Cedente: str | None = Field(default=None, description="Cedente")
+    Importo_iniziale_outstanding: float | None = Field(default=None, ge=0.0, description="Importo iniziale outstanding")
+    Decreto_sospeso: str | int | None = Field(default=None, description="Decreto sospeso")
+    Notifica_Decreto: str | int | None = Field(default=None, description="Notifica decreto")
+    Opposizione_al_decreto_ingiuntivo: str | int | None = Field(default=None, description="Opposizione al decreto ingiuntivo")
+    Ricorso_al_TAR: str | int | None = Field(default=None, description="Ricorso al TAR")
+    Sentenza_TAR: str | int | None = Field(default=None, description="Sentenza TAR")
+    Atto_di_Precetto: str | int | None = Field(default=None, description="Atto di precetto")
+    Decreto_Ingiuntivo: str | int | None = Field(default=None, description="Decreto ingiuntivo")
+    Sentenza_giudizio_opposizione: str | int | None = Field(default=None, description="Sentenza giudizio opposizione")
+    giorni_da_iscrizione: int | None = Field(default=None, ge=0, description="Giorni da iscrizione")
+    giorni_da_cessione: int | None = Field(default=None, ge=0, description="Giorni da cessione")
+    Zona: str | None = Field(default=None, description="Zona")
 
 class CurveIn(PredictIn):
-    iscr_start: int = 0
-    iscr_end: int = 1500
-    step: int = 50
+    iscr_start: int = Field(default=0, ge=0, description="Giorni da iscrizione - inizio")
+    iscr_end: int = Field(default=1500, ge=0, description="Giorni da iscrizione - fine")
+    step: int = Field(default=50, ge=1, description="Step per la curva")
 
-# --------- Mapper: API -> nomi "raw" del training ---------
-def _to_df(d: dict) -> pd.DataFrame:
-    return pd.DataFrame([{
-        "Debitore_cluster": d.get("Debitore_cluster"),
-        "Stato_Giudizio": d.get("Stato_Giudizio"),
-        "Cedente": d.get("Cedente"),
-        "Importo iniziale outstanding": d.get("Importo_iniziale_outstanding"),
-        "Decreto sospeso": d.get("Decreto_sospeso"),
-        "Notifica Decreto": d.get("Notifica_Decreto"),
-        "Opposizione al decreto ingiuntivo": d.get("Opposizione_al_decreto_ingiuntivo"),
-        "Ricorso al TAR": d.get("Ricorso_al_TAR"),
-        "Sentenza TAR": d.get("Sentenza_TAR"),
-        "Atto di Precetto": d.get("Atto_di_Precetto"),
-        "Decreto Ingiuntivo": d.get("Decreto_Ingiuntivo"),
-        "Sentenza giudizio opposizione": d.get("Sentenza_giudizio_opposizione"),
-        "giorni_da_iscrizione": d.get("giorni_da_iscrizione"),
-        "giorni_da_cessione": d.get("giorni_da_cessione"),
-        "Zona": d.get("Zona"),
-    }])
+# ===== UTILITY FUNCTIONS =====
+def _to_model_format(d: dict) -> pd.DataFrame:
+    """Converte input API -> formato atteso dal modello"""
+    logger.info(f"🔄 Conversione input: {d}")
+    
+    try:
+        # Mapping esplicito API -> modello
+        row = {
+            "Debitore_cluster": d.get("Debitore_cluster"),
+            "Stato_Giudizio": d.get("Stato_Giudizio"), 
+            "Cedente": d.get("Cedente"),
+            "Importo iniziale outstanding": d.get("Importo_iniziale_outstanding"),  # ⚠️ Nota l'underscore -> spazio
+            "Decreto sospeso": d.get("Decreto_sospeso"),
+            "Notifica Decreto": d.get("Notifica_Decreto"),
+            "Opposizione al decreto ingiuntivo": d.get("Opposizione_al_decreto_ingiuntivo"),
+            "Ricorso al TAR": d.get("Ricorso_al_TAR"),
+            "Sentenza TAR": d.get("Sentenza_TAR"),
+            "Atto di Precetto": d.get("Atto_di_Precetto"),
+            "Decreto Ingiuntivo": d.get("Decreto_Ingiuntivo"),
+            "Sentenza giudizio opposizione": d.get("Sentenza_giudizio_opposizione"),
+            "giorni_da_iscrizione": d.get("giorni_da_iscrizione"),
+            "giorni_da_cessione": d.get("giorni_da_cessione"),
+            "Zona": d.get("Zona"),
+        }
+        
+        df = pd.DataFrame([row])
+        logger.info(f"✅ Conversione completata - Shape: {df.shape}")
+        return df
+        
+    except Exception as e:
+        logger.error(f"❌ Errore nella conversione: {e}")
+        raise HTTPException(status_code=400, detail=f"Errore nella conversione dati: {str(e)}")
 
-# --------- Endpoints ---------
+# ===== ENDPOINTS =====
 @app.get("/")
 def root():
-    return {"ok": True, "service": "incassi-api"}
+    return {
+        "ok": True, 
+        "service": "incassi-api",
+        "model_version": getattr(mdl, "model_version", "unknown")
+    }
 
 @app.get("/version")
 def version():
     return {
         "model_version": getattr(mdl, "model_version", "unknown"),
         "p100_threshold": float(getattr(mdl, "p100_thr", 0.5)),
+        "expected_features": len(getattr(mdl, "feat_cols_full", [])),
     }
 
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    try:
+        # Quick model test
+        test_df = pd.DataFrame([{"giorni_da_iscrizione": 100}])
+        _ = mdl._ensure_raw_cols(test_df)
+        return {"status": "healthy", "model": "loaded"}
+    except Exception as e:
+        raise HTTPException(status_code=503, detail=f"Model unhealthy: {str(e)}")
+
 @app.post("/predict")
 def predict(inp: PredictIn):
+    """Predizione singola"""
     try:
-        df = _to_df(inp.dict())
+        logger.info("🚀 /predict chiamato")
+        logger.info(f"📥 Input ricevuto: {inp.dict()}")
+        
+        # Converti input -> formato modello
+        df = _to_model_format(inp.dict())
+        logger.info(f"🔄 DataFrame creato: {df.shape}")
+        
+        # Predizione
+        logger.info("🔧 Esecuzione predizione...")
         p100, prob_ord, yhat, final_class, _ = mdl.predict(df)
-        return {
+        
+        result = {
             "p100": float(p100),
             "prob_ord": np.asarray(prob_ord, dtype=float).tolist(),
             "yhat": float(yhat),
             "final_class": str(final_class),
         }
+        
+        logger.info(f"✅ Predizione completata: yhat={result['yhat']:.2f}")
+        return result
+        
+    except HTTPException:
+        raise  # Re-raise HTTP exceptions
     except Exception as e:
-        print("PREDICT ERROR:\n", traceback.format_exc())
-        return JSONResponse(status_code=500, content={"error": str(e)})
+        logger.error(f"❌ ERRORE in /predict: {e}")
+        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Errore interno: {str(e)}")
 
 @app.post("/curve_iscrizione")
 def curve_iscrizione(inp: CurveIn):
+    """Curva di crescita per giorni da iscrizione"""
     try:
-        base = inp.dict()
-        out = mdl.curve_iscrizione(base, inp.iscr_start, inp.iscr_end, inp.step)
-        # JSON-safe
-        out["x"] = [int(v) for v in out.get("x", [])]
-        out["p100"] = [float(v) for v in out.get("p100", [])]
-        for k, arr in list(out.get("classes", {}).items()):
-            out["classes"][k] = [float(v) for v in arr]
-        return out
+        logger.info("🚀 /curve_iscrizione chiamato")
+        
+        # Validazione parametri
+        if inp.iscr_end <= inp.iscr_start:
+            raise HTTPException(status_code=400, detail="iscr_end deve essere > iscr_start")
+        
+        if (inp.iscr_end - inp.iscr_start) / inp.step > 1000:
+            raise HTTPException(status_code=400, detail="Troppi punti nella curva (max 1000)")
+        
+        # Converti input -> base row
+        base_dict = inp.dict()
+        
+        # Esegui curva
+        logger.info(f"🔧 Calcolo curva: {inp.iscr_start}-{inp.iscr_end} step {inp.step}")
+        out = mdl.curve_iscrizione(base_dict, inp.iscr_start, inp.iscr_end, inp.step)
+        
+        # JSON-safe conversion
+        result = {
+            "x": [int(v) for v in out.get("x", [])],
+            "p100": [float(v) for v in out.get("p100", [])],
+            "classes": {}
+        }
+        
+        for k, arr in out.get("classes", {}).items():
+            result["classes"][k] = [float(v) for v in arr]
+            
+        logger.info(f"✅ Curva completata: {len(result['x'])} punti")
+        return result
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        print("CURVE ERROR:\n", traceback.format_exc())
-        return JSONResponse(status_code=500, content={"error": str(e)})
+        logger.error(f"❌ ERRORE in /curve_iscrizione: {e}")
+        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Errore interno: {str(e)}")
+
+# ===== STARTUP EVENT =====
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🚀 API avviata con successo")
+    logger.info(f"📋 Modello version: {getattr(mdl, 'model_version', 'unknown')}")
+    logger.info(f"🎯 Soglia p100: {getattr(mdl, 'p100_thr', 0.5):.3f}")