Correct version

main.py

@@ -2,6 +2,8 @@ import sys
 from pathlib import Path
 import logging
 from contextlib import asynccontextmanager
+import atexit
+import shutil
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -24,51 +26,103 @@ from config import (
     HUGGINGFACE_API_KEY, HUGGINGFACE_STANCE_MODEL_ID, HUGGINGFACE_LABEL_MODEL_ID,
     HOST, PORT, RELOAD,
     CORS_ORIGINS, CORS_METHODS, CORS_HEADERS, CORS_CREDENTIALS,
-    PRELOAD_MODELS_ON_STARTUP, LOAD_STANCE_MODEL, LOAD_KPA_MODEL
+    PRELOAD_MODELS_ON_STARTUP, LOAD_STANCE_MODEL, LOAD_KPA_MODEL,
+    GROQ_API_KEY, GROQ_STT_MODEL, GROQ_TTS_MODEL, GROQ_CHAT_MODEL
 )
 
-# --- Import des singletons de services ---
-from services.stance_model_manager import stance_model_manager
-from services.label_model_manager import kpa_model_manager
+# --- Fonction de nettoyage ---
+def cleanup_temp_files():
+    """Nettoyer les fichiers temporaires audio au démarrage"""
+    temp_dir = Path("temp_audio")
+    if temp_dir.exists():
+        try:
+            shutil.rmtree(temp_dir)
+            logger.info("✓ Cleaned up previous temp audio files")
+        except Exception as e:
+            logger.warning(f"⚠ Could not clean temp directory: {e}")
+
+# Appeler au démarrage
+cleanup_temp_files()
+
+# Configurer le nettoyage à la fermeture
+@atexit.register
+def cleanup_on_exit():
+    temp_dir = Path("temp_audio")
+    if temp_dir.exists():
+        try:
+            shutil.rmtree(temp_dir)
+        except:
+            pass
 
-from services.stt_service import speech_to_text
-from services.tts_service import text_to_speech
+# --- Import des singletons de services ---
+try:
+    from services.stance_model_manager import stance_model_manager
+    from services.label_model_manager import kpa_model_manager
+    logger.info("✓ Model managers imported")
+except ImportError as e:
+    logger.warning(f"⚠ Could not import model managers: {e}")
+    stance_model_manager = None
+    kpa_model_manager = None
 
 # --- Lifespan / startup API ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     logger.info("="*60)
-    logger.info("🚀 API STARTUP - Loading HuggingFace models...")
+    logger.info("🚀 API STARTUP - Loading models and checking APIs...")
     logger.info("="*60)
-
+    
+    # Vérifier les clés API
+    if not GROQ_API_KEY:
+        logger.warning("⚠ GROQ_API_KEY is not set. STT/TTS features may not work.")
+    else:
+        logger.info("✓ GROQ_API_KEY is configured")
+        
+    if not HUGGINGFACE_API_KEY:
+        logger.warning("⚠ HUGGINGFACE_API_KEY is not set. Local models may not work.")
+    else:
+        logger.info("✓ HUGGINGFACE_API_KEY is configured")
+
+    # Précharger les modèles Hugging Face si configuré
     if PRELOAD_MODELS_ON_STARTUP:
-
+        
         # Charger stance model
-        if LOAD_STANCE_MODEL:
+        if LOAD_STANCE_MODEL and stance_model_manager and HUGGINGFACE_STANCE_MODEL_ID:
             try:
                 stance_model_manager.load_model(HUGGINGFACE_STANCE_MODEL_ID, HUGGINGFACE_API_KEY)
-                logger.info("✓ Stance model loaded")
+                logger.info("✓ Stance model loaded successfully")
             except Exception as e:
                 logger.error(f"✗ Failed loading stance model: {e}")
 
         # Charger KPA model
-        if LOAD_KPA_MODEL:
+        if LOAD_KPA_MODEL and kpa_model_manager and HUGGINGFACE_LABEL_MODEL_ID:
             try:
                 kpa_model_manager.load_model(HUGGINGFACE_LABEL_MODEL_ID, HUGGINGFACE_API_KEY)
-                logger.info("✓ KPA model loaded")
+                logger.info("✓ KPA model loaded successfully")
             except Exception as e:
                 logger.error(f"✗ Failed loading KPA model: {e}")
 
