Upload folder using huggingface_hub

.env.example

@@ -28,6 +28,9 @@ API_PORT=8000
 # Mode debug (True/False)
 DEBUG=False
 
+# Activer l'interface Gradio
+GRADIO_ENABLED=True
+
 # ===== LOGGING =====
 # Niveau de log (DEBUG, INFO, WARNING, ERROR)
 LOG_LEVEL=INFO

HF_DEPLOYMENT.md

@@ -0,0 +1,168 @@
+# Déploiement sur HuggingFace Spaces
+
+## Architecture déployée
+
+L'application lance **2 services simultanément** :
+
+1. **FastAPI** (port 8000) : API REST complète
+2. **Gradio** (port 7860) : Interface web interactive
+
+## URLs d'accès
+
+Sur HuggingFace Spaces, l'application sera accessible à :
+
+- **Interface Gradio** : `https://votre-space.hf.space/` (port public 7860)
+- **API FastAPI** : Accessible en interne via `http://localhost:8000`
+
+⚠️ **Note importante** : HuggingFace Spaces n'expose publiquement que le port 7860 (Gradio). L'API FastAPI est accessible uniquement en interne ou via l'interface Gradio.
+
+## Configuration requise sur HF Spaces
+
+### 1. Variables d'environnement (Secrets)
+
+Dans les paramètres de votre Space, configurez ces secrets :
+
+```bash
+API_KEY=votre-clé-api-production
+DEBUG=false
+LOG_LEVEL=INFO
+GRADIO_ENABLED=true
+```
+
+### 2. Fichiers nécessaires
+
+Ces fichiers doivent être présents dans le repository :
+
+```
+.
+├── app.py                 # Lance FastAPI + Gradio
+├── api.py                 # Code FastAPI
+├── db_models.py          # Modèles BDD (optionnel sur HF)
+├── pyproject.toml        # Dépendances Poetry
+├── poetry.lock           # Lock des versions
+├── README.md             # Documentation + metadata HF
+└── src/
+    ├── __init__.py
+    ├── auth.py
+    ├── config.py
+    ├── gradio_ui.py      # Interface Gradio
+    ├── logger.py
+    ├── models.py
+    ├── preprocessing.py
+    ├── rate_limit.py
+    └── schemas.py
+```
+
+### 3. Metadata HF dans README.md
+
+Assurez-vous que le header YAML dans `README.md` contient :
+
+```yaml
+---
+title: Employee Turnover Prediction API
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: "5.9.1"
+app_file: app.py
+pinned: false
+---
+```
+
+## Comment l'application démarre
+
+1. `app.py` démarre FastAPI sur le port 8000 (background)
+2. Attend que FastAPI soit opérationnel (health check)
+3. Lance Gradio sur le port 7860 (foreground)
+4. Les deux services communiquent en interne
+
+## Test local
+
+Pour tester localement avant déploiement :
+
+```bash
+# Activer l'environnement virtuel
+source .venv/bin/activate
+
+# Lancer l'application
+python app.py
+```
+
+Puis accédez à :
+- Gradio : http://localhost:7860
+- FastAPI : http://localhost:8000/docs
+
+## Utilisation de l'API depuis l'extérieur
+
+### Option 1 : Via l'interface Gradio (recommandé)
+
+Utilisez l'interface web directement sur `https://votre-space.hf.space/`
+
+### Option 2 : Via l'API Gradio (pour scripts externes)
+
+Gradio expose automatiquement une API pour ses fonctions :
+
+```python
+from gradio_client import Client
+
+client = Client("https://votre-space.hf.space/")
+result = client.predict(
+    nombre_participation_pee=0,
+    nb_formations_suivies=2,
+    # ... autres paramètres
+    api_name="/predict"
+)
+print(result)
+```
+
+### Option 3 : FastAPI (uniquement en local ou si proxy configuré)
+
+L'API FastAPI n'est pas directement accessible depuis l'extérieur sur HF Spaces.
+
+## Dépannage
+
+### Le Space ne démarre pas
+
+1. Vérifiez les logs dans l'onglet "Logs" de HF Spaces
+2. Vérifiez que `pyproject.toml` et `poetry.lock` sont à jour
+3. Vérifiez que toutes les dépendances sont installables
+
+### FastAPI ne démarre pas
+
+- Vérifiez que `uvicorn` est dans les dépendances
+- Vérifiez les logs pour les erreurs de port
+- Assurez-vous que le modèle est bien téléchargeable depuis HF Hub
+
+### Gradio ne répond pas
+
+- Vérifiez que le port 7860 n'est pas bloqué
+- Vérifiez que `sdk: gradio` est bien dans le README
+- Vérifiez que `app_file: app.py` pointe vers le bon fichier
+
+## Logs et monitoring
+
+Les logs sont visibles dans l'onglet "Logs" de HF Spaces. Format :
+
+```
+2026-01-12 03:22:01,905 - INFO - 🚀 Démarrage de l'application complète
+2026-01-12 03:22:02,256 - INFO - [FastAPI] Application startup complete
+2026-01-12 03:22:04,855 - INFO - ✅ FastAPI démarré et opérationnel
+2026-01-12 03:22:06,717 - INFO - 🌐 Lancement du serveur sur 0.0.0.0:7860...
+```
+
+## Mise à jour du déploiement
+
+Pour mettre à jour l'application :
+
+1. Committez vos changements sur GitHub
+2. HF Spaces se synchronise automatiquement
+3. Le Space redémarre avec les nouveaux fichiers
+4. Vérifiez les logs pour confirmer le bon démarrage
+
+## Support
+
+En cas de problème :
+1. Consultez les logs HF Spaces
+2. Testez localement avec `python app.py`
+3. Vérifiez la documentation : https://huggingface.co/docs/hub/spaces

