[UPDATE] use flask api insted gradio

app.py

@@ -1,84 +1,71 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+from flask import Flask, request, jsonify
 import torch
 import torchaudio
 import librosa
 import os
 import base64
 import tempfile
-import io
-import uvicorn
 from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
 from huggingface_hub import login
 import logging
-from contextlib import asynccontextmanager
-from typing import Optional
-import json
 
 # Configuration du logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+app = Flask(__name__)
+
 # Configuration du modèle
 MODEL_NAME = "Ronaldodev/speech-to-text-fongbe"
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
-# Variables globales pour le modèle
+# Variables globales pour le modèle (chargement à la demande)
 model = None
 processor = None
+model_loaded = False
 
 
-# Modèles Pydantic pour les requêtes
-class AudioBase64Request(BaseModel):
-    audio_base64: str
-    remove_prefix: bool = True
-
-
-class TranscriptionResponse(BaseModel):
-    success: bool
-    transcription: Optional[str] = None
-    error: Optional[str] = None
-    model_name: str = MODEL_NAME
-
-
-class HealthResponse(BaseModel):
-    status: str
-    model_loaded: bool
-    message: str
+def load_model_if_needed():
+    """Charge le modèle seulement quand nécessaire"""
+    global model, processor, model_loaded
 
-
-# Fonction pour charger le modèle
-async def load_model():
-    """Charge le modèle au démarrage de l'application"""
-    global model, processor
+    if model_loaded and model is not None and processor is not None:
+        return True
 
     try:
         logger.info("🔄 Chargement du modèle STT Fongbé...")
 
-        if not HF_TOKEN:
-            raise ValueError("HF_TOKEN non configuré dans les variables d'environnement")
-
-        login(token=HF_TOKEN)
-        logger.info("✅ Authentification Hugging Face réussie")
+        if HF_TOKEN:
+            login(token=HF_TOKEN)
+            logger.info("✅ Authentification Hugging Face réussie")
+        else:
+            logger.info("⚠️ Pas de token HF - tentative sans authentification")
 
-        model = AutoModelForSpeechSeq2Seq.from_pretrained(MODEL_NAME)
+        # Chargement optimisé
         processor = AutoProcessor.from_pretrained(MODEL_NAME)
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.float16,
+            low_cpu_mem_usage=True,
+            use_safetensors=True
+        )
+
+        model.eval()
+        if hasattr(model, 'half'):
+            model = model.half()
 
+        model_loaded = True
         logger.info("✅ Modèle STT Fongbé chargé avec succès!")
         return True
 
     except Exception as e:
-        logger.error(f"❌ Erreur lors du chargement du modèle: {e}")
+        logger.error(f"❌ Erreur chargement modèle: {e}")
+        model_loaded = False
         return False
 
 
-# Fonction pour traiter l'audio
 def process_audio_data(audio_data, sample_rate=None):
     """Traite les données audio pour la transcription"""
-    if model is None or processor is None:
-        raise HTTPException(status_code=503, detail="Modèle non chargé")
-
     try:
         # Convertir en mono si nécessaire
         if len(audio_data.shape) > 1:
@@ -118,87 +105,74 @@ def process_audio_data(audio_data, sample_rate=None):
         return transcription.strip()
 
     except Exception as e:
-        logger.error(f"❌ Erreur lors du traitement audio: {e}")
-        raise HTTPException(status_code=500, detail=f"Erreur de transcription: {str(e)}")
-
-
-# Context manager pour le cycle de vie de l'app
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Démarrage
-    logger.info("🚀 Démarrage de l'API STT Fongbé")
-    success = await load_model()
-    if not success:
-        logger.error("❌ Impossible de charger le modèle")
-    yield
-    # Arrêt
-    logger.info("🔴 Arrêt de l'API STT Fongbé")
-
-
-# Création de l'application FastAPI
-app = FastAPI(
-    title="🎤 API STT Fongbé",
-    description="API de reconnaissance vocale pour la langue Fongbé",
-    version="1.0.0",
-    lifespan=lifespan
-)
-
-# Configuration CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # À restreindre en production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ENDPOINTS API
-
-@app.get("/", response_model=HealthResponse)
-async def root():
+        logger.error(f"❌ Erreur traitement audio: {e}")
+        raise e
+
+
+@app.route("/", methods=["GET"])
+def health_check():
     """Point d'entrée principal de l'API"""
-    return HealthResponse(
-        status="running",
-        model_loaded=model is not None and processor is not None,
-        message="API STT Fongbé opérationnelle"
-    )
+    return jsonify({
+        "status": "OK",
+        "message": "🎤 API STT Fongbé - Reconnaissance vocale pour la langue Fongbé",
+        "model_name": MODEL_NAME,
+        "model_loaded": model_loaded,
+        "version": "1.0.0"
+    })
 
 
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
+@app.route("/health", methods=["GET"])
+def health():
     """Vérification de l'état de santé de l'API"""