-    logger.info("✓ Startup complete. API ready.")
+    logger.info("="*60)
+    logger.info("✓ Startup complete. API ready to receive requests.")
+    logger.info(f"  STT Model: {GROQ_STT_MODEL}")
+    logger.info(f"  TTS Model: {GROQ_TTS_MODEL}")
+    logger.info(f"  Chat Model: {GROQ_CHAT_MODEL}")
+    logger.info("="*60)
+    
     yield
-    logger.info("🛑 Shutting down...")
+    
+    logger.info("🛑 Shutting down API...")
+    # Nettoyage final
+    cleanup_on_exit()
 
 # --- FastAPI app ---
 app = FastAPI(
     title=API_TITLE,
     description=API_DESCRIPTION,
     version=API_VERSION,
-    lifespan=lifespan
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
 )
 
 # --- CORS ---
@@ -81,41 +135,98 @@ app.add_middleware(
 )
 
 # --- Routes ---
+# STT Routes
 try:
     from routes.stt_routes import router as stt_router
     app.include_router(stt_router, prefix="/api/v1/stt", tags=["Speech To Text"])
     logger.info("✓ STT route loaded (Groq Whisper)")
+except ImportError as e:
+    logger.warning(f"⚠ STT route not found: {e}")
 except Exception as e:
     logger.warning(f"⚠ Failed loading STT route: {e}")
 
+# TTS Routes
 try:
     from routes.tts_routes import router as tts_router
     app.include_router(tts_router, prefix="/api/v1/tts", tags=["Text To Speech"])
     logger.info("✓ TTS route loaded (Groq PlayAI TTS)")
+except ImportError as e:
+    logger.warning(f"⚠ TTS route not found: {e}")
 except Exception as e:
     logger.warning(f"⚠ Failed loading TTS route: {e}")
 
+# Main API Routes
 try:
     from routes import api_router
     app.include_router(api_router)
     logger.info("✓ Main API routes loaded")
+except ImportError as e:
+    logger.warning(f"⚠ Main API routes not found: {e}")
 except Exception as e:
     logger.warning(f"⚠ Failed loading main API routes: {e}")
 
 # --- Basic routes ---
-@app.get("/health")
+@app.get("/health", tags=["Health"])
 async def health():
-    return {"status": "healthy", "service": "NLP Debater + Groq Voice"}
+    """Health check endpoint"""
+    health_status = {
+        "status": "healthy",
+        "service": "NLP Debater + Groq Voice",
+        "features": {
+            "stt": GROQ_STT_MODEL if GROQ_API_KEY else "disabled",
+            "tts": GROQ_TTS_MODEL if GROQ_API_KEY else "disabled",
+            "chat": GROQ_CHAT_MODEL if GROQ_API_KEY else "disabled",
+            "stance_model": "loaded" if (stance_model_manager and stance_model_manager.model is not None) else "not loaded",
+            "kpa_model": "loaded" if (kpa_model_manager and kpa_model_manager.model is not None) else "not loaded"
+        }
+    }
+    return health_status
 
-@app.get("/")
+@app.get("/", tags=["Root"])
 async def root():
+    """Root endpoint with API information"""
     return {
         "message": "NLP Debater API with Groq Voice Support",
-        "docs": "/docs",
-        "voice_stt": "/api/v1/stt",
-        "voice_tts": "/api/v1/tts"
+        "version": API_VERSION,
+        "endpoints": {
+            "docs": "/docs",
+            "redoc": "/redoc",
+            "health": "/health",
+            "stt": "/api/v1/stt/",
+            "tts": "/api/v1/tts/"
+        },
+        "models": {
+            "stt": GROQ_STT_MODEL,
+            "tts": GROQ_TTS_MODEL,
+            "chat": GROQ_CHAT_MODEL
+        }
+    }
+
+# --- Error handlers ---
+@app.exception_handler(404)
+async def not_found_handler(request, exc):
+    return {
+        "error": "Not Found",
+        "message": f"The requested URL {request.url} was not found",
+        "available_endpoints": {
+            "GET /": "API information",
+            "GET /health": "Health check",
+            "POST /api/v1/stt/": "Speech to text",
+            "POST /api/v1/tts/": "Text to speech"
+        }
     }
 
 # --- Run server ---
 if __name__ == "__main__":
-    uvicorn.run("main:app", host=HOST, port=PORT, reload=RELOAD)
+    logger.info("="*60)
+    logger.info(f"Starting server on {HOST}:{PORT}")
+    logger.info(f"Reload mode: {RELOAD}")
+    logger.info("="*60)
+    
+    uvicorn.run(
+        "main:app",
+        host=HOST,
+        port=PORT,
+        reload=RELOAD,
+        log_level="info"
+    )

