Delete server.py

server.py

@@ -1,277 +0,0 @@
-# -*- coding: utf-8 -*-
-import numpy as np
-import pandas as pd
-import cloudpickle as cp
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import traceback
-import logging
-import sys
-import signal
-import threading
-import time
-
-# Setup logging ultra-dettagliato
-logging.basicConfig(
-    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 - Super Debug", version="debug-2.0")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-mdl = None
-
-# 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("🔧 Caricamento modello...")
-        
-        import os
-        if not os.path.exists("incassi_model.pkl"):
-            raise FileNotFoundError("File non trovato")
-        
-        with open("incassi_model.pkl", "rb") as f:
-            mdl = cp.load(f)
-        
-        logger.info(f"✅ Modello caricato: {type(mdl)}")
-        logger.info(f"📋 Attributi: {dir(mdl)[:10]}...")  # primi 10 attributi
-        
-        return True
-    except Exception as e:
-        logger.error(f"❌ Errore caricamento: {e}")
-        return False
-
-model_loaded = load_model()
-
-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 safe_to_model_format(d: dict) -> pd.DataFrame:
-    """Conversione sicura con timeout"""
-    logger.info("🔄 Conversione input...")
-    
-    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: {df.shape}, cols: {list(df.columns)[:5]}...")
-    return df
-
-@app.get("/")
-def root():
-    return {
-        "ok": True,
-        "service": "incassi-super-debug",
-        "model_loaded": model_loaded,
-    }
-
-@app.get("/status")
-def status():
-    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 {
-            "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:
-        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_ensure_cols")
-def test_ensure_cols(inp: PredictIn):
-    """Test solo _ensure_raw_cols"""
-    try:
-        logger.info("🧪 Test ensure_raw_cols...")
-        
-        if not mdl:
-            raise HTTPException(status_code=503, detail="Modello non caricato")
-        
-        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")
-        
-    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("🔧 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 preprocess: {e}")
-        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Errore preprocess: {str(e)}")
-
-@app.post("/predict")
-def predict(inp: PredictIn):
-    """Predizione completa con timeout estremo"""
-    try:
-        logger.info("🚀 PREDICT con timeout...")
-        
-        if not mdl:
-            raise HTTPException(status_code=503, detail="Modello non caricato")
-        
-        df = safe_to_model_format(inp.dict())
-        
-        # Predict con timeout di 30 secondi
-        def run_predict():
-            logger.info("🔧 Esecuzione mdl.predict()...")
-            result = mdl.predict(df)
-            logger.info("✅ mdl.predict() completato")
-            return result
-        
-        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 PREDICT: {e}")
-        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Errore predict: {str(e)}")
-
-logger.info("🚀 Super Debug Server inizializzato")