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 os
-
-# Setup logging
-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 - Working Version",
-    description="API per predire incassi - Versione funzionante", 
-    version="v1.0-stable"
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Variabile globale per il modello
-mdl = None
-
-def load_model():
-    global mdl
-    try:
-        logger.info("🔧 Caricamento modello...")
-        
-        if not os.path.exists("incassi_model.pkl"):
-            logger.error("❌ File incassi_model.pkl non trovato")
-            return False
-        
-        file_size = os.path.getsize("incassi_model.pkl")
-        logger.info(f"📁 File trovato - Dimensione: {file_size} bytes")
-        
-        with open("incassi_model.pkl", "rb") as f:
-            mdl = cp.load(f)
-        
-        logger.info(f"✅ Modello caricato: {type(mdl)}")
-        
-        # Controlla se ha i metodi necessari
-        if hasattr(mdl, 'predict'):
-            logger.info("✅ Metodo predict trovato")
-        else:
-            logger.error("❌ Metodo predict non trovato")
-            return False
-            
-        if hasattr(mdl, 'model_version'):
-            logger.info(f"📋 Versione modello: {mdl.model_version}")
-        
-        return True
-        
-    except Exception as e:
-        logger.error(f"❌ Errore nel caricamento modello: {e}")
-        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        return False
-
-# Carica modello all'avvio
-logger.info("🚀 Caricamento modello all'avvio...")
-model_loaded = load_model()
-
-if not model_loaded:
-    logger.error("❌ FATALE: Impossibile caricare il modello")
-else:
-    logger.info("✅ Modello caricato con successo")
-
-# Pydantic models
-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
-
-class CurveIn(PredictIn):
-    iscr_start: int = 0
-    iscr_end: int = 1500
-    step: int = 50
-
-def to_model_format(d: dict) -> pd.DataFrame:
-    """Conversione input API -> formato modello"""
-    logger.info("🔄 Conversione input...")
-    
-    # Mapping esplicito
-    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: spazio vs underscore
-        "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: {df.shape}")
-    return df
-
-# ENDPOINTS
-@app.get("/")
-def root():
-    return {
-        "ok": True,
-        "service": "incassi-api-stable",
-        "model_loaded": model_loaded,
-        "version": "v1.0-stable"
-    }
-
-@app.get("/status") 
-def status():
-    """Status del sistema"""
-    if not mdl:
-        return {
-            "error": "Modello non caricato",
-            "model_loaded": False
-        }
-    
-    try:
-        return {
-            "model_loaded": True,
-            "model_type": str(type(mdl)),
-            "model_version": getattr(mdl, "model_version", "unknown"),
-            "has_predict": hasattr(mdl, "predict"),
-            "has_stage1": hasattr(mdl, "stage1") and mdl.stage1 is not None,
-            "has_stage2": hasattr(mdl, "stage2") and mdl.stage2 is not None,
-            "p100_threshold": getattr(mdl, "p100_thr", "unknown")
-        }
-    except Exception as e:
-        return {
-            "error": f"Errore status: {e}",
-            "model_loaded": model_loaded
-        }
-
-@app.get("/health")
-def health():
-    """Health check"""
-    if not model_loaded:
-        raise HTTPException(status_code=503, detail="Modello non caricato")
-    
-    return {"status": "healthy", "timestamp": pd.Timestamp.now().isoformat()}
-
-@app.post("/predict")
-def predict(inp: PredictIn):
-    """Predizione principale"""
-    try:
-        logger.info("🚀 /predict chiamato")
-        
-        if not mdl:
-            raise HTTPException(status_code=503, detail="Modello non caricato")
-        
-        # Converti input
-        df = to_model_format(inp.dict())
-        logger.info("✅ Input convertito")
-        
-        # Esegui predizione con gestione errori
-        logger.info("🔧 Esecuzione predizione...")
-        try:
-            result = mdl.predict(df)
-            logger.info("✅ Predizione completata")
-        except Exception as predict_error:
-            logger.error(f"❌ Errore in mdl.predict(): {predict_error}")
-            logger.error(f"❌ Traceback predict:\n{traceback.format_exc()}")
-            
-            # Restituisci errore dettagliato
-            error_msg = f"Errore nella predizione: {str(predict_error)}"
-            if "set" in str(predict_error).lower():
-                error_msg += " (Problema con funzione set - modello da rigenerare)"
-            
-            raise HTTPException(status_code=500, detail=error_msg)
-        
-        # Estrai risultati
-        p100, prob_ord, yhat, final_class, _ = result
-        
-        # Formatta response
-        response = {
-            "p100": float(p100),
-            "prob_ord": [float(x) for x in prob_ord],  # Converti ogni elemento
-            "yhat": float(yhat),
-            "final_class": str(final_class),
-        }
-        
-        logger.info(f"✅ Response formattato: yhat={response['yhat']:.2f}")
-        return response
-        
-    except HTTPException:
-        raise  # Re-raise HTTP exceptions as-is
-    except Exception as e:
-        logger.error(f"❌ Errore generale in /predict: {e}")
-        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        
-        error_detail = f"Errore interno: {str(e)}"
-        raise HTTPException(status_code=500, detail=error_detail)
-
-@app.post("/curve_iscrizione")
-def curve_iscrizione(inp: CurveIn):
-    """Curva di crescita giorni iscrizione"""
-    try:
-        logger.info("🚀 /curve_iscrizione chiamato")
-        
-        if not mdl:
-            raise HTTPException(status_code=503, detail="Modello non caricato")
-        
-        # 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 > 500:  # Limite ragionevole
-            raise HTTPException(status_code=400, detail="Troppi punti nella curva (max 500)")
-        
-        # Esegui curva
-        base_dict = inp.dict()
-        logger.info(f"🔧 Calcolo curva: {inp.iscr_start}-{inp.iscr_end} step {inp.step}")
-        
-        try:
-            result = mdl.curve_iscrizione(base_dict, inp.iscr_start, inp.iscr_end, inp.step)
-            logger.info("✅ Curva completata")
-        except Exception as curve_error:
-            logger.error(f"❌ Errore in curve_iscrizione: {curve_error}")
-            raise HTTPException(status_code=500, detail=f"Errore curva: {str(curve_error)}")
-        
-        # Formatta response (assicura JSON serializzabile)
-        response = {
-            "x": [int(v) for v in result.get("x", [])],
-            "p100": [float(v) for v in result.get("p100", [])],
-            "classes": {}
-        }
-        
-        for class_name, values in result.get("classes", {}).items():
-            response["classes"][str(class_name)] = [float(v) for v in values]
-        
-        logger.info(f"✅ Curva completata: {len(response['x'])} punti")
-        return response
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"❌ Errore generale in /curve_iscrizione: {e}")
-        logger.error(f"❌ Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Errore interno: {str(e)}")
-
-# Startup message
-logger.info("🚀 Server inizializzato")
-logger.info(f"📋 Modello caricato: {model_loaded}")
-if model_loaded and mdl:
-    logger.info(f"📋 Versione modello: {getattr(mdl, 'model_version', 'unknown')}")