QUICK_DEPLOY.md

@@ -0,0 +1,139 @@
+# Guide de déploiement rapide sur HuggingFace Spaces
+
+## ✅ Prérequis
+
+Votre application est maintenant configurée pour déployer **FastAPI + Gradio** ensemble.
+
+## 🚀 Déploiement en 3 étapes
+
+### Étape 1 : Tester localement
+
+```bash
+# Lancer le script de test
+./test_deployment.sh
+```
+
+Si tous les tests passent ✅, passez à l'étape 2.
+
+### Étape 2 : Commiter les changements
+
+```bash
+# Voir les fichiers modifiés
+git status
+
+# Ajouter tous les fichiers
+git add app.py src/Dockerfile HF_DEPLOYMENT.md test_deployment.sh QUICK_DEPLOY.md
+
+# Commiter
+git commit -m "Deploy: FastAPI + Gradio on HuggingFace Spaces"
+
+# Pousser sur GitHub
+git push origin main
+```
+
+### Étape 3 : Synchroniser HuggingFace Spaces
+
+HuggingFace Spaces se synchronise automatiquement avec votre repo GitHub.
+
+1. Allez sur https://huggingface.co/spaces/votre-username/votre-space
+2. Cliquez sur l'onglet **"Settings"**
+3. Dans "Repository", vérifiez que le lien GitHub est configuré
+4. Le Space va se rebuilder automatiquement
+5. Vérifiez les logs dans l'onglet **"Logs"**
+
+## 📋 Checklist de vérification
+
+- [ ] Les tests locaux passent (`./test_deployment.sh`)
+- [ ] Le fichier `README.md` contient le header YAML avec `sdk: gradio`
+- [ ] Les dépendances sont à jour dans `pyproject.toml`
+- [ ] Les secrets sont configurés sur HF Spaces (API_KEY, DEBUG, etc.)
+- [ ] Le repository GitHub est synchronisé
+
+## 🔍 Vérification après déploiement
+
+Une fois le Space déployé, vérifiez :
+
+1. **Interface Gradio** : Accédez à `https://votre-space.hf.space/`
+   - Testez une prédiction unitaire
+   - Testez une prédiction batch
+
+2. **Logs** : Consultez les logs sur HF Spaces
+   ```
+   ✅ Recherchez ces messages :
+   - "🚀 Démarrage de l'application complète"
+   - "[FastAPI] Application startup complete"
+   - "✅ FastAPI démarré et opérationnel"
+   - "🌐 Lancement du serveur sur 0.0.0.0:7860"
+   ```
+
+3. **API interne** : L'API FastAPI tourne en interne (non accessible publiquement)
+
+## ⚠️ Problèmes courants
+
+### Le Space ne démarre pas
+
+**Symptômes** : Le Space affiche "Building" indéfiniment ou erreur au démarrage
+
+**Solutions** :
+1. Vérifiez les logs HF Spaces
+2. Vérifiez que `pyproject.toml` et `poetry.lock` sont synchronisés
+3. Vérifiez que toutes les dépendances sont installables
+4. Essayez de rebuilder manuellement : Settings → Factory reboot
+
+### FastAPI ne démarre pas
+
+**Symptômes** : Dans les logs, erreur au démarrage de uvicorn
+
+**Solutions** :
+1. Vérifiez que `uvicorn` est dans `pyproject.toml`
+2. Vérifiez que `api.py` est bien copié (voir `src/Dockerfile`)
+3. Vérifiez que le modèle est téléchargeable depuis HF Hub
+
+### Gradio ne répond pas
+
+**Symptômes** : "502 Bad Gateway" ou page blanche
+
+**Solutions** :
+1. Vérifiez que `sdk: gradio` est dans le header YAML du README
+2. Vérifiez que `app_file: app.py` pointe vers le bon fichier
+3. Attendez 2-3 minutes (le premier démarrage est long)
+
+### "API not found" dans l'interface
+
+**Symptômes** : L'interface s'affiche mais les prédictions échouent
+
+**Solutions** :
+1. Vérifiez que FastAPI a bien démarré (logs)
+2. Vérifiez que le port 8000 n'est pas bloqué
+3. Augmentez le temps d'attente dans `app.py` (ligne avec `sleep(5)`)
+
+## 🔄 Mise à jour du Space
+
+Pour mettre à jour votre Space après modification :
+
+```bash
+# 1. Modifier vos fichiers
+# 2. Commiter
+git add .
+git commit -m "Update: description des changements"
+git push origin main
+
+# 3. HF Spaces se met à jour automatiquement (1-2 minutes)
+```
+
+## 📞 Support
+
+- Documentation HF : https://huggingface.co/docs/hub/spaces
+- Documentation Gradio : https://gradio.app/docs/
+- Documentation FastAPI : https://fastapi.tiangolo.com/
+
+## 🎉 Vous êtes prêt !
+
+Votre application est maintenant prête à être déployée avec :
+- ✅ API REST complète (FastAPI)
+- ✅ Interface web interactive (Gradio)
+- ✅ Prédictions unitaires et batch
+- ✅ Documentation automatique
+- ✅ Monitoring et logs
+
+Bon déploiement ! 🚀

