Upload app.py

app.py

@@ -1,7 +1,7 @@
 """
 PlotWeaver — Live Commentary Translation Platform (Single File)
 ================================================================
-Three engines: Qwen Omni | YourVoic API | Local (Whisper+NLLB+MMS-TTS)
+Two engines: Qwen Omni | YourVoic API (with NLLB MT)
 """
 
 import os, io, re, time, base64, struct, shutil, subprocess, tempfile, logging
@@ -35,89 +35,69 @@ QWEN_VOICES = [
 #   }
 
 LANGUAGES = {
-    # ---- Global Languages (Qwen Omni — best quality) ----
-    "Arabic": {
-        "nllb": "arb_Arab", "yourvoic_lang": "ar-SA",
-        "yourvoic_voices": ["Peter"], "tts_engine": "qwen",
-        "qwen_code": "ar", "qwen_name": "Modern Standard Arabic (العربية الفصحى)",
-    },
-    "Spanish": {
-        "nllb": "spa_Latn", "yourvoic_lang": "es-ES",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "es", "qwen_name": "Spanish",
-    },
-    "French": {
-        "nllb": "fra_Latn", "yourvoic_lang": "fr-FR",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "fr", "qwen_name": "French",
-    },
-    "German": {
-        "nllb": "deu_Latn", "yourvoic_lang": "de-DE",
+    # ---- Qwen Omni Languages (end-to-end speech-to-speech, 11 languages) ----
+    "English": {
+        "nllb": "eng_Latn", "yourvoic_lang": "en-US",
         "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "de", "qwen_name": "German",
+        "qwen_code": "en", "qwen_name": "English",
     },
-    "Mandarin": {
+    "Chinese (Mandarin)": {
         "nllb": "zho_Hans", "yourvoic_lang": "zh-CN",
         "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
         "qwen_code": "zh", "qwen_name": "Mandarin Chinese",
     },
-    "Italian": {
-        "nllb": "ita_Latn", "yourvoic_lang": "it-IT",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "it", "qwen_name": "Italian",
-    },
     "Japanese": {
         "nllb": "jpn_Jpan", "yourvoic_lang": "ja-JP",
         "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
         "qwen_code": "ja", "qwen_name": "Japanese",
     },
-    "Portuguese": {
-        "nllb": "por_Latn", "yourvoic_lang": "pt-BR",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "pt", "qwen_name": "Portuguese",
-    },
-    "Hindi": {
-        "nllb": "hin_Deva", "yourvoic_lang": "hi-IN",
-        "yourvoic_voices": ["Rahul", "Deepika", "Aditya"], "tts_engine": "qwen",
-        "qwen_code": "hi", "qwen_name": "Hindi",
-    },
     "Korean": {
         "nllb": "kor_Hang", "yourvoic_lang": "ko-KR",
         "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
         "qwen_code": "ko", "qwen_name": "Korean",
     },
+    "German": {
+        "nllb": "deu_Latn", "yourvoic_lang": "de-DE",
+        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
+        "qwen_code": "de", "qwen_name": "German",
+    },
+    "French": {
+        "nllb": "fra_Latn", "yourvoic_lang": "fr-FR",
+        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
+        "qwen_code": "fr", "qwen_name": "French",
+    },
     "Russian": {
         "nllb": "rus_Cyrl", "yourvoic_lang": "ru-RU",
         "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
         "qwen_code": "ru", "qwen_name": "Russian",
     },
-
-    # ---- African Languages (Local pipeline: Whisper → NLLB → MMS-TTS) ----
-    "Yoruba": {
-        "nllb": "yor_Latn", "yourvoic_lang": None,
-        "yourvoic_voices": [], "tts_engine": "local",
-        "qwen_code": None, "qwen_name": None,
+    "Portuguese": {
+        "nllb": "por_Latn", "yourvoic_lang": "pt-BR",
+        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
+        "qwen_code": "pt", "qwen_name": "Portuguese",
     },
-    "Hausa": {
-        "nllb": "hau_Latn", "yourvoic_lang": None,
-        "yourvoic_voices": [], "tts_engine": "local",
-        "qwen_code": None, "qwen_name": None,
+    "Spanish": {
+        "nllb": "spa_Latn", "yourvoic_lang": "es-ES",
+        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
+        "qwen_code": "es", "qwen_name": "Spanish",
     },
-    "Igbo": {
-        "nllb": "ibo_Latn", "yourvoic_lang": None,
-        "yourvoic_voices": [], "tts_engine": "local",
-        "qwen_code": None, "qwen_name": None,
+    "Italian": {
+        "nllb": "ita_Latn", "yourvoic_lang": "it-IT",
+        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
+        "qwen_code": "it", "qwen_name": "Italian",
+    },
+    "Arabic": {
+        "nllb": "arb_Arab", "yourvoic_lang": "ar-SA",
+        "yourvoic_voices": ["Peter"], "tts_engine": "qwen",
+        "qwen_code": "ar", "qwen_name": "Modern Standard Arabic",
     },
+
+    # ---- African Languages (YourVoic API) ----
     "Swahili": {
         "nllb": "swh_Latn", "yourvoic_lang": "sw-KE",
         "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
         "qwen_code": None, "qwen_name": None,
     },
-    "Zulu": {
-        "nllb": "zul_Latn", "yourvoic_lang": None,
-        "yourvoic_voices": [], "tts_engine": "local",
-        "qwen_code": None, "qwen_name": None,
-    },
     "Amharic": {
         "nllb": "amh_Ethi", "yourvoic_lang": "am-ET",
         "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
@@ -130,6 +110,11 @@ LANGUAGES = {
     },
 
     # ---- South Asian (YourVoic TTS + NLLB MT) ----
+    "Hindi": {
+        "nllb": "hin_Deva", "yourvoic_lang": "hi-IN",
+        "yourvoic_voices": ["Rahul", "Deepika", "Aditya"], "tts_engine": "yourvoic",
+        "qwen_code": None, "qwen_name": None,
+    },
     "Bengali": {
         "nllb": "ben_Beng", "yourvoic_lang": "bn-IN",
         "yourvoic_voices": ["Sneha", "Aryan"], "tts_engine": "yourvoic",
@@ -281,8 +266,8 @@ LANGUAGE_GROUPS = {
 # All language display names (for dropdowns)
 ALL_LANGUAGE_NAMES = sorted(LANGUAGES.keys())
 
-# Languages that use local TTS (your fine-tuned models)
-LOCAL_TTS_LANGUAGES = [k for k, v in LANGUAGES.items() if v["tts_engine"] == "local"]
+# Languages that use YourVoic API
+YOURVOIC_LANGUAGES = [k for k, v in LANGUAGES.items() if v["tts_engine"] == "yourvoic"]
 
 # Languages that use YourVoic API
 YOURVOIC_LANGUAGES = [k for k, v in LANGUAGES.items() if v["tts_engine"] == "yourvoic"]
@@ -299,12 +284,12 @@ TORCH_DTYPE = torch.float16 if torch.cuda.is_available() else torch.float32
 asr_pipe = None
 mt_tokenizer = None
 mt_model = None
-tts_pipe_local = None  # Local TTS for Yoruba/Hausa/Igbo/Zulu
+
 
 
 def load_models():
     """Load all models at startup."""
-    global asr_pipe, mt_tokenizer, mt_model, tts_pipe_local
+    global asr_pipe, mt_tokenizer, mt_model
     from transformers import (
         pipeline as hf_pipeline,
         AutoTokenizer,
@@ -335,17 +320,6 @@ def load_models():
     mt_tokenizer.src_lang = "eng_Latn"
     print("  MT loaded")
 
-    # Local TTS (Yoruba)
-    TTS_MODEL_ID = "PlotweaverAI/yoruba-mms-tts-new"
-    print(f"  Loading local TTS: {TTS_MODEL_ID}")
-    tts_pipe_local = hf_pipeline(
-        "text-to-speech",
-        model=TTS_MODEL_ID,
-        device=DEVICE,
-        torch_dtype=TORCH_DTYPE,
-    )
-    print("  Local TTS loaded")
-
     # Diagnostics
     print(f"\n=== Device diagnostics ===")
     print(f"CUDA available: {torch.cuda.is_available()}")
@@ -353,8 +327,8 @@ def load_models():
         print(f"CUDA device: {torch.cuda.get_device_name(0)}")
     print(f"ASR on: {next(asr_pipe.model.parameters()).device}")
     print(f"MT on: {next(mt_model.parameters()).device}")
-    print(f"TTS on: {next(tts_pipe_local.model.parameters()).device}")
     print(f"YourVoic API key: {'set' if os.environ.get('YOURVOIC_API_KEY') else 'NOT SET'}")
+    print(f"Dashscope key: {'set' if os.environ.get('DASHSCOPE_API_KEY') else 'NOT SET'}")
     print(f"==========================\n")
     print("All models loaded!")
 
@@ -538,7 +512,7 @@ def mux_video_audio(video_path, audio_path, output_path, extend_video=False, tar
 
 
 # =============================================================================
-# TTS ENGINE: YourVoic API + Local MMS-TTS
+# TTS ENGINE: YourVoic API
 # =============================================================================
 
 YOURVOIC_API_KEY = os.environ.get("YOURVOIC_API_KEY", "")
@@ -546,80 +520,110 @@ YOURVOIC_STREAM_URL = "https://yourvoic.com/api/v1/tts/stream"
 
 
 def synthesize_yourvoic(text, language_code, voice="Peter", speed=1.0):
-    """
-    Synthesize text using YourVoic API.
-    Returns (audio_array, sample_rate) or raises on failure.
-    """
+    """Synthesize text using YourVoic API."""
     if not YOURVOIC_API_KEY:
-        raise RuntimeError(
-            "YOURVOIC_API_KEY not set. Add it as a Space secret."
-        )
+        raise RuntimeError("YOURVOIC_API_KEY not set.")
 
-    headers = {
-        "X-API-Key": YOURVOIC_API_KEY,
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "text": text,
-        "voice": voice,
-        "language": language_code,
-        "model": "aura-prime",
-        "speed": speed,
-    }
+    headers = {"X-API-Key": YOURVOIC_API_KEY, "Content-Type": "application/json"}
+    payload = {"text": text, "voice": voice, "language": language_code, "model": "aura-prime", "speed": speed}
 
     t0 = time.time()
-    response = requests.post(
-        YOURVOIC_STREAM_URL,
-        headers=headers,
-        json=payload,
-        stream=True,
-        timeout=60,
-    )
+    response = requests.post(YOURVOIC_STREAM_URL, headers=headers, json=payload, stream=True, timeout=60)
 
     if response.status_code != 200:
-        raise RuntimeError(
-            f"YourVoic API error {response.status_code}: {response.text[:200]}"
-        )
+        raise RuntimeError(f"YourVoic error {response.status_code}: {response.text[:200]}")
 
-    # Collect streamed audio bytes into a temp file
-    import tempfile
-    tmp_raw = tempfile.NamedTemporaryFile(suffix=".audio", delete=False)
+    # Detect format from content-type header
+    ct = response.headers.get("content-type", "").lower()
+    logger.info(f"YourVoic content-type: {ct}")
+
+    # Collect audio bytes
+    audio_data = b""
     for chunk in response.iter_content(chunk_size=8192):
-        tmp_raw.write(chunk)
-    tmp_raw.close()
+        audio_data += chunk
 
     elapsed = time.time() - t0
-    logger.info(f"YourVoic TTS: {len(text)} chars, {elapsed:.2f}s")
+    logger.info(f"YourVoic TTS: {len(text)} chars, {elapsed:.2f}s, {len(audio_data)} bytes")
+
+    # Log first bytes for format detection
+    magic = audio_data[:16] if len(audio_data) > 16 else audio_data
+    logger.info(f"YourVoic first bytes: {magic[:8]}")
+
+    # Determine file extension from content-type or magic bytes
+    if b"RIFF" in audio_data[:4]:
+        ext = ".wav"
+    elif b"\xff\xfb" in audio_data[:3] or b"\xff\xf3" in audio_data[:3] or b"ID3" in audio_data[:3]:
+        ext = ".mp3"
+    elif b"OggS" in audio_data[:4]:
+        ext = ".ogg"
+    elif b"fLaC" in audio_data[:4]:
+        ext = ".flac"
+    elif "mp3" in ct or "mpeg" in ct:
+        ext = ".mp3"
+    elif "ogg" in ct:
+        ext = ".ogg"
+    elif "wav" in ct:
+        ext = ".wav"
+    elif "flac" in ct:
+        ext = ".flac"
+    elif "linear16" in ct or "pcm" in ct or "l16" in ct:
+        ext = ".raw"
+    else:
+        ext = ".mp3"  # Most common API default
+        logger.warning(f"Unknown YourVoic format (ct={ct}), guessing mp3")
+
+    # Save with correct extension
+    tmp_path = tempfile.NamedTemporaryFile(suffix=ext, delete=False).name
+    with open(tmp_path, "wb") as f:
+        f.write(audio_data)
 
     # Try reading directly with soundfile
     try:
-        audio_array, sample_rate = sf.read(tmp_raw.name, dtype="float32")
-        os.unlink(tmp_raw.name)
+        audio_array, sample_rate = sf.read(tmp_path, dtype="float32")
+        os.unlink(tmp_path)
         return audio_array, sample_rate
     except Exception as e:
-        logger.warning(f"soundfile can't read YourVoic output directly: {e}")
+        logger.warning(f"soundfile can't read {ext}: {e}")
+
+    # Handle raw PCM (linear16): wrap in WAV header
+    if ext == ".raw":
+        try:
+            sr = 24000
+            raw_data = audio_data
+            wav_path = tmp_path + ".wav"
+            with open(wav_path, "wb") as f:
+                f.write(b"RIFF")
+                f.write(struct.pack("<I", 36 + len(raw_data)))
+                f.write(b"WAVE")
+                f.write(b"fmt ")
+                f.write(struct.pack("<IHHIIHH", 16, 1, 1, sr, sr * 2, 2, 16))
+                f.write(b"data")
+                f.write(struct.pack("<I", len(raw_data)))
+                f.write(raw_data)
+            audio_array, sample_rate = sf.read(wav_path, dtype="float32")
+            os.unlink(tmp_path)
+            os.unlink(wav_path)
+            return audio_array, sample_rate
+        except Exception as e:
+            logger.warning(f"Raw PCM wrap failed: {e}")
 
-    # Fallback: convert with ffmpeg to WAV
+    # Fallback: convert with ffmpeg
     try:
-        import subprocess
-        tmp_wav = tmp_raw.name + ".wav"
+        wav_path = tmp_path + ".wav"
         result = subprocess.run(
-            ["ffmpeg", "-y", "-i", tmp_raw.name,
-             "-acodec", "pcm_s16le", "-ar", "24000", "-ac", "1", tmp_wav],
+            ["ffmpeg", "-y", "-i", tmp_path, "-acodec", "pcm_s16le", "-ar", "24000", "-ac", "1", wav_path],
             capture_output=True, text=True,
         )
-        os.unlink(tmp_raw.name)
+        os.unlink(tmp_path)
         if result.returncode != 0:
-            raise RuntimeError(f"ffmpeg conversion failed: {result.stderr[:200]}")
-        audio_array, sample_rate = sf.read(tmp_wav, dtype="float32")
-        os.unlink(tmp_wav)
+            raise RuntimeError(f"ffmpeg failed: {result.stderr[-300:]}")
+        audio_array, sample_rate = sf.read(wav_path, dtype="float32")
+        os.unlink(wav_path)
         return audio_array, sample_rate
     except Exception as e2:
-        # Clean up
-        for f in [tmp_raw.name, tmp_raw.name + ".wav"]:
-            if os.path.exists(f):
-                os.unlink(f)
-        raise RuntimeError(f"Failed to decode YourVoic audio: {e2}")
+        for f in [tmp_path, tmp_path + ".wav"]:
+            if os.path.exists(f): os.unlink(f)
+        raise RuntimeError(f"YourVoic decode failed: {e2}")
 
 
 def synthesize_yourvoic_to_file(text, language_code, output_path, voice="Peter", speed=1.0):
@@ -629,42 +633,26 @@ def synthesize_yourvoic_to_file(text, language_code, output_path, voice="Peter",
     return output_path, sr
 
 
-def synthesize_local(text, tts_pipe):
-    """
-    Synthesize text using local HuggingFace TTS pipeline (MMS-TTS).
-    Returns (audio_array, sample_rate).
-    """
-    t0 = time.time()
-    result = tts_pipe(text)
-    audio = np.array(result["audio"]).squeeze()
-    sr = result["sampling_rate"]
-    elapsed = time.time() - t0
-    logger.info(f"Local TTS: {len(text)} chars, {elapsed:.2f}s, {len(audio)/sr:.1f}s audio")
-    return audio, sr
 
 
-def synthesize_chunked(text, language_config, tts_pipe=None, sentences_per_chunk=2):
+def synthesize_chunked(text, language_config, sentences_per_chunk=2):
     """
-    Synthesize long text by chunking into sentence groups.
-    Routes to either YourVoic or local TTS based on language config.
+    Synthesize long text by chunking into sentence groups via YourVoic API.
 
     Args:
         text: Full text to synthesize
-        language_config: Dict from LANGUAGES (has tts_engine, yourvoic_lang, etc.)
-        tts_pipe: Local HuggingFace TTS pipeline (needed for local engine)
+        language_config: Dict from LANGUAGES (has yourvoic_lang, yourvoic_voices, etc.)
         sentences_per_chunk: How many sentences to synthesize per API call
 
     Returns:
         (audio_array, sample_rate)
     """
-    import re
     sentences = re.split(r'(?<=[.!?])\s+', text)
     sentences = [s.strip() for s in sentences if s.strip()]
 
     if not sentences:
-        return np.array([], dtype=np.float32), 16000
+        return np.zeros(int(0.5 * 16000), dtype=np.float32), 16000
 
-    engine = language_config["tts_engine"]
     audio_segments = []
     output_sr = None
 
@@ -674,20 +662,14 @@ def synthesize_chunked(text, language_config, tts_pipe=None, sentences_per_chunk
             continue
 
         try:
-            if engine == "yourvoic":
-                voice = language_config["yourvoic_voices"][0] if language_config["yourvoic_voices"] else "Peter"
-                lang_code = language_config["yourvoic_lang"]
-                audio_seg, seg_sr = synthesize_yourvoic(chunk_text, lang_code, voice)
-            else:
-                if tts_pipe is None:
-                    raise RuntimeError("Local TTS pipeline not loaded")
-                audio_seg, seg_sr = synthesize_local(chunk_text, tts_pipe)
+            voice = language_config["yourvoic_voices"][0] if language_config.get("yourvoic_voices") else "Peter"
+            lang_code = language_config["yourvoic_lang"]
+            audio_seg, seg_sr = synthesize_yourvoic(chunk_text, lang_code, voice)
 
             if output_sr is None:
                 output_sr = seg_sr
             if len(audio_seg) > 0:
                 audio_segments.append(audio_seg)
-                # Small silence between chunks
                 silence = np.zeros(int(0.15 * seg_sr), dtype=np.float32)
                 audio_segments.append(silence)
 
@@ -696,11 +678,9 @@ def synthesize_chunked(text, language_config, tts_pipe=None, sentences_per_chunk
             continue
 
     if not audio_segments:
-        # Return a short silence instead of empty array to prevent Gradio crash
         fallback_sr = output_sr or 16000
-        silence = np.zeros(int(0.5 * fallback_sr), dtype=np.float32)
         logger.warning("All TTS chunks failed — returning silence")
-        return silence, fallback_sr
+        return np.zeros(int(0.5 * fallback_sr), dtype=np.float32), fallback_sr
 
     return np.concatenate(audio_segments), output_sr
 
@@ -1008,7 +988,7 @@ def get_voices_for_language(lang_name):
     elif engine == "yourvoic" and config.get("yourvoic_voices"):
         return config["yourvoic_voices"]
     elif engine == "local":
-        return ["Default (local model)"]
+        return ["Peter"]
     return ["Peter"]
 
 
@@ -1053,7 +1033,7 @@ def full_pipeline_audio(audio_input, target_language):
     # TTS
     t0 = time.time()
     audio_out, sr_out = synthesize_chunked(
-        translated, lang_config, tts_pipe=tts_pipe_local
+        translated, lang_config
     )
     log.append(f"\n**TTS** ({time.time()-t0:.2f}s) = {len(audio_out)/sr_out:.1f}s audio")
 
@@ -1088,7 +1068,7 @@ def full_pipeline_text(english_text, target_language, voice_name):
     # TTS
     t0 = time.time()
     audio_out, sr_out = synthesize_chunked(
-        translated, lang_config, tts_pipe=tts_pipe_local
+        translated, lang_config
     )
     log.append(f"\n**TTS** ({time.time()-t0:.2f}s) = {len(audio_out)/sr_out:.1f}s audio")
 
@@ -1101,7 +1081,7 @@ def full_pipeline_text(english_text, target_language, voice_name):
 def dub_video(video_path, target_languages, dub_voice, chunk_seconds, progress=gr.Progress()):
     """
     Dub a video into one or more target languages.
-    Routes to Qwen Omni for global languages, local pipeline for African languages.
+    Routes to Qwen Omni for global languages, YourVoic for others.
     """
     if video_path is None:
         return None, "Please upload a video."
@@ -1173,7 +1153,7 @@ def dub_video(video_path, target_languages, dub_voice, chunk_seconds, progress=g
                 progress(0.65, desc=f"{lang_name}: synthesizing...")
                 t0 = time.time()
                 tgt_audio, tgt_sr = synthesize_chunked(
-                    translated, lang_config, tts_pipe=tts_pipe_local
+                    translated, lang_config
                 )
                 sf.write(tgt_audio_raw, tgt_audio, tgt_sr)
                 tgt_duration = len(tgt_audio) / tgt_sr
@@ -1247,7 +1227,7 @@ with gr.Blocks(
     <div class="main-header">
         <h1>PlotWeaver</h1>
         <p>Live commentary translation platform &mdash; English to 40+ languages</p>
-        <p style="font-size:0.8rem; color:#999">ASR (Whisper) &rarr; MT (NLLB-200) &rarr; TTS (YourVoic + local models)</p>
+        <p style="font-size:0.8rem; color:#999">Qwen Omni (11 languages) + YourVoic API + NLLB-200 (27 languages)</p>
     </div>
     """)
 
@@ -1373,7 +1353,7 @@ with gr.Blocks(
             gr.Markdown(
                 "Upload a video with English commentary and get back a dubbed version. "
                 "**Global languages** (Arabic, French, Spanish, etc.) use Qwen Omni for best quality. "
-                "**African languages** (Yoruba, Hausa, etc.) use the local Whisper → NLLB → MMS-TTS pipeline."
+                "**African/regional languages** use YourVoic API with NLLB translation."
             )
 
             with gr.Row():
@@ -1496,7 +1476,7 @@ with gr.Blocks(
                     info += f"**YourVoic language:** `{config.get('yourvoic_lang', 'N/A')}`\n\n"
                     info += f"**Available voices:** {', '.join(voices) if voices else 'Peter (default)'}"
                 else:
-                    info += f"**Engine:** Local pipeline (Whisper ASR + NLLB MT + MMS-TTS)\n\n"
+                    info += f"**Engine:** Not available\n\n"
                     info += f"**NLLB code:** `{config.get('nllb', 'N/A')}`\n\n"
                     info += "Uses locally fine-tuned models on GPU. Voice selection not available."
 
@@ -1510,8 +1490,8 @@ with gr.Blocks(
 **PlotWeaver** by PlotweaverAI | Models:
 [ASR](https://huggingface.co/PlotweaverAI/whisper-small-de-en) |
 [MT](https://huggingface.co/PlotweaverAI/nllb-200-distilled-600M-african-6lang) |
-[TTS](https://huggingface.co/PlotweaverAI/yoruba-mms-tts-new) |
-[YourVoic API](https://yourvoic.com)
+[TTS](https://yourvoic.com) |
+[Qwen Omni](https://www.alibabacloud.com/help/en/model-studio/qwen-omni)
 """)