Update server.py

server.py

@@ -8,20 +8,19 @@ from pydantic import BaseModel
 import traceback
 import logging
 import sys
+import signal
+import threading
+import time
 
-# Setup logging più dettagliato
+# Setup logging ultra-dettagliato
 logging.basicConfig(
-    level=logging.INFO,
+    level=logging.DEBUG,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     handlers=[logging.StreamHandler(sys.stdout)]
 )
 logger = logging.getLogger(__name__)
 
-app = FastAPI(
-    title="Incassi API - Debug Mode",
-    description="API per debug del modello incassi", 
-    version="debug-1.0"
-)
+app = FastAPI(title="Incassi API - Super Debug", version="debug-2.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -31,53 +30,35 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Variabile globale per il modello
 mdl = None
 
-# ===== CARICAMENTO MODELLO CON STEP-BY-STEP DEBUG =====
+# Funzione di timeout per debug
+def timeout_handler(signum, frame):
+    logger.error("⏰ TIMEOUT! Operazione bloccata")
+    raise TimeoutError("Operazione bloccata oltre il timeout")
+
 def load_model():
     global mdl
     try:
-        logger.info("🔧 STEP 1: Inizio caricamento modello...")
+        logger.info("🔧 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")
+            raise FileNotFoundError("File non trovato")
         
-        # 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')}")
+        logger.info(f"✅ Modello caricato: {type(mdl)}")
+        logger.info(f"📋 Attributi: {dir(mdl)[:10]}...")  # primi 10 attributi
         
-        # 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 nel caricamento modello: {e}")
-        logger.error(f"❌ Traceback completo:\n{traceback.format_exc()}")
+        logger.error(f"❌ Errore caricamento: {e}")
         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
@@ -95,9 +76,9 @@ class PredictIn(BaseModel):
     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...")
+def safe_to_model_format(d: dict) -> pd.DataFrame:
+    """Conversione sicura con timeout"""
+    logger.info("🔄 Conversione input...")
     
     row = {
         "Debitore_cluster": d.get("Debitore_cluster"),
@@ -118,111 +99,179 @@ def _to_model_format(d: dict) -> pd.DataFrame:
     }
     
     df = pd.DataFrame([row])
-    logger.info(f"✅ DataFrame creato - Shape: {df.shape}")
+    logger.info(f"✅ DataFrame: {df.shape}, cols: {list(df.columns)[:5]}...")
     return df
 
-# ===== ENDPOINTS =====
 @app.get("/")
 def root():
     return {
         "ok": True,
-        "service": "incassi-api-debug",
+        "service": "incassi-super-debug",
         "model_loaded": model_loaded,
-        "model_version": getattr(mdl, "model_version", "N/A") if mdl else "N/A"
     }
 
 @app.get("/status")
 def status():
-    """Status dettagliato del sistema"""
     if not mdl:
         return {"error": "Modello non caricato"}
     
+    return {
+        "model_loaded": True,
+        "model_type": str(type(mdl)),
+        "has_predict": hasattr(mdl, "predict"),
+        "has_stage1": hasattr(mdl, "stage1"),
+        "has_stage2": hasattr(mdl, "stage2"),
+        "methods": [m for m in dir(mdl) if not m.startswith('_')][:10]
+    }
+
+@app.post("/test_conversion")
+def test_conversion(inp: PredictIn):
+    """Test solo conversione dati"""
     try:
+        logger.info("🧪 Test conversione...")
+        
+        if not mdl:
+            raise HTTPException(status_code=503, detail="Modello non caricato")
+        
+        # Solo conversione
+        df = safe_to_model_format(inp.dict())
+        logger.info("✅ Conversione OK")
+        
         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,
+            "status": "conversion_ok",
+            "shape": df.shape,
+            "columns_sample": list(df.columns)[:10],
+            "first_row_sample": {k: str(v)[:50] for k, v in df.iloc[0].to_dict().items() if k in list(df.columns)[:5]}
         }
+        
     except Exception as e:
-        return {"error": f"Errore status: {e}"}
+        logger.error(f"❌ Errore conversione: {e}")
+        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Errore conversione: {str(e)}")
 
-@app.post("/test_simple")
-def test_simple(inp: PredictIn):
-    """Test semplificato - solo conversione dati"""
+@app.post("/test_ensure_cols")
+def test_ensure_cols(inp: PredictIn):
+    """Test solo _ensure_raw_cols"""
     try:
-        logger.info("🧪 Test semplice avviato...")
+        logger.info("🧪 Test ensure_raw_cols...")
         
         if not mdl:
             raise HTTPException(status_code=503, detail="Modello non caricato")
         
