Upload folder using huggingface_hub

app.py

@@ -6,11 +6,29 @@ Lance l'interface Gradio pour la prédiction de turnover.
 """
 import sys
 import os
+import logging
 
-from src.gradio_ui import launch_standalone
+# Configurer le logging avant toute chose
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    stream=sys.stdout,
+    force=True,
+)
+logger = logging.getLogger(__name__)
 
 # Ajouter le répertoire src au path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
 
 if __name__ == "__main__":
-    launch_standalone()
+    try:
+        logger.info("🚀 Démarrage de l'application Gradio...")
+        from src.gradio_ui import launch_standalone
+
+        launch_standalone()
+    except KeyboardInterrupt:
+        logger.info("⏹️ Application arrêtée par l'utilisateur")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"❌ Erreur fatale: {e}", exc_info=True)
+        sys.exit(1)

src/Dockerfile

@@ -35,10 +35,11 @@ EXPOSE 7860
 ENV DEBUG=false
 ENV LOG_LEVEL=INFO
 ENV API_KEY=change-me-in-production
+ENV PYTHONUNBUFFERED=1
 
-# Healthcheck - vérifier que FastAPI répond sur /health
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-  CMD curl -f http://localhost:7860/health || exit 1
+# Healthcheck - vérifier que Gradio répond
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+  CMD curl -f http://localhost:7860/ || exit 1
 
-# Commande de démarrage - FastAPI avec Gradio monté sur /ui
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Commande de démarrage - Lancer l'app Gradio directement
+CMD ["python", "app.py"]

src/gradio_ui.py

@@ -586,37 +586,55 @@ def create_gradio_interface():
 def launch_standalone():
     """Lance Gradio en mode standalone (pour HuggingFace Spaces)."""
     import sys
+    import logging
 
-    print("🚀 Démarrage de l'application Gradio...", flush=True)
-    print(f"Python version: {sys.version}", flush=True)
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        force=True,
+    )
+    logger = logging.getLogger(__name__)
+
+    logger.info("🚀 Démarrage de l'application Gradio...")
+    logger.info(f"Python version: {sys.version}")
 
     # Pré-charger le modèle pour éviter le timeout au premier appel
-    print("📦 Pré-chargement du modèle...", flush=True)
+    logger.info("📦 Pré-chargement du modèle...")
     try:
         from src.models import load_model
 
         model = load_model()
-        print(f"✅ Modèle chargé: {type(model).__name__}", flush=True)
+        logger.info(f"✅ Modèle chargé: {type(model).__name__}")
     except Exception as e:
-        print(f"⚠️ Erreur chargement modèle: {e}", flush=True)
+        logger.warning(f"⚠️ Erreur chargement modèle au démarrage: {e}")
+        logger.warning("L'application continuera sans préchargement du modèle")
 
-    print("🎨 Création de l'interface Gradio...", flush=True)
-    demo = create_gradio_interface()
+    try:
+        logger.info("🎨 Création de l'interface Gradio...")
+        demo = create_gradio_interface()
+        logger.info("✅ Interface Gradio créée avec succès")
+    except Exception as e:
+        logger.error(
+            f"❌ Erreur lors de la création de l'interface: {e}", exc_info=True
+        )
+        sys.exit(1)
 
     # Configuration pour HuggingFace Spaces
-    # Ne pas utiliser queue() qui peut causer des problèmes sur HF Spaces
-    # car il nécessite un serveur websocket supplémentaire
-
-    print("🌐 Lancement du serveur sur 0.0.0.0:7860...", flush=True)
+    logger.info("🌐 Lancement du serveur sur 0.0.0.0:7860...")
     sys.stdout.flush()
     sys.stderr.flush()
 
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-    )
+    try:
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            quiet=False,
+        )
+    except Exception as e:
+        logger.error(f"❌ Erreur lors du lancement du serveur: {e}", exc_info=True)
+        sys.exit(1)
 
 
 # Pour lancer en standalone

src/models.py

@@ -48,15 +48,24 @@ def load_model(force_reload: bool = False) -> Any:
 
     try:
         import joblib
+        import logging
 
-        print(f"🔄 Chargement du modèle depuis HF Hub: {HF_MODEL_REPO}")
+        logger = logging.getLogger(__name__)
 
-        # 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"
-        )
+        logger.info(f"🔄 Chargement du modèle depuis HF Hub: {HF_MODEL_REPO}")
 
-        print(f"📦 Modèle téléchargé: {model_path}")
+        # Télécharger le modèle depuis Hugging Face Hub
+        try:
+            model_path = hf_hub_download(
+                repo_id=HF_MODEL_REPO,
+                filename=MODEL_FILENAME,
+                repo_type="model",
+            )
+        except Exception as download_error:
+            logger.error(f"Erreur téléchargement HF Hub: {download_error}")
+            raise
+
+        logger.info(f"📦 Modèle téléchargé: {model_path}")
 
         # Charger le modèle avec joblib
         model = joblib.load(model_path)
@@ -64,12 +73,15 @@ def load_model(force_reload: bool = False) -> Any:
         # Mettre en cache
         _model_cache = model
 
-        print(f"✅ Modèle chargé avec succès: {type(model).__name__}")
+        logger.info(f"✅ Modèle chargé avec succès: {type(model).__name__}")
         return model
 
     except Exception as e:
+        import logging
+
+        logger = logging.getLogger(__name__)
         error_msg = f"❌ Erreur lors du chargement du modèle: {str(e)}"
-        print(error_msg)
+        logger.error(error_msg)
         raise HTTPException(
             status_code=500,
             detail={