first commit

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+.tox/
+
+# Audio files
+*.wav
+*.mp3
+*.m4a
+*.ogg
+
+# Output
+output*.wav
+*.pyc
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Model cache (optional, remove if using persistent storage)
+# .cache/

ARCHITECTURE.md

@@ -0,0 +1,273 @@
+# Architecture et Documentation Technique
+
+## 🏗️ Architecture de l'API
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      Client/Frontend                        │
+│  (Web, Mobile, CLI, Python Client, cURL, etc.)             │
+└────────────────────┬────────────────────────────────────────┘
+                     │ HTTP/REST
+┌────────────────────▼────────────────────────────────────────┐
+│                    Flask API Server                         │
+│  - Health Check         GET /health                         │
+│  - Documentation        GET /                               │
+│  - Langues              GET /supported-languages            │
+│  - ASR (Audio→Text)     POST /asr                           │
+│  - TTS (Text→Audio)     POST /tts                           │
+└────────────┬──────────────────────────────┬─────────────────┘
+             │                              │
+    ┌────────▼──────────┐        ┌──────────▼──────────┐
+    │  ASR Pipeline     │        │  TTS Pipeline      │
+    │                   │        │                    │
+    │ 1. Load Audio     │        │ 1. Validate Text   │
+    │ 2. Process       │        │ 2. Load Model      │
+    │ 3. Tokenize      │        │ 3. Tokenize        │
+    │ 4. Infer w/ MMS  │        │ 4. Infer (VITS)    │
+    │ 5. Decode        │        │ 5. Generate WAV    │
+    └────────┬──────────┘        └──────────┬─────────┘
+             │                              │
+    ┌────────▼──────────────────────────────▼──────────┐
+    │         Model Cache & Management               │
+    │  - facebook/mms-1b-all (ASR)                   │
+    │  - facebook/mms-tts-* (8 langues)             │
+    │  - Thread-safe loading                        │
+    │  - Lazy initialization                        │
+    └────────┬──────────────────────────────────────┘
+             │
+    ┌────────▼──────────────────────────────────────┐
+    │   PyTorch / GPU Support                      │
+    │  - Détection automatique GPU/CPU             │
+    │  - Device management                        │
+    └──────────────────────────────────────────────┘
+```
+
+## 📊 Flow des requêtes
+
+### ASR (Automatic Speech Recognition)
+
+```
+Audio File
+    ↓
+[Validation] → Error if invalid
+    ↓
+[Load & Resample] → Convert to 16kHz mono
+    ↓
+[Normalize] → [-1, 1] range
+    ↓
+[Truncate] → Max 30 seconds
+    ↓
+[Tokenize] → Convert to features
+    ↓
+[Infer] → facebook/mms-1b-all (GPU/CPU)
+    ↓
+[Decode] → Text output
+    ↓
+JSON Response
+```
+
+### TTS (Text-to-Speech)
+
+```
+Text + Language
+    ↓
+[Validation] → Error if empty/too long
+    ↓
+[Load Model] → facebook/mms-tts-{lang}
+    ↓
+[Tokenize] → Convert text to token IDs
+    ↓
+[Infer] → VITS model (GPU/CPU)
+    ↓
+[Generate WAV] → Audio synthesis (22050 Hz)
+    ↓
+WAV File (audio/wav)
+```
+
+## 🧠 Modèles utilisés
+
+### ASR: facebook/mms-1b-all
+
+- **Architecture**: wav2vec2
+- **Taille**: 964.8M parameters
+- **Langues**: 100+ (ISO 639-3)
+- **Input**: Audio 16kHz mono
+- **Output**: Transcription texte
+- **Entraînement**: XLSL-R + Fine-tuning multilingual
+
+### TTS: facebook/mms-tts-{language}
+
+- **Architecture**: VITS (Variational Inference Text-to-Speech)
+- **Taille**: ~5-10M parameters par modèle
+- **Langues**: 8 (voir supported languages)
+- **Input**: Texte (max 1000 chars)
+- **Output**: Waveform 22050 Hz
+- **Entraînement**: Multilingual dataset + data augmentation
+
+## 🔧 Configuration
+
+```python
+SAMPLE_RATE = 16000           # Taux d'échantillonnage ASR
+MAX_AUDIO_LENGTH = 30         # Max 30 secondes d'audio
+MAX_TEXT_LENGTH = 1000        # Max 1000 caractères
+DEVICE = auto (GPU if available)
+MODEL_CACHE = Thread-safe dict
+```
+
+## 📈 Performance
+
+| Métrique | Valeur |
+|----------|--------|
+| Première requête ASR | 2-5 min (chargement modèle) |
+| Requêtes suivantes ASR | 1-10 sec (audio 10sec) |
+| Première requête TTS | 30-60 sec (chargement modèle) |
+| Requêtes suivantes TTS | 1-5 sec (100 chars) |
+| Mémoire GPU | ~2GB (ASR) + 1GB (TTS) |
+| Mémoire RAM | ~1GB cache |
+
+## 🔐 Sécurité
+
+### Input Validation
+- ✅ Vérification type fichier audio
+- ✅ Limitation taille audio (30s)
+- ✅ Limitation taille texte (1000 chars)
+- ✅ Vérification contenu non-vide
+
+### Rate Limiting (À ajouter)
+```python
+from flask_limiter import Limiter
+limiter = Limiter(app, key_func=lambda: request.remote_addr)
+
+@app.route('/tts')
+@limiter.limit("10/minute")
+def tts():
+    ...
+```
+
+### Authentication (À ajouter)
+```python
+from functools import wraps
+def require_token(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        token = request.headers.get('Authorization')
+        if not validate_token(token):
+            return {'error': 'Unauthorized'}, 401
+        return f(*args, **kwargs)
+    return decorated
+```
+
+## 🚀 Optimisations
+
+### Cache des modèles
+- Modèles chargés une seule fois
+- Partage entre toutes les requêtes
+- Thread-safe avec locks
+
+### GPU Acceleration
+- Détection automatique GPU
+- Inference sur GPU si disponible
+- Fallback CPU automatique
+
+### Memory Management
+- Gradients désactivés pour inférence
+- Modèles en eval mode
+- Audio / texte tronqués
+
+## 📦 Déploiement
+
+### Local Development
+```bash
+python app_v2.py
+# Runs on http://localhost:7860
+```
+
+### Docker
+```bash
+docker build -t mms-api .
+docker run -p 7860:7860 mms-api
+```
+
+### Docker Compose (avec GPU)
+```bash
+docker-compose up
+```
+
+### Hugging Face Spaces
+- Crée un Space Docker
+- Push code vers HF
+- Auto-build et déploiement
+- URL: https://huggingface.co/spaces/{user}/{space}
+
+## 📡 API Endpoints
+
+### GET /
+Documentation et métadonnées
+
+### GET /health
+État du service et device info
+
+### GET /supported-languages
+Langues supportées ASR/TTS
+
+### GET /models-info
+Infos détaillées sur les modèles
+
+### POST /asr
+Transcription audio
+- **Input**: multipart/form-data (audio + language)
+- **Output**: JSON (transcription + métadonnées)
+
+### POST /tts
+Synthèse vocale
+- **Input**: JSON (text + language)
+- **Output**: WAV audio file
+
+## 🐛 Debugging
+
+### Logs
+```bash
+# Local
+python app_v2.py
+# Voir les logs en stdout
+
+# Docker
+docker logs <container_id>
+
+# HF Spaces
+# Voir onglet "Logs" dans le Space
+```
+
+### Common Issues
+
+**Issue**: Model not found
+**Solution**: Attendre le téléchargement des modèles (5-10 min)
+
+**Issue**: CUDA out of memory
+**Solution**: Réduire MAX_AUDIO_LENGTH ou utiliser CPU
+
+**Issue**: Port already in use
+**Solution**: `PORT=8080 python app_v2.py`
+
+## 🔮 Roadmap
+
+- [ ] Streaming ASR/TTS
+- [ ] Batch processing
+- [ ] WebSockets pour streaming
+- [ ] Caching Redis
+- [ ] Database logging
+- [ ] Rate limiting
+- [ ] Authentication/API keys
+- [ ] Metrics (Prometheus)
+- [ ] Web UI (Gradio/Streamlit)
+- [ ] More languages
+- [ ] Emotion synthesis
+- [ ] Custom voices
+
+## 📚 Références
+
+- [Meta MMS Paper](https://arxiv.org/abs/2305.13516)
+- [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all)
+- [facebook/mms-tts](https://huggingface.co/facebook/mms-tts)
+- [Transformers Documentation](https://huggingface.co/docs/transformers)
+- [Flask Documentation](https://flask.palletsprojects.com/)

DEPLOYMENT.md

@@ -0,0 +1,206 @@
+# Guide de déploiement sur Hugging Face Spaces
+
+## Prérequis
+
+- Compte Hugging Face: https://huggingface.co
+- Git installé localement
+- Token HF avec permissions write (https://huggingface.co/settings/tokens)
+
+## Étapes de déploiement
+
+### 1. Créer un Space sur Hugging Face
+
+```bash
+# Visite https://huggingface.co/new-space
+# - Remplis le formulaire:
+#   - Name: mms-asr-tts (ou autre nom)
+#   - License: OpenRAIL (ou CC-BY-NC-4.0 pour correspondre à Meta)
+#   - Space SDK: Docker
+# - Clique "Create Space"
+```
+
+### 2. Cloner le Space
+
+```bash
+git clone https://huggingface.co/spaces/<username>/<space-name>
+cd <space-name>
+```
+
+### 3. Copier les fichiers du projet
+
+```bash
+# Depuis le répertoire du projet
+cp app_v2.py app.py
+cp requirements.txt .
+cp Dockerfile .
+cp README.md .
+cp .gitignore .
+cp examples.py .
+cp client.py .
+```
+
+### 4. Configurer le fichier de révision de Hugging Face
+
+Crée `README_SPACE.md` avec les métadonnées:
+
+```yaml
+---
+title: Meta MMS ASR/TTS
+description: API multilingue pour reconnaissance vocale et synthèse vocale
+sdk: docker
+pinned: false
+app_port: 7860
+models:
+  - facebook/mms-1b-all
+  - facebook/mms-tts-eng
+  - facebook/mms-tts-yor
+  - facebook/mms-tts-beh
+  - facebook/mms-tts-ddn
+  - facebook/mms-tts-ewe
+  - facebook/mms-tts-gej
+  - facebook/mms-tts-tbz
+  - facebook/mms-tts-bba
+tags:
+  - ASR
+  - TTS
+  - Speech
+  - Audio
+  - Multilingual
+  - MMS
+---
+```
+
+### 5. Pousser vers Hugging Face
+
+```bash
+# Configure Git si nécessaire
+git config user.email "email@example.com"
+git config user.name "Your Name"
+
+# Ajoute et pousse
+git add .
+git commit -m "Initial commit: Meta MMS ASR/TTS API"
+git push
+```
+
+### 6. Attendre le déploiement
+
+Le Space se construira automatiquement (5-15 minutes). Pendant ce temps:
+- Les dépendances seront installées
+- Les modèles seront téléchargés (peut prendre du temps)
+- L'application sera lancée
+
+### 7. Tester le Space
+
+```bash
+# Accède à: https://huggingface.co/spaces/<username>/<space-name>
+# Teste les endpoints:
+# - GET / → Documentation
+# - GET /health → État
+# - POST /tts → Teste avec du texte en Yoruba/autres langues
+```
+
+## Troubleshooting
+
+### Erreur: "Model not found"
+
+Solution: Les modèles peuvent prendre du temps à télécharger. Attends 5-10 minutes et réessaie.
+
+### Erreur: "CUDA out of memory"
+
+Solution: 
+- Réduis MAX_AUDIO_LENGTH ou MAX_TEXT_LENGTH
+- Utilise CPU au lieu du GPU
+- Ajoute à requirements.txt: `transformers[deepspeed]`
+
+### Erreur: "Port already in use"
+
+Solution: Le port 7860 est utilisé par défaut sur HF Spaces. Vérifier `app_port` dans README.md
+
+## Optimisation pour Production
+
+### Augmenter les ressources
+
+Modifie le `docker-compose.yml`:
+
+```yaml
+deploy:
+  resources:
+    limits:
+      memory: 8G
+    reservations:
+      memory: 4G
+      devices:
+        - driver: nvidia
+          count: 1  # GPU
+          capabilities: [gpu]
+```
+
+### Ajouter du caching
+
+Modifie le Dockerfile pour persister les modèles:
+
+```dockerfile
+ENV HF_HOME=/app/hf_cache
+ENV TORCH_HOME=/app/torch_cache
+```
+
+### Ajouter de l'authentification
+
+Pour limiter l'accès:
+
+```python
+from functools import wraps
+from flask import request
+
+def require_token(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        token = request.headers.get('Authorization', '').replace('Bearer ', '')
+        if token != os.getenv('API_TOKEN'):
+            return {'error': 'Unauthorized'}, 401
+        return f(*args, **kwargs)
+    return decorated
+
+@app.route('/tts', methods=['POST'])
+@require_token
+def tts():
+    # ...
+```
+
+## Monitoring
+
+### Logs
+
+Accède aux logs du Space:
+- https://huggingface.co/spaces/<username>/<space-name>/logs
+
+### Métriques
+
+Ajoute à `app.py`:
+
+```python
+from prometheus_client import Counter, Histogram
+
+requests_total = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
+request_duration = Histogram('request_duration_seconds', 'Request duration', ['endpoint'])
+```
+
+## Coûts
+
+- **Gratuit**: Un Space gratuit avec ressources limitées (2-4GB RAM, pas de GPU)
+- **Libre** (avec GPU): Nécessite un Space payant (~$5-20/mois selon GPU)
+
+## Support
+
+Pour les problèmes:
+1. Vérifie les logs: https://huggingface.co/spaces/<username>/<space-name>/logs
+2. Consulte la doc: https://huggingface.co/docs/hub/spaces
+3. Pose une question: https://discuss.huggingface.co
+
+## Prochaines étapes
+
+1. ✅ Déploie d'abord sur HF Spaces
+2. Teste tous les endpoints
+3. Collecte du feedback
+4. Ajoute des fonctionnalités (streaming, batch processing, etc.)

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Installe les dépendances système
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libsndfile1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copie les fichiers
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+# Expose le port
+EXPOSE 7860
+
+# Lance l'app
+CMD ["python", "app.py"]

GRADIO_DEPLOY.md

@@ -0,0 +1,182 @@
+# 🚀 Guide de déploiement Gradio sur Hugging Face Spaces
+
+## Étape 1: Préparer le Space
+
+### 1.1 Créer un nouveau Space
+- Va sur https://huggingface.co/new-space
+- Remplis les informations:
+  - **Space name**: `mms-speech` (ou autre nom)
+  - **License**: `openrail` ou `cc-by-nc-4.0`
+  - **SDK**: `Gradio`
+  - **Template**: `Blank`
+- Clique **"Create Space"**
+
+### 1.2 Cloner le Space
+```bash
+# Après la création, clique sur "Clone this space" ou:
+git clone https://huggingface.co/spaces/<your-username>/<space-name>
+cd <space-name>
+```
+
+## Étape 2: Copier les fichiers
+
+Depuis ton répertoire de projet:
+
+```bash
+# Copie les fichiers essentiels
+cp app.py requirements.txt README.md .
+```
+
+**Files nécessaires:**
+- `app.py` - Application Gradio
+- `requirements.txt` - Dépendances
+
+**Optionnel:**
+- `README.md` - Documentation du Space
+- `.gitignore` - (déjà créé)
+
+## Étape 3: Vérifier les fichiers
+
+```bash
+# Vérifie que tu as:
+ls -la
+# app.py
+# requirements.txt
+# README.md
+# .git/
+```
+
+## Étape 4: Push vers Hugging Face
+
+```bash
+# Configure Git (si première fois)
+git config user.email "ton.email@example.com"
+git config user.name "Ton Nom"
+
+# Ajoute les fichiers
+git add app.py requirements.txt README.md
+
+# Commit
+git commit -m "Add MMS Speech AI with Gradio"
+
+# Push
+git push
+```
+
+## Étape 5: Attendre le déploiement
+
+Le Space se construira automatiquement:
+
+1. **Installation des dépendances** (2-5 min)
+2. **Téléchargement des modèles** (5-15 min)
+3. **Lancement de l'app** (1-2 min)
+
+### Vérifier le statut
+- Va sur ton Space: `https://huggingface.co/spaces/<username>/<space-name>`
+- Vérifie la section "Logs" pour voir la progression
+
+## Étape 6: Tester
+
+Une fois déployé:
+
+1. **Onglet ASR**: Enregistre de l'audio et transcris
+2. **Onglet TTS**: Écris du texte et génère l'audio
+3. **Onglet About**: Vérifie les infos
+
+## 📋 Contenu des fichiers
+
+### app.py
+```python
+import gradio as gr
+import torch
+from transformers import ...
+
+# Interface Gradio avec 3 onglets:
+# - ASR (transcription)
+# - TTS (synthèse vocale)
+# - About (informations)
+```
+
+### requirements.txt
+```
+gradio==4.26.0
+transformers==4.36.2
+torch==2.1.1
+torchaudio==2.1.1
+librosa==0.10.0
+soundfile==0.12.1
+numpy==1.24.3
+```
+
+## 🆘 Troubleshooting
+
+### Les modèles prennent longtemps à charger
+✅ **Normal!** Les modèles font plusieurs GB. Attends 5-15 minutes.
+- Vérifie les logs: onglet "Logs" dans ton Space
+
+### Erreur: "Model not found"
+✅ Attends que le téléchargement se termine
+- Regarde les logs pour voir la progression
+
+### Space reste "Building"
+✅ Cliquez sur le "Restart" button dans les settings du Space
+- Va dans "Settings" → "Restart this Space"
+
+### "RuntimeError: CUDA out of memory"
+✅ Les ressources GPU sont limitées
+- Réduis `MAX_AUDIO_LENGTH` ou `MAX_TEXT_LENGTH` dans app.py
+- Ou HF bascule automatiquement sur CPU
+
+### Je n'ai pas accès au Space
+✅ Vérifie la visibilité:
+- Va dans "Settings"
+- Change "Private" → "Public" si tu veux le partager
+
+## 🎯 Après le déploiement
+
+### Partager ton Space
+```
+URL: https://huggingface.co/spaces/<username>/<space-name>
+```
+
+### Mettre à jour le code
+```bash
+# Modifie app.py
+git add app.py
+git commit -m "Update features"
+git push
+```
+
+L'app se redéploiera automatiquement!
+
+### Ajouter une description
+- Va dans "Settings" → "Space Settings"
+- Remplis "Short description" et "Description"
+
+## 📊 Ressources GPU
+
+Hugging Face offre:
+- **Gratuit**: CPU seul (~2-4GB RAM)
+- **Upgradable**: GPU payant (~$5-20/mois)
+
+Pour voir les options:
+- Va dans ton Space Settings
+- Regarde "Hardware" et clique "Upgrade to GPU"
+
+## 🔗 Liens utiles
+
+- [HF Spaces Docs](https://huggingface.co/docs/hub/spaces)
+- [Gradio Docs](https://www.gradio.app/)
+- [MMS Paper](https://arxiv.org/abs/2305.13516)
+
+## ✅ Checklist final
+
+- [ ] Space créé sur HF
+- [ ] Files copiés (app.py, requirements.txt)
+- [ ] Git push effectué
+- [ ] Déploiement en cours (vérifier logs)
+- [ ] App accessible et fonctionnelle
+- [ ] ASR fonctionne
+- [ ] TTS fonctionne
+
+Bravo! 🎉 Ton app est live!

GRADIO_SUMMARY.txt

@@ -0,0 +1,196 @@
+"""
+📊 RÉSUMÉ - Meta MMS Speech AI (Gradio)
+
+Application Gradio pour:
+- ASR: Audio → Texte (100+ langues)
+- TTS: Texte → Audio (8 langues)
+
+Déployée sur Hugging Face Spaces
+"""
+
+print("""
+╔════════════════════════════════════════════════════════════════╗
+║           🎙️  Meta MMS Speech AI - Gradio  📢                 ║
+║      Reconnaissance vocale + Synthèse vocale multilingue       ║
+║                        Interface Web                          ║
+╚════════════════════════════════════════════════════════════════╝
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 FILES DU PROJET
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📂 CORE:
+   📄 app.py                  ⭐ Application Gradio
+   📄 requirements.txt        ⭐ Dépendances
+
+📂 DOCUMENTATION:
+   📄 README.md              → Guide d'utilisation
+   📄 GRADIO_DEPLOY.md       → Guide de déploiement sur HF
+   📄 ARCHITECTURE.md        → Architecture technique
+   📄 DEPLOYMENT.md          → (Ancien, pour Flask)
+
+📂 UTILITAIRES:
+   📄 run.sh                 → Lancer l'app facilement
+   📄 client.py              → Client Python (optionnel)
+   📄 examples.py            → Exemples d'utilisation
+   📄 test_api.py            → Tests unitaires
+
+📂 CONFIG:
+   📄 .gitignore             → Git configuration
+   📄 requirements-dev.txt   → Dépendances dev
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 FEATURES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🔊 ASR (Automatic Speech Recognition):
+   • Modèle: facebook/mms-1b-all (964M params)
+   • Langues: 100+ (ISO 639-3)
+   • Input: Audio (microphone ou upload)
+   • Output: Texte transcrit
+   • Limite: 30 secondes
+
+📢 TTS (Text-to-Speech):
+   • Modèles: facebook/mms-tts-* (VITS)
+   • Langues: 8 (beh, bba, ddn, ewe, gej, tbz, yor, eng)
+   • Input: Texte (max 1000 chars)
+   • Output: Audio WAV (22050 Hz)
+
+🌐 Interface:
+   • Gradio (web UI moderne)
+   • 3 onglets: ASR, TTS, About
+   • Responsive design
+   • Partage automatique avec .share
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🚀 DÉMARRAGE RAPIDE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1️⃣  Installation:
+    cd /home/ronaldo/Bureau/test
+    pip install -r requirements.txt
+
+2️⃣  Lancer l'app:
+    python app.py
+    # ou: bash run.sh
+
+3️⃣  Ouvrir dans le navigateur:
+    http://localhost:7860
+
+4️⃣  Utiliser:
+    - ASR: Enregistre/upload audio → Transcris
+    - TTS: Écris texte → Génère audio
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🌐 DÉPLOIEMENT SUR HUGGING FACE SPACES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1️⃣  Créer un Space:
+    https://huggingface.co/new-space
+    - SDK: Gradio
+    - Template: Blank
+
+2️⃣  Cloner:
+    git clone https://huggingface.co/spaces/<user>/<space>
+    cd <space>
+
+3️⃣  Copier:
+    cp app.py requirements.txt README.md .
+
+4️⃣  Push:
+    git add .
+    git commit -m "Add MMS Speech"
+    git push
+
+5️⃣  Attendre:
+    ~15-20 minutes pour le déploiement complet
+
+📌 Voir GRADIO_DEPLOY.md pour les instructions détaillées!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 TIPS IMPORTANTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ Cache des modèles:
+   Les modèles sont chargés UNE FOIS et mis en cache.
+   Première requête: 2-5 min
+   Requêtes suivantes: 1-10 sec
+
+✅ GPU/CPU:
+   Détection automatique du GPU.
+   Fallback CPU si GPU non disponible.
+
+✅ Langues TTS disponibles:
+   - beh (Biali) 🇧🇯
+   - bba (Baatombu) 🇧🇯
+   - ddn (Dendi) 🇧🇯
+   - ewe (Éwé) 🇬🇭
+   - gej (Mina) 🇧🇯
+   - tbz (Ditammari) 🇧🇯
+   - yor (Yoruba) 🇳🇬
+   - eng (English) 🇬🇧
+
+✅ Dépannage:
+   - Voir README.md section "Troubleshooting"
+   - Voir GRADIO_DEPLOY.md section "Troubleshooting"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 STRUCTURE DE L'APP GRADIO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+app.py contient:
+
+1️⃣  Imports & Configuration
+   - Modèles: ASR (mms-1b-all) + TTS (mms-tts-*)
+   - Config: SAMPLE_RATE, MAX_AUDIO_LENGTH, etc.
+
+2️⃣  Functions principales
+   - load_asr_model()      → Charge le modèle ASR
+   - load_tts_model()      → Charge les modèles TTS
+   - transcribe_audio()    → Transcription audio
+   - synthesize_speech()   → Génération audio
+
+3️⃣  Interface Gradio (3 onglets)
+   - ASR Tab: Enregistre/upload + transcris
+   - TTS Tab: Écrit texte + génère audio
+   - About Tab: Infos + documentation
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🔗 RESSOURCES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 Documentation:
+   • Meta MMS Paper: https://arxiv.org/abs/2305.13516
+   • facebook/mms-1b-all: https://huggingface.co/facebook/mms-1b-all
+   • facebook/mms-tts: https://huggingface.co/facebook/mms-tts
+   • Gradio Docs: https://www.gradio.app/
+   • HF Spaces: https://huggingface.co/spaces
+
+🛠️ Outils:
+   • Transformers: https://huggingface.co/docs/transformers
+   • PyTorch: https://pytorch.org/
+   • Librosa: https://librosa.org/
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚖️  LICENCE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+CC-BY-NC-4.0 (comme les modèles Meta MMS)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✨ À bientôt! 🎙️
+
+Pour commencer: python app.py
+Pour déployer: Voir GRADIO_DEPLOY.md
+
+Bon codage! 🚀
+""")

PROJECT_SUMMARY.py

@@ -0,0 +1,197 @@
+"""
+📊 Résumé complet du projet MMS ASR/TTS API
+
+Ce projet fournit une API Flask pour:
+- ASR (Automatic Speech Recognition): Audio → Texte avec support 100+ langues
+- TTS (Text-to-Speech): Texte → Audio pour 8 langues
+
+Utilise les modèles Meta MMS:
+- facebook/mms-1b-all (ASR, 964M params)
+- facebook/mms-tts-{lang} (TTS, 8 langues)
+"""
+
+import json
+
+PROJECT_STRUCTURE = {
+    "docs": {
+        "README.md": "Documentation générale du projet",
+        "ARCHITECTURE.md": "Architecture technique détaillée",
+        "DEPLOYMENT.md": "Guide de déploiement sur Hugging Face Spaces",
+    },
+    "source_code": {
+        "app.py": "API Flask v1 - Version stable",
+        "app_v2.py": "API Flask v2 - Version optimisée (RECOMMANDÉE) ⭐",
+        "client.py": "Client Python pour tester l'API",
+        "examples.py": "Exemples d'utilisation des endpoints",
+    },
+    "testing": {
+        "test_api.py": "Tests unitaires avec pytest",
+        "setup_project.py": "Script de vérification et setup du projet",
+    },
+    "deployment": {
+        "requirements.txt": "Dépendances production",
+        "requirements-dev.txt": "Dépendances développement (tests, linting)",
+        "Dockerfile": "Conteneur Docker pour déploiement",
+        "docker-compose.yml": "Orchestration Docker (GPU support)",
+        ".gitignore": "Fichiers à ignorer par Git",
+    },
+}
+
+QUICK_START = """
+🚀 DÉMARRAGE RAPIDE
+═══════════════════════════════════════════════════════════════
+
+1️⃣  Installation:
+    cd /home/ronaldo/Bureau/test
+    pip install -r requirements.txt
+
+2️⃣  Lancer l'API:
+    python app_v2.py
+    # API disponible sur http://localhost:7860
+
+3️⃣  Tester dans un autre terminal:
+    python examples.py
+
+4️⃣  Tester avec curl:
+    # ASR - Convertir audio en texte
+    curl -X POST -F "audio=@audio.wav" \\
+      http://localhost:7860/asr
+
+    # TTS - Convertir texte en audio
+    curl -X POST -H "Content-Type: application/json" \\
+      -d '{"text":"Hello","language":"eng"}' \\
+      http://localhost:7860/tts --output hello.wav
+
+5️⃣  Déployer sur Hugging Face:
+    Voir DEPLOYMENT.md pour les instructions
+"""
+
+FEATURES = {
+    "ASR": {
+        "model": "facebook/mms-1b-all",
+        "languages": "100+ langues (ISO 639-3)",
+        "input": "Audio (WAV, MP3, etc.)",
+        "output": "Texte transcrit",
+        "endpoint": "POST /asr",
+    },
+    "TTS": {
+        "model": "facebook/mms-tts-* (VITS)",
+        "languages": 8,
+        "supported": ["beh", "bba", "ddn", "ewe", "gej", "tbz", "yor", "eng"],
+        "input": "Texte (max 1000 chars)",
+        "output": "Audio WAV (22050 Hz)",
+        "endpoint": "POST /tts",
+    },
+    "General": {
+        "framework": "Flask",
+        "gpu_support": "CUDA auto-detect",
+        "cache": "In-memory model cache (thread-safe)",
+        "cors": "Enabled",
+        "max_audio": "30 secondes",
+        "max_text": "1000 caractères",
+    },
+}
+
+ENDPOINTS = {
+    "GET /": "Documentation de l'API",
+    "GET /health": "État du service + device info",
+    "GET /supported-languages": "Langues supportées",
+    "GET /models-info": "Informations détaillées sur les modèles",
+    "POST /asr": "Audio → Texte (ASR)",
+    "POST /tts": "Texte → Audio (TTS)",
+}
+
+def print_section(title, content=None):
+    """Affiche une section formatée"""
+    print(f"\n{'═' * 70}")
+    print(f"  {title}")
+    print(f"{'═' * 70}")
+    if content:
+        print(content)
+
+def print_project_structure():
+    """Affiche la structure du projet"""
+    for category, files in PROJECT_STRUCTURE.items():
+
+        print(f"\n📂 {category.upper()}:")
+        for filename, description in files.items():
+            print(f"   📄 {filename:25} → {description}")
+
+def print_features():
+    """Affiche les features"""
+    print(f"\n🎯 FEATURES:")
+    for feature, details in FEATURES.items():
+        print(f"\n   {feature}:")
+        for key, value in details.items():
+            if isinstance(value, list):
+                value = ", ".join(value)
+            print(f"      • {key}: {value}")
+
+def print_endpoints():
+    """Affiche les endpoints"""
+    print(f"\n📡 API ENDPOINTS:")
+    for endpoint, description in ENDPOINTS.items():
+        print(f"   {endpoint:25} → {description}")
+
+def main():
+    """Fonction principale"""
+    print("""
+╔════════════════════════════════════════════════════════════════╗
+║                  🎙️  Meta MMS ASR/TTS API  🔊                 ║
+║            Reconnaissance vocale + Synthèse vocale             ║
+║                    Multilingue & GPU-ready                    ║
+╚═════════════════════════════��══════════════════════════════════╝
+    """)
+
+    print_section("📋 STRUCTURE DU PROJET")
+    print_project_structure()
+
+    print_section("🎯 FEATURES")
+    print_features()
+
+    print_section("📡 API ENDPOINTS")
+    print_endpoints()
+
+    print_section("🚀 DÉMARRAGE RAPIDE")
+    print(QUICK_START)
+
+    print_section("💡 INFORMATIONS SUPPLÉMENTAIRES")
+    print("""
+✅ Recommandations:
+   • Utiliser app_v2.py (v1 is deprecated)
+   • Installer requirements.txt pour prod
+   • Voir examples.py pour voir comment utiliser l'API
+   • Pour dev: pip install -r requirements-dev.txt
+
+📚 Documentation complète:
+   • README.md - Documentation générale
+   • ARCHITECTURE.md - Architecture technique
+   • DEPLOYMENT.md - Déploiement sur HF Spaces
+
+🧪 Tests:
+   • pytest test_api.py -v
+
+📊 Déploiement:
+   • Local: python app_v2.py
+   • Docker: docker build -t mms . && docker run -p 7860:7860 mms
+   • HF Spaces: Voir DEPLOYMENT.md
+
+🌐 URLs importantes:
+   • facebook/mms-1b-all: https://huggingface.co/facebook/mms-1b-all
+   • facebook/mms-tts: https://huggingface.co/facebook/mms-tts
+   • Meta MMS Paper: https://arxiv.org/abs/2305.13516
+    """)
+
+    print_section("🎓 PROCHAINES ÉTAPES")
+    print("""
+1. ✅ Installer les dépendances
+2. ✅ Lancer l'API localement
+3. ✅ Tester les endpoints
+4. ✅ Déployer sur Hugging Face Spaces
+5. ✅ Ajouter des features (streaming, batch, etc.)
+
+Bon codage! 🚀
+    """)
+
+if __name__ == "__main__":
+    main()

README.md

@@ -0,0 +1,204 @@
+# 🎙️ Meta MMS Speech AI - Gradio Interface
+
+Une interface **Gradio** simple et élégante pour:
+- **ASR** (Automatic Speech Recognition): Convertir l'audio en texte (100+ langues)
+- **TTS** (Text-to-Speech): Convertir le texte en audio (8 langues)
+
+Utilise les modèles Meta MMS:
+- `facebook/mms-1b-all` pour l'ASR
+- `facebook/mms-tts-*` pour le TTS
+
+## 🌐 Déploiement en ligne
+
+**Accès direct:** [Hugging Face Spaces](https://huggingface.co/spaces)
+
+## 🚀 Installation locale
+
+### Prérequis
+- Python 3.10+
+- (Optionnel) CUDA 11.8+ pour GPU
+
+### Installation
+
+```bash
+# Clone ou télécharge le repo
+git clone <url>
+cd mms-speech
+
+# Crée un environnement virtuel
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# Installe les dépendances
+pip install -r requirements.txt
+```
+
+### Lancement
+
+```bash
+python app.py
+```
+
+L'interface Gradio s'ouvrira automatiquement sur `http://localhost:7860`
+
+## 📱 Interface utilisateur
+
+### Onglet 1: 🔊 ASR (Audio → Texte)
+- Enregistre ou upload un fichier audio
+- Choisis la langue
+- Clique "Transcrire"
+- Récupère le texte transcrit
+
+**Langues supportées:**
+- English, French, Spanish, German, Portuguese, Arabic, Hindi, Chinese, Japanese, et 90+ autres
+
+### Onglet 2: 📢 TTS (Texte → Audio)
+- Entre du texte
+- Choisis la langue
+- Clique "Générer l'audio"
+- Écoute ou télécharge l'audio généré
+
+**Langues TTS:**
+- 🇧🇯 Biali (beh)
+- 🇧🇯 Baatombu (bba)
+- 🇧🇯 Dendi (ddn)
+- 🇬🇭 Éwé (ewe)
+- 🇧🇯 Mina (gej)
+- 🇧🇯 Ditammari (tbz)
+- 🇳🇬 Yoruba (yor)
+- 🇬🇧 English (eng)
+
+### Onglet 3: ℹ️ À propos
+Informations sur les modèles et ressources
+
+## 📊 Modèles utilisés
+
+### ASR: facebook/mms-1b-all
+- **Architecture:** wav2vec2
+- **Taille:** 964.8M parameters
+- **Langues:** 100+ (ISO 639-3)
+- **Input:** Audio 16kHz mono
+- **Output:** Texte transcrit
+
+### TTS: facebook/mms-tts-{lang}
+- **Architecture:** VITS
+- **Taille:** ~5-10M parameters par langue
+- **Langues:** 8
+- **Input:** Texte (max 1000 chars)
+- **Output:** Audio WAV 22050Hz
+
+## 💡 Utilisation
+
+### Exemple ASR
+1. Clique sur le micro ou "Upload file"
+2. Enregistre ou uploader ton audio
+3. Sélectionne la langue
+4. Clique "Transcrire"
+
+### Exemple TTS
+1. Écris "Àbọ̀ wa" (hello en Yoruba)
+2. Sélectionne "Yoruba (yor)"
+3. Clique "Générer l'audio"
+4. Écoute le résultat!
+
+## 🔧 Développement
+
+### Installer les dépendances dev
+```bash
+pip install -r requirements-dev.txt
+```
+
+### Tests
+```bash
+pytest test_api.py -v
+```
+
+### Linting
+```bash
+black app.py
+flake8 app.py
+```
+
+## 🌐 Déploiement sur Hugging Face Spaces
+
+### 1. Créer un Space
+- Va sur https://huggingface.co/new-space
+- Choisis "Gradio" comme SDK
+- Sélectionne "Blank" comme template
+
+### 2. Cloner le Space
+```bash
+git clone https://huggingface.co/spaces/<username>/<space-name>
+cd <space-name>
+```
+
+### 3. Copier les fichiers
+```bash
+cp app.py requirements.txt README.md .
+```
+
+### 4. Push vers Hugging Face
+```bash
+git add .
+git commit -m "Add MMS Speech AI"
+git push
+```
+
+### 5. Attendre le déploiement
+- HF va installer les dépendances (2-5 min)
+- Télécharger les modèles (5-15 min)
+- Lancer l'app automatiquement
+
+**URL du Space:** `https://huggingface.co/spaces/<username>/<space-name>`
+
+## ⚙️ Configuration
+
+```python
+SAMPLE_RATE = 16000          # Taux ASR
+MAX_AUDIO_LENGTH = 30        # Max 30 sec
+MAX_TEXT_LENGTH = 1000       # Max 1000 chars
+```
+
+## 📈 Performance
+
+| Action | Temps |
+|--------|-------|
+| Première requête ASR | 2-5 min (chargement) |
+| Requêtes ASR suivantes | 1-10 sec |
+| Première requête TTS | 30-60 sec (chargement) |
+| Requêtes TTS suivantes | 1-5 sec |
+
+## 🐛 Troubleshooting
+
+**Q: Les modèles prennent trop de temps à charger**
+A: C'est normal! Les modèles sont volumineux. La première requête charge le modèle (2-5 min), puis ça devient rapide.
+
+**Q: "CUDA out of memory"**
+A: Réduis `MAX_AUDIO_LENGTH` ou `MAX_TEXT_LENGTH`, ou utilise CPU.
+
+**Q: Je ne vois pas mon audio après avoir enregistré**
+A: Attends que le traitement soit terminé. Gradio affichera le résultat automatiquement.
+
+**Q: L'audio généré est muet**
+A: Vérifie que tu as écrit du texte et choisi une langue correcte.
+
+## 📚 Ressources
+
+- [Meta MMS Paper](https://arxiv.org/abs/2305.13516)
+- [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all)
+- [facebook/mms-tts](https://huggingface.co/facebook/mms-tts)
+- [Gradio Documentation](https://www.gradio.app/)
+- [Hugging Face Spaces](https://huggingface.co/spaces)
+
+## ⚖️ Licence
+
+CC-BY-NC-4.0 (même que les modèles Meta MMS)
+
+## 👨‍💻 Auteur
+
+Créé avec ❤️ pour explorer la synthèse et reconnaissance vocale multilingue.
+
+---
+
+**Happy speaking! 🎙️**
+

app.py

@@ -0,0 +1,312 @@
+import gradio as gr
+import torch
+from transformers import AutoModelForCTC, AutoProcessor, VitsModel, AutoTokenizer
+import librosa
+import numpy as np
+import io
+import soundfile as sf
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration
+SAMPLE_RATE = 16000
+MAX_AUDIO_LENGTH = 30
+
+# Mapping des langues TTS
+LANGUAGE_MAPPING = {
+    "Biali (beh)": "facebook/mms-tts-beh",
+    "Baatombu (bba)": "facebook/mms-tts-bba",
+    "Dendi (ddn)": "facebook/mms-tts-ddn",
+    "Éwé (ewe)": "facebook/mms-tts-ewe",
+    "Mina (gej)": "facebook/mms-tts-gej",
+    "Ditammari (tbz)": "facebook/mms-tts-tbz",
+    "Yoruba (yor)": "facebook/mms-tts-yor",
+    "English (eng)": "facebook/mms-tts-eng",
+}
+
+# Cache des modèles
+models_cache = {}
+
+def get_device():
+    """Retourne le device disponible"""
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+def load_asr_model():
+    """Charge le modèle ASR"""
+    if "asr" not in models_cache:
+        device = get_device()
+        logger.info("⏳ Chargement du modèle ASR...")
+        processor = AutoProcessor.from_pretrained("facebook/mms-1b-all")
+        model = AutoModelForCTC.from_pretrained("facebook/mms-1b-all").to(device)
+        model.eval()
+        models_cache["asr"] = {"model": model, "processor": processor}
+        logger.info("✅ Modèle ASR chargé")
+    return models_cache["asr"]["model"], models_cache["asr"]["processor"]
+
+def load_tts_model(language_name):
+    """Charge le modèle TTS pour une langue"""
+    if language_name not in models_cache:
+        device = get_device()
+        model_id = LANGUAGE_MAPPING.get(language_name)
+        if not model_id:
+            raise ValueError(f"Langue non supportée: {language_name}")
+
+        logger.info(f"⏳ Chargement du modèle TTS {language_name}...")
+        model = VitsModel.from_pretrained(model_id).to(device)
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model.eval()
+        models_cache[language_name] = {"model": model, "tokenizer": tokenizer}
+        logger.info(f"✅ Modèle TTS {language_name} chargé")
+    return models_cache[language_name]["model"], models_cache[language_name]["tokenizer"]
+
+def process_audio(audio_data):
+    """Traite l'audio"""
+    try:
+        if isinstance(audio_data, tuple):
+            # Gradio retourne (sample_rate, audio_array)
+            sr, audio = audio_data
+        else:
+            sr = SAMPLE_RATE
+            audio = audio_data
+
+        # Convertit en float32 si nécessaire
+        audio = np.array(audio, dtype=np.float32)
+
+        # Mono
+        if len(audio.shape) > 1:
+            audio = np.mean(audio, axis=1)
+
+        # Rééchantillonne
+        if sr != SAMPLE_RATE:
+            audio = librosa.resample(audio, orig_sr=sr, target_sr=SAMPLE_RATE)
+
+        # Normalise
+        if np.max(np.abs(audio)) > 0:
+            audio = audio / np.max(np.abs(audio))
+
+        # Tronque
+        max_samples = MAX_AUDIO_LENGTH * SAMPLE_RATE
+        if len(audio) > max_samples:
+            audio = audio[:max_samples]
+
+        return audio
+    except Exception as e:
+        logger.error(f"Erreur traitement audio: {e}")
+        raise
+
+def transcribe_audio(audio, language):
+    """Transcrit l'audio en texte (ASR)"""
+    if audio is None:
+        return "❌ Veuillez enregistrer ou uploader un fichier audio"
+
+    try:
+        audio_processed = process_audio(audio)
+        model, processor = load_asr_model()
+        processor.current_lang = language
+
+        device = get_device()
+        with torch.no_grad():
+            inputs = processor(audio_processed, sampling_rate=SAMPLE_RATE, return_tensors="pt").to(device)
+            outputs = model(**inputs)
+            ids = torch.argmax(outputs.logits, dim=-1)[0]
+            transcription = processor.decode(ids)
+
+        return f"✅ Transcription:\n{transcription}"
+    except Exception as e:
+        logger.error(f"Erreur ASR: {e}")
+        return f"❌ Erreur: {str(e)}"
+
+def synthesize_speech(text, language):
+    """Synthétise le texte en audio (TTS)"""
+    if not text or not text.strip():
+        return None, "❌ Veuillez entrer du texte"
+
+    try:
+        text = text.strip()[:1000]  # Limite à 1000 chars
+        model, tokenizer = load_tts_model(language)
+
+        device = get_device()
+        with torch.no_grad():
+            inputs = tokenizer(text, return_tensors="pt").to(device)
+            outputs = model(**inputs)
+            waveform = outputs.waveform.cpu().numpy().flatten()
+
+        # Convertit en (sample_rate, audio_array) pour Gradio
+        return (22050, waveform), f"✅ Audio généré avec succès!"
+
+    except Exception as e:
+        logger.error(f"Erreur TTS: {e}")
+        return None, f"❌ Erreur: {str(e)}"
+
+# ============= INTERFACE GRADIO =============
+
+with gr.Blocks(title="🎙️ MMS ASR/TTS - Speech AI", theme=gr.themes.Soft()) as demo:
+    gr.HTML("""
+        <div style="text-align: center;">
+            <h1>🎙️ Meta MMS Speech AI</h1>
+            <p style="font-size: 16px; color: #666;">
+                Reconnaissance vocale (ASR) + Synthèse vocale (TTS) multilingue
+            </p>
+            <p style="font-size: 14px; color: #999;">
+                Utilise les modèles <strong>facebook/mms-1b-all</strong> et <strong>facebook/mms-tts</strong>
+            </p>
+        </div>
+    """)
+
+    with gr.Tabs():
+        # ============= TAB 1: ASR =============
+        with gr.TabItem("🔊 ASR (Audio → Texte)", id="asr"):
+            gr.HTML("<h2>Reconnaissance Vocale Multilingue</h2>")
+            gr.HTML("<p>Enregistre ou uploader un fichier audio pour obtenir la transcription.</p>")
+
+            with gr.Row():
+                with gr.Column():
+                    audio_input = gr.Audio(
+                        label="📁 Fichier audio",
+                        type="numpy",
+                        sources=["upload", "microphone"]
+                    )
+                    language_asr = gr.Dropdown(
+                        choices=[
+                            "English (eng)",
+                            "French (fra)",
+                            "Spanish (spa)",
+                            "German (deu)",
+                            "Portuguese (por)",
+                            "Arabic (ara)",
+                            "Hindi (hin)",
+                            "Chinese (zho)",
+                            "Japanese (jpn)",
+                        ],
+                        value="English (eng)",
+                        label="🌐 Langue"
+                    )
+                    btn_asr = gr.Button("🎯 Transcrire", variant="primary", size="lg")
+
+                with gr.Column():
+                    output_asr = gr.Textbox(
+                        label="📝 Transcription",
+                        lines=6,
+                        interactive=False
+                    )
+
+            btn_asr.click(
+                fn=transcribe_audio,
+                inputs=[audio_input, language_asr],
+                outputs=output_asr
+            )
+
+        # ============= TAB 2: TTS =============
+        with gr.TabItem("📢 TTS (Texte → Audio)", id="tts"):
+            gr.HTML("<h2>Synthèse Vocale</h2>")
+            gr.HTML("<p>Entre du texte et écoute la synthèse vocale dans la langue choisie.</p>")
+
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="✍️ Texte à convertir",
+                        placeholder="Écris du texte ici...",
+                        lines=4
+                    )
+                    language_tts = gr.Dropdown(
+                        choices=list(LANGUAGE_MAPPING.keys()),
+                        value="English (eng)",
+                        label="🌐 Langue"
+                    )
+                    btn_tts = gr.Button("🔊 Générer l'audio", variant="primary", size="lg")
+                    info_tts = gr.Textbox(
+                        label="📊 Info",
+                        interactive=False,
+                        value="Clique sur 'Générer l'audio' pour commencer"
+                    )
+
+                with gr.Column():
+                    audio_output = gr.Audio(
+                        label="🎵 Audio généré",
+                        type="numpy"
+                    )
+
+            btn_tts.click(
+                fn=synthesize_speech,
+                inputs=[text_input, language_tts],
+                outputs=[audio_output, info_tts]
+            )
+
+            # Exemples
+            gr.Examples(
+                examples=[
+                    ["Hello world", "English (eng)"],
+                    ["Àbọ̀ wa", "Yoruba (yor)"],
+                    ["Bonjour", "English (eng)"],
+                ],
+                inputs=[text_input, language_tts],
+                label="💡 Exemples"
+            )
+
+        # ============= TAB 3: INFOS =============
+        with gr.TabItem("ℹ️ À propos", id="about"):
+            gr.HTML("""
+                <h2>À propos de cette API</h2>
+
+                <h3>🎙️ ASR (Automatic Speech Recognition)</h3>
+                <ul>
+                    <li><strong>Modèle:</strong> facebook/mms-1b-all (964M params)</li>
+                    <li><strong>Langues:</strong> 100+ langues (ISO 639-3)</li>
+                    <li><strong>Architecture:</strong> wav2vec2</li>
+                    <li><strong>Taux d'échantillonnage:</strong> 16 kHz</li>
+                    <li><strong>Limite:</strong> 30 secondes d'audio</li>
+                </ul>
+
+                <h3>📢 TTS (Text-to-Speech)</h3>
+                <ul>
+                    <li><strong>Modèle:</strong> facebook/mms-tts-* (VITS)</li>
+                    <li><strong>Langues supportées:</strong> 8 langues</li>
+                    <li><strong>Taux d'échantillonnage:</strong> 22050 Hz</li>
+                    <li><strong>Limite:</strong> 1000 caractères</li>
+                </ul>
+
+                <h3>🌍 Langues TTS</h3>
+                <ul>
+                    <li>🇧🇯 Biali (beh)</li>
+                    <li>🇧🇯 Baatombu (bba)</li>
+                    <li>🇧🇯 Dendi (ddn)</li>
+                    <li>🇬🇭 Éwé (ewe)</li>
+                    <li>🇧🇯 Mina (gej)</li>
+                    <li>🇧🇯 Ditammari (tbz)</li>
+                    <li>🇳🇬 Yoruba (yor)</li>
+                    <li>🇬🇧 English (eng)</li>
+                </ul>
+
+                <h3>🚀 Déploiement</h3>
+                <p>Cette application est déployée sur <strong>Hugging Face Spaces</strong></p>
+                <p>Code source: <a href="https://huggingface.co/spaces" target="_blank">GitHub</a></p>
+
+                <h3>📚 Ressources</h3>
+                <ul>
+                    <li><a href="https://arxiv.org/abs/2305.13516" target="_blank">Meta MMS Paper</a></li>
+                    <li><a href="https://huggingface.co/facebook/mms-1b-all" target="_blank">facebook/mms-1b-all</a></li>
+                    <li><a href="https://huggingface.co/facebook/mms-tts" target="_blank">facebook/mms-tts</a></li>
+                </ul>
+
+                <h3>⚖️ Licence</h3>
+                <p>CC-BY-NC-4.0 (comme les modèles Meta MMS)</p>
+            """)
+
+    # Footer
+    gr.HTML("""
+        <hr>
+        <div style="text-align: center; font-size: 12px; color: #999; margin-top: 20px;">
+            <p>🏠 Powered by <strong>Gradio</strong> + <strong>Hugging Face</strong> |
+               Device: <span id="device">Loading...</span></p>
+        </div>
+        <script>
+            document.getElementById('device').innerText = document.body.innerText.includes('cuda') ? '🚀 GPU' : '💻 CPU';
+        </script>
+    """)
+
+if __name__ == "__main__":
+    logger.info(f"🚀 Démarrage de l'interface Gradio")
+    logger.info(f"📊 Device: {get_device()}")
+    demo.launch(share=True, debug=False)

app_config.yaml

@@ -0,0 +1,12 @@
+title: Meta MMS ASR/TTS API
+description: API pour la reconnaissance vocale et synthèse vocale multilingue
+sdk: docker
+pinned: false
+space_id: ronaldodev/mms-asr-tts
+tags:
+  - ASR
+  - TTS
+  - Speech
+  - Audio
+  - MMS
+  - Multilingual

app_v2.py

@@ -0,0 +1,326 @@
+"""
+Version améliorée de app.py avec optimisations de performance
+"""
+
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+import torch
+from transformers import AutoModelForCTC, AutoProcessor, VitsModel, AutoTokenizer
+import librosa
+import numpy as np
+import io
+import logging
+import threading
+import time
+from pathlib import Path
+
+app = Flask(__name__)
+CORS(app)
+
+# Configuration des logs
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Configuration
+SAMPLE_RATE = 16000
+MAX_AUDIO_LENGTH = 30
+MAX_TEXT_LENGTH = 1000
+
+# Dictionnaire de mapping pour les langues TTS
+LANGUAGE_MAPPING = {
+    "beh": "facebook/mms-tts-beh",
+    "bba": "facebook/mms-tts-bba",
+    "ddn": "facebook/mms-tts-ddn",
+    "ewe": "facebook/mms-tts-ewe",
+    "gej": "facebook/mms-tts-gej",
+    "tbz": "facebook/mms-tts-tbz",
+    "yor": "facebook/mms-tts-yor",
+    "eng": "facebook/mms-tts-eng",
+    "fra": "facebook/mms-tts-fra",
+}
+
+# Cache pour les modèles
+models_cache = {}
+cache_lock = threading.Lock()
+
+# Métadonnées de l'API
+API_METADATA = {
+    "name": "Meta MMS ASR/TTS API",
+    "version": "2.0",
+    "description": "Reconnaissance vocale et synthèse vocale multilingue",
+    "models": {
+        "asr": "facebook/mms-1b-all (964M parameters)",
+        "tts": f"{len(LANGUAGE_MAPPING)} langues supportées"
+    }
+}
+
+def get_device():
+    """Retourne le device (GPU ou CPU)"""
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    if torch.cuda.is_available():
+        logger.info(f"GPU disponible: {torch.cuda.get_device_name(0)}")
+    return device
+
+def load_asr_model():
+    """Charge le modèle ASR avec cache"""
+    with cache_lock:
+        if "asr" not in models_cache:
+            try:
+                device = get_device()
+                logger.info("⏳ Chargement du modèle ASR facebook/mms-1b-all...")
+
+                processor = AutoProcessor.from_pretrained("facebook/mms-1b-all")
+                model = AutoModelForCTC.from_pretrained("facebook/mms-1b-all").to(device)
+                model.eval()
+
+                # Désactif les gradients
+                with torch.no_grad():
+                    pass
+
+                models_cache["asr"] = {"model": model, "processor": processor}
+                logger.info("✅ Modèle ASR chargé")
+            except Exception as e:
+                logger.error(f"❌ Erreur lors du chargement du modèle ASR: {e}")
+                raise
+
+    return models_cache["asr"]["model"], models_cache["asr"]["processor"]
+
+def load_tts_model(language_code):
+    """Charge le modèle TTS pour une langue"""
+    with cache_lock:
+        if language_code not in models_cache:
+            try:
+                model_id = LANGUAGE_MAPPING.get(language_code)
+                if not model_id:
+                    raise ValueError(f"Langue non supportée: {language_code}")
+
+                device = get_device()
+                logger.info(f"⏳ Chargement du modèle TTS {language_code} ({model_id})...")
+
+                model = VitsModel.from_pretrained(model_id).to(device)
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                model.eval()
+
+                models_cache[language_code] = {"model": model, "tokenizer": tokenizer}
+                logger.info(f"✅ Modèle TTS {language_code} chargé")
+            except Exception as e:
+                logger.error(f"❌ Erreur lors du chargement du modèle TTS {language_code}: {e}")
+                raise
+
+    return models_cache[language_code]["model"], models_cache[language_code]["tokenizer"]
+
+def process_audio(audio_data, target_sr=SAMPLE_RATE):
+    """Traite et normalise l'audio"""
+    try:
+        if isinstance(audio_data, bytes):
+            audio, sr = librosa.load(io.BytesIO(audio_data), sr=None, mono=True)
+        else:
+            audio = audio_data
+            sr = SAMPLE_RATE
+
+        # Rééchantillonne si nécessaire
+        if sr != target_sr:
+            audio = librosa.resample(audio, orig_sr=sr, target_sr=target_sr)
+
+        # Normalise
+        if np.max(np.abs(audio)) > 0:
+            audio = audio / np.max(np.abs(audio))
+
+        # Tronque si trop long
+        max_samples = MAX_AUDIO_LENGTH * target_sr
+        if len(audio) > max_samples:
+            audio = audio[:max_samples]
+            logger.warning(f"Audio tronqué à {MAX_AUDIO_LENGTH}s")
+
+        return audio
+    except Exception as e:
+        logger.error(f"❌ Erreur lors du traitement audio: {e}")
+        raise
+
+@app.route("/", methods=["GET"])
+def index():
+    """Documentation de l'API"""
+    return jsonify({
+        **API_METADATA,
+        "device": get_device(),
+        "endpoints": {
+            "GET /health": "État du service",
+            "GET /supported-languages": "Langues supportées",
+            "POST /asr": "Audio → Texte",
+            "POST /tts": "Texte → Audio",
+            "GET /models-info": "Infos sur les modèles",
+        },
+        "docs": "https://github.com/ronaldodev/mms-asr-tts"
+    })
+
+@app.route("/health", methods=["GET"])
+def health():
+    """Vérifier l'état du service"""
+    try:
+        device = get_device()
+        return jsonify({
+            "status": "healthy",
+            "device": device,
+            "timestamp": time.time(),
+            "cached_models": list(models_cache.keys())
+        })
+    except Exception as e:
+        return jsonify({"status": "error", "error": str(e)}), 500
+
+@app.route("/models-info", methods=["GET"])
+def models_info():
+    """Informations détaillées sur les modèles"""
+    return jsonify({
+        "asr": {
+            "model_id": "facebook/mms-1b-all",
+            "parameters": "964.8M",
+            "architecture": "wav2vec2",
+            "languages": 100,
+            "description": "Automatic Speech Recognition multilingue"
+        },
+        "tts": {
+            "model_family": "facebook/mms-tts-*",
+            "architecture": "VITS",
+            "sample_rate": 22050,
+            "supported_languages": LANGUAGE_MAPPING,
+            "description": "Text-to-Speech pour 8 langues"
+        }
+    })
+
+@app.route("/supported-languages", methods=["GET"])
+def supported_languages():
+    """Langues supportées"""
+    return jsonify({
+        "asr": {
+            "model": "facebook/mms-1b-all",
+            "languages": 100,
+            "description": "Support de 100+ langues ISO 639-3"
+        },
+        "tts": {
+            "languages": LANGUAGE_MAPPING,
+            "count": len(LANGUAGE_MAPPING),
+            "sample_rate": 22050
+        }
+    })
+
+@app.route("/asr", methods=["POST"])
+def asr():
+    """Convertir audio en texte (ASR)"""
+    start_time = time.time()
+    try:
+        if "audio" not in request.files:
+            return jsonify({"error": "Pas de fichier audio fourni"}), 400
+
+        audio_file = request.files["audio"]
+        language = request.form.get("language", "eng")
+
+        logger.info(f"📥 ASR demandé: language={language}, file={audio_file.filename}")
+
+        # Valide le fichier
+        if not audio_file.filename:
+            return jsonify({"error": "Nom de fichier invalide"}), 400
+
+        # Charge et traite l'audio
+        audio_data = audio_file.read()
+        audio = process_audio(audio_data)
+        logger.info(f"   Audio chargé: {len(audio)/SAMPLE_RATE:.2f}s")
+
+        # Charge le modèle
+        model, processor = load_asr_model()
+        processor.current_lang = language
+
+        # Inférence
+        device = get_device()
+        with torch.no_grad():
+            inputs = processor(audio, sampling_rate=SAMPLE_RATE, return_tensors="pt").to(device)
+            outputs = model(**inputs)
+            ids = torch.argmax(outputs.logits, dim=-1)[0]
+            transcription = processor.decode(ids)
+
+        elapsed = time.time() - start_time
+        logger.info(f"✅ ASR complété en {elapsed:.2f}s: {transcription}")
+
+        return jsonify({
+            "transcription": transcription,
+            "language": language,
+            "audio_length": len(audio) / SAMPLE_RATE,
+            "processing_time": elapsed,
+            "confidence": "not_available"
+        })
+
+    except Exception as e:
+        logger.error(f"❌ Erreur ASR: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/tts", methods=["POST"])
+def tts():
+    """Convertir texte en audio (TTS)"""
+    start_time = time.time()
+    try:
+        data = request.get_json()
+
+        if not data or "text" not in data:
+            return jsonify({"error": "Paramètre 'text' requis"}), 400
+
+        text = data["text"].strip()
+        language = data.get("language", "eng")
+
+        if not text:
+            return jsonify({"error": "Le texte ne peut pas être vide"}), 400
+
+        # Limite la longueur
+        if len(text) > MAX_TEXT_LENGTH:
+            text = text[:MAX_TEXT_LENGTH]
+            logger.warning(f"Texte tronqué à {MAX_TEXT_LENGTH} caractères")
+
+        logger.info(f"📥 TTS demandé: language={language}, text_len={len(text)}")
+
+        # Charge le modèle
+        model, tokenizer = load_tts_model(language)
+
+        # Inférence
+        device = get_device()
+        with torch.no_grad():
+            inputs = tokenizer(text, return_tensors="pt").to(device)
+            outputs = model(**inputs)
+            waveform = outputs.waveform.cpu().numpy().flatten()
+
+        # Encode en WAV
+        import soundfile as sf
+        audio_bytes = io.BytesIO()
+        sf.write(audio_bytes, waveform, 22050, format="WAV")
+        audio_bytes.seek(0)
+
+        elapsed = time.time() - start_time
+        logger.info(f"✅ TTS complété en {elapsed:.2f}s: {len(waveform)} samples")
+
+        return send_file(
+            audio_bytes,
+            mimetype="audio/wav",
+            as_attachment=True,
+            download_name=f"tts_{language}.wav"
+        )
+
+    except ValueError as e:
+        logger.error(f"❌ Erreur TTS (valeur): {e}")
+        return jsonify({"error": str(e)}), 400
+    except Exception as e:
+        logger.error(f"❌ Erreur TTS: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.errorhandler(404)
+def not_found(e):
+    return jsonify({"error": "Endpoint non trouvé"}), 404
+
+@app.errorhandler(500)
+def server_error(e):
+    return jsonify({"error": "Erreur serveur interne"}), 500
+
+if __name__ == "__main__":
+    logger.info(f"🚀 Démarrage de l'API MMS")
+    logger.info(f"📊 Device: {get_device()}")
+    logger.info(f"🌐 Démarrage sur 0.0.0.0:7860")
+    app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)

client.py

@@ -0,0 +1,102 @@
+"""Client pour tester l'API MMS ASR/TTS"""
+
+import requests
+import io
+import json
+from pathlib import Path
+
+class MMSClient:
+    def __init__(self, base_url="http://localhost:7860"):
+        self.base_url = base_url
+
+    def health(self):
+        """Vérifie l'état du service"""
+        response = requests.get(f"{self.base_url}/health")
+        return response.json()
+
+    def get_supported_languages(self):
+        """Récupère les langues supportées"""
+        response = requests.get(f"{self.base_url}/supported-languages")
+        return response.json()
+
+    def asr(self, audio_path, language="eng"):
+        """
+        Convertit l'audio en texte
+
+        Args:
+            audio_path: chemin vers le fichier audio
+            language: code de langue ISO 639-3
+        """
+        with open(audio_path, "rb") as f:
+            files = {"audio": f}
+            data = {"language": language}
+            response = requests.post(
+                f"{self.base_url}/asr",
+                files=files,
+                data=data
+            )
+        return response.json()
+
+    def tts(self, text, language="eng"):
+        """
+        Convertit le texte en audio
+
+        Args:
+            text: texte à convertir
+            language: code de langue (beh, bba, ddn, ewe, gej, tbz, yor, eng)
+
+        Returns:
+            bytes: données audio WAV
+        """
+        payload = {
+            "text": text,
+            "language": language
+        }
+        response = requests.post(
+            f"{self.base_url}/tts",
+            json=payload
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            # Convertit le hex en bytes
+            audio_bytes = bytes.fromhex(data["audio"])
+            return audio_bytes, data
+        else:
+            return None, response.json()
+
+    def save_audio(self, audio_bytes, output_path):
+        """Sauvegarde l'audio dans un fichier"""
+        with open(output_path, "wb") as f:
+            f.write(audio_bytes)
+        print(f"Audio sauvegardé: {output_path}")
+
+
+if __name__ == "__main__":
+    client = MMSClient()
+
+    # Test 1: Vérifier l'état du service
+    print("=== Test 1: Santé ===")
+    print(client.health())
+
+    # Test 2: Langues supportées
+    print("\n=== Test 2: Langues supportées ===")
+    print(json.dumps(client.get_supported_languages(), indent=2, ensure_ascii=False))
+
+    # Test 3: TTS - Yoruba
+    print("\n=== Test 3: TTS - Yoruba ===")
+    audio, data = client.tts("Àbọ̀ wa", language="yor")
+    if audio:
+        client.save_audio(audio, "output_yoruba.wav")
+        print(f"Audio généré: {len(audio)} bytes")
+    else:
+        print("Erreur:", data)
+
+    # Test 4: TTS - English
+    print("\n=== Test 4: TTS - English ===")
+    audio, data = client.tts("Hello world", language="eng")
+    if audio:
+        client.save_audio(audio, "output_english.wav")
+        print(f"Audio généré: {len(audio)} bytes")
+    else:
+        print("Erreur:", data)

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  mms-api:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - .:/app
+      - model_cache:/root/.cache/huggingface
+    environment:
+      - CUDA_VISIBLE_DEVICES=0
+    shm_size: 4gb
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [ gpu ]
+
+volumes:
+  model_cache:

examples.py

@@ -0,0 +1,148 @@
+"""Exemples d'utilisation de l'API MMS ASR/TTS"""
+
+import requests
+import json
+
+BASE_URL = "http://localhost:7860"
+
+# Exemples de textes dans différentes langues
+EXAMPLES = {
+    "beh": {
+        "text": "Àbọ̀ wa",
+        "translation": "Hello"
+    },
+    "bba": {
+        "text": "A gbà kú",
+        "translation": "Good morning"
+    },
+    "ddn": {
+        "text": "Sàlaam alaikum",
+        "translation": "Peace be upon you"
+    },
+    "ewe": {
+        "text": "Woé gbé o",
+        "translation": "Hello"
+    },
+    "gej": {
+        "text": "A-kúma",
+        "translation": "Good morning"
+    },
+    "tbz": {
+        "text": "Salaam",
+        "translation": "Hello"
+    },
+    "yor": {
+        "text": "Àbọ̀ wa",
+        "translation": "Hello"
+    },
+    "eng": {
+        "text": "Hello world",
+        "translation": "Hello world"
+    }
+}
+
+def test_tts():
+    """Test TTS pour toutes les langues"""
+    print("=" * 60)
+    print("TEST TTS (Text-to-Speech)")
+    print("=" * 60)
+
+    for lang, data in EXAMPLES.items():
+        print(f"\n📢 Langue: {lang} ({data['translation']})")
+        print(f"   Texte: {data['text']}")
+
+        try:
+            response = requests.post(
+                f"{BASE_URL}/tts",
+                json={"text": data["text"], "language": lang},
+                timeout=60
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                audio_size = len(result["audio"]) // 2  # hex = 2 chars per byte
+                print(f"   ✅ Audio généré: {audio_size} bytes")
+                print(f"   Sample rate: {result['sample_rate']} Hz")
+
+                # Sauvegarde l'audio
+                with open(f"output_{lang}.wav", "wb") as f:
+                    f.write(bytes.fromhex(result["audio"]))
+                print(f"   Fichier: output_{lang}.wav")
+            else:
+                print(f"   ❌ Erreur {response.status_code}: {response.json()}")
+        except Exception as e:
+            print(f"   ❌ Exception: {e}")
+
+def test_health():
+    """Teste la santé du service"""
+    print("=" * 60)
+    print("TEST SANTÉ DU SERVICE")
+    print("=" * 60)
+
+    try:
+        response = requests.get(f"{BASE_URL}/health")
+        data = response.json()
+        print(f"✅ Status: {data['status']}")
+        print(f"   Device: {data['device']}")
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+
+def test_supported_languages():
+    """Liste les langues supportées"""
+    print("=" * 60)
+    print("LANGUES SUPPORTÉES")
+    print("=" * 60)
+
+    try:
+        response = requests.get(f"{BASE_URL}/supported-languages")
+        data = response.json()
+        print(f"\n🎤 ASR: {data['asr']}")
+        print(f"\n📢 TTS: {', '.join(data['tts'])}")
+        print(f"\n📝 Codes de langue:")
+        for code, name in data['language_codes'].items():
+            print(f"   {code:5} -> {name}")
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+
+def test_asr_sample():
+    """Test ASR (nécessite un fichier audio)"""
+    print("\n" + "=" * 60)
+    print("TEST ASR (Automatic Speech Recognition)")
+    print("=" * 60)
+
+    audio_path = "sample_audio.wav"
+    try:
+        with open(audio_path, "rb") as f:
+            files = {"audio": f}
+            response = requests.post(
+                f"{BASE_URL}/asr",
+                files=files,
+                data={"language": "eng"},
+                timeout=60
+            )
+
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ Transcription: {result['transcription']}")
+            print(f"   Langue: {result['language']}")
+            print(f"   Durée: {result['audio_length']:.2f}s")
+        else:
+            print(f"❌ Erreur {response.status_code}: {response.json()}")
+    except FileNotFoundError:
+        print(f"⚠️  Fichier audio introuvable: {audio_path}")
+        print("   Pour tester l'ASR, fournir un fichier audio valide")
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+
+if __name__ == "__main__":
+    print("\n🚀 MMS ASR/TTS API - Exemples d'utilisation\n")
+
+    # Tests
+    test_health()
+    test_supported_languages()
+    test_tts()
+    test_asr_sample()
+
+    print("\n" + "=" * 60)
+    print("Tests terminés!")
+    print("=" * 60)

requirements-dev.txt

@@ -0,0 +1,21 @@
+# Dépendances pour le développement
+-r requirements.txt
+
+# Testing
+pytest==7.4.3
+pytest-cov==4.1.0
+requests-mock==1.11.0
+
+# Code quality
+black==23.12.0
+flake8==6.1.0
+pylint==3.0.3
+isort==5.13.2
+
+# Debugging
+ipython==8.18.1
+ipdb==0.13.13
+
+# Documentation
+sphinx==7.2.6
+sphinx-rtd-theme==2.0.0

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.26.0
+transformers==4.36.2
+torch==2.1.1
+torchaudio==2.1.1
+librosa==0.10.0
+soundfile==0.12.1
+numpy==1.24.3

run.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+# Script de démarrage de l'app Gradio MMS
+
+echo "🚀 Démarrage de Meta MMS Speech AI (Gradio)"
+echo "==========================================="
+
+# Vérifie si Python est disponible
+if ! command -v python &> /dev/null; then
+    echo "❌ Python n'est pas installé"
+    exit 1
+fi
+
+# Crée un environnement virtuel s'il n'existe pas
+if [ ! -d "venv" ]; then
+    echo "📦 Création de l'environnement virtuel..."
+    python -m venv venv
+fi
+
+# Active l'environnement virtuel
+echo "🔧 Activation de l'environnement virtuel..."
+source venv/bin/activate
+
+# Installe les dépendances
+echo "📚 Installation des dépendances..."
+pip install -q -r requirements.txt
+
+# Démarre l'application
+echo ""
+echo "✅ Démarrage de Gradio sur http://localhost:7860"
+echo ""
+echo "Interface Gradio disponible avec:"
+echo "  🔊 ASR (Audio → Texte)"
+echo "  📢 TTS (Texte → Audio)"
+echo "  ℹ️  À propos"
+echo ""
+
+python app.py
+

setup_project.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Script de vérification et configuration du projet MMS ASR/TTS
+"""
+
+import os
+import sys
+from pathlib import Path
+
+def check_files():
+    """Vérifie que tous les fichiers requis existent"""
+    required_files = [
+        "app.py",
+        "requirements.txt",
+        "Dockerfile",
+        "README.md",
+        "DEPLOYMENT.md",
+    ]
+
+    print("📋 Vérification des fichiers...")
+    missing = []
+
+    for file in required_files:
+        if Path(file).exists():
+            print(f"  ✅ {file}")
+        else:
+            print(f"  ❌ {file} (manquant)")
+            missing.append(file)
+
+    return len(missing) == 0
+
+def check_dependencies():
+    """Vérifie les dépendances Python"""
+    print("\n📦 Vérification des dépendances...")
+
+    required_packages = {
+        "flask": "Flask (API web)",
+        "torch": "PyTorch (ML)",
+        "transformers": "Hugging Face Transformers",
+        "librosa": "Audio processing",
+    }
+
+    for package, description in required_packages.items():
+        try:
+            __import__(package)
+            print(f"  ✅ {package:15} - {description}")
+        except ImportError:
+            print(f"  ❌ {package:15} - {description} (non installé)")
+
+def show_quick_start():
+    """Affiche le guide de démarrage rapide"""
+    print("\n" + "="*60)
+    print("🚀 GUIDE DE DÉMARRAGE RAPIDE")
+    print("="*60)
+
+    print("""
+1️⃣  Installation des dépendances:
+    pip install -r requirements.txt
+
+2️⃣  Lancement de l'API:
+    python app_v2.py
+    # Ou: bash run.sh
+
+3️⃣  Test des endpoints (dans un autre terminal):
+    python examples.py
+
+    # Ou avec curl:
+    curl http://localhost:7860/health
+    curl http://localhost:7860/supported-languages
+
+    curl -X POST -H "Content-Type: application/json" \\
+      -d '{"text": "Hello", "language": "eng"}' \\
+      http://localhost:7860/tts --output audio.wav
+
+4️⃣  Déploiement sur Hugging Face Spaces:
+    - Voir DEPLOYMENT.md pour les instructions détaillées
+
+📂 Structure du projet:
+    .
+    ├── app.py              # API Flask principale (v1)
+    ├── app_v2.py           # API Flask optimisée (v2) ⭐ RECOMMANDÉ
+    ├── requirements.txt    # Dépendances
+    ├── Dockerfile          # Conteneur Docker
+    ├── docker-compose.yml  # Orchestration Docker
+    ├── client.py           # Client Python pour tester
+    ├── examples.py         # Exemples d'utilisation
+    ├── test_api.py         # Tests unitaires
+    ├── run.sh              # Script de lancement
+    ├── README.md           # Documentation générale
+    └── DEPLOYMENT.md       # Guide de déploiement
+
+🔧 Développement:
+    pip install -r requirements-dev.txt
+    pytest test_api.py -v
+    black .
+    flake8 .
+
+📚 Documentation:
+    - App v2 est la version recommandée (meilleure gestion d'erreurs)
+    - Supporte 100+ langues pour l'ASR
+    - Supporte 8 langues pour le TTS
+    - Compatible GPU/CPU
+    - Cache des modèles pour performance
+
+🌐 Endpoints disponibles:
+    GET  /              → Documentation
+    GET  /health        → État du service
+    GET  /models-info   → Infos détaillées
+    GET  /supported-languages → Langues supportées
+    POST /asr           → Audio → Texte
+    POST /tts           → Texte → Audio (retourne WAV)
+
+📊 Langues TTS:
+    - beh (Biali)
+    - bba (Baatombu)
+    - ddn (Dendi)
+    - ewe (Éwé)
+    - gej (Mina)
+    - tbz (Ditammari)
+    - yor (Yoruba)
+    - eng (English)
+
+💡 Tips:
+    - La première requête peut être lente (chargement des modèles)
+    - Utilise GPU pour de meilleures performances
+    - Cache les modèles automatiquement après le chargement
+    - Limite: 30s pour audio ASR, 1000 chars pour TTS
+    """)
+
+def main():
+    """Fonction principale"""
+    print("\n🎯 Configuration du projet MMS ASR/TTS\n")
+
+    # Vérifie les fichiers
+    files_ok = check_files()
+
+    # Vérifie les dépendances
+    check_dependencies()
+
+    # Affiche le guide de démarrage
+    show_quick_start()
+
+    # Status final
+    print("\n" + "="*60)
+    if files_ok:
+        print("✅ Configuration complète! Prêt à démarrer!")
+        print("="*60)
+        print("\n👉 Prochaine étape: python app_v2.py\n")
+        return 0
+    else:
+        print("⚠️  Certains fichiers manquent. Vérifie l'installation.")
+        print("="*60)
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

test_api.py

@@ -0,0 +1,131 @@
+"""
+Tests unitaires pour l'API MMS ASR/TTS
+"""
+
+import pytest
+import json
+import io
+from flask import Flask
+import sys
+from pathlib import Path
+
+# Importe l'app
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Note: Pour les tests complets, il faudrait utiliser une version mockée
+# des modèles ou des fixtures avec des modèles minimalistes
+
+@pytest.fixture
+def client():
+    """Crée un client Flask pour les tests"""
+    from app_v2 import app
+    app.config['TESTING'] = True
+    with app.test_client() as client:
+        yield client
+
+class TestAPI:
+    """Tests des endpoints"""
+
+    def test_health(self, client):
+        """Test le endpoint /health"""
+        response = client.get('/health')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'status' in data
+        assert data['status'] == 'healthy'
+
+    def test_index(self, client):
+        """Test le endpoint racine"""
+        response = client.get('/')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'name' in data
+        assert 'endpoints' in data
+
+    def test_supported_languages(self, client):
+        """Test le endpoint /supported-languages"""
+        response = client.get('/supported-languages')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'asr' in data
+        assert 'tts' in data
+        assert 'eng' in data['tts']['languages']
+
+    def test_models_info(self, client):
+        """Test le endpoint /models-info"""
+        response = client.get('/models-info')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'asr' in data
+        assert 'tts' in data
+
+    def test_tts_missing_text(self, client):
+        """Test TTS sans texte"""
+        response = client.post('/tts',
+            data=json.dumps({}),
+            content_type='application/json'
+        )
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+
+    def test_tts_empty_text(self, client):
+        """Test TTS avec texte vide"""
+        response = client.post('/tts',
+            data=json.dumps({'text': '   '}),
+            content_type='application/json'
+        )
+        assert response.status_code == 400
+
+    def test_asr_missing_file(self, client):
+        """Test ASR sans fichier"""
+        response = client.post('/asr')
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+
+    def test_404(self, client):
+        """Test endpoint inexistant"""
+        response = client.get('/nonexistent')
+        assert response.status_code == 404
+
+class TestLanguageMapping:
+    """Tests du mapping des langues"""
+
+    def test_supported_languages(self):
+        """Vérifie que les langues documentées sont configurées"""
+        from app_v2 import LANGUAGE_MAPPING
+
+        expected_languages = ['beh', 'bba', 'ddn', 'ewe', 'gej', 'tbz', 'yor', 'eng']
+        for lang in expected_languages:
+            assert lang in LANGUAGE_MAPPING, f"Langue {lang} manquante"
+
+    def test_language_mapping_format(self):
+        """Vérifie le format du mapping des langues"""
+        from app_v2 import LANGUAGE_MAPPING
+
+        for lang, model_id in LANGUAGE_MAPPING.items():
+            assert isinstance(lang, str)
+            assert isinstance(model_id, str)
+            assert model_id.startswith('facebook/mms-tts-')
+
+class TestConfig:
+    """Tests de configuration"""
+
+    def test_sample_rate(self):
+        """Test que SAMPLE_RATE est correct"""
+        from app_v2 import SAMPLE_RATE
+        assert SAMPLE_RATE == 16000
+
+    def test_max_audio_length(self):
+        """Test que MAX_AUDIO_LENGTH est raisonnable"""
+        from app_v2 import MAX_AUDIO_LENGTH
+        assert 10 <= MAX_AUDIO_LENGTH <= 120
+
+    def test_max_text_length(self):
+        """Test que MAX_TEXT_LENGTH est raisonnable"""
+        from app_v2 import MAX_TEXT_LENGTH
+        assert 100 <= MAX_TEXT_LENGTH <= 5000
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])