Update app.py

app.py

@@ -1,13 +1,14 @@
 import sys
-from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
-import joblib
 import pandas as pd
 import numpy as np
-from pydantic import BaseModel
+import joblib
+import __main__
+from fastapi import FastAPI, Body
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel, Field
 from sklearn.base import BaseEstimator, TransformerMixin
 
-# --- 1. DEFINITION DE LA CLASSE ---
+# --- 1. CLASSE PERSONNALISÉE (DÉFINITION ROBUSTE) ---
 class DFToHashedTokens(BaseEstimator, TransformerMixin):
     def __init__(self, columns=None):
         self.columns = columns
@@ -17,82 +18,107 @@ class DFToHashedTokens(BaseEstimator, TransformerMixin):
     
     def transform(self, X):
         X = X.copy()
-        if self.columns:
-            for col in self.columns:
-                X[col] = X[col].astype(str)
+        # Sécurité : on récupère 'columns' dynamiquement pour éviter l'AttributeError
+        cols = getattr(self, 'columns', None)
+        if cols is not None:
+            for col in cols:
+                if col in X.columns:
+                    X[col] = X[col].astype(str)
         return X
 
-# --- 2. L'ASTUCE ANTI-ERREUR (CRUCIAL) ---
-# On injecte la classe dans le module '__main__' pour que joblib la trouve
-import __main__
+# Injection dans le namespace principal pour joblib
 __main__.DFToHashedTokens = DFToHashedTokens
 
-# --- 3. CHARGEMENT DU MODÈLE ---
-# On le place dans une fonction ou on le charge après l'injection
+# --- 2. CHARGEMENT DU MODÈLE ---
 try:
-    # Assure-toi que le nom du fichier est exactement celui-ci sur Hugging Face
     model = joblib.load('fraud_model_hashing.pkl')
     print("✅ Modèle chargé avec succès")
 except Exception as e:
     model = None
-    print(f"❌ Erreur lors du chargement : {e}")
+    print(f"❌ Erreur critique lors du chargement : {e}")
+
+# --- 3. CONFIGURATION API ET SCHÉMA ---
+app = FastAPI(
+    title="Fraud Detection API",
+    description="API de prédiction de fraude bancaire basée sur un modèle de Hashing."
+)
 
-# --- 4. CONFIGURATION API ---
-app = FastAPI(title="Fraud Detection API")
+class Transaction(BaseModel):
+    # Field(..., example=...) permet de remplir automatiquement la doc Swagger
+    amt: float = Field(..., example=85.20)
+    trans_date_trans_time: str = Field(..., example="2024-02-18 14:30:00")
+    dob: str = Field(..., example="1985-05-20")
+    lat: float = Field(..., example=48.8566)
+    long: float = Field(..., example=2.3522)
+    merch_lat: float = Field(..., example=48.8584)
+    merch_long: float = Field(..., example=2.2945)
+    city_pop: float = Field(..., example=2000000)
+    category: str = Field(..., example="shopping_net")
+    gender: str = Field(..., example="F")
+    state: str = Field(..., example="NY")
+    merchant: str = Field(..., example="Amazon")
+    job: str = Field(..., example="Data Scientist")
+    cc_num: int = Field(..., example=1234567890123456)
 
 @app.get("/", include_in_schema=False)
 def root():
     return RedirectResponse(url="/docs")
 
-# --- 5. SCHÉMA ET PRÉPARATION ---
-class Transaction(BaseModel):
-    amt: float
-    trans_date_trans_time: str
-    dob: str
-    lat: float
-    long: float
-    merch_lat: float
-    merch_long: float
-    city_pop: float
-    category: str
-    gender: str
-    state: str
-    merchant: str
-    job: str
-    cc_num: int
-
+# --- 4. LOGIQUE DE PRÉPARATION ---
 def prepare_input(data: dict):
     df = pd.DataFrame([data])
-    dt = pd.to_datetime(df["trans_date_trans_time"])
+    
+    # Dates & Temps
+    dt = pd.to_datetime(df["trans_date_trans_time"], errors='coerce')
+    dob = pd.to_datetime(df["dob"], errors='coerce')
+    
+    if dt.isna().any() or dob.isna().any():
+        raise ValueError("Format de date invalide. Utilisez YYYY-MM-DD HH:MM:SS")
+
     df["hour"] = dt.dt.hour
     df["day_of_week"] = dt.dt.dayofweek
     df["day"] = dt.dt.day
     df["month"] = dt.dt.month
     
-    dob = pd.to_datetime(df["dob"])
+    # Âge
     df["age"] = ((dt - dob).dt.days / 365.25).astype("float32")
     
+    # Distance Haversine
     lat1, lon1 = np.radians(df["lat"]), np.radians(df["long"])
     lat2, lon2 = np.radians(df["merch_lat"]), np.radians(df["merch_long"])
     d = np.sin((lat2-lat1)/2)**2 + np.cos(lat1)*np.cos(lat2)*np.sin((lon2-lon1)/2)**2
     df["distance"] = (6371 * 2 * np.arcsin(np.sqrt(d))).astype("float32")
 
+    # Agrégats (valeurs par défaut pour prédiction unitaire)
     df["avg_amt"] = df["amt"]
     df["std_amt"] = 0.0
     df["nb_trans"] = 1.0
 
-    cols = ['amt', 'hour', 'day_of_week', 'day', 'month', 'age', 'lat', 'long', 
-            'city_pop', 'distance', 'avg_amt', 'std_amt', 'nb_trans', 
-            'category', 'gender', 'state', 'merchant', 'job']
-    return df[cols]
+    # Sélection stricte des 18 colonnes attendues par le modèle
+    expected_cols = [
+        'amt', 'hour', 'day_of_week', 'day', 'month', 'age', 'lat', 'long', 
+        'city_pop', 'distance', 'avg_amt', 'std_amt', 'nb_trans', 
+        'category', 'gender', 'state', 'merchant', 'job'
+    ]
+    return df[expected_cols]
 
+# --- 5. ENDPOINT ---
 @app.post("/predict")
 def predict(data: Transaction):
     if model is None:
-        return {"status": "error", "message": "Model not loaded"}
+        return {"status": "error", "message": "Modèle non chargé sur le serveur."}
     try:
-        X = prepare_input(data.dict())
-        prediction = model.predict(X)
-        return {"is_fraud": int(prediction[0])}
+        X_processed = prepare_input(data.dict())
+        prediction = model.predict(X_processed)
+        return {
+            "prediction": int(prediction[0]),
+            "label": "FRAUDE" if int(prediction[0]) == 1 else "LÉGITIME",
+            "status": "success"
+        }
     except Exception as e:
-        return {"status": "error", "message": str(e)}
+        return {"status": "error", "message": str(e)}
+
+if __name__ == "__main__":
+    import uvicorn
+    # Port 7860 est le port standard pour Hugging Face Spaces
+    uvicorn.run(app, host="0.0.0.0", port=7860)