-        # Solo conversione, SENZA predict
-        df = _to_model_format(inp.dict())
-        logger.info(f"✅ Conversione riuscita: {df.shape}")
+        df = safe_to_model_format(inp.dict())
+        logger.info("🔧 Chiamata _ensure_raw_cols...")
+        
+        # Test con timeout di 10 secondi
+        def run_ensure():
+            return mdl._ensure_raw_cols(df)
+        
+        # Esegui in thread separato per timeout
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_ensure)
+            try:
+                df_ensured = future.result(timeout=10)
+                logger.info("✅ _ensure_raw_cols OK")
+                return {
+                    "status": "ensure_cols_ok",
+                    "original_shape": df.shape,
+                    "ensured_shape": df_ensured.shape
+                }
+            except concurrent.futures.TimeoutError:
+                logger.error("⏰ _ensure_raw_cols TIMEOUT")
+                raise HTTPException(status_code=408, detail="_ensure_raw_cols timeout")
         
-        # Test solo _ensure_raw_cols (metodo più semplice)
-        logger.info("🔧 Test _ensure_raw_cols...")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"❌ Errore ensure_cols: {e}")
+        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Errore ensure_cols: {str(e)}")
+
+@app.post("/test_preprocess")
+def test_preprocess(inp: PredictIn):
+    """Test solo _preprocess_apply"""
+    try:
+        logger.info("🧪 Test preprocess...")
+        
+        if not mdl:
+            raise HTTPException(status_code=503, detail="Modello non caricato")
+        
+        df = safe_to_model_format(inp.dict())
         df_ensured = mdl._ensure_raw_cols(df)
-        logger.info(f"✅ _ensure_raw_cols riuscito: {df_ensured.shape}")
         
-        return {
-            "status": "success",
-            "input_shape": df.shape,
-            "ensured_shape": df_ensured.shape,
-            "columns": list(df.columns),
-        }
+        logger.info("🔧 Chiamata _preprocess_apply...")
+        
+        # Test con timeout
+        def run_preprocess():
+            return mdl._preprocess_apply(df_ensured)
         
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_preprocess)
+            try:
+                df_processed = future.result(timeout=15)
+                logger.info("✅ _preprocess_apply OK")
+                return {
+                    "status": "preprocess_ok", 
+                    "processed_shape": df_processed.shape,
+                    "processed_columns_count": len(df_processed.columns)
+                }
+            except concurrent.futures.TimeoutError:
+                logger.error("⏰ _preprocess_apply TIMEOUT")
+                raise HTTPException(status_code=408, detail="_preprocess_apply timeout")
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"❌ Errore test_simple: {e}")
+        logger.error(f"❌ Errore preprocess: {e}")
         logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Errore preprocess: {str(e)}")
 
-@app.post("/predict")  
+@app.post("/predict")
 def predict(inp: PredictIn):
-    """Predizione completa con debug step-by-step"""
+    """Predizione completa con timeout estremo"""
     try:
-        logger.info("🚀 PREDICT chiamato...")
+        logger.info("🚀 PREDICT con timeout...")
         
         if not mdl:
             raise HTTPException(status_code=503, detail="Modello non caricato")
         
-        # Step 1: Conversione
-        logger.info("🔧 Step 1: Conversione input...")
-        df = _to_model_format(inp.dict())
+        df = safe_to_model_format(inp.dict())
         
-        # Step 2: Predict con cattura errore specifica
-        logger.info("🔧 Step 2: Chiamata mdl.predict...")
-        try:
+        # Predict con timeout di 30 secondi
+        def run_predict():
+            logger.info("🔧 Esecuzione mdl.predict()...")
             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}")
-        
-        # Step 3: Formattazione output
-        logger.info("🔧 Step 3: Formattazione output...")
-        p100, prob_ord, yhat, final_class, _ = result
-        
-        response = {
-            "p100": float(p100),
-            "prob_ord": np.asarray(prob_ord, dtype=float).tolist(),
-            "yhat": float(yhat),
-            "final_class": str(final_class),
-        }
+            logger.info("✅ mdl.predict() completato")
+            return result
         
-        logger.info(f"✅ Predizione completata: yhat={response['yhat']:.2f}")
-        return response
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_predict)
+            try:
+                result = future.result(timeout=30)
+                
+                p100, prob_ord, yhat, final_class, _ = result
+                response = {
+                    "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: {response['yhat']:.2f}")
+                return response
+                
+            except concurrent.futures.TimeoutError:
+                logger.error("⏰ PREDICT TIMEOUT dopo 30 secondi")
+                raise HTTPException(status_code=408, detail="Predizione timeout - modello bloccato")
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"❌ ERRORE GENERALE in predict: {e}")
+        logger.error(f"❌ ERRORE PREDICT: {e}")
         logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Errore predict: {str(e)}")
 
-logger.info("🚀 Server inizializzato - Modello caricato senza test predict")
+logger.info("🚀 Super Debug Server inizializzato")