Update server.py

server.py

@@ -4,214 +4,225 @@ import pandas as pd
 import cloudpickle as cp
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 import traceback
 import logging
+import sys
 
-# Setup logging
-logging.basicConfig(level=logging.INFO)
+# Setup logging più dettagliato
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
 logger = logging.getLogger(__name__)
 
 app = FastAPI(
-    title="Incassi API",
-    description="API per predire incassi con hurdle logit + ordinal XGB",
-    version="1.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
+    title="Incassi API - Debug Mode",
+    description="API per debug del modello incassi", 
+    version="debug-1.0"
 )
 
-# CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# 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):
-    # 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 = 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")
+# Variabile globale per il modello
+mdl = None
 
-# ===== UTILITY FUNCTIONS =====
-def _to_model_format(d: dict) -> pd.DataFrame:
-    """Converte input API -> formato atteso dal modello"""
-    logger.info(f"🔄 Conversione input: {d}")
-    
+# ===== CARICAMENTO MODELLO CON STEP-BY-STEP DEBUG =====
+def load_model():
+    global mdl
     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"),
-        }
+        logger.info("🔧 STEP 1: Inizio caricamento modello...")
+        
+        # Verifica esistenza file
+        import os
+        if not os.path.exists("incassi_model.pkl"):
+            raise FileNotFoundError("File incassi_model.pkl non trovato")
+        
+        file_size = os.path.getsize("incassi_model.pkl")
+        logger.info(f"📁 File trovato - Dimensione: {file_size} bytes")
         
-        df = pd.DataFrame([row])
-        logger.info(f"✅ Conversione completata - Shape: {df.shape}")
-        return df
+        # Carica il modello
+        logger.info("🔧 STEP 2: Caricamento pickle...")
+        with open("incassi_model.pkl", "rb") as f:
+            mdl = cp.load(f)
+        
+        logger.info("🔧 STEP 3: Modello caricato in memoria")
+        logger.info(f"📋 Tipo modello: {type(mdl)}")
+        logger.info(f"📋 Versione: {getattr(mdl, 'model_version', 'N/A')}")
+        
+        # Test attributi base (SENZA chiamare predict)
+        logger.info("🔧 STEP 4: Verifica attributi modello...")
+        logger.info(f"📋 p100_thr: {getattr(mdl, 'p100_thr', 'N/A')}")
+        logger.info(f"📋 feat_cols_full length: {len(getattr(mdl, 'feat_cols_full', []))}")
+        logger.info(f"📋 stage1 type: {type(getattr(mdl, 'stage1', None))}")
+        logger.info(f"📋 stage2 type: {type(getattr(mdl, 'stage2', None))}")
+        
+        logger.info("✅ STEP 5: Modello caricato con successo (SENZA test predict)")
+        return True
         
     except Exception as e:
-        logger.error(f"❌ Errore nella conversione: {e}")
-        raise HTTPException(status_code=400, detail=f"Errore nella conversione dati: {str(e)}")
+        logger.error(f"❌ ERRORE nel caricamento modello: {e}")
+        logger.error(f"❌ Traceback completo:\n{traceback.format_exc()}")
+        return False
+
+# Carica modello all'import
+model_loaded = load_model()
+if not model_loaded:
+    logger.error("❌ FATALE: Impossibile caricare il modello")
+
+# ===== PYDANTIC MODELS SEMPLIFICATI =====
+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 | None = None
+    Notifica_Decreto: str | None = None
+    Opposizione_al_decreto_ingiuntivo: str | None = None
+    Ricorso_al_TAR: str | None = None
+    Sentenza_TAR: str | None = None
+    Atto_di_Precetto: str | None = None
+    Decreto_Ingiuntivo: str | None = None
+    Sentenza_giudizio_opposizione: str | None = None
+    giorni_da_iscrizione: int | None = None
+    giorni_da_cessione: int | None = None
+    Zona: str | None = None
+
+def _to_model_format(d: dict) -> pd.DataFrame:
+    """Conversione input -> formato modello"""
+    logger.info("🔄 Conversione input in corso...")
+    
+    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"),
+        "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"✅ DataFrame creato - Shape: {df.shape}")
+    return df
 
 # ===== ENDPOINTS =====
 @app.get("/")
 def root():
     return {
-        "ok": True, 
-        "service": "incassi-api",
-        "model_version": getattr(mdl, "model_version", "unknown")
+        "ok": True,
+        "service": "incassi-api-debug",
+        "model_loaded": model_loaded,
+        "model_version": getattr(mdl, "model_version", "N/A") if mdl else "N/A"
     }
 
