Update app.py

app.py

@@ -84,73 +84,62 @@ def _safe_name(stem, ext=".mp4"):
     return f"{stem}_{uuid.uuid4().hex[:6]}{ext}"
 
 # ============================================================
-# SYNTHÈSE VOCALE — Parler-TTS multivoix (FR & NL) + gTTS fallback
+# SYNTHÈSE VOCALE — Edge-TTS multivoix (FR/NL) + gTTS fallback
 # ============================================================
-from transformers import pipeline
+import asyncio
+import edge_tts
 import soundfile as sf
 
-print("[TTS] Initialisation des modèles Parler-TTS...")
-
-# Charger les modèles FR et NL
-try:
-    tts_fr = pipeline("text-to-speech", model="parler-tts/parler_tts_mini_v0.1", speaker="fr_female_1")
-    tts_nl = pipeline("text-to-speech", model="parler-tts/parler_tts_mini_v0.1", speaker="nl_female_1")
-    print("[TTS] Modèles Parler-TTS chargés avec succès (FR/NL).")
-except Exception as e:
-    print(f"[TTS] Erreur de chargement Parler-TTS : {e}")
-    tts_fr = tts_nl = None
-
-
-# --- Liste des voix disponibles ---
-PARLER_VOICES = {
-    "🇫🇷 Femme 1 (Jeanne)": "fr_female_1",
-    "🇫🇷 Femme 2 (Chloé)": "fr_female_2",
-    "🇫🇷 Homme 1 (Louis)": "fr_male_1",
-    "🇫🇷 Homme 2 (Hugo)": "fr_male_2",
-    "🇳🇱 Vrouw 1 (Anke)": "nl_female_1",
-    "🇳🇱 Vrouw 2 (Sofie)": "nl_female_2",
-    "🇳🇱 Man 1 (Bart)": "nl_male_1",
-    "🇳🇱 Man 2 (Tom)": "nl_male_2",
+# --- Voix Edge disponibles ---
+EDGE_VOICES = {
+    # Français
+    "🇫🇷 Denise (Femme, France)": "fr-FR-DeniseNeural",
+    "🇫🇷 Henri (Homme, France)": "fr-FR-HenriNeural",
+    "🇫🇷 Vivienne (Femme, Belgique)": "fr-BE-VivienneNeural",
+    "🇫🇷 Charline (Femme, Canada)": "fr-CA-CharlineNeural",
+
+    # Néerlandais
+    "🇳🇱 Maaike (Femme, Pays-Bas)": "nl-NL-MaaikeNeural",
+    "🇳🇱 Coen (Homme, Pays-Bas)": "nl-NL-CoenNeural",
+    "🇳🇱 Arnaud (Homme, Belgique)": "nl-BE-ArnaudNeural",
+    "🇳🇱 Dena (Femme, Belgique)": "nl-BE-DenaNeural",
 }
 
 
-def get_parler_voices(lang="fr"):
-    """Retourne les voix disponibles selon la langue (FR/NL)."""
+def get_edge_voices(lang="fr"):
+    """Retourne les voix Edge disponibles selon la langue."""
     if lang == "fr":
-        return [v for k, v in PARLER_VOICES.items() if k.startswith("🇫🇷")]
+        return [v for k, v in EDGE_VOICES.items() if k.startswith("🇫🇷")]
     elif lang == "nl":
-        return [v for k, v in PARLER_VOICES.items() if k.startswith("🇳🇱")]
-    return list(PARLER_VOICES.values())
+        return [v for k, v in EDGE_VOICES.items() if k.startswith("🇳🇱")]
+    return list(EDGE_VOICES.values())
 
 
-def tts_parler(text: str, langue: str = "fr", speaker: str = None) -> str:
-    """Génère un fichier WAV avec Parler-TTS (FR/NL)."""
-    out = os.path.join(TMP_DIR, f"parler_{langue}_{uuid.uuid4().hex}.wav")
-    try:
-        if langue == "nl":
-            model = tts_nl
-        else:
-            model = tts_fr
+async def _edge_tts_async(text, voice, outfile):
+    """Appel asynchrone à edge-tts."""
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(outfile)
+    return outfile
 
-        if model is None:
-            raise RuntimeError("Modèle Parler non chargé.")
 
-        result = model(text, speaker=speaker or ("nl_female_1" if langue == "nl" else "fr_female_1"))
-        sf.write(out, result["audio"], result["sampling_rate"])
+def tts_edge(text: str, voice: str = "fr-FR-DeniseNeural") -> str:
+    """Génère un fichier audio .mp3 avec Edge-TTS."""
+    out = os.path.join(TMP_DIR, f"edge_{uuid.uuid4().hex}.mp3")
+    try:
+        asyncio.run(_edge_tts_async(text, voice, out))
         return out
     except Exception as e:
-        print(f"[TTS] Erreur Parler-TTS ({e}), fallback gTTS.")
-        return tts_gtts(text, lang=langue)
+        print(f"[Edge-TTS] Erreur: {e}")
+        return tts_gtts(text, lang="fr" if voice.startswith("fr") else "nl")
 
 
 def tts_gtts(text: str, lang: str = "fr") -> str:
-    """Fallback simple via Google Text-to-Speech (gTTS)."""
+    """Fallback simple via Google TTS."""
     from gtts import gTTS
     out = os.path.join(TMP_DIR, f"gtts_{uuid.uuid4().hex}.mp3")
     gTTS(text=text, lang=lang).save(out)
     return out
 
-
 def _normalize_audio_to_wav(in_path: str) -> str:
     # Convertit n'importe quel format (mp3/wav) en WAV standard (44.1kHz stéréo)
     from pydub import AudioSegment
@@ -342,14 +331,14 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
                   position_presentateur="bottom-right", plein=False,
                   moteur_voix="Parler-TTS (offline)", langue="fr", speaker=None):
 