app.py

@@ -1,12 +1,16 @@
 #!/usr/bin/env python3
 """
-App Gradio pour Hugging Face Spaces.
+App pour Hugging Face Spaces.
 
-Lance l'interface Gradio pour la prédiction de turnover.
+Lance FastAPI (port 8000) et Gradio (port 7860) simultanément.
 """
 import sys
 import os
 import logging
+import subprocess
+import time
+import signal
+from threading import Thread
 
 # Configurer le logging avant toute chose
 logging.basicConfig(
@@ -22,20 +26,116 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
 
 from src.config import get_settings  # noqa: E402
 
-if __name__ == "__main__":
+
+# Variables globales pour les processus
+fastapi_process = None
+gradio_thread = None
+
+
+def start_fastapi():
+    """Lance le serveur FastAPI en subprocess."""
+    global fastapi_process
+    logger.info("🚀 Démarrage de FastAPI sur port 8000...")
+
     try:
-        settings = get_settings()
-        if not settings.GRADIO_ENABLED:
-            logger.info("Gradio désactivée (GRADIO_ENABLED=False) - arrêt.")
-            sys.exit(0)
+        fastapi_process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m",
+                "uvicorn",
+                "api:app",
+                "--host",
+                "0.0.0.0",
+                "--port",
+                "8000",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
 
-        logger.info("🚀 Démarrage de l'application Gradio...")
+        # Logger la sortie de FastAPI
+        for line in iter(fastapi_process.stdout.readline, ""):
+            if line:
+                logger.info(f"[FastAPI] {line.rstrip()}")
+
+    except Exception as e:
+        logger.error(f"❌ Erreur démarrage FastAPI: {e}", exc_info=True)
+
+
+def start_gradio():
+    """Lance l'interface Gradio."""
+    logger.info("🎨 Démarrage de Gradio sur port 7860...")
+    try:
         from src.gradio_ui import launch_standalone
 
         launch_standalone()
+    except Exception as e:
+        logger.error(f"❌ Erreur démarrage Gradio: {e}", exc_info=True)
+
+
+def cleanup(signum=None, frame=None):
+    """Nettoie les processus avant de quitter."""
+    logger.info("🛑 Arrêt des services...")
+
+    if fastapi_process:
+        logger.info("Arrêt de FastAPI...")
+        fastapi_process.terminate()
+        try:
+            fastapi_process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            logger.warning("FastAPI ne répond pas, forçage de l'arrêt...")
+            fastapi_process.kill()
+
+    logger.info("✅ Arrêt propre effectué")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        settings = get_settings()
+
+        # Installer les handlers de signaux
+        signal.signal(signal.SIGINT, cleanup)
+        signal.signal(signal.SIGTERM, cleanup)
+
+        logger.info("=" * 60)
+        logger.info("🚀 Démarrage de l'application complète")
+        logger.info("   - FastAPI sur http://0.0.0.0:8000")
+        logger.info("   - Gradio sur http://0.0.0.0:7860")
+        logger.info("=" * 60)
+
+        # Lancer FastAPI en thread séparé
+        fastapi_thread = Thread(target=start_fastapi, daemon=True)
+        fastapi_thread.start()
+
+        # Attendre que FastAPI démarre
+        logger.info("⏳ Attente du démarrage de FastAPI...")
+        time.sleep(5)
+
+        # Vérifier que FastAPI est démarré
+        import requests
+
+        for i in range(10):
+            try:
+                response = requests.get("http://localhost:8000/health", timeout=2)
+                if response.status_code == 200:
+                    logger.info("✅ FastAPI démarré et opérationnel")
+                    break
+            except Exception:
+                logger.info(f"⏳ Tentative {i + 1}/10 de connexion à FastAPI...")
+                time.sleep(2)
+        else:
+            logger.warning("⚠️ FastAPI ne répond pas, mais on continue...")
+
+        # Lancer Gradio (bloquant - dans le thread principal)
+        start_gradio()
+
     except KeyboardInterrupt:
         logger.info("⏹️ Application arrêtée par l'utilisateur")
-        sys.exit(0)
+        cleanup()
     except Exception as e:
         logger.error(f"❌ Erreur fatale: {e}", exc_info=True)
+        cleanup()
         sys.exit(1)

src/Dockerfile

@@ -21,15 +21,15 @@ RUN poetry install --no-dev --no-interaction --no-ansi
 
 # Copier le code de l'application
 COPY app.py .
+COPY api.py .
 COPY db_models.py .
 COPY src/ ./src/
-COPY .env.example .env
 
 # Créer le dossier logs
 RUN mkdir -p logs
 
-# Exposer le port (7860 = Gradio par défaut sur HuggingFace Spaces)
-EXPOSE 7860
+# Exposer les ports (7860 = Gradio, 8000 = FastAPI)
+EXPOSE 7860 8000
 
 # Variables d'environnement par défaut
 ENV DEBUG=false

test_deployment.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+# Script de test avant déploiement sur HuggingFace Spaces
+# Vérifie que FastAPI et Gradio fonctionnent correctement ensemble
+
+set -e
+
+echo "=========================================="
+echo "🧪 Test de l'application avant déploiement"
+echo "=========================================="
+
+# Couleurs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Fonction de nettoyage
+cleanup() {
+    echo -e "\n${YELLOW}🧹 Nettoyage...${NC}"
+    pkill -f "python app.py" 2>/dev/null || true
+    pkill -f "uvicorn api:app" 2>/dev/null || true
+    sleep 2
+}
+
+# Nettoyer avant de commencer
+cleanup
+
+# Trap pour nettoyer en cas d'interruption
+trap cleanup EXIT INT TERM
+
+echo -e "\n${YELLOW}1️⃣  Démarrage de l'application...${NC}"
+
+# Chercher l'environnement virtuel
+if [ -d ".venv" ]; then
+    PYTHON=".venv/bin/python"
+elif [ -d "venv" ]; then
+    PYTHON="venv/bin/python"
+else
+    PYTHON="python3"
+fi
+
+echo -e "${YELLOW}   Using Python: $PYTHON${NC}"
+$PYTHON app.py > /tmp/app_test.log 2>&1 &
+APP_PID=$!
+
+# Attendre le démarrage
+echo -e "${YELLOW}⏳ Attente du démarrage (20s)...${NC}"
+sleep 20
+
+# Vérifier que le processus tourne
+if ! ps -p $APP_PID > /dev/null; then
+    echo -e "${RED}❌ L'application a crashé au démarrage${NC}"
+    echo -e "\n${YELLOW}Logs:${NC}"
+    tail -30 /tmp/app_test.log
+    exit 1
+fi
+
+echo -e "${GREEN}✅ Application démarrée${NC}"
+
+# Test 1: Health check FastAPI
+echo -e "\n${YELLOW}2️⃣  Test health check FastAPI (port 8000)...${NC}"
+if curl -s -f http://localhost:8000/health > /dev/null; then
+    echo -e "${GREEN}✅ FastAPI répond${NC}"
+    curl -s http://localhost:8000/health | python3 -m json.tool 2>/dev/null || echo "{}"
+else
+    echo -e "${RED}❌ FastAPI ne répond pas${NC}"
+    tail -30 /tmp/app_test.log
+    exit 1
+fi
+
+# Test 2: Gradio home
+echo -e "\n${YELLOW}3️⃣  Test interface Gradio (port 7860)...${NC}"
+if curl -s -f http://localhost:7860/ > /dev/null; then
+    echo -e "${GREEN}✅ Gradio répond${NC}"
+else
+    echo -e "${RED}❌ Gradio ne répond pas${NC}"
+    tail -30 /tmp/app_test.log
+    exit 1
+fi
+
+# Test 3: Prédiction API
+echo -e "\n${YELLOW}4️⃣  Test prédiction via API FastAPI...${NC}"
+
+# Récupérer la clé API depuis .env ou utiliser la clé par défaut
+if [ -f ".env" ]; then
+    API_KEY=$(grep "^API_KEY=" .env | cut -d'=' -f2)
+else
+    API_KEY="dev-key-change-me-in-production"
+fi
+
+RESPONSE=$(curl -s -X POST http://localhost:8000/predict \
+  -H "Content-Type: application/json" \
+  -H "X-API-Key: $API_KEY" \
+  -d '{
+    "nombre_participation_pee": 0,
+    "nb_formations_suivies": 2,
+    "nombre_employee_sous_responsabilite": 1,
+    "distance_domicile_travail": 15,
+    "niveau_education": 3,
+    "domaine_etude": "Infra & Cloud",
+    "ayant_enfants": "Y",
+    "frequence_deplacement": "Occasionnel",
+    "annees_depuis_la_derniere_promotion": 2,
+    "annes_sous_responsable_actuel": 5,
+    "satisfaction_employee_environnement": 3,
+    "note_evaluation_precedente": 4,
+    "niveau_hierarchique_poste": 2,
+    "satisfaction_employee_nature_travail": 3,
+    "satisfaction_employee_equipe": 3,
+    "satisfaction_employee_equilibre_pro_perso": 2,
+    "note_evaluation_actuelle": 4,
+    "heure_supplementaires": "Non",
+    "augementation_salaire_precedente": 5.5,
+    "age": 35,
+    "genre": "M",
+    "revenu_mensuel": 4500.0,
+    "statut_marital": "Marié(e)",
+    "departement": "Commercial",
+    "poste": "Manager",
+    "nombre_experiences_precedentes": 3,
+    "nombre_heures_travailless": 80,
+    "annee_experience_totale": 10,
+    "annees_dans_l_entreprise": 5,
+    "annees_dans_le_poste_actuel": 2
+  }')
+
+if echo "$RESPONSE" | grep -q "prediction"; then
+    echo -e "${GREEN}✅ Prédiction réussie${NC}"
+    echo "$RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$RESPONSE"
+else
+    echo -e "${RED}❌ Erreur lors de la prédiction${NC}"
+    echo "$RESPONSE"
+    exit 1
+fi
+
+# Test 4: Documentation Swagger
+echo -e "\n${YELLOW}5️⃣  Test documentation Swagger...${NC}"
+if curl -s -f http://localhost:8000/docs > /dev/null; then
+    echo -e "${GREEN}✅ Documentation accessible${NC}"
+else
+    echo -e "${RED}❌ Documentation non accessible${NC}"
+    exit 1
+fi
+
+# Résumé final
+echo -e "\n=========================================="
+echo -e "${GREEN}✅ TOUS LES TESTS SONT PASSÉS !${NC}"
+echo -e "=========================================="
+echo ""
+echo "L'application est prête pour le déploiement sur HuggingFace Spaces."
+echo ""
+echo "Prochaines étapes :"
+echo "1. Committez vos changements : git add . && git commit -m 'Deploy FastAPI + Gradio'"
+echo "2. Poussez sur GitHub : git push origin main"
+echo "3. HF Spaces se synchronisera automatiquement"
+echo "4. Vérifiez les logs sur https://huggingface.co/spaces/votre-username/votre-space/logs"
+echo ""
+echo "URLs attendues sur HF Spaces :"
+echo "  - Interface : https://votre-space.hf.space/"
+echo "  - API interne : http://localhost:8000 (non publique)"
+echo ""
+
+# Nettoyer
+cleanup
+
+exit 0