models/stt.py

@@ -2,3 +2,10 @@ from pydantic import BaseModel
 
 class STTResponse(BaseModel):
     text: str
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Bonjour, comment allez-vous aujourd'hui ?"
+            }
+        }

models/tts.py

@@ -1,6 +1,16 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+from typing import Optional
 
 class TTSRequest(BaseModel):
-    text: str
-    voice: str = "Aaliyah-PlayAI"
-    format: str = "wav"
+    text: str = Field(..., min_length=1, max_length=5000)
+    voice: str = Field(default="Aaliyah-PlayAI")
+    format: str = Field(default="wav", pattern="^(wav|mp3)$")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Bonjour, ceci est un test de synthèse vocale.",
+                "voice": "Aaliyah-PlayAI",
+                "format": "wav"
+            }
+        }

requirements.txt

@@ -2,31 +2,19 @@ fastapi==0.104.1
 uvicorn[standard]==0.24.0
 python-multipart==0.0.6
 python-dotenv==1.0.0
-gtts==2.3.2
 pydantic==2.5.0
-SpeechRecognition==3.10.0
-pyttsx3==2.90
 
-# Fix compatibilité NumPy + Torch + Transformers
-numpy==1.26.4
-
-# Transformers et dépendances compatibles
-transformers==4.35.0
-tokenizers==0.14.1
-huggingface_hub==0.16.4
-accelerate==0.20.3
-safetensors>=0.3.1
-
-# Modèle killer pour protobuf
-protobuf==3.20.0
+# API Clients
+requests==2.31.0
+groq==0.9.0
 
-# Audio + STT
+# Audio processing (optionnel si vous avez besoin de traitement local)
 soundfile==0.12.1
-requests==2.31.0
 
-# PyTorch CPU compatible NumPy<2
+# Hugging Face
+transformers==4.35.0
 torch==2.0.1+cpu
 --extra-index-url https://download.pytorch.org/whl/cpu
 
-# Groq SDK
-groq==0.9.0
+# Autres dépendances
+numpy==1.26.4

routes/stt_routes.py

@@ -1,27 +1,42 @@
-from fastapi import APIRouter, UploadFile, File
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
 from services.stt_service import speech_to_text
 from models.stt import STTResponse
 import os
 import uuid
+import tempfile
+from pathlib import Path
 
 router = APIRouter(prefix="/stt", tags=["Speech To Text"])
 
 @router.post("/", response_model=STTResponse)
-async def convert_stt(file: UploadFile = File(...)):
-    # dossier temporaire
-    os.makedirs("audio/temp", exist_ok=True)
+async def convert_speech_to_text(file: UploadFile = File(...)):
+    """
+    Convert uploaded audio file to text using Groq's Whisper API
+    """
+    # Vérifier le type de fichier
+    if not file.content_type or not file.content_type.startswith('audio/'):
+        raise HTTPException(status_code=400, detail="File must be an audio file")
     
-    # nom temporaire unique
-    temp_name = f"audio/temp/{uuid.uuid4()}_{file.filename}"
+    # Créer un fichier temporaire unique
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+        temp_path = temp_file.name
+        
+        # Écrire le contenu téléchargé
+        content = await file.read()
+        temp_file.write(content)
     
-    # save file
-    with open(temp_name, "wb") as f:
-        f.write(await file.read())
-
-    # STT conversion
-    text = speech_to_text(temp_name)
-
-    # cleanup
-    os.remove(temp_name)
-
-    return STTResponse(text=text)
+    try:
+        # Convertir audio en texte
+        text = speech_to_text(temp_path)
+        
+        # Nettoyer le fichier temporaire
+        os.unlink(temp_path)
+        
+        return STTResponse(text=text)
+        
+    except Exception as e:
+        # Nettoyer en cas d'erreur
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+        raise HTTPException(status_code=500, detail=str(e))

routes/tts_routes.py

@@ -1,22 +1,41 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException
 from fastapi.responses import FileResponse
 from models.tts import TTSRequest
 from services.tts_service import text_to_speech
+import os
 from pathlib import Path
 
 router = APIRouter(prefix="/tts", tags=["Text To Speech"])
 
 @router.post("/")