-@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"""
+@app.get("/status")
+def status():
+    """Status dettagliato del sistema"""
+    if not mdl:
+        return {"error": "Modello non caricato"}
+    
     try:
-        # Quick model test
-        test_df = pd.DataFrame([{"giorni_da_iscrizione": 100}])
-        _ = mdl._ensure_raw_cols(test_df)
-        return {"status": "healthy", "model": "loaded"}
+        return {
+            "model_loaded": True,
+            "model_type": str(type(mdl)),
+            "model_version": getattr(mdl, "model_version", "N/A"),
+            "p100_threshold": getattr(mdl, "p100_thr", "N/A"),
+            "features_count": len(getattr(mdl, "feat_cols_full", [])),
+            "stage1_loaded": hasattr(mdl, "stage1") and mdl.stage1 is not None,
+            "stage2_loaded": hasattr(mdl, "stage2") and mdl.stage2 is not None,
+        }
     except Exception as e:
-        raise HTTPException(status_code=503, detail=f"Model unhealthy: {str(e)}")
+        return {"error": f"Errore status: {e}"}
 
-@app.post("/predict")
-def predict(inp: PredictIn):
-    """Predizione singola"""
+@app.post("/test_simple")
+def test_simple(inp: PredictIn):
+    """Test semplificato - solo conversione dati"""
     try:
-        logger.info("🚀 /predict chiamato")
-        logger.info(f"📥 Input ricevuto: {inp.dict()}")
+        logger.info("🧪 Test semplice avviato...")
+        
+        if not mdl:
+            raise HTTPException(status_code=503, detail="Modello non caricato")
         
-        # Converti input -> formato modello
+        # Solo conversione, SENZA predict
         df = _to_model_format(inp.dict())
-        logger.info(f"🔄 DataFrame creato: {df.shape}")
+        logger.info(f"✅ Conversione riuscita: {df.shape}")
         
-        # Predizione
-        logger.info("🔧 Esecuzione predizione...")
-        p100, prob_ord, yhat, final_class, _ = mdl.predict(df)
+        # Test solo _ensure_raw_cols (metodo più semplice)
+        logger.info("🔧 Test _ensure_raw_cols...")
+        df_ensured = mdl._ensure_raw_cols(df)
+        logger.info(f"✅ _ensure_raw_cols riuscito: {df_ensured.shape}")
         
-        result = {
-            "p100": float(p100),
-            "prob_ord": np.asarray(prob_ord, dtype=float).tolist(),
-            "yhat": float(yhat),
-            "final_class": str(final_class),
+        return {
+            "status": "success",
+            "input_shape": df.shape,
+            "ensured_shape": df_ensured.shape,
+            "columns": list(df.columns),
         }
         
-        logger.info(f"✅ Predizione completata: yhat={result['yhat']:.2f}")
-        return result
-        
-    except HTTPException:
-        raise  # Re-raise HTTP exceptions
     except Exception as e:
-        logger.error(f"❌ ERRORE in /predict: {e}")
+        logger.error(f"❌ Errore test_simple: {e}")
         logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Errore interno: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/curve_iscrizione")
-def curve_iscrizione(inp: CurveIn):
-    """Curva di crescita per giorni da iscrizione"""
+@app.post("/predict")  
+def predict(inp: PredictIn):
+    """Predizione completa con debug step-by-step"""
     try:
-        logger.info("🚀 /curve_iscrizione chiamato")
+        logger.info("🚀 PREDICT chiamato...")
         
-        # Validazione parametri
-        if inp.iscr_end <= inp.iscr_start:
-            raise HTTPException(status_code=400, detail="iscr_end deve essere > iscr_start")
+        if not mdl:
+            raise HTTPException(status_code=503, detail="Modello non caricato")
         
-        if (inp.iscr_end - inp.iscr_start) / inp.step > 1000:
-            raise HTTPException(status_code=400, detail="Troppi punti nella curva (max 1000)")
+        # Step 1: Conversione
+        logger.info("🔧 Step 1: Conversione input...")
+        df = _to_model_format(inp.dict())
         
-        # Converti input -> base row
-        base_dict = inp.dict()
+        # Step 2: Predict con cattura errore specifica
+        logger.info("🔧 Step 2: Chiamata mdl.predict...")
+        try:
+            result = mdl.predict(df)
+            logger.info("✅ mdl.predict completato")
+        except Exception as predict_error:
+            logger.error(f"❌ ERRORE SPECIFICO in mdl.predict: {predict_error}")
+            logger.error(f"❌ Tipo errore: {type(predict_error)}")
+            logger.error(f"❌ Traceback predict:\n{traceback.format_exc()}")
+            raise HTTPException(status_code=500, detail=f"Errore in predict: {predict_error}")
         
-        # 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)
+        # Step 3: Formattazione output
+        logger.info("🔧 Step 3: Formattazione output...")
+        p100, prob_ord, yhat, final_class, _ = result
         
-        # JSON-safe conversion
-        result = {
-            "x": [int(v) for v in out.get("x", [])],
-            "p100": [float(v) for v in out.get("p100", [])],
-            "classes": {}
+        response = {
+            "p100": float(p100),
+            "prob_ord": np.asarray(prob_ord, dtype=float).tolist(),
+            "yhat": float(yhat),
+            "final_class": str(final_class),
         }
         
-        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
+        logger.info(f"✅ Predizione completata: yhat={response['yhat']:.2f}")
+        return response
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"❌ ERRORE in /curve_iscrizione: {e}")
+        logger.error(f"❌ ERRORE GENERALE in predict: {e}")
         logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Errore interno: {str(e)}")
+        raise HTTPException(status_code=500, detail=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}")
+logger.info("🚀 Server inizializzato - Modello caricato senza test predict")