Déploiement auto depuis GitHub Actions avec LFS

Dockerfile

@@ -27,10 +27,13 @@ COPY --chown=user models/ ./models/
 # 7. Variables de l'API avec le nouveau chemin
 ENV GLOBAL_THRESHOLD=0.45
 ENV MODEL_PATH=$HOME/app/models/pmvl_catboost_final.cbm
-ENV MODEL_FEATURES_PATH=$HOME/app/models/pmvl_feature_columns.txt
+ENV FEATURES_PATH=$HOME/app/models/pmvl_feature_columns.txt
 
 # 8. Exposer le port 7860 (Port par défaut de Hugging Face Spaces)
 EXPOSE 7860
 
-# 9. Démarrage de l'API sur le port 7860
+# 9. Création du dossier de logs avec les permissions nécessaires
+RUN mkdir -p $HOME/app/logs && chmod -R 777 $HOME/app/logs
+
+# 10. Démarrage de l'API sur le port 7860
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/main.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse
 import os
@@ -9,6 +9,11 @@ import gradio as gr
 from .schemas import PMVLFeatures, PredictionResponse
 from .model_loader import get_model, get_feature_columns
 
+import json
+import time
+from uuid import uuid4
+from pathlib import Path
+
 GLOBAL_THRESHOLD_ENV = "GLOBAL_THRESHOLD"
 DEFAULT_THRESHOLD = 0.45
 
@@ -26,6 +31,71 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# On crée le dossier logs s'il n'existe pas
+LOG_DIR = Path("logs")
+LOG_DIR.mkdir(exist_ok=True)
+PRODUCTION_LOGS_FILE = LOG_DIR / "production_logs.jsonl"
+
+@app.middleware("http")
+async def production_logging_middleware(request: Request, call_next):
+    """
+    Middleware pour logger chaque requête à l'API en production.
+    Idéal pour surveiller la latence, le taux d'erreur et capturer
+    les données pour l'analyse de Data Drift ultérieure.
+    """
+    start_time = time.time()
+    request_id = str(uuid4())
+    
+    # On lit le body de la requête (nécessaire pour capturer les inputs)
+    body_bytes = b""
+    if request.url.path == "/predict" and request.method == "POST":
+        body_bytes = await request.body()
+        
+    # Fonction pour reconstruire le body afin que les routes suivantes puissent le lire
+    async def receive():
+        return {"type": "http.request", "body": body_bytes}
+    request._receive = receive
+    
+    # Exécution de la requête
+    response = None
+    error_msg = None
+    try:
+        response = await call_next(request)
+        status_code = response.status_code
+    except Exception as e:
+        status_code = 500
+        error_msg = str(e)
+        raise e
+    finally:
+        latency_ms = (time.time() - start_time) * 1000
+        
+        # On ne loggue en détail que les appels à l'endpoint de prédiction
+        if request.url.path == "/predict":
+            # Extraction des inputs
+            input_data = None
+            if body_bytes:
+                try:
+                    input_data = json.loads(body_bytes.decode("utf-8"))
+                except json.JSONDecodeError:
+                    input_data = "Unparseable JSON"
+            
+            # Préparation du log
+            log_entry = {
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime()),
+                "request_id": request_id,
+                "endpoint": request.url.path,
+                "latency_ms": round(latency_ms, 2),
+                "status_code": status_code,
+                "input_features": input_data,
+                "error": error_msg
+            }
+            
+            # Écriture dans le fichier JSONL
+            with open(PRODUCTION_LOGS_FILE, "a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+                
+    return response
+
 GROUP_KEYS = [
     "PMVL[ENTITE]",
     "PMVL[Selected Fund code]",
@@ -84,7 +154,7 @@ def run_model_prediction(features: PMVLFeatures) -> PredictionResponse:
     feature_columns = get_feature_columns()
 
     # 1) Récupérer les données brutes
-    raw_dict = features.model_dump(by_alias=True)
+    raw_dict = features.model_dump(by_alias=True, mode="json")
     # Le modèle n'utilise pas directement la date
     raw_dict.pop("PMVL[Holding date]", None)
 
@@ -130,7 +200,26 @@ def health_check():
 @app.post("/predict", response_model=PredictionResponse, tags=["prédiction"])
 def predict_pmvl(features: PMVLFeatures):
     try:
-        return run_model_prediction(features)
+        # Exécution de la prédiction existante
+        result = run_model_prediction(features)
+        
+        # --- NOUVEAU CODE POUR LE LOGGING DES OUTPUTS ---
+        # On ajoute une entrée spécifique pour les outputs dans un fichier séparé
+        # ou on l'ajoute au fichier principal. Ici, on crée un log d'inférence complet.
+        inference_log = {
+    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime()),
+    "input_features": features.model_dump(mode="json"),
+    "output": {
+        "proba_bonne_estimation": result.proba_bonne_estimation,
+        "prediction": result.prediction,
+        "seuil_applique": result.seuil_applique,
+    },
+}
+        with open(LOG_DIR / "inference_results.jsonl", "a", encoding="utf-8") as f:
+            f.write(json.dumps(inference_log) + "\n")
+        # ------------------------------------------------
+            
+        return result
     except Exception as e:
         raise HTTPException(
             status_code=500,

app/schemas.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, ConfigDict
 from typing import Optional
 from datetime import date
 
@@ -123,8 +123,7 @@ class PMVLFeatures(BaseModel):
         description="Nom du portefeuille"
     )
 
-    class Config:
-        populate_by_name = True  # Nouvelle syntaxe Pydantic V2
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class PredictionResponse(BaseModel):