-async def generate_tts(request: TTSRequest):
-    output_path = text_to_speech(
-    text=request.text,
-    voice=request.voice,
-    fmt=request.format
-)
-
-
-    return FileResponse(
-        output_path,
-        filename=output_path.name,
-        media_type="audio/wav"
-    )
+async def generate_speech(request: TTSRequest):
+    """
+    Convert text to speech and return audio file
+    """
+    try:
+        # Générer l'audio
+        audio_path = text_to_speech(
+            text=request.text,
+            voice=request.voice,
+            fmt=request.format
+        )
+        
+        # Vérifier que le fichier existe
+        if not Path(audio_path).exists():
+            raise HTTPException(status_code=500, detail="Audio file generation failed")
+        
+        # Déterminer le type MIME
+        media_type = "audio/wav" if request.format == "wav" else "audio/mpeg"
+        
+        # Retourner le fichier audio
+        return FileResponse(
+            path=audio_path,
+            filename=f"speech.{request.format}",
+            media_type=media_type,
+            headers={
+                "Content-Disposition": f"attachment; filename=speech.{request.format}"
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

services/stt_service.py

@@ -1,26 +1,40 @@
 import requests
 from config import GROQ_API_KEY, GROQ_STT_MODEL
+import tempfile
+import os
 
 def speech_to_text(audio_file: str) -> str:
+    """
+    Convert audio file to text using Groq's Whisper API
+    """
     if not GROQ_API_KEY:
         raise RuntimeError("GROQ_API_KEY is not set in config")
 
-    url = "https://api.groq.ai/openai/v1/audio/transcriptions"
-
+    url = "https://api.groq.com/openai/v1/audio/transcriptions"
+    
     headers = {
         "Authorization": f"Bearer {GROQ_API_KEY}"
     }
-
-    with open(audio_file, "rb") as f:
+    
+    # Lire le fichier audio
+    with open(audio_file, "rb") as audio_data:
         files = {
-            "file": (audio_file, f, "audio/wav")
+            "file": (os.path.basename(audio_file), audio_data, "audio/wav")
         }
         data = {
-            "model": GROQ_STT_MODEL
+            "model": GROQ_STT_MODEL,
+            "temperature": 0,
+            "response_format": "json"
         }
-
-        response = requests.post(url, headers=headers, data=data, files=files)
-        response.raise_for_status()
-
-        result = response.json()
-        return result.get("text", "")
+        
+        try:
+            response = requests.post(url, headers=headers, files=files, data=data)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result.get("text", "")
+            
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Groq STT API error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Unexpected error in speech_to_text: {str(e)}")

services/tts_service.py

@@ -1,31 +1,54 @@
 import requests
 import uuid
+import os
+from pathlib import Path
 from config import GROQ_API_KEY, GROQ_TTS_MODEL
 
-def text_to_speech(text: str, voice: str, fmt: str):
+def text_to_speech(text: str, voice: str = "Aaliyah-PlayAI", fmt: str = "wav") -> str:
+    """
+    Convert text to speech using Groq's TTS API
+    Returns the path to the generated audio file
+    """
     if not GROQ_API_KEY:
         raise RuntimeError("GROQ_API_KEY is not set in config")
-
-    url = "https://api.groq.ai/openai/v1/audio/speech"
-
+    
+    if not text or not text.strip():
+        raise ValueError("Text cannot be empty")
+    
+    url = "https://api.groq.com/openai/v1/audio/speech"
+    
     headers = {
         "Authorization": f"Bearer {GROQ_API_KEY}",
         "Content-Type": "application/json"
     }
-
+    
     payload = {
         "model": GROQ_TTS_MODEL,
+        "input": text.strip(),
         "voice": voice,
-        "format": fmt,
-        "input": text
+        "response_format": fmt
     }
-
-    output_file = f"audio_{uuid.uuid4()}.{fmt}"
-
-    response = requests.post(url, headers=headers, json=payload)
-    response.raise_for_status()
-
-    with open(output_file, "wb") as f:
-        f.write(response.content)
-
-    return output_file
+    
+    try:
+        # Créer un répertoire temporaire pour les fichiers audio
+        temp_dir = Path("temp_audio")
+        temp_dir.mkdir(exist_ok=True)
+        
+        # Nom de fichier unique
+        output_filename = f"tts_{uuid.uuid4().hex[:8]}.{fmt}"
+        output_path = temp_dir / output_filename
+        
+        # Appel API Groq
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        # Sauvegarder le fichier audio
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+        
+        return str(output_path)
+        
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Groq TTS API error: {str(e)}")
+    except Exception as e:
+        raise Exception(f"Unexpected error in text_to_speech: {str(e)}")