Upload folder using huggingface_hub

.env.production

@@ -0,0 +1,13 @@
+# Production environment variables for HuggingFace Spaces
+
+# Security
+DEBUG=false
+API_KEY=${HF_SPACE_API_KEY}
+
+# API Configuration
+API_VERSION=2.1.0
+LOG_LEVEL=INFO
+
+# HuggingFace Model
+HF_MODEL_REPO=ASI-Engineer/employee-turnover-model
+MODEL_FILENAME=model/model.pkl

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Installer les dépendances système
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copier les fichiers de dépendances
+COPY requirements.txt .
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le code de l'application
+COPY app.py .
+COPY src/ ./src/
+COPY .env.example .env
+
+# Créer le dossier logs
+RUN mkdir -p logs
+
+# Exposer le port
+EXPOSE 8000
+
+# Variables d'environnement par défaut
+ENV DEBUG=false
+ENV LOG_LEVEL=INFO
+ENV API_KEY=change-me-in-production
+
+# Healthcheck
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+  CMD curl -f http://localhost:8000/health || exit 1
+
+# Commande de démarrage
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

README.md

@@ -1,106 +1,239 @@
----
-title: OC P5 - API ML Déployée
-emoji: 🎯
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-# 🎯 Employee Turnover Prediction - DEV Environment
-
-Interface Gradio pour tester le modèle de prédiction de départ des employés (turnover).
-
-## 🚀 Modèle ML
-
-- **Algorithme**: XGBoost optimisé avec RandomizedSearchCV
-- **Équilibrage**: SMOTE pour gérer le déséquilibre de classes (ratio 5:1)
-- **Tracking**: MLflow pour versioning et reproductibilité
-- **Métriques**: F1-Score optimisé (0.51), Accuracy 79%
-- **Stockage**: [Hugging Face Hub](https://huggingface.co/ASI-Engineer/employee-turnover-model)
-
-## 📊 Fonctionnalités
-
-- **Status Checker**: Vérifier l'état du modèle et les métriques
-- **API Simple**: Interface Gradio pour tests rapides
-- **Chargement automatique**: Modèle téléchargé depuis HF Hub au démarrage
-
-## 🔧 Architecture
-
-```python
-# Chargement du modèle depuis HF Hub
-model_path = hf_hub_download(
-    repo_id="ASI-Engineer/employee-turnover-model",
-    filename="model/model.pkl"
-)
-model = mlflow.sklearn.load_model(str(Path(model_path).parent))
+# 🚀 Employee Turnover Prediction API - v2.1.0
+
+## 📊 Vue d'ensemble
+
+API REST de prédiction du turnover des employés basée sur un modèle XGBoost avec SMOTE.
+
+**✨ Nouveautés v2.1.0** :
+- 📝 Logging structuré JSON
+- 🛡️ Rate limiting (20 req/min par IP)
+- ⚡ Gestion d'erreurs améliorée
+- 📊 Monitoring des performances
+- 🔐 Authentification API Key
+
+## 🏗️ Architecture
+
+```
+OC_P5/
+├── app.py                    # Point d'entrée FastAPI
+├── src/
+│   ├── auth.py              # Authentification API Key
+│   ├── config.py            # Configuration centralisée
+│   ├── logger.py            # Logging structuré (NOUVEAU)
+│   ├── models.py            # Chargement modèle HF Hub
+│   ├── preprocessing.py     # Pipeline preprocessing
+│   ├── rate_limit.py        # Rate limiting (NOUVEAU)
+│   └── schemas.py           # Validation Pydantic
+├── tests/                   # Suite pytest (33 tests, 88% couverture)
+├── logs/                    # Logs JSON (NOUVEAU)
+│   ├── api.log              # Tous les logs
+│   └── error.log            # Erreurs uniquement
+├── docs/                    # Documentation
+├── ml_model/                # Scripts training
+└── data/                    # Données sources
 ```
 
-## 🛠️ Installation & Développement
+## 🚀 Installation
 
 ### Prérequis
 - Python 3.12+
-- Poetry (gestionnaire de dépendances)
+- Poetry 1.7+
+- Git
 
-### Installation avec Poetry
+### Setup rapide
 
 ```bash
-# Installer Poetry (si pas déjà fait)
-curl -sSL https://install.python-poetry.org | python3 -
+# 1. Cloner le repo
+git clone https://github.com/chaton59/OC_P5.git
+cd OC_P5
 
-# Installer les dépendances
+# 2. Installer les dépendances
 poetry install
 
-# Activer l'environnement virtuel
-poetry shell
+# 3. Configurer l'environnement
+cp .env.example .env
+# Éditer .env avec vos valeurs
+
+# 4. Lancer l'API
+poetry run uvicorn app:app --reload
+
+# 5. Accéder à la documentation
+# http://localhost:8000/docs
+```
+
+## 📝 Configuration (.env)
+
+```bash
+# Mode développement (désactive auth + active logs détaillés)
+DEBUG=true
 
-# Lancer le pipeline d'entraînement
-poetry run python main.py
+# API Key (requis en production)
+API_KEY=your-secret-key-here
 
-# Lancer l'interface Gradio
-poetry run python app.py
+# Logging (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+LOG_LEVEL=INFO
+
+# HuggingFace Model
+HF_MODEL_REPO=ASI-Engineer/employee-turnover-model
+MODEL_FILENAME=model/model.pkl
 ```
 
-### Requirements.txt pour HF Spaces
+## 🔒 Authentification
+
+### Mode DEBUG (développement)
+```bash
+# L'API Key n'est PAS requise
+curl http://localhost:8000/predict -H "Content-Type: application/json" -d '{...}'
+```
+
+### Mode PRODUCTION
+```bash
+# L'API Key est REQUISE
+curl http://localhost:8000/predict \
+  -H "X-API-Key: your-secret-key" \
+  -H "Content-Type: application/json" \
+  -d '{...}'
+```
 
-Le fichier `requirements.txt` est **minimal et optimisé** pour HF Spaces (seulement gradio, huggingface-hub, joblib).
+## 📡 Endpoints
 
-Il est **généré automatiquement** par le CI/CD lors des déploiements.
+### 🏥 Health Check
+```bash
+GET /health
+
+# Réponse
+{
+  "status": "healthy",
+  "model_loaded": true,
+  "model_type": "Pipeline",
+  "version": "2.1.0"
+}
+```
 
-Pour le générer manuellement :
+### 🔮 Prédiction
 ```bash
-./scripts/export_requirements.sh
+POST /predict
+Content-Type: application/json
+X-API-Key: your-key (en production)
+
+# Exemple payload (voir docs/API_GUIDE.md pour tous les champs)
+{
+  "satisfaction_employee_environnement": 3,
+  "satisfaction_employee_nature_travail": 4,
+  "satisfaction_employee_equipe": 5,
+  "satisfaction_employee_equilibre_pro_perso": 3,
+  "note_evaluation_actuelle": 85,
+  "annees_depuis_la_derniere_promotion": 2,
+  "nombre_formations_realisees": 3,
+  ...
+}
+
+# Réponse
+{
+  "prediction": 0,                    # 0 = reste, 1 = part
+  "probability_0": 0.85,              # Probabilité de rester
+  "probability_1": 0.15,              # Probabilité de partir
+  "risk_level": "Low"                 # Low, Medium, High
+}
+```
+
+## 📊 Logging
+
+### Logs structurés JSON
+
+**Fichiers** :
+- `logs/api.log` : Tous les logs
+- `logs/error.log` : Erreurs uniquement
+
+**Format** :
+```json
+{
+  "timestamp": "2025-12-26T10:30:45",
+  "level": "INFO",
+  "logger": "employee_turnover_api",
+  "message": "Request POST /predict",
+  "method": "POST",
+  "path": "/predict",
+  "status_code": 200,
+  "duration_ms": 23.45,
+  "client_host": "127.0.0.1"
+}
+```
+
+## 🛡️ Rate Limiting
+
+**Configuration** :
+- **Développement** : Désactivé (DEBUG=true)
+- **Production** : 20 requêtes/minute par IP ou API Key
+
+**En cas de dépassement** :
+```json
+{
+  "error": "Rate limit exceeded",
+  "message": "20 per 1 minute"
+}
 ```
 
-### Tests et Linting
+## ✅ Tests
 
 ```bash
-# Formater le code
-poetry run black .
+# Tous les tests
+poetry run pytest tests/ -v
 
-# Linter
-poetry run flake8 .
+# Avec couverture
+poetry run pytest tests/ --cov --cov-report=html
 
-# Tests
-poetry run pytest --cov=ml_model tests/
+# Voir rapport HTML
+open htmlcov/index.html
 ```
 
-## 📈 Métriques
+**Résultats** :
+- ✅ 33 tests passés
+- 📊 88% de couverture globale
+
+## 🚀 Déploiement
+
+### Variables d'environnement requises
+```bash
+DEBUG=false
+API_KEY=<votre-clé-sécurisée>
+LOG_LEVEL=INFO
+```
+
+### HuggingFace Spaces
+Prêt pour déploiement avec `app.py` et `requirements.txt`
+
+## 📚 Documentation
+
+- **API Interactive** : http://localhost:8000/docs
+- **ReDoc** : http://localhost:8000/redoc
+- **Guide complet** : [docs/API_GUIDE.md](docs/API_GUIDE.md)
+- **Standards** : [docs/standards.md](docs/standards.md)
+- **Couverture tests** : [docs/TEST_COVERAGE.md](docs/TEST_COVERAGE.md)
+
+## 📦 Dépendances principales
+
+- **FastAPI** 0.115.14 : Framework web
+- **Pydantic** 2.12.5 : Validation données
+- **XGBoost** 2.1.3 : Modèle ML
+- **SlowAPI** 0.1.9 : Rate limiting
+- **python-json-logger** 4.0.0 : Logs structurés
+- **pytest** 9.0.2 : Tests
 
-- **F1-Score**: 0.5136
-- **Accuracy**: 79%
-- **Données**: 1470 échantillons, 50 features
-- **Classes**: {0: 1233, 1: 237} - Ratio 5.20:1
+## 🔄 Changelog
 
-## 🔗 Liens
+### v2.1.0 (26 décembre 2025)
+- ✨ Système de logging structuré JSON
+- 🛡️ Rate limiting avec SlowAPI
+- ⚡ Amélioration gestion d'erreurs
+- 📊 Monitoring des performances
 
-- **Modèle**: [employee-turnover-model](https://huggingface.co/ASI-Engineer/employee-turnover-model)
-- **GitHub**: [OC_P5](https://github.com/chaton59/OC_P5)
-- **CI/CD**: GitHub Actions avec déploiement automatique
+### v2.0.0 (26 décembre 2025)
+- ✅ Suite de tests complète (33 tests)
+- 🔐 Authentification API Key
+- 📊 88% de couverture de code
 
-Ce Space est synchronisé automatiquement via CI/CD depuis la branche `dev` du repository GitHub.
+## 👥 Auteurs
 
-**Repository**: [chaton59/OC_P5](https://github.com/chaton59/OC_P5)
+- **Projet** : OpenClassrooms P5
+- **Repo** : [github.com/chaton59/OC_P5](https://github.com/chaton59/OC_P5)

README_HF.md

@@ -1,33 +1,49 @@
 ---
-title: Employee Turnover Prediction - DEV
-emoji: 🎯
+title: Employee Turnover Prediction API
+emoji: 👔
 colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
+colorTo: purple
+sdk: docker
+pinned: true
+license: mit
+app_port: 8000
 ---
 
-# 🎯 Employee Turnover Prediction - Environment DEV
+# Employee Turnover Prediction API 🚀
 
-Interface de test pour prédire le risque de départ des employés.
+API de prédiction du turnover des employés avec XGBoost + SMOTE.
 
-## 🚀 Modèle
+## 🎯 Fonctionnalités
 
-- **Algorithme**: XGBoost avec RandomizedSearchCV
-- **Équilibrage**: SMOTE pour classes déséquilibrées (ratio 5:1)
-- **Tracking**: MLflow pour versioning et reproductibilité
-- **Métriques**: Optimisé pour F1-Score
+- ✅ Prédiction de turnover (0 = reste, 1 = part)
+- 📊 Probabilités et niveau de risque (Low/Medium/High)
+- 🔐 Authentification API Key
+- 📝 Logs structurés JSON
+- 🛡️ Rate limiting (20 req/min)
+- 📚 Documentation OpenAPI/Swagger
 
-## 📊 Utilisation
+## 🔗 Endpoints
 
-1. Ajustez les paramètres de l'employé (satisfaction, évaluation, projets, etc.)
-2. Cliquez sur "Prédire le risque de départ"
-3. Obtenez la probabilité de turnover et les recommandations
+- **Docs** : `/docs` - Documentation interactive
+- **Health** : `/health` - Status de l'API
+- **Predict** : `/predict` - Prédiction de turnover
 
-## 🔧 Développement
+## 🚀 Utilisation
 
-Ce Space est synchronisé automatiquement via CI/CD depuis la branche `dev` du repository GitHub.
+```bash
+# Health check
+curl https://asi-engineer-employee-turnover-api.hf.space/health
 
-**Repository**: [chaton59/OC_P5](https://github.com/chaton59/OC_P5)
+# Prédiction
+curl -X POST https://asi-engineer-employee-turnover-api.hf.space/predict \
+  -H "Content-Type: application/json" \
+  -d '{
+    "satisfaction_employee_environnement": 3,
+    "satisfaction_employee_nature_travail": 4,
+    ...
+  }'
+```
+
+## 📚 Documentation complète
+
+Voir [GitHub Repository](https://github.com/chaton59/OC_P5) pour la documentation complète.

app.py

@@ -1,138 +1,252 @@
 #!/usr/bin/env python3
 """
-Interface Gradio pour tester le modèle Employee Turnover en production.
+API FastAPI pour le modèle Employee Turnover.
 
-Déploiement sur Hugging Face Spaces pour tests rapides.
-Version de démonstration - Interface complète en développement.
+Cette API expose le modèle de prédiction de départ des employés avec :
+- Validation stricte des inputs via Pydantic
+- Preprocessing automatique
+- Health check pour monitoring
+- Documentation OpenAPI/Swagger automatique
 """
-import gradio as gr
-from huggingface_hub import hf_hub_download
+import time
+from contextlib import asynccontextmanager
 
-# Configuration
-HF_MODEL_REPO = "ASI-Engineer/employee-turnover-model"
+from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
 
+from src.auth import verify_api_key
+from src.config import get_settings
+from src.logger import logger, log_model_load, log_request
+from src.models import get_model_info, load_model
+from src.preprocessing import preprocess_for_prediction
+from src.rate_limit import limiter
+from src.schemas import EmployeeInput, HealthCheck, PredictionOutput
 
-def load_model():
+# Charger la configuration
+settings = get_settings()
+API_VERSION = settings.API_VERSION
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
     """
-    Charge le modèle depuis Hugging Face Hub.
+    Gestion du cycle de vie de l'application.
 
-    En production (HF Spaces), charge uniquement depuis HF Hub.
-    Le fallback MLflow local n'est disponible qu'en développement local.
+    Charge le modèle au démarrage et le garde en cache.
     """
+    logger.info(
+        "🚀 Démarrage de l'API Employee Turnover...", extra={"version": API_VERSION}
+    )
+
+    start_time = time.time()
     try:
-        import joblib
+        # Pré-charger le modèle au démarrage
+        model = load_model()
+        duration_ms = (time.time() - start_time) * 1000
 
-        # Download model pickle from HF Hub
-        model_path = hf_hub_download(
-            repo_id=HF_MODEL_REPO, filename="model/model.pkl", repo_type="model"
-        )
-        model = joblib.load(model_path)
-        print(f"✅ Modèle chargé depuis HF Hub: {HF_MODEL_REPO}")
-        return model, "HF Hub"
+        model_type = type(model).__name__
+        log_model_load(model_type, duration_ms, True)
+        logger.info("✅ Modèle chargé avec succès")
     except Exception as e:
-        print(f"❌ Erreur chargement depuis HF Hub: {e}")
-        return None, "Error"
-
-
-# Charger le modèle au démarrage
-try:
-    model, model_source = load_model()
-    MODEL_LOADED = model is not None
-except Exception as e:
-    print(f"❌ Erreur lors du chargement du modèle: {e}")
-    MODEL_LOADED = False
-    model = None
-    model_source = "Error"
-
-
-def get_model_info():
-    """Retourne les informations sur le modèle."""
-    if not MODEL_LOADED:
-        return {
-            "status": "❌ Modèle non disponible",
-            "error": "Le modèle n'a pas pu être chargé",
-            "solution": "Vérifiez que le modèle est bien enregistré sur HF Hub ou entraîné localement",
-        }
+        duration_ms = (time.time() - start_time) * 1000
+        log_model_load("Unknown", duration_ms, False)
+        logger.error("Le modèle n'a pas pu être chargé", extra={"error": str(e)})
+
+    yield  # L'application tourne
+
+    logger.info("🛑 Arrêt de l'API")
+
+
+# Créer l'application FastAPI
+app = FastAPI(
+    title="Employee Turnover Prediction API",
+    description="API de prédiction du turnover des employés avec XGBoost + SMOTE",
+    version=API_VERSION,
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Ajouter rate limiting
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# Configurer CORS (autoriser tous les domaines en dev)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Middleware de logging des requêtes
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    """
+    Middleware pour logger toutes les requêtes HTTP.
+    """
+    start_time = time.time()
 
-    try:
-        info = {
-            "status": "✅ Modèle chargé avec succès",
-            "source": model_source,
-            "model_type": type(model).__name__,
-            "features": "~50 features (après preprocessing)",
-            "algorithme": "XGBoost + SMOTE",
-            "hf_hub_repo": HF_MODEL_REPO,
-        }
-
-        info["info"] = "Interface de prédiction en développement - API FastAPI à venir"
-        return info
+    # Traiter la requête
+    response = await call_next(request)
 
-    except Exception as e:
-        return {"status": "✅ Modèle chargé (info limitées)", "error": str(e)}
+    # Calculer la durée
+    duration_ms = (time.time() - start_time) * 1000
 
+    # Logger
+    log_request(
+        method=request.method,
+        path=request.url.path,
+        status_code=response.status_code,
+        duration_ms=duration_ms,
+        client_host=request.client.host if request.client else None,
+    )
 
-# Interface Gradio
-with gr.Blocks(  # type: ignore[attr-defined]
-    title="Employee Turnover Prediction - DEV", theme=gr.themes.Soft()  # type: ignore[attr-defined]
-) as demo:
-    gr.Markdown("# 🎯 Prédiction du Turnover - Employee Attrition")  # type: ignore[attr-defined]
-    gr.Markdown("## Environment DEV - Test de déploiement CI/CD")  # type: ignore[attr-defined]
+    return response
 
-    gr.Markdown(  # type: ignore[attr-defined]
-        """
-    ### 📊 Statut du projet
 
-    Ce Space est synchronisé automatiquement depuis GitHub (branche `dev`).
+@app.get("/", tags=["Root"])
+async def root():
+    """
+    Endpoint racine avec informations sur l'API.
+    """
+    return {
+        "message": "Employee Turnover Prediction API",
+        "version": API_VERSION,
+        "docs": "/docs",
+        "health": "/health",
+        "predict": "/predict (POST)",
+    }
 
-    **Actuellement disponible :**
-    - ✅ Pipeline d'entraînement MLflow complet (`main.py`)
-    - ✅ Déploiement automatique CI/CD (GitHub Actions → HF Spaces)
-    - ✅ Tests unitaires et linting automatisés
 
-    **En développement :**
-    - 🚧 Interface de prédiction interactive
-    - 🚧 API FastAPI avec endpoints de prédiction
-    - 🚧 Intégration PostgreSQL pour tracking des prédictions
+@app.get("/health", response_model=HealthCheck, tags=["Monitoring"])
+async def health_check():
     """
-    )
+    Health check endpoint pour monitoring.
+
+    Vérifie que l'API est opérationnelle et que le modèle est chargé.
+
+    Returns:
+        HealthCheck: Status de l'API et du modèle.
 
-    with gr.Row():  # type: ignore[attr-defined]
-        with gr.Column():  # type: ignore[attr-defined]
-            gr.Markdown("### 🔍 Informations sur le modèle")  # type: ignore[attr-defined]
-            check_btn = gr.Button("📊 Vérifier le statut du modèle", variant="primary")  # type: ignore[attr-defined]
+    Raises:
+        HTTPException: 503 si le modèle n'est pas disponible.
+    """
+    try:
+        model_info = get_model_info()
+
+        return HealthCheck(
+            status="healthy",
+            model_loaded=model_info.get("cached", False),
+            model_type=model_info.get("model_type", "Unknown"),
+            version=API_VERSION,
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=503,
+            detail={
+                "status": "unhealthy",
+                "error": "Model not available",
+                "message": str(e),
+            },
+        )
 
-        with gr.Column():  # type: ignore[attr-defined]
-            model_output = gr.JSON(label="Statut")  # type: ignore[attr-defined]
 
-    check_btn.click(fn=get_model_info, inputs=[], outputs=model_output)
+@app.post(
+    "/predict",
+    response_model=PredictionOutput,
+    tags=["Prediction"],
+    dependencies=[Depends(verify_api_key)] if settings.is_api_key_required else [],
+)
+@limiter.limit("20/minute")
+async def predict(request: Request, employee: EmployeeInput):
+    """
+    Endpoint de prédiction du turnover d'un employé.
 
-    gr.Markdown("---")  # type: ignore[attr-defined]
+    **PROTÉGÉ PAR API KEY** : Requiert le header `X-API-Key` en production.
 
-    gr.Markdown(  # type: ignore[attr-defined]
-        """
-    ### 🛠️ Prochaines étapes (selon etapes.txt)
+    Prend en entrée les données d'un employé, applique le preprocessing
+    et retourne la prédiction avec les probabilités.
 
-    1. **Étape 3** : Développement API FastAPI
-       - Endpoints de prédiction avec validation Pydantic
-       - Chargement dynamique des preprocessing artifacts (scaler, encoders)
-       - Documentation Swagger/OpenAPI automatique
+    Args:
+        employee: Données de l'employé validées par Pydantic.
 
-    2. **Étape 4** : Intégration PostgreSQL
-       - Stockage des inputs/outputs des prédictions
-       - Traçabilité complète des requêtes
+    Returns:
+        PredictionOutput: Prédiction et probabilités.
 
-    3. **Étape 5** : Tests unitaires et fonctionnels
-       - Tests des endpoints API
-       - Tests de charge et performance
-       - Couverture de code avec pytest-cov
+    Raises:
+        HTTPException: 401 si API key invalide ou manquante.
+        HTTPException: 500 si erreur lors de la prédiction.
 
-    ### 📚 Documentation
-    - **Repository GitHub** : [chaton59/OC_P5](https://github.com/chaton59/OC_P5)
-    - **MLflow Tracking** : Disponible en local (`./scripts/start_mlflow.sh`)
-    - **Métriques** : F1-Score optimisé, gestion classes déséquilibrées (SMOTE)
+    Examples:
+        ```bash
+        # Avec authentification
+        curl -X POST http://localhost:8000/predict \\
+          -H "X-API-Key: your-secret-key" \\
+          -H "Content-Type: application/json" \\
+          -d '{...}'
+        ```
     """
-    )
+    try:
+        # 1. Charger le modèle
+        model = load_model()
+
+        # 2. Préprocessing
+        X = preprocess_for_prediction(employee)
+
+        # 3. Prédiction
+        prediction = int(model.predict(X)[0])
+
+        # 4. Probabilités (si le modèle supporte predict_proba)
+        try:
+            probabilities = model.predict_proba(X)[0]
+            prob_0 = float(probabilities[0])
+            prob_1 = float(probabilities[1])
+        except AttributeError:
+            # Si le modèle ne supporte pas predict_proba
+            prob_0 = 1.0 if prediction == 0 else 0.0
+            prob_1 = 1.0 if prediction == 1 else 0.0
+
+        # 5. Niveau de risque
+        if prob_1 < 0.3:
+            risk_level = "Low"
+        elif prob_1 < 0.7:
+            risk_level = "Medium"
+        else:
+            risk_level = "High"
+
+        return PredictionOutput(
+            prediction=prediction,
+            probability_0=prob_0,
+            probability_1=prob_1,
+            risk_level=risk_level,
+        )
+
+    except Exception:
+        logger.exception("Unexpected error during prediction")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Prediction failed",
+                "message": "An unexpected error occurred. Please contact support.",
+            },
+        )
 
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    import uvicorn
+
+    print("🚀 Lancement de l'API en mode développement...")
+    print("📖 Documentation : http://localhost:8000/docs")
+
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info",
+    )

requirements.txt

@@ -1,9 +1,103 @@
-# Minimal requirements for HF Spaces deployment
-# Only the dependencies needed for app.py and model loading
-gradio>=5.9.0
-huggingface-hub>=0.27.0
-joblib>=1.4.0
-scikit-learn>=1.6.0
-imbalanced-learn>=0.13.0
-xgboost>=2.1.0
-numpy>=2.0.0
+alembic==1.17.2 ; python_version >= "3.12" and python_version < "4.0"
+annotated-types==0.7.0 ; python_version >= "3.12" and python_version < "4.0"
+anyio==4.12.0 ; python_version >= "3.12" and python_version < "4.0"
+blinker==1.9.0 ; python_version >= "3.12" and python_version < "4.0"
+cachetools==6.2.4 ; python_version >= "3.12" and python_version < "4.0"
+certifi==2025.11.12 ; python_version >= "3.12" and python_version < "4.0"
+cffi==2.0.0 ; python_version >= "3.12" and python_version < "4.0" and platform_python_implementation != "PyPy"
+charset-normalizer==3.4.4 ; python_version >= "3.12" and python_version < "4.0"
+click==8.3.1 ; python_version >= "3.12" and python_version < "4.0"
+cloudpickle==3.1.2 ; python_version >= "3.12" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.12" and python_version < "4.0" and (platform_system == "Windows" or sys_platform == "win32")
+contourpy==1.3.3 ; python_version >= "3.12" and python_version < "4.0"
+cryptography==46.0.3 ; python_version >= "3.12" and python_version < "4.0"
+cycler==0.12.1 ; python_version >= "3.12" and python_version < "4.0"
+databricks-sdk==0.76.0 ; python_version >= "3.12" and python_version < "4.0"
+deprecated==1.3.1 ; python_version >= "3.12" and python_version < "4.0"
+docker==7.1.0 ; python_version >= "3.12" and python_version < "4.0"
+fastapi==0.115.14 ; python_version >= "3.12" and python_version < "4.0"
+filelock==3.20.1 ; python_version >= "3.12" and python_version < "4.0"
+flask-cors==6.0.2 ; python_version >= "3.12" and python_version < "4.0"
+flask==3.1.2 ; python_version >= "3.12" and python_version < "4.0"
+fonttools==4.61.1 ; python_version >= "3.12" and python_version < "4.0"
+fsspec==2025.12.0 ; python_version >= "3.12" and python_version < "4.0"
+gitdb==4.0.12 ; python_version >= "3.12" and python_version < "4.0"
+gitpython==3.1.45 ; python_version >= "3.12" and python_version < "4.0"
+google-auth==2.45.0 ; python_version >= "3.12" and python_version < "4.0"
+graphene==3.4.3 ; python_version >= "3.12" and python_version < "4.0"
+graphql-core==3.2.7 ; python_version >= "3.12" and python_version < "4.0"
+graphql-relay==3.2.0 ; python_version >= "3.12" and python_version < "4.0"
+greenlet==3.3.0 ; python_version >= "3.12" and python_version < "4.0" and (platform_machine == "aarch64" or platform_machine == "ppc64le" or platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "AMD64" or platform_machine == "win32" or platform_machine == "WIN32")
+gunicorn==23.0.0 ; python_version >= "3.12" and python_version < "4.0" and platform_system != "Windows"
+h11==0.16.0 ; python_version >= "3.12" and python_version < "4.0"
+hf-xet==1.2.0 ; python_version >= "3.12" and python_version < "4.0" and (platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "AMD64" or platform_machine == "arm64" or platform_machine == "aarch64")
+httpcore==1.0.9 ; python_version >= "3.12" and python_version < "4.0"
+httptools==0.7.1 ; python_version >= "3.12" and python_version < "4.0"
+httpx==0.28.1 ; python_version >= "3.12" and python_version < "4.0"
+huey==2.5.5 ; python_version >= "3.12" and python_version < "4.0"
+huggingface-hub==1.2.3 ; python_version >= "3.12" and python_version < "4.0"
+idna==3.11 ; python_version >= "3.12" and python_version < "4.0"
+imbalanced-learn==0.13.0 ; python_version >= "3.12" and python_version < "4.0"
+importlib-metadata==8.7.1 ; python_version >= "3.12" and python_version < "4.0"
+itsdangerous==2.2.0 ; python_version >= "3.12" and python_version < "4.0"
+jinja2==3.1.6 ; python_version >= "3.12" and python_version < "4.0"
+joblib==1.5.3 ; python_version >= "3.12" and python_version < "4.0"
+kiwisolver==1.4.9 ; python_version >= "3.12" and python_version < "4.0"
+limits==5.6.0 ; python_version >= "3.12" and python_version < "4.0"
+mako==1.3.10 ; python_version >= "3.12" and python_version < "4.0"
+markupsafe==3.0.3 ; python_version >= "3.12" and python_version < "4.0"
+matplotlib==3.10.8 ; python_version >= "3.12" and python_version < "4.0"
+mlflow-skinny==3.8.1 ; python_version >= "3.12" and python_version < "4.0"
+mlflow-tracing==3.8.1 ; python_version >= "3.12" and python_version < "4.0"
+mlflow==3.8.1 ; python_version >= "3.12" and python_version < "4.0"
+numpy==2.4.0 ; python_version >= "3.12" and python_version < "4.0"
+nvidia-nccl-cu12==2.28.9 ; python_version >= "3.12" and python_version < "4.0" and platform_system == "Linux" and platform_machine != "aarch64"
+opentelemetry-api==1.39.1 ; python_version >= "3.12" and python_version < "4.0"
+opentelemetry-proto==1.39.1 ; python_version >= "3.12" and python_version < "4.0"
+opentelemetry-sdk==1.39.1 ; python_version >= "3.12" and python_version < "4.0"
+opentelemetry-semantic-conventions==0.60b1 ; python_version >= "3.12" and python_version < "4.0"
+packaging==25.0 ; python_version >= "3.12" and python_version < "4.0"
+pandas==2.3.3 ; python_version >= "3.12" and python_version < "4.0"
+pillow==12.0.0 ; python_version >= "3.12" and python_version < "4.0"
+protobuf==6.33.2 ; python_version >= "3.12" and python_version < "4.0"
+pyarrow==22.0.0 ; python_version >= "3.12" and python_version < "4.0"
+pyasn1-modules==0.4.2 ; python_version >= "3.12" and python_version < "4.0"
+pyasn1==0.6.1 ; python_version >= "3.12" and python_version < "4.0"
+pycparser==2.23 ; python_version >= "3.12" and python_version < "4.0" and platform_python_implementation != "PyPy" and implementation_name != "PyPy"
+pydantic-core==2.41.5 ; python_version >= "3.12" and python_version < "4.0"
+pydantic==2.12.5 ; python_version >= "3.12" and python_version < "4.0"
+pyparsing==3.3.1 ; python_version >= "3.12" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.12" and python_version < "4.0"
+python-dotenv==1.2.1 ; python_version >= "3.12" and python_version < "4.0"
+python-json-logger==4.0.0 ; python_version >= "3.12" and python_version < "4.0"
+pytz==2025.2 ; python_version >= "3.12" and python_version < "4.0"
+pywin32==311 ; python_version >= "3.12" and python_version < "4.0" and sys_platform == "win32"
+pyyaml==6.0.3 ; python_version >= "3.12" and python_version < "4.0"
+requests==2.32.5 ; python_version >= "3.12" and python_version < "4.0"
+rsa==4.9.1 ; python_version >= "3.12" and python_version < "4.0"
+scikit-learn==1.6.1 ; python_version >= "3.12" and python_version < "4.0"
+scipy==1.16.3 ; python_version >= "3.12" and python_version < "4.0"
+shellingham==1.5.4 ; python_version >= "3.12" and python_version < "4.0"
+six==1.17.0 ; python_version >= "3.12" and python_version < "4.0"
+sklearn-compat==0.1.5 ; python_version >= "3.12" and python_version < "4.0"
+slowapi==0.1.9 ; python_version >= "3.12" and python_version < "4.0"
+smmap==5.0.2 ; python_version >= "3.12" and python_version < "4.0"
+sqlalchemy==2.0.45 ; python_version >= "3.12" and python_version < "4.0"
+sqlparse==0.5.5 ; python_version >= "3.12" and python_version < "4.0"
+starlette==0.46.2 ; python_version >= "3.12" and python_version < "4.0"
+threadpoolctl==3.6.0 ; python_version >= "3.12" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.12" and python_version < "4.0"
+typer-slim==0.21.0 ; python_version >= "3.12" and python_version < "4.0"
+typing-extensions==4.15.0 ; python_version >= "3.12" and python_version < "4.0"
+typing-inspection==0.4.2 ; python_version >= "3.12" and python_version < "4.0"
+tzdata==2025.3 ; python_version >= "3.12" and python_version < "4.0"
+urllib3==2.6.2 ; python_version >= "3.12" and python_version < "4.0"
+uvicorn==0.32.1 ; python_version >= "3.12" and python_version < "4.0"
+uvloop==0.22.1 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "win32" and sys_platform != "cygwin" and platform_python_implementation != "PyPy"
+waitress==3.0.2 ; python_version >= "3.12" and python_version < "4.0" and platform_system == "Windows"
+watchfiles==1.1.1 ; python_version >= "3.12" and python_version < "4.0"
+websockets==15.0.1 ; python_version >= "3.12" and python_version < "4.0"
+werkzeug==3.1.4 ; python_version >= "3.12" and python_version < "4.0"
+wrapt==2.0.1 ; python_version >= "3.12" and python_version < "4.0"
+xgboost==2.1.4 ; python_version >= "3.12" and python_version < "4.0"
+zipp==3.23.0 ; python_version >= "3.12" and python_version < "4.0"

src/__init__.py

@@ -0,0 +1 @@
+"""Module src pour l'API FastAPI."""

src/auth.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Module d'authentification pour l'API.
+
+Fournit un système de vérification de clé API via header HTTP.
+"""
+from fastapi import Header, HTTPException, status
+from fastapi.security import APIKeyHeader
+
+from src.config import get_settings
+
+# Schéma pour la documentation Swagger
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+async def verify_api_key(x_api_key: str = Header(None)) -> str:
+    """
+    Vérifie que la clé API fournie est valide.
+
+    Cette fonction est utilisée comme dépendance FastAPI (Depends).
+    Elle vérifie le header HTTP "X-API-Key" et compare avec la clé configurée.
+
+    Args:
+        x_api_key: Clé API fournie dans le header HTTP.
+
+    Returns:
+        str: La clé API validée.
+
+    Raises:
+        HTTPException: 401 si la clé est manquante ou invalide.
+
+    Comment ça marche :
+        1. FastAPI extrait automatiquement le header "X-API-Key"
+        2. La fonction compare avec la clé configurée dans .env
+        3. Si valide → continue, sinon → erreur 401
+
+    Exemple d'utilisation :
+        ```python
+        @app.post("/predict", dependencies=[Depends(verify_api_key)])
+        async def predict(...):
+            # Cette route est protégée !
+        ```
+
+    Exemple de requête curl :
+        ```bash
+        curl -X POST http://localhost:8000/predict \\
+          -H "X-API-Key: your-secret-key" \\
+          -H "Content-Type: application/json" \\
+          -d '{...}'
+        ```
+    """
+    settings = get_settings()
+
+    # En mode DEBUG, on peut désactiver l'auth
+    if settings.DEBUG:
+        return "debug-mode-no-auth-required"
+
+    # Vérifier que la clé est fournie
+    if not x_api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail={
+                "error": "API Key missing",
+                "message": "Le header 'X-API-Key' est requis pour accéder à cette ressource",
+                "solution": "Ajoutez le header: -H 'X-API-Key: votre-cle-api'",
+            },
+            headers={"WWW-Authenticate": "ApiKey"},
+        )
+
+    # Vérifier que la clé est correcte
+    if x_api_key != settings.API_KEY:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail={
+                "error": "Invalid API Key",
+                "message": "La clé API fournie est invalide",
+                "solution": "Vérifiez votre clé API ou contactez l'administrateur",
+            },
+            headers={"WWW-Authenticate": "ApiKey"},
+        )
+
+    return x_api_key
+
+
+def get_api_key_dependency():
+    """
+    Retourne la dépendance d'authentification si nécessaire.
+
+    Permet de conditionner l'authentification selon la config.
+
+    Returns:
+        Depends(verify_api_key) si auth requise, None sinon.
+    """
+    settings = get_settings()
+    if settings.is_api_key_required:
+        from fastapi import Depends
+
+        return Depends(verify_api_key)
+    return None

src/config.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Module de configuration de l'application.
+
+Charge les variables d'environnement depuis .env et fournit
+une interface pour accéder à la configuration de manière sécurisée.
+"""
+import os
+from functools import lru_cache
+
+from dotenv import load_dotenv
+
+# Charger .env au démarrage du module
+load_dotenv()
+
+
+class Settings:
+    """
+    Configuration de l'application.
+
+    Toutes les valeurs sensibles (API keys, etc.) sont chargées depuis
+    les variables d'environnement ou le fichier .env.
+    """
+
+    # ===== SÉCURITÉ =====
+    API_KEY: str = os.getenv("API_KEY", "dev-key-change-me-in-production")
+
+    # ===== API =====
+    API_VERSION: str = os.getenv("API_VERSION", "1.0.0")
+    API_HOST: str = os.getenv("API_HOST", "0.0.0.0")
+    API_PORT: int = int(os.getenv("API_PORT", "8000"))
+
+    # ===== MODÈLE =====
+    HF_MODEL_REPO: str = os.getenv(
+        "HF_MODEL_REPO", "ASI-Engineer/employee-turnover-model"
+    )
+    MODEL_FILENAME: str = os.getenv("MODEL_FILENAME", "model/model.pkl")
+
+    # ===== ENVIRONNEMENT =====
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+
+    @property
+    def is_api_key_required(self) -> bool:
+        """
+        Vérifie si l'API key est requise.
+
+        Returns:
+            False en mode DEBUG, True en production.
+        """
+        return not self.DEBUG
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """
+    Retourne l'instance singleton des settings.
+
+    Le décorateur @lru_cache() assure qu'on ne crée qu'une seule instance.
+
+    Returns:
+        Settings: Configuration de l'application.
+    """
+    return Settings()

src/logger.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Module de logging structuré pour l'API Employee Turnover.
+
+Fournit un système de logging centralisé avec :
+- Logs structurés en JSON
+- Rotation automatique des fichiers
+- Niveaux de log configurables
+- Intégration FastAPI
+"""
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+from pythonjsonlogger import jsonlogger
+
+from src.config import get_settings
+
+settings = get_settings()
+
+# Créer le dossier logs s'il n'existe pas
+LOG_DIR = Path("logs")
+LOG_DIR.mkdir(exist_ok=True)
+
+# Fichiers de logs
+LOG_FILE = LOG_DIR / "api.log"
+ERROR_LOG_FILE = LOG_DIR / "error.log"
+
+
+class CustomJsonFormatter(jsonlogger.JsonFormatter):
+    """
+    Formatter JSON personnalisé avec champs supplémentaires.
+    """
+
+    def add_fields(
+        self,
+        log_record: Dict[str, Any],
+        record: logging.LogRecord,
+        message_dict: Dict[str, Any],
+    ) -> None:
+        """
+        Ajoute des champs personnalisés aux logs JSON.
+        """
+        super().add_fields(log_record, record, message_dict)
+
+        # Ajouter des métadonnées
+        log_record["level"] = record.levelname
+        log_record["logger"] = record.name
+        log_record["module"] = record.module
+        log_record["function"] = record.funcName
+        log_record["line"] = record.lineno
+
+        # Timestamp ISO 8601
+        if not log_record.get("timestamp"):
+            log_record["timestamp"] = self.formatTime(record, self.datefmt)
+
+
+def setup_logger(name: str = "employee_turnover_api") -> logging.Logger:
+    """
+    Configure et retourne un logger structuré.
+
+    Args:
+        name: Nom du logger.
+
+    Returns:
+        Logger configuré avec handlers console et fichiers.
+
+    Examples:
+        >>> logger = setup_logger()
+        >>> logger.info("API démarrée", extra={"version": "2.0.0"})
+    """
+    logger = logging.getLogger(name)
+
+    # Éviter duplication si déjà configuré
+    if logger.handlers:
+        return logger
+
+    # Niveau de log depuis configuration
+    log_level = getattr(logging, settings.LOG_LEVEL.upper(), logging.INFO)
+    logger.setLevel(log_level)
+
+    # === HANDLER CONSOLE (stdout) ===
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+
+    # Format simple pour la console en dev, JSON en prod
+    if settings.DEBUG:
+        console_format = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    else:
+        console_format = CustomJsonFormatter(
+            "%(timestamp)s %(level)s %(name)s %(message)s"
+        )
+
+    console_handler.setFormatter(console_format)
+    logger.addHandler(console_handler)
+
+    # === HANDLER FICHIER (tous les logs) ===
+    file_handler = logging.FileHandler(LOG_FILE, encoding="utf-8")
+    file_handler.setLevel(log_level)
+    file_handler.setFormatter(
+        CustomJsonFormatter("%(timestamp)s %(level)s %(name)s %(message)s")
+    )
+    logger.addHandler(file_handler)
+
+    # === HANDLER ERREURS UNIQUEMENT ===
+    error_handler = logging.FileHandler(ERROR_LOG_FILE, encoding="utf-8")
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(
+        CustomJsonFormatter("%(timestamp)s %(level)s %(name)s %(message)s")
+    )
+    logger.addHandler(error_handler)
+
+    # Éviter propagation au root logger
+    logger.propagate = False
+
+    return logger
+
+
+def log_request(
+    method: str,
+    path: str,
+    status_code: int,
+    duration_ms: float,
+    **kwargs: Any,
+) -> None:
+    """
+    Log une requête HTTP avec métadonnées.
+
+    Args:
+        method: Méthode HTTP (GET, POST...).
+        path: Chemin de l'endpoint.
+        status_code: Code de statut HTTP.
+        duration_ms: Durée de la requête en millisecondes.
+        **kwargs: Métadonnées additionnelles.
+
+    Examples:
+        >>> log_request("POST", "/predict", 200, 45.3, user_id="123")
+    """
+    logger = logging.getLogger("employee_turnover_api")
+
+    log_data = {
+        "method": method,
+        "path": path,
+        "status_code": status_code,
+        "duration_ms": round(duration_ms, 2),
+        **kwargs,
+    }
+
+    # Niveau selon status code
+    if status_code >= 500:
+        logger.error(f"Request {method} {path}", extra=log_data)
+    elif status_code >= 400:
+        logger.warning(f"Request {method} {path}", extra=log_data)
+    else:
+        logger.info(f"Request {method} {path}", extra=log_data)
+
+
+def log_prediction(
+    employee_id: str | None,
+    prediction: int,
+    probability: float,
+    risk_level: str,
+    duration_ms: float,
+) -> None:
+    """
+    Log une prédiction effectuée.
+
+    Args:
+        employee_id: ID de l'employé (optionnel).
+        prediction: Prédiction (0 ou 1).
+        probability: Probabilité de turnover.
+        risk_level: Niveau de risque ("low", "medium", "high").
+        duration_ms: Durée du preprocessing + pr��diction.
+
+    Examples:
+        >>> log_prediction("EMP123", 1, 0.87, "high", 23.4)
+    """
+    logger = logging.getLogger("employee_turnover_api")
+
+    logger.info(
+        "Prediction made",
+        extra={
+            "employee_id": employee_id,
+            "prediction": prediction,
+            "probability": round(probability, 4),
+            "risk_level": risk_level,
+            "duration_ms": round(duration_ms, 2),
+        },
+    )
+
+
+def log_model_load(model_type: str, duration_ms: float, success: bool) -> None:
+    """
+    Log le chargement du modèle.
+
+    Args:
+        model_type: Type de modèle chargé.
+        duration_ms: Durée du chargement.
+        success: Si le chargement a réussi.
+
+    Examples:
+        >>> log_model_load("XGBoost Pipeline", 1234.5, True)
+    """
+    logger = logging.getLogger("employee_turnover_api")
+
+    log_data = {
+        "model_type": model_type,
+        "duration_ms": round(duration_ms, 2),
+        "success": success,
+    }
+
+    if success:
+        logger.info("Model loaded successfully", extra=log_data)
+    else:
+        logger.error("Model loading failed", extra=log_data)
+
+
+# Créer le logger global
+logger = setup_logger()

src/models.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Module de chargement et gestion du modèle MLflow.
+
+Ce module encapsule la logique de chargement du modèle depuis Hugging Face Hub
+via MLflow, avec gestion des erreurs et versioning.
+"""
+from typing import Any, Optional
+
+from fastapi import HTTPException
+from huggingface_hub import hf_hub_download
+
+# Configuration
+HF_MODEL_REPO = "ASI-Engineer/employee-turnover-model"
+MODEL_FILENAME = "model/model.pkl"
+
+# Cache global du modèle
+_model_cache: Optional[Any] = None
+
+
+def load_model(force_reload: bool = False) -> Any:
+    """
+    Charge le modèle depuis Hugging Face Hub via MLflow.
+
+    Cette fonction implémente un système de cache pour éviter de recharger
+    le modèle à chaque appel. Le modèle est chargé une seule fois au démarrage
+    de l'application et mis en cache.
+
+    Args:
+        force_reload: Si True, force le rechargement du modèle même s'il est en cache.
+
+    Returns:
+        Le modèle MLflow chargé et prêt pour l'inférence.
+
+    Raises:
+        HTTPException: 500 si le modèle ne peut pas être chargé.
+
+    Examples:
+        >>> model = load_model()
+        >>> # Utiliser le modèle pour prédiction
+        >>> predictions = model.predict(X)
+    """
+    global _model_cache
+
+    # Retourner le modèle en cache si disponible
+    if _model_cache is not None and not force_reload:
+        return _model_cache
+
+    try:
+        import joblib
+
+        print(f"🔄 Chargement du modèle depuis HF Hub: {HF_MODEL_REPO}")
+
+        # Télécharger le modèle depuis Hugging Face Hub
+        model_path = hf_hub_download(
+            repo_id=HF_MODEL_REPO, filename=MODEL_FILENAME, repo_type="model"
+        )
+
+        print(f"📦 Modèle téléchargé: {model_path}")
+
+        # Charger le modèle avec joblib
+        model = joblib.load(model_path)
+
+        # Mettre en cache
+        _model_cache = model
+
+        print(f"✅ Modèle chargé avec succès: {type(model).__name__}")
+        return model
+
+    except Exception as e:
+        error_msg = f"❌ Erreur lors du chargement du modèle: {str(e)}"
+        print(error_msg)
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Model loading failed",
+                "message": str(e),
+                "model_repo": HF_MODEL_REPO,
+                "solution": "Vérifiez que le modèle est disponible sur HF Hub et correctement entraîné",
+            },
+        )
+
+
+def get_model_info() -> dict:
+    """
+    Retourne les informations sur le modèle chargé.
+
+    Returns:
+        Dict contenant les métadonnées du modèle.
+
+    Raises:
+        HTTPException: 500 si le modèle n'est pas chargé.
+    """
+    try:
+        model = load_model()
+
+        return {
+            "status": "✅ Modèle chargé",
+            "model_type": type(model).__name__,
+            "hf_hub_repo": HF_MODEL_REPO,
+            "model_file": MODEL_FILENAME,
+            "cached": _model_cache is not None,
+        }
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail={"error": "Model info unavailable", "message": str(e)},
+        )
+
+
+def load_preprocessing_artifacts(run_id: str) -> dict:
+    """
+    Charge les artifacts de preprocessing (scaler, encoders) depuis MLflow.
+
+    Args:
+        run_id: ID du run MLflow contenant les artifacts.
+
+    Returns:
+        Dict contenant les artifacts de preprocessing.
+
+    Raises:
+        HTTPException: 500 si les artifacts ne peuvent pas être chargés.
+
+    Note:
+        Cette fonction sera implémentée quand les preprocessing artifacts
+        seront disponibles dans le modèle HF Hub.
+    """
+    raise NotImplementedError(
+        "Le chargement des preprocessing artifacts sera implémenté "
+        "lors de l'intégration complète avec MLflow"
+    )
+
+
+if __name__ == "__main__":
+    # Test de chargement du modèle
+    print("=" * 80)
+    print("TEST DE CHARGEMENT DU MODÈLE")
+    print("=" * 80)
+
+    try:
+        model = load_model()
+        print("\n✅ Test réussi!")
+        print(f"Type de modèle: {type(model).__name__}")
+
+        # Afficher les infos
+        info = get_model_info()
+        print("\nInformations du modèle:")
+        for key, value in info.items():
+            print(f"  {key}: {value}")
+
+    except Exception as e:
+        print(f"\n❌ Test échoué: {e}")

src/preprocessing.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Module de preprocessing pour transformer les données d'entrée avant prédiction.
+
+Ce module applique les mêmes transformations que le pipeline d'entraînement :
+- Feature engineering (ratios, moyennes)
+- Encoding (OneHot, Ordinal)
+- Scaling (StandardScaler)
+"""
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
+
+from src.schemas import EmployeeInput
+
+
+def create_input_dataframe(employee: EmployeeInput) -> pd.DataFrame:
+    """
+    Convertit un objet EmployeeInput Pydantic en DataFrame pandas.
+
+    Args:
+        employee: Données validées d'un employé.
+
+    Returns:
+        DataFrame avec une seule ligne contenant toutes les features.
+    """
+    data = {
+        # SONDAGE
+        "nombre_participation_pee": [employee.nombre_participation_pee],
+        "nb_formations_suivies": [employee.nb_formations_suivies],
+        "nombre_employee_sous_responsabilite": [
+            employee.nombre_employee_sous_responsabilite
+        ],
+        "distance_domicile_travail": [employee.distance_domicile_travail],
+        "niveau_education": [employee.niveau_education],
+        "domaine_etude": [employee.domaine_etude],
+        "ayant_enfants": [employee.ayant_enfants],
+        "frequence_deplacement": [employee.frequence_deplacement],
+        "annees_depuis_la_derniere_promotion": [
+            employee.annees_depuis_la_derniere_promotion
+        ],
+        "annes_sous_responsable_actuel": [employee.annes_sous_responsable_actuel],
+        # EVALUATION
+        "satisfaction_employee_environnement": [
+            employee.satisfaction_employee_environnement
+        ],
+        "note_evaluation_precedente": [employee.note_evaluation_precedente],
+        "niveau_hierarchique_poste": [employee.niveau_hierarchique_poste],
+        "satisfaction_employee_nature_travail": [
+            employee.satisfaction_employee_nature_travail
+        ],
+        "satisfaction_employee_equipe": [employee.satisfaction_employee_equipe],
+        "satisfaction_employee_equilibre_pro_perso": [
+            employee.satisfaction_employee_equilibre_pro_perso
+        ],
+        "note_evaluation_actuelle": [employee.note_evaluation_actuelle],
+        "heure_supplementaires": [employee.heure_supplementaires],
+        "augementation_salaire_precedente": [employee.augementation_salaire_precedente],
+        # SIRH
+        "age": [employee.age],
+        "genre": [employee.genre],
+        "revenu_mensuel": [employee.revenu_mensuel],
+        "statut_marital": [employee.statut_marital],
+        "departement": [employee.departement],
+        "poste": [employee.poste],
+        "nombre_experiences_precedentes": [employee.nombre_experiences_precedentes],
+        "nombre_heures_travailless": [employee.nombre_heures_travailless],
+        "annee_experience_totale": [employee.annee_experience_totale],
+        "annees_dans_l_entreprise": [employee.annees_dans_l_entreprise],
+        "annees_dans_le_poste_actuel": [employee.annees_dans_le_poste_actuel],
+    }
+
+    return pd.DataFrame(data)
+
+
+def engineer_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Applique le feature engineering (mêmes transformations que l'entraînement).
+
+    Args:
+        df: DataFrame avec les colonnes brutes.
+
+    Returns:
+        DataFrame avec les features engineered ajoutées.
+    """
+    df = df.copy()
+
+    # Ratios (+ 1 pour éviter division par zéro)
+    df["revenu_par_anciennete"] = df["revenu_mensuel"] / (
+        df["annees_dans_l_entreprise"] + 1
+    )
+    df["experience_par_anciennete"] = df["annee_experience_totale"] / (
+        df["annees_dans_l_entreprise"] + 1
+    )
+    df["promo_par_anciennete"] = df["annees_depuis_la_derniere_promotion"] / (
+        df["annees_dans_l_entreprise"] + 1
+    )
+
+    # Moyenne de satisfaction
+    df["satisfaction_moyenne"] = df[
+        [
+            "satisfaction_employee_environnement",
+            "satisfaction_employee_nature_travail",
+            "satisfaction_employee_equipe",
+            "satisfaction_employee_equilibre_pro_perso",
+        ]
+    ].mean(axis=1)
+
+    return df
+
+
+def encode_and_scale(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Encode les variables catégorielles et scale les numériques.
+    IMPORTANT: Doit correspondre EXACTEMENT au pipeline d'entraînement.
+
+    Args:
+        df: DataFrame avec features engineered.
+
+    Returns:
+        DataFrame transformé avec 50 colonnes (comme training).
+    """
+    df = df.copy()
+
+    # === ENCODING ===
+
+    # NOTE: ayant_enfants et heure_supplementaires sont SUPPRIMÉS
+    # (ne font pas partie des features du modèle d'entraînement)
+    cols_to_drop = ["ayant_enfants", "heure_supplementaires"]
+    df = df.drop(columns=[col for col in cols_to_drop if col in df.columns])
+
+    # OneHot pour variables catégorielles non-ordonnées
+    # IMPORTANT: Utiliser les mêmes catégories que lors de l'entraînement
+    cat_non_ord = ["genre", "statut_marital", "departement", "poste", "domaine_etude"]
+
+    # Définir toutes les catégories possibles (depuis training data)
+    categories_dict = {
+        "genre": ["F", "M"],
+        "statut_marital": ["Célibataire", "Divorcé(e)", "Marié(e)"],
+        "departement": ["Commercial", "Consulting", "Ressources Humaines"],
+        "poste": [
+            "Assistant de Direction",
+            "Cadre Commercial",
+            "Consultant",
+            "Directeur Technique",
+            "Manager",
+            "Représentant Commercial",
+            "Ressources Humaines",
+            "Senior Manager",
+            "Tech Lead",
+        ],
+        "domaine_etude": [
+            "Autre",
+            "Entrepreunariat",
+            "Infra & Cloud",
+            "Marketing",
+            "Ressources Humaines",
+            "Transformation Digitale",
+        ],
+    }
+
+    onehot = OneHotEncoder(
+        sparse_output=False,
+        handle_unknown="ignore",
+        categories=[categories_dict[col] for col in cat_non_ord],
+    )
+
+    encoded_non_ord = pd.DataFrame(
+        onehot.fit_transform(df[cat_non_ord]),
+        columns=onehot.get_feature_names_out(cat_non_ord),
+        index=df.index,
+    )
+
+    # Ordinal pour fréquence déplacement
+    ordinal = OrdinalEncoder(categories=[["Aucun", "Occasionnel", "Frequent"]])
+    df["frequence_deplacement"] = ordinal.fit_transform(
+        df[["frequence_deplacement"]]
+    ).flatten()
+
+    # Supprimer les colonnes catégorielles originales
+    df = df.drop(columns=cat_non_ord)
+
+    # Concaténer les encodages OneHot
+    df = pd.concat([df, encoded_non_ord], axis=1)
+
+    # === SCALING ===
+
+    # Colonnes numériques à scaler
+    quantitative_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+    # Retirer les colonnes OneHot du scaling (elles sont déjà 0/1)
+    cols_to_scale = [
+        col
+        for col in quantitative_cols
+        if df[col].nunique() > 2  # Exclut colonnes binaires (0/1)
+    ]
+
+    # Appliquer le scaling uniquement s'il y a des colonnes
+    if cols_to_scale:
+        scaler = StandardScaler()
+        df[cols_to_scale] = scaler.fit_transform(df[cols_to_scale])
+
+    return df
+
+
+def preprocess_for_prediction(employee: EmployeeInput) -> np.ndarray:
+    """
+    Pipeline complet de preprocessing pour une prédiction.
+
+    Args:
+        employee: Données validées d'un employé.
+
+    Returns:
+        Array numpy transformé prêt pour model.predict().
+
+    Examples:
+        >>> from src.schemas import EmployeeInput
+        >>> employee = EmployeeInput(...)
+        >>> X = preprocess_for_prediction(employee)
+        >>> prediction = model.predict(X)
+    """
+    # 1. Créer DataFrame
+    df = create_input_dataframe(employee)
+
+    # 2. Feature engineering
+    df = engineer_features(df)
+
+    # 3. Encoding et scaling
+    df = encode_and_scale(df)
+
+    # 4. Convertir en numpy array (le modèle attend un array)
+    return df.values
+
+
+# TODO: Implémenter le chargement des artifacts sauvegardés
+# def load_preprocessing_artifacts(run_id: str) -> dict:
+#     """
+#     Charge les encoders et scaler depuis MLflow.
+#
+#     Returns:
+#         dict avec keys: 'onehot_encoder', 'ordinal_encoder', 'scaler'
+#     """
+#     pass

src/rate_limit.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+Module de rate limiting pour protéger l'API contre les abus.
+
+Utilise SlowAPI pour limiter le nombre de requêtes par IP/utilisateur.
+"""
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from src.config import get_settings
+
+settings = get_settings()
+
+# Créer le limiter avec stratégie par IP
+limiter = Limiter(
+    key_func=get_remote_address,
+    default_limits=["100/minute"] if not settings.DEBUG else [],
+    storage_uri="memory://",  # En production: utiliser Redis
+    strategy="fixed-window",
+)
+
+
+def get_rate_limit_key(request):
+    """
+    Fonction pour obtenir la clé de rate limiting.
+
+    En production, on pourrait utiliser l'API Key au lieu de l'IP.
+
+    Args:
+        request: Requête FastAPI.
+
+    Returns:
+        Clé unique pour identifier l'utilisateur.
+    """
+    # Priorité: API Key > IP
+    api_key = request.headers.get("X-API-Key")
+    if api_key:
+        return f"api_key:{api_key}"
+
+    return get_remote_address(request)

src/schemas.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Schémas Pydantic pour validation des données d'entrée de l'API.
+
+Ces schémas correspondent aux colonnes brutes du dataset avant preprocessing,
+permettant une validation stricte des inputs avec messages d'erreur clairs.
+"""
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+# Enums pour les valeurs catégorielles
+class GenreEnum(str, Enum):
+    """Genre de l'employé."""
+
+    M = "M"
+    F = "F"
+
+
+class StatutMaritalEnum(str, Enum):
+    """Statut marital de l'employé."""
+
+    CELIBATAIRE = "Célibataire"
+    MARIE = "Marié(e)"
+    DIVORCE = "Divorcé(e)"
+
+
+class DepartementEnum(str, Enum):
+    """Département de l'employé."""
+
+    COMMERCIAL = "Commercial"
+    CONSULTING = "Consulting"
+
+
+class DomaineEtudeEnum(str, Enum):
+    """Domaine d'études de l'employé."""
+
+    INFRA_CLOUD = "Infra & Cloud"
+    TRANSFORMATION_DIGITALE = "Transformation Digitale"
+    AUTRE = "Autre"
+
+
+class FrequenceDeplacementEnum(str, Enum):
+    """Fréquence des déplacements professionnels."""
+
+    AUCUN = "Aucun"
+    OCCASIONNEL = "Occasionnel"
+    FREQUENT = "Frequent"
+
+
+class EmployeeInput(BaseModel):
+    """
+    Schéma de validation pour les données d'entrée d'un employé.
+
+    Tous les champs correspondent aux colonnes brutes des 3 fichiers CSV
+    (sondage, eval, sirh) avant preprocessing.
+    """
+
+    # === Données SONDAGE ===
+    nombre_participation_pee: int = Field(
+        ..., ge=0, description="Nombre de participations au PEE"
+    )
+    nb_formations_suivies: int = Field(
+        ..., ge=0, le=10, description="Nombre de formations suivies"
+    )
+    nombre_employee_sous_responsabilite: int = Field(
+        ..., ge=0, description="Nombre d'employés sous responsabilité"
+    )
+    distance_domicile_travail: int = Field(
+        ..., ge=0, le=50, description="Distance domicile-travail en km"
+    )
+    niveau_education: int = Field(
+        ..., ge=1, le=5, description="Niveau d'éducation (1-5)"
+    )
+    domaine_etude: DomaineEtudeEnum = Field(..., description="Domaine d'études")
+    ayant_enfants: Literal["Y", "N"] = Field(..., description="A des enfants (Y/N)")
+    frequence_deplacement: FrequenceDeplacementEnum = Field(
+        ..., description="Fréquence des déplacements"
+    )
+    annees_depuis_la_derniere_promotion: int = Field(
+        ..., ge=0, description="Années depuis la dernière promotion"
+    )
+    annes_sous_responsable_actuel: int = Field(
+        ..., ge=0, description="Années sous le responsable actuel"
+    )
+
+    # === Données EVALUATION ===
+    satisfaction_employee_environnement: int = Field(
+        ..., ge=1, le=4, description="Satisfaction environnement (1-4)"
+    )
+    note_evaluation_precedente: int = Field(
+        ..., ge=1, le=5, description="Note évaluation précédente (1-5)"
+    )
+    niveau_hierarchique_poste: int = Field(
+        ..., ge=1, le=5, description="Niveau hiérarchique (1-5)"
+    )
+    satisfaction_employee_nature_travail: int = Field(
+        ..., ge=1, le=4, description="Satisfaction nature du travail (1-4)"
+    )
+    satisfaction_employee_equipe: int = Field(
+        ..., ge=1, le=4, description="Satisfaction équipe (1-4)"
+    )
+    satisfaction_employee_equilibre_pro_perso: int = Field(
+        ..., ge=1, le=4, description="Satisfaction équilibre pro/perso (1-4)"
+    )
+    note_evaluation_actuelle: int = Field(
+        ..., ge=1, le=5, description="Note évaluation actuelle (1-5)"
+    )
+    heure_supplementaires: Literal["Oui", "Non"] = Field(
+        ..., description="Fait des heures supplémentaires"
+    )
+    augementation_salaire_precedente: float = Field(
+        ..., ge=0, le=100, description="Augmentation salaire précédente (%)"
+    )
+
+    # === Données SIRH ===
+    age: int = Field(..., ge=18, le=70, description="Âge de l'employé")
+    genre: GenreEnum = Field(..., description="Genre")
+    revenu_mensuel: float = Field(..., ge=1000, description="Revenu mensuel (€)")
+    statut_marital: StatutMaritalEnum = Field(..., description="Statut marital")
+    departement: DepartementEnum = Field(..., description="Département")
+    poste: str = Field(..., min_length=3, description="Intitulé du poste")
+    nombre_experiences_precedentes: int = Field(
+        ..., ge=0, description="Nombre d'expériences précédentes"
+    )
+    nombre_heures_travailless: int = Field(
+        ..., ge=35, le=80, description="Nombre d'heures travaillées par semaine"
+    )
+    annee_experience_totale: int = Field(
+        ..., ge=0, description="Années d'expérience totale"
+    )
+    annees_dans_l_entreprise: int = Field(
+        ..., ge=0, description="Années dans l'entreprise"
+    )
+    annees_dans_le_poste_actuel: int = Field(
+        ..., ge=0, description="Années dans le poste actuel"
+    )
+
+    @field_validator("augementation_salaire_precedente")
+    @classmethod
+    def validate_augmentation(cls, v: float) -> float:
+        """Nettoie le format de l'augmentation (enlève % si présent)."""
+        if isinstance(v, str):
+            v = float(v.replace(" %", "").replace("%", ""))
+        return v
+
+    class Config:
+        """Configuration Pydantic."""
+
+        json_schema_extra = {
+            "example": {
+                # Exemple basé sur la première ligne des CSV
+                "nombre_participation_pee": 0,
+                "nb_formations_suivies": 0,
+                "nombre_employee_sous_responsabilite": 1,
+                "distance_domicile_travail": 1,
+                "niveau_education": 2,
+                "domaine_etude": "Infra & Cloud",
+                "ayant_enfants": "Y",
+                "frequence_deplacement": "Occasionnel",
+                "annees_depuis_la_derniere_promotion": 0,
+                "annes_sous_responsable_actuel": 5,
+                "satisfaction_employee_environnement": 2,
+                "note_evaluation_precedente": 3,
+                "niveau_hierarchique_poste": 2,
+                "satisfaction_employee_nature_travail": 4,
+                "satisfaction_employee_equipe": 1,
+                "satisfaction_employee_equilibre_pro_perso": 1,
+                "note_evaluation_actuelle": 3,
+                "heure_supplementaires": "Oui",
+                "augementation_salaire_precedente": 11.0,
+                "age": 41,
+                "genre": "F",
+                "revenu_mensuel": 5993.0,
+                "statut_marital": "Célibataire",
+                "departement": "Commercial",
+                "poste": "Cadre Commercial",
+                "nombre_experiences_precedentes": 8,
+                "nombre_heures_travailless": 80,
+                "annee_experience_totale": 8,
+                "annees_dans_l_entreprise": 6,
+                "annees_dans_le_poste_actuel": 4,
+            }
+        }
+
+
+class PredictionOutput(BaseModel):
+    """Schéma de sortie pour les prédictions."""
+
+    prediction: int = Field(..., description="Classe prédite (0=reste, 1=part)")
+    probability_0: float = Field(
+        ..., ge=0, le=1, description="Probabilité de rester (classe 0)"
+    )
+    probability_1: float = Field(
+        ..., ge=0, le=1, description="Probabilité de partir (classe 1)"
+    )
+    risk_level: str = Field(..., description="Niveau de risque (Low/Medium/High)")
+
+    class Config:
+        """Configuration Pydantic."""
+
+        json_schema_extra = {
+            "example": {
+                "prediction": 1,
+                "probability_0": 0.35,
+                "probability_1": 0.65,
+                "risk_level": "High",
+            }
+        }
+
+
+class HealthCheck(BaseModel):
+    """Schéma pour le endpoint health check."""
+
+    status: str = Field(..., description="Status de l'API")
+    model_loaded: bool = Field(..., description="Modèle chargé ou non")
+    model_type: str = Field(..., description="Type du modèle")
+    version: str = Field(..., description="Version de l'API")
+
+    class Config:
+        """Configuration Pydantic."""
+
+        json_schema_extra = {
+            "example": {
+                "status": "healthy",
+                "model_loaded": True,
+                "model_type": "Pipeline",
+                "version": "1.0.0",
+            }
+        }