-    # 1) TTS (Parler-TTS multivoix ou fallback)
+    # 1) TTS (Edge multivoix ou fallback)
     try:
-        audio_mp = tts_parler(texte_voix, langue=langue, speaker=speaker)
+        audio_mp = tts_edge(texte_voix, voice=speaker or ("fr-FR-DeniseNeural" if langue == "fr" else "nl-NL-MaaikeNeural"))
     except Exception as e:
-        print(f"[Capsule] Erreur TTS Parler ({e}), fallback gTTS.")
+        print(f"[Capsule] Erreur TTS Edge ({e}), fallback gTTS.")
         audio_mp = tts_gtts(texte_voix, lang=langue)
-
-    # 🔧 S'assurer qu'on a un WAV standard
+    
+    # S'assurer qu'on a un WAV
     audio_wav = audio_mp
     if not audio_mp.lower().endswith(".wav"):
         try:
@@ -357,6 +346,7 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
         except Exception as e:
             print(f"[Audio] Normalisation échouée ({e}), on garde {audio_mp}")
 
+
     # 2) Fond (PIL)
     fond_path = make_background(titre, sous_titre, texte_ecran, theme,
                                 logo_path, logo_pos, image_fond, fond_mode)
@@ -503,20 +493,19 @@ with gr.Blocks(title="Créateur de Capsules CPAS – SadTalker + Kokoro",
                 
                 def maj_voix(lang):
                     try:
-                        voices = get_parler_voices(lang)
+                        voices = get_edge_voices(lang)
                         return gr.update(choices=voices, value=voices[0] if voices else None)
                     except Exception as e:
                         return gr.update(choices=[], value=None)
                 
                 speaker_id = gr.Dropdown(
-                    label="🎙 Voix Parler-TTS",
-                    choices=get_parler_voices("fr"),
-                    value="fr_female_1",
+                    label="🎙 Voix Edge-TTS",
+                    choices=get_edge_voices("fr"),
+                    value="fr-FR-DeniseNeural",
                     info="Choisissez la voix selon la langue (FR/NL)"
                 )
                 langue.change(maj_voix, [langue], [speaker_id])
 
-
                 voix_type = gr.Radio(["Féminine","Masculine"], label="Voix IA", value="Féminine")
                 moteur_voix = gr.Radio(
                     ["Kokoro (HuggingFace, offline)", "gTTS (en ligne)"],