-    model_loaded = model is not None and processor is not None
-
-    return HealthResponse(
-        status="healthy" if model_loaded else "unhealthy",
-        model_loaded=model_loaded,
-        message="Modèle chargé et prêt" if model_loaded else "Modèle non chargé"
-    )
+    return jsonify({
+        "status": "healthy" if model_loaded else "model_not_loaded",
+        "model_loaded": model_loaded,
+        "model_name": MODEL_NAME,
+        "message": "Modèle chargé et prêt" if model_loaded else "Modèle sera chargé à la première utilisation"
+    })
 
 
-@app.post("/transcribe/base64", response_model=TranscriptionResponse)
-async def transcribe_base64(request: AudioBase64Request):
+@app.route("/transcribe/base64", methods=["POST"])
+def transcribe_base64():
     """
     Transcription audio à partir de données base64
-
-    - **audio_base64**: Données audio encodées en base64 (avec ou sans préfixe data:audio/...)
-    - **remove_prefix**: Supprime automatiquement le préfixe data:audio/... (défaut: True)
+    Body JSON: {
+        "audio_base64": "data:audio/wav;base64,..." ou "UklGR...",
+        "remove_prefix": true (optionnel, défaut: true)
+    }
     """
     try:
+        data = request.get_json()
+        if not data or "audio_base64" not in data:
+            return jsonify({
+                "success": False,
+                "error": "Paramètre 'audio_base64' requis"
+            }), 400
+
+        # Charger le modèle si nécessaire
+        if not load_model_if_needed():
+            return jsonify({
+                "success": False,
+                "error": "Impossible de charger le modèle"
+            }), 503
+
         logger.info("🎵 Transcription via base64...")
 
-        audio_base64 = request.audio_base64.strip()
+        audio_base64 = data["audio_base64"].strip()
+        remove_prefix = data.get("remove_prefix", True)
 
         # Supprimer le préfixe data:audio/... si présent
-        if request.remove_prefix and audio_base64.startswith('data:'):
+        if remove_prefix and audio_base64.startswith('data:'):
             audio_base64 = audio_base64.split(',')[1]
 
         # Décoder le base64
         try:
             audio_bytes = base64.b64decode(audio_base64)
         except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Données base64 invalides: {str(e)}")
+            return jsonify({
+                "success": False,
+                "error": f"Données base64 invalides: {str(e)}"
+            }), 400
 
         # Créer un fichier temporaire
         with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
@@ -215,42 +189,57 @@ async def transcribe_base64(request: AudioBase64Request):
 
             logger.info(f"✅ Transcription réussie: '{transcription}'")
 
-            return TranscriptionResponse(
-                success=True,
-                transcription=transcription
-            )
+            return jsonify({
+                "success": True,
+                "transcription": transcription,
+                "model_name": MODEL_NAME
+            })
 
         finally:
             # Nettoyer le fichier temporaire
             if os.path.exists(temp_path):
                 os.unlink(temp_path)
 
-    except HTTPException:
-        raise
     except Exception as e:
         logger.error(f"❌ Erreur transcription base64: {e}")
-        return TranscriptionResponse(
-            success=False,
-            error=str(e)
-        )
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
 
 
-@app.post("/transcribe/file", response_model=TranscriptionResponse)
-async def transcribe_file(audio_file: UploadFile = File(...)):
+@app.route("/transcribe/file", methods=["POST"])
+def transcribe_file():
     """
     Transcription audio à partir d'un fichier uploadé
-
-    - **audio_file**: Fichier audio (WAV, MP3, M4A, etc.)
+    Form-data avec 'audio_file' contenant le fichier audio
     """
     try:
-        logger.info(f"🎵 Transcription du fichier: {audio_file.filename}")
+        # Vérifier qu'un fichier est présent
+        if 'audio_file' not in request.files:
+            return jsonify({
+                "success": False,
+                "error": "Aucun fichier 'audio_file' fourni"
+            }), 400
+
+        audio_file = request.files['audio_file']
+        if audio_file.filename == '':
+            return jsonify({
+                "success": False,
+                "error": "Aucun fichier sélectionné"
+            }), 400
+
+        # Charger le modèle si nécessaire
+        if not load_model_if_needed():
+            return jsonify({
+                "success": False,
+                "error": "Impossible de charger le modèle"
+            }), 503
 
-        # Vérifier le type de fichier
-        if not audio_file.content_type or not audio_file.content_type.startswith('audio/'):
-            logger.warning(f"⚠️ Type de fichier suspect: {audio_file.content_type}")
+        logger.info(f"🎵 Transcription du fichier: {audio_file.filename}")
 
         # Lire le fichier
-        audio_bytes = await audio_file.read()
+        audio_bytes = audio_file.read()
 
         # Créer un fichier temporaire
         with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
@@ -267,38 +256,52 @@ async def transcribe_file(audio_file: UploadFile = File(...)):
 
             logger.info(f"✅ Transcription réussie: '{transcription}'")
 
-            return TranscriptionResponse(
-                success=True,
-                transcription=transcription
-            )
+            return jsonify({
+                "success": True,
+                "transcription": transcription,
+                "model_name": MODEL_NAME,
+                "filename": audio_file.filename
+            })
 
         finally:
             # Nettoyer le fichier temporaire
             if os.path.exists(temp_path):
                 os.unlink(temp_path)
 
-    except HTTPException:
-        raise
     except Exception as e:
         logger.error(f"❌ Erreur transcription fichier: {e}")
-        return TranscriptionResponse(
-            success=False,
-            error=str(e)
-        )
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
 
 
-@app.post("/transcribe/url")
-async def transcribe_url(url: str):
+@app.route("/transcribe/url", methods=["POST"])
+def transcribe_url():
     """
     Transcription audio à partir d'une URL
-
-    - **url**: URL vers un fichier audio accessible publiquement
+    Body JSON: {"url": "https://example.com/audio.wav"}
     """
     try:
-        import requests
-
+        data = request.get_json()
+        if not data or "url" not in data:
+            return jsonify({
+                "success": False,
+                "error": "Paramètre 'url' requis"
+            }), 400
+
+        # Charger le modèle si nécessaire
+        if not load_model_if_needed():
+            return jsonify({
+                "success": False,
+                "error": "Impossible de charger le modèle"
+            }), 503
+
+        url = data["url"]
         logger.info(f"🌐 Téléchargement depuis URL: {url}")
 
+        import requests
+
         # Télécharger le fichier
         response = requests.get(url, timeout=30)
         response.raise_for_status()
@@ -318,10 +321,12 @@ async def transcribe_url(url: str):
 
             logger.info(f"✅ Transcription réussie: '{transcription}'")
 
-            return TranscriptionResponse(
-                success=True,
-                transcription=transcription
-            )
+            return jsonify({
+                "success": True,
+                "transcription": transcription,
+                "model_name": MODEL_NAME,
+                "url": url
+            })
 
         finally:
             # Nettoyer le fichier temporaire
@@ -330,27 +335,34 @@ async def transcribe_url(url: str):
 
     except Exception as e:
         logger.error(f"❌ Erreur transcription URL: {e}")
-        return TranscriptionResponse(
-            success=False,
-            error=str(e)
-        )
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
 
 
-if __name__ == "__main__":
-    # Configuration pour le développement
-    port = int(os.environ.get("PORT", 8000))
+@app.route("/test", methods=["GET"])
+def test():
+    """Endpoint de test simple"""
+    return jsonify({
+        "status": "API fonctionnelle",
+        "message": "Test réussi ✅",
+        "model_loaded": model_loaded,
+        "timestamp": "2025-01-04"
+    })
 
-    print("🚀 DÉMARRAGE API STT FONGBÉ - FASTAPI")
+
+if __name__ == "__main__":
+    print("🚀 DÉMARRAGE API STT FONGBÉ - FLASK")
     print("=" * 50)
-    print(f"🌐 http://localhost:{port}")
-    print(f"📖 Documentation: http://localhost:{port}/docs")
-    print(f"🔧 Redoc: http://localhost:{port}/redoc")
+    print("🌐 Port: 7860")
+    print("📖 Endpoints disponibles:")
+    print("  GET  /              - Statut de l'API")
+    print("  GET  /health        - Santé de l'API")
+    print("  GET  /test          - Test simple")
+    print("  POST /transcribe/base64 - Transcription base64")
+    print("  POST /transcribe/file   - Transcription fichier")
+    print("  POST /transcribe/url    - Transcription URL")
     print("=" * 50)
 
-    uvicorn.run(
-        "app:app",  # Remplacez "app" par le nom de votre fichier si différent
-        host="0.0.0.0",
-        port=port,
-        reload=False,  # À désactiver en production
-        log_level="info"
-    )
+    app.run(host="0.0.0.0", port=7860, debug=True)

requirements.txt

@@ -1,12 +1,8 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-python-multipart==0.0.6
-torch
-torchaudio
+flask==2.3.3
+torch>=2.0.0
+torchaudio>=2.0.0
 librosa==0.10.1
 transformers>=4.35.0
 huggingface_hub>=0.17.0
-pydantic==2.4.2
-python-jose[cryptography]==3.3.0
 requests==2.31.0
 numpy>=1.24.0