Upload 3 files

README.md

@@ -1,25 +1,76 @@
 ---
-title: PlotWeaver - Live Commentary Translation
-emoji: "\U0001F3DF\uFE0F"
+title: Live Football Commentary Translator
+emoji: ⚽
 colorFrom: green
-colorTo: yellow
+colorTo: blue
 sdk: gradio
-sdk_version: "5.50.0"
+sdk_version: 5.42.0
+python_version: "3.11"
 app_file: app.py
-pinned: true
-license: mit
-hardware: t4-small
-models:
-  - PlotweaverAI/whisper-small-de-en
-  - PlotweaverAI/nllb-200-distilled-600M-african-6lang
-  - PlotweaverAI/yoruba-mms-tts-new
-tags:
-  - speech-to-speech
-  - translation
-  - dubbing
-  - multi-language
-  - football
-  - commentary
-  - streaming
-short_description: Translate live English commentary to 40+ languages with AI
+pinned: false
+license: apache-2.0
 ---
+
+# Live Football Commentary Translator
+
+Speak (or upload) commentary in one language, hear it spoken in another.
+
+## What this is
+
+A HuggingFace Space that translates football commentary between languages.
+Two modes:
+
+- **Single clip** — record or upload one clip, get one translation.
+- **Continuous live** — start a session, speak naturally, translations chunk
+  at natural pauses (~0.8s silence) and play sequentially.
+
+Sources: English, Scottish English, German, Spanish, Arabic
+Targets: all of the above + Swahili, Amharic, Afrikaans
+
+## How it works
+
+Two pipelines, routed by target language:
+
+| Target language | Pipeline | Cost |
+|---|---|---|
+| English, Scottish-EN, German, Spanish, Arabic | Single Qwen-Omni call: audio in → translated speech out | 1 API call |
+| Swahili, Amharic, Afrikaans | Qwen-Omni (audio → translated text), then YourVoic (text → speech) | 2 API calls |
+
+Qwen-Omni is `qwen3.5-omni-plus` on DashScope International. YourVoic is the
+fallback for languages Qwen-Omni doesn't cover natively. This split exists
+because Qwen-Omni does not produce intelligible speech in Swahili, Amharic,
+or Afrikaans on its own.
+
+## Deploy
+
+1. Create a new HuggingFace Space, SDK = Gradio
+2. Upload `app.py`, `requirements.txt`, and this `README.md`
+3. Add secrets in **Settings → Variables and secrets**:
+   - `DASHSCOPE_API_KEY` (required) — get one from DashScope International
+   - `YOURVOIC_API_KEY` (required for Swahili/Amharic/Afrikaans only)
+4. (Recommended) Set hardware to **ZeroGPU** if you have access. CPU also works
+   but will be slower on the audio-decode steps.
+
+## Expected latency
+
+On free ZeroGPU, expect 3-8 seconds from end-of-speech to start-of-output. The
+demo is designed to feel "live-ish" but not simultaneous-interpretation grade.
+Speak in short bursts — one play, one tackle, one moment — rather than long
+monologues.
+
+## Known limitations
+
+- "Scottish English" is treated as accented English in the system prompt rather
+  than a separate language. Qwen-Omni's Scottish accent is decent but not
+  authentic.
+- YourVoic voice support per language is sparsely documented. The code falls
+  back to a universal voice ("Peter") if the primary choice fails.
+- Arabic voice cloning is intentionally not exposed — the underlying
+  `qwen3-tts-vc` model doesn't support Arabic.
+- Free-tier ZeroGPU has cold-start delays. First call after idle is slower.
+
+## Files
+
+- `app.py` — Gradio UI and pipeline
+- `requirements.txt` — Python dependencies
+- `README.md` — this file (also the Space metadata header)

app.py

@@ -1,1680 +1,779 @@
 """
-PlotWeaver — Live Commentary Translation Platform (Single File)
-================================================================
-Two engines: Qwen Omni | YourVoic API (with NLLB MT)
+Live Football Commentary Translator
+====================================
+Audio in (live commentator) -> Translate -> Audio out (target language).
+
+Two modes:
+  1. Single clip: record/upload, click translate, hear result.
+  2. Continuous live: start recording, speak naturally, translations queue up
+     and play sequentially. Energy-based VAD chunks speech at ~0.8s pauses.
+
+Engines:
+  - Qwen-Omni (qwen3.5-omni-plus) handles audio-in -> translated-speech-out
+    in ONE call for languages it covers (English, German, Spanish, Arabic,
+    Scottish-accented English).
+  - For African target languages (Swahili, Amharic, Afrikaans), Qwen-Omni
+    does audio -> translated text, then YourVoic does text -> speech.
+
+Deploy as a Hugging Face Space (SDK: Gradio). Add these secrets:
+  - DASHSCOPE_API_KEY  (required, for Qwen-Omni)
+  - YOURVOIC_API_KEY   (required for Swahili/Amharic/Afrikaans targets)
 """
 
-import os, io, re, time, base64, struct, shutil, subprocess, tempfile, logging
-import torch, numpy as np, requests, soundfile as sf, gradio as gr
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-logger = logging.getLogger(__name__)
-
-
-# =============================================================================
+import os
+import base64
+import json
+import struct
+import subprocess
+import tempfile
+import threading
+import time
+import uuid
+import queue
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+import gradio as gr
+import requests as http_requests
+from openai import OpenAI
+
+# ==========================================
+# CONFIGURATION
+# ==========================================
+OMNI_MODEL = "qwen3.5-omni-plus"
+DASHSCOPE_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+YOURVOIC_TTS_URL = "https://yourvoic.com/api/v1/tts/generate"
+
+# Continuous-mode VAD tuning
+VAD_SILENCE_SEC = 0.8          # pause length that ends an utterance
+VAD_MIN_UTTERANCE_SEC = 1.2    # don't send anything shorter than this
+VAD_MAX_UTTERANCE_SEC = 12.0   # force-flush if user keeps talking
+VAD_RMS_THRESHOLD = 0.015      # RMS above this = voice. Lower = more sensitive.
+
+# Poll interval for the output drain loop
+OUTPUT_POLL_SEC = 0.3
+
+# ==========================================
 # LANGUAGES
-# =============================================================================
-
-# Qwen Omni voices (work across all Qwen-supported languages)
-QWEN_VOICES = [
-    "Cherry", "Serena", "Ethan", "Chelsie", "Momo", "Vivian", "Moon", "Maia",
-    "Kai", "Nofish", "Bella", "Jennifer", "Ryan", "Katerina", "Aiden",
-    "Eldric Sage", "Mia", "Mochi", "Bellona", "Vincent", "Bunny", "Neil",
-    "Elias", "Arthur", "Seren", "Bodega", "Sonrisa", "Alek", "Dolce",
-    "Sohee", "Ono Anna", "Lenn", "Emilien", "Andre",
-]
-
-# Each language entry:
-#   "Display Name": {
-#       "nllb": NLLB-200 language code (for local/yourvoic pipeline translation),
-#       "yourvoic_lang": YourVoic language code (or None),
-#       "yourvoic_voices": list of YourVoic voice names,
-#       "tts_engine": "qwen" | "yourvoic" | "local",
-#       "qwen_code": short language code for Qwen prompts (or None),
-#       "qwen_name": full language name for Qwen system prompt (or None),
-#   }
-
-LANGUAGES = {
-    # ---- 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": "en", "qwen_name": "English",
-    },
-    "Chinese (Mandarin)": {
-        "nllb": "zho_Hans", "yourvoic_lang": "zh-CN",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "zh", "qwen_name": "Mandarin Chinese",
-    },
-    "Japanese": {
-        "nllb": "jpn_Jpan", "yourvoic_lang": "ja-JP",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "ja", "qwen_name": "Japanese",
-    },
-    "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",
-    },
-    "Portuguese": {
-        "nllb": "por_Latn", "yourvoic_lang": "pt-BR",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "pt", "qwen_name": "Portuguese",
-    },
-    "Spanish": {
-        "nllb": "spa_Latn", "yourvoic_lang": "es-ES",
-        "yourvoic_voices": ["Peter", "Kylie"], "tts_engine": "qwen",
-        "qwen_code": "es", "qwen_name": "Spanish",
-    },
-    "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,
-    },
-    "Amharic": {
-        "nllb": "amh_Ethi", "yourvoic_lang": "am-ET",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Afrikaans": {
-        "nllb": "afr_Latn", "yourvoic_lang": "af-ZA",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-
-    # ---- 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",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Tamil": {
-        "nllb": "tam_Taml", "yourvoic_lang": "ta-IN",
-        "yourvoic_voices": ["Priya", "Kumar"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Telugu": {
-        "nllb": "tel_Telu", "yourvoic_lang": "te-IN",
-        "yourvoic_voices": ["Arjun", "Lakshmi"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Marathi": {
-        "nllb": "mar_Deva", "yourvoic_lang": "mr-IN",
-        "yourvoic_voices": ["Anjali", "Rohan"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Urdu": {
-        "nllb": "urd_Arab", "yourvoic_lang": "ur-PK",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Nepali": {
-        "nllb": "npi_Deva", "yourvoic_lang": "ne-NP",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-
-    # ---- Southeast Asian (YourVoic) ----
-    "Indonesian": {
-        "nllb": "ind_Latn", "yourvoic_lang": "id-ID",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Vietnamese": {
-        "nllb": "vie_Latn", "yourvoic_lang": "vi-VN",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Thai": {
-        "nllb": "tha_Thai", "yourvoic_lang": "th-TH",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Malay": {
-        "nllb": "zsm_Latn", "yourvoic_lang": "ms-MY",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Filipino": {
-        "nllb": "tgl_Latn", "yourvoic_lang": "fil-PH",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-
-    # ---- European (YourVoic) ----
-    "Dutch": {
-        "nllb": "nld_Latn", "yourvoic_lang": "nl-NL",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Polish": {
-        "nllb": "pol_Latn", "yourvoic_lang": "pl-PL",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Turkish": {
-        "nllb": "tur_Latn", "yourvoic_lang": "tr-TR",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Swedish": {
-        "nllb": "swe_Latn", "yourvoic_lang": "sv-SE",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Romanian": {
-        "nllb": "ron_Latn", "yourvoic_lang": "ro-RO",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Greek": {
-        "nllb": "ell_Grek", "yourvoic_lang": "el-GR",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Ukrainian": {
-        "nllb": "ukr_Cyrl", "yourvoic_lang": "uk-UA",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Finnish": {
-        "nllb": "fin_Latn", "yourvoic_lang": "fi-FI",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Danish": {
-        "nllb": "dan_Latn", "yourvoic_lang": "da-DK",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Norwegian": {
-        "nllb": "nob_Latn", "yourvoic_lang": "nb-NO",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-
-    # ---- Middle Eastern (YourVoic) ----
-    "Persian": {
-        "nllb": "pes_Arab", "yourvoic_lang": "fa-IR",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
-    "Hebrew": {
-        "nllb": "heb_Hebr", "yourvoic_lang": "he-IL",
-        "yourvoic_voices": ["Peter"], "tts_engine": "yourvoic",
-        "qwen_code": None, "qwen_name": None,
-    },
+# ==========================================
+SOURCE_LANGUAGES = {
+    "English":              {"code": "en",      "omni_hint": "English"},
+    "Scottish English":     {"code": "en-scot", "omni_hint": "Scottish-accented English"},
+    "German":               {"code": "de",      "omni_hint": "German"},
+    "Spanish":              {"code": "es",      "omni_hint": "Spanish"},
+    "Arabic":               {"code": "ar",      "omni_hint": "Arabic"},
 }
 
-
-# Group languages by category for the UI
-LANGUAGE_GROUPS = {
-    "Global Languages": [
-        "Spanish", "French", "German", "Mandarin", "Italian",
-        "Japanese", "Portuguese", "Hindi", "Arabic", "Korean", "Russian",
-    ],
-    "African Languages": [
-        "Swahili", "Amharic", "Afrikaans",
-    ],
-    "South Asian": [
-        "Bengali", "Tamil", "Telugu", "Marathi", "Urdu", "Nepali",
-    ],
-    "Southeast Asian": [
-        "Indonesian", "Vietnamese", "Thai", "Malay", "Filipino",
-    ],
-    "European": [
-        "Dutch", "Polish", "Turkish", "Swedish", "Romanian",
-        "Greek", "Ukrainian", "Finnish", "Danish", "Norwegian",
-    ],
-    "Middle Eastern": [
-        "Persian", "Hebrew",
-    ],
+TARGET_LANGUAGES = {
+    "English":           {"engine": "qwen",     "omni_hint": "English"},
+    "Scottish English":  {"engine": "qwen",     "omni_hint": "Scottish-accented English"},
+    "German":            {"engine": "qwen",     "omni_hint": "German"},
+    "Spanish":           {"engine": "qwen",     "omni_hint": "Spanish"},
+    "Arabic":            {"engine": "qwen",     "omni_hint": "Arabic"},
+    "Swahili":           {"engine": "yourvoic", "omni_hint": "Swahili",   "yourvoic_lang": "sw-KE"},
+    "Amharic":           {"engine": "yourvoic", "omni_hint": "Amharic",   "yourvoic_lang": "am-ET"},
+    "Afrikaans":         {"engine": "yourvoic", "omni_hint": "Afrikaans", "yourvoic_lang": "af-ZA"},
 }
 
-# All language display names (for dropdowns)
-ALL_LANGUAGE_NAMES = sorted(LANGUAGES.keys())
-
-# 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"]
-
-
-# =============================================================================
-# PIPELINE: ASR + MT + Video helpers
-# =============================================================================
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-TORCH_DTYPE = torch.float16 if torch.cuda.is_available() else torch.float32
-
-# Models (loaded once at startup)
-asr_pipe = None
-mt_tokenizer = None
-mt_model = None
+QWEN_VOICES = [
+    "Ethan -- Warm, energetic (good default)",
+    "Ryan -- Dramatic, rhythmic (good for live action)",
+    "Cherry -- Sunny, friendly",
+    "Jennifer -- Cinematic narrator",
+    "Vincent -- Rich, theatrical",
+    "Bellona -- Strong, commanding",
+]
 
+YOURVOIC_VOICE_MAP = {
+    "Swahili":   ["Peter"],
+    "Amharic":   ["Peter"],
+    "Afrikaans": ["Peter"],
+}
 
+YOURVOIC_MODEL = "aura-prime"
+
+# ==========================================
+# HELPERS
+# ==========================================
+def voice_name(label: str) -> str:
+    return label.split("--")[0].strip()
+
+
+def write_wav(samples: np.ndarray, sample_rate: int, output_path: str) -> None:
+    """Write a numpy int16/float audio array to a WAV file."""
+    if samples.dtype == np.float32 or samples.dtype == np.float64:
+        samples = np.clip(samples, -1.0, 1.0)
+        samples = (samples * 32767).astype(np.int16)
+    elif samples.dtype != np.int16:
+        samples = samples.astype(np.int16)
+    if samples.ndim > 1:
+        samples = samples.mean(axis=1).astype(np.int16)
+
+    nc, bps = 1, 16
+    sr = sample_rate
+    br = sr * nc * bps // 8
+    ba = nc * bps // 8
+    raw = samples.tobytes()
+    ds = len(raw)
+    with open(output_path, "wb") as f:
+        f.write(b"RIFF"); f.write(struct.pack("<I", 36 + ds))
+        f.write(b"WAVE"); f.write(b"fmt ")
+        f.write(struct.pack("<I", 16)); f.write(struct.pack("<H", 1))
+        f.write(struct.pack("<H", nc));  f.write(struct.pack("<I", sr))
+        f.write(struct.pack("<I", br));  f.write(struct.pack("<H", ba))
+        f.write(struct.pack("<H", bps)); f.write(b"data")
+        f.write(struct.pack("<I", ds));  f.write(raw)
 
-def load_models():
-    """Load all models at startup."""
-    global asr_pipe, mt_tokenizer, mt_model
-    from transformers import (
-        pipeline as hf_pipeline,
-        AutoTokenizer,
-        AutoModelForSeq2SeqLM,
-    )
 
-    print(f"Device: {DEVICE} | Dtype: {TORCH_DTYPE}")
-    print("Loading models...")
-
-    # ASR
-    ASR_MODEL_ID = "PlotweaverAI/whisper-small-de-en"
-    print(f"  Loading ASR: {ASR_MODEL_ID}")
-    asr_pipe = hf_pipeline(
-        "automatic-speech-recognition",
-        model=ASR_MODEL_ID,
-        device=DEVICE,
-        torch_dtype=TORCH_DTYPE,
+def base64_to_wav(b64_data: str, output_path: str) -> None:
+    """Qwen-Omni returns base64 PCM @ 24kHz. Wrap in WAV container."""
+    audio_bytes = base64.b64decode(b64_data)
+    sr, nc, bps = 24000, 1, 16
+    br = sr * nc * bps // 8
+    ba = nc * bps // 8
+    ds = len(audio_bytes)
+    with open(output_path, "wb") as f:
+        f.write(b"RIFF"); f.write(struct.pack("<I", 36 + ds))
+        f.write(b"WAVE"); f.write(b"fmt ")
+        f.write(struct.pack("<I", 16)); f.write(struct.pack("<H", 1))
+        f.write(struct.pack("<H", nc));  f.write(struct.pack("<I", sr))
+        f.write(struct.pack("<I", br));  f.write(struct.pack("<H", ba))
+        f.write(struct.pack("<H", bps)); f.write(b"data")
+        f.write(struct.pack("<I", ds));  f.write(audio_bytes)
+
+
+def normalize_audio_file(input_path: str, out_dir: str) -> str:
+    """Convert any audio file to 16kHz mono WAV (what Omni expects)."""
+    out_path = os.path.join(out_dir, f"in_{uuid.uuid4().hex[:8]}.wav")
+    subprocess.run(
+        ["ffmpeg", "-y", "-i", input_path,
+         "-ar", "16000", "-ac", "1", "-acodec", "pcm_s16le", out_path],
+        capture_output=True, check=True,
     )
-    print("  ASR loaded")
-
-    # MT
-    MT_MODEL_ID = "PlotweaverAI/nllb-200-distilled-600M-african-6lang"
-    print(f"  Loading MT: {MT_MODEL_ID}")
-    mt_tokenizer = AutoTokenizer.from_pretrained(MT_MODEL_ID)
-    mt_model = AutoModelForSeq2SeqLM.from_pretrained(
-        MT_MODEL_ID, torch_dtype=TORCH_DTYPE
-    ).to(DEVICE)
-    mt_tokenizer.src_lang = "eng_Latn"
-    print("  MT loaded")
-
-    # Diagnostics
-    print(f"\n=== Device diagnostics ===")
-    print(f"CUDA available: {torch.cuda.is_available()}")
-    if torch.cuda.is_available():
-        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"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!")
-
-
-# ---- Text Processing ----
-
-def split_into_sentences(text):
-    """Split raw ASR text into individual sentences."""
-    text = text.strip()
-    if not text:
-        return []
-    text = '. '.join(s.strip().capitalize() for s in text.split('. ') if s.strip())
-    if re.search(r'[.!?]', text):
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        return [s.strip() for s in sentences if s.strip()]
-    words = text.split()
-    MAX_WORDS = 12
-    sentences = []
-    for i in range(0, len(words), MAX_WORDS):
-        chunk = ' '.join(words[i:i + MAX_WORDS])
-        if not chunk.endswith(('.', '!', '?')):
-            chunk += '.'
-        chunk = chunk[0].upper() + chunk[1:] if len(chunk) > 1 else chunk.upper()
-        sentences.append(chunk)
-    return sentences
-
-
-# ---- ASR ----
-
-def transcribe(audio_array, sample_rate=16000):
-    """ASR: English audio to text. Handles both short and long audio."""
-    if len(audio_array) < 1600:
-        return ""
-
-    duration_s = len(audio_array) / sample_rate
-
-    if sample_rate != 16000:
-        import torchaudio.functional as F_audio
-        audio_tensor = torch.from_numpy(audio_array).float()
-        audio_tensor = F_audio.resample(audio_tensor, sample_rate, 16000)
-        audio_array = audio_tensor.numpy()
-        sample_rate = 16000
-
-    if duration_s <= 28:
-        result = asr_pipe(
-            {"raw": audio_array, "sampling_rate": sample_rate},
-            return_timestamps=False,
-        )
-        return result["text"].strip()
-
-    # Long-form: native Whisper generate
-    model = asr_pipe.model
-    processor = asr_pipe.feature_extractor
-    tokenizer = asr_pipe.tokenizer
-
-    inputs = processor(
-        audio_array, sampling_rate=16000, return_tensors="pt",
-        truncation=False, padding="longest", return_attention_mask=True,
+    return out_path
+
+
+def audio_file_to_data_uri(path: str) -> str:
+    b64 = base64.b64encode(open(path, "rb").read()).decode()
+    return f"data:audio/wav;base64,{b64}"
+
+
+# ==========================================
+# CORE: Qwen-Omni audio -> translated speech (one call)
+# ==========================================
+def omni_audio_to_speech(client: OpenAI,
+                         audio_path: str,
+                         source_hint: str,
+                         target_hint: str,
+                         voice: str,
+                         out_dir: str) -> tuple:
+    audio_uri = audio_file_to_data_uri(audio_path)
+
+    sys_prompt = (
+        f"You are a live football commentary translator. "
+        f"The user will speak in {source_hint}. "
+        f"Listen carefully and respond by speaking the equivalent commentary in {target_hint}. "
+        f"Match the energy and excitement of live football commentary. "
+        f"Keep the same meaning. Do NOT add commentary of your own. "
+        f"Respond ONLY with the spoken {target_hint} translation."
     )
-    input_features = inputs.input_features.to(DEVICE, dtype=TORCH_DTYPE)
-    attention_mask = inputs.attention_mask.to(DEVICE) if "attention_mask" in inputs else None
-
-    generate_kwargs = {"return_timestamps": True, "language": "en", "task": "transcribe"}
-    if attention_mask is not None:
-        generate_kwargs["attention_mask"] = attention_mask
-
-    with torch.no_grad():
-        predicted_ids = model.generate(input_features, **generate_kwargs)
-
-    transcription = tokenizer.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-    return transcription.strip()
-
-
-# ---- MT ----
-
-def translate_sentence(text, target_nllb_code, fast=True, max_length=256):
-    """Translate a single sentence from English to target language."""
-    inputs = mt_tokenizer(text, return_tensors="pt", truncation=True).to(DEVICE)
-    tgt_lang_id = mt_tokenizer.convert_tokens_to_ids(target_nllb_code)
-
-    generate_kwargs = {
-        "forced_bos_token_id": tgt_lang_id,
-        "repetition_penalty": 1.5,
-        "no_repeat_ngram_size": 3,
-    }
-    if fast:
-        generate_kwargs.update({"max_length": 128, "num_beams": 1, "do_sample": False})
-    else:
-        generate_kwargs.update({"max_length": max_length, "num_beams": 4, "early_stopping": True})
-
-    with torch.no_grad():
-        output_ids = mt_model.generate(**inputs, **generate_kwargs)
-
-    return mt_tokenizer.decode(output_ids[0], skip_special_tokens=True)
-
-
-def translate_text(text, target_nllb_code, fast=True):
-    """Split and translate full text sentence-by-sentence."""
-    sentences = split_into_sentences(text)
-    if not sentences:
-        return "", [], []
-    translations = []
-    for s in sentences:
-        yo = translate_sentence(s, target_nllb_code, fast=fast)
-        translations.append(yo)
-    return ' '.join(translations), sentences, translations
-
-
-# ---- Video Processing ----
-
-def extract_audio_from_video(video_path, output_path, target_sr=16000):
-    """Extract audio track from video as 16kHz mono WAV."""
-    cmd = [
-        "ffmpeg", "-y", "-i", video_path,
-        "-vn", "-acodec", "pcm_s16le", "-ar", str(target_sr), "-ac", "1",
-        output_path,
-    ]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"ffmpeg extraction failed: {result.stderr[:200]}")
-    return output_path
-
-
-def get_media_duration(path):
-    """Get duration in seconds."""
-    cmd = [
-        "ffprobe", "-v", "error",
-        "-show_entries", "format=duration",
-        "-of", "default=noprint_wrappers=1:nokey=1", path,
-    ]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"ffprobe failed: {result.stderr[:200]}")
-    return float(result.stdout.strip())
-
-
-def stretch_audio_to_duration(input_path, output_path, target_duration_s):
-    """Stretch/compress audio to match target duration."""
-    current_duration = get_media_duration(input_path)
-    if current_duration <= 0:
-        raise RuntimeError("Invalid audio duration")
-
-    ratio = current_duration / target_duration_s
-    filters = []
-    remaining = ratio
-    while remaining > 2.0:
-        filters.append("atempo=2.0")
-        remaining /= 2.0
-    while remaining < 0.5:
-        filters.append("atempo=0.5")
-        remaining /= 0.5
-    filters.append(f"atempo={remaining:.4f}")
-
-    cmd = ["ffmpeg", "-y", "-i", input_path, "-filter:a", ",".join(filters), output_path]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"ffmpeg tempo failed: {result.stderr[:200]}")
-    return output_path
-
-
-def mux_video_audio(video_path, audio_path, output_path, extend_video=False, target_duration=None):
-    """Combine video with new audio. Optionally extend video by freezing last frame."""
-    if extend_video and target_duration:
-        cmd = [
-            "ffmpeg", "-y", "-i", video_path, "-i", audio_path,
-            "-filter_complex", f"[0:v]tpad=stop_mode=clone:stop_duration={target_duration}[v]",
-            "-map", "[v]", "-map", "1:a:0",
-            "-c:v", "libx264", "-preset", "fast", "-c:a", "aac",
-            "-t", str(target_duration), output_path,
-        ]
-    else:
-        cmd = [
-            "ffmpeg", "-y", "-i", video_path, "-i", audio_path,
-            "-c:v", "copy", "-c:a", "aac",
-            "-map", "0:v:0", "-map", "1:a:0", "-shortest", output_path,
-        ]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"ffmpeg mux failed: {result.stderr[:200]}")
-    return output_path
-
-
-# =============================================================================
-# TTS ENGINE: YourVoic API
-# =============================================================================
-
-YOURVOIC_API_KEY = os.environ.get("YOURVOIC_API_KEY", "")
-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."""
-    if not YOURVOIC_API_KEY:
-        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}
-
-    logger.info(f"YourVoic request: lang={language_code}, voice={voice}, text={text[:50]}")
-
-    t0 = time.time()
-    response = requests.post(YOURVOIC_STREAM_URL, headers=headers, json=payload, stream=True, timeout=60)
-
-    if response.status_code != 200:
-        error_text = response.text[:300] if hasattr(response, 'text') else str(response.status_code)
-        raise RuntimeError(f"YourVoic error {response.status_code}: {error_text}")
-
-    # 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):
-        audio_data += chunk
-
-    elapsed = time.time() - t0
-    logger.info(f"YourVoic TTS: {len(text)} chars, {elapsed:.2f}s, {len(audio_data)} bytes")
-
-    # Check for empty response
-    if len(audio_data) == 0:
-        raise RuntimeError(
-            f"YourVoic returned empty audio. This usually means the voice '{voice}' "
-            f"doesn't support language '{language_code}'. Try a different voice."
-        )
-
-    # 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]}")
-
-    # Handle raw PCM directly (audio/pcm) — wrap in WAV header
-    if "pcm" in ct or "linear16" in ct or "l16" in ct:
-        sr = 24000  # YourVoic default sample rate for PCM
-        wav_path = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
-        with open(wav_path, "wb") as f:
-            f.write(b"RIFF")
-            f.write(struct.pack("<I", 36 + len(audio_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(audio_data)))
-            f.write(audio_data)
-        try:
-            audio_array, sample_rate = sf.read(wav_path, dtype="float32")
-            os.unlink(wav_path)
-            logger.info(f"YourVoic PCM decoded: {len(audio_array)/sample_rate:.2f}s at {sample_rate}Hz")
-            return audio_array, sample_rate
-        except Exception as e:
-            os.unlink(wav_path)
-            raise RuntimeError(f"PCM decode failed: {e}")
-
-    # Determine file extension from magic bytes or content-type
-    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"
-    else:
-        ext = ".mp3"
-        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_path, dtype="float32")
-        os.unlink(tmp_path)
-        return audio_array, sample_rate
-    except Exception as e:
-        logger.warning(f"soundfile can't read {ext}: {e}")
-
-    # Fallback: convert with ffmpeg
-    try:
-        wav_path = tmp_path + ".wav"
-        result = subprocess.run(
-            ["ffmpeg", "-y", "-i", tmp_path, "-acodec", "pcm_s16le", "-ar", "24000", "-ac", "1", wav_path],
-            capture_output=True, text=True,
+        completion = client.chat.completions.create(
+            model=OMNI_MODEL,
+            messages=[
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": [
+                    {"type": "input_audio",
+                     "input_audio": {"data": audio_uri, "format": "wav"}},
+                    {"type": "text",
+                     "text": f"Translate this commentary into {target_hint} and speak it."},
+                ]},
+            ],
+            modalities=["text", "audio"],
+            audio={"voice": voice, "format": "wav"},
+            stream=True,
+            stream_options={"include_usage": True},
         )
-        os.unlink(tmp_path)
-        if result.returncode != 0:
-            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:
-        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):
-    """Synthesize via YourVoic and save to file."""
-    audio, sr = synthesize_yourvoic(text, language_code, voice, speed)
-    sf.write(output_path, audio, sr)
-    return output_path, sr
 
+        audio_parts, text_parts = [], []
+        for event in completion:
+            if not event.choices:
+                continue
+            delta = event.choices[0].delta
+            if hasattr(delta, "content") and delta.content:
+                text_parts.append(delta.content)
+            if hasattr(delta, "audio") and delta.audio:
+                if isinstance(delta.audio, dict) and "data" in delta.audio:
+                    audio_parts.append(delta.audio["data"])
+                elif hasattr(delta.audio, "data") and delta.audio.data:
+                    audio_parts.append(delta.audio.data)
+
+        transcript = "".join(text_parts).strip()
+        if not audio_parts:
+            return None, transcript, "No audio received from Qwen-Omni"
+
+        out_wav = os.path.join(out_dir, f"out_{uuid.uuid4().hex[:8]}.wav")
+        base64_to_wav("".join(audio_parts), out_wav)
+        return out_wav, transcript, None
 
+    except Exception as e:
+        return None, "", f"Qwen-Omni error: {e}"
 
 
-def synthesize_chunked(text, language_config, sentences_per_chunk=2):
-    """
-    Synthesize long text by chunking into sentence groups via YourVoic API.
-
-    Args:
-        text: Full text to synthesize
-        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)
-    """
-    sentences = re.split(r'(?<=[.!?])\s+', text)
-    sentences = [s.strip() for s in sentences if s.strip()]
-
-    if not sentences:
-        return np.zeros(int(0.5 * 16000), dtype=np.float32), 16000
-
-    audio_segments = []
-    output_sr = None
+def omni_audio_to_text(client: OpenAI,
+                       audio_path: str,
+                       source_hint: str,
+                       target_hint: str) -> tuple:
+    audio_uri = audio_file_to_data_uri(audio_path)
 
-    for i in range(0, len(sentences), sentences_per_chunk):
-        chunk_text = ' '.join(sentences[i:i + sentences_per_chunk])
-        if not chunk_text:
-            continue
+    sys_prompt = (
+        f"You are a translator. The user will speak in {source_hint}. "
+        f"Translate what they say into {target_hint}. "
+        f"Output ONLY the {target_hint} translation as plain text. No commentary, no quotes."
+    )
 
+    try:
+        completion = client.chat.completions.create(
+            model=OMNI_MODEL,
+            messages=[
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": [
+                    {"type": "input_audio",
+                     "input_audio": {"data": audio_uri, "format": "wav"}},
+                    {"type": "text",
+                     "text": f"Translate into {target_hint}."},
+                ]},
+            ],
+            modalities=["text"],
+        )
+        text = completion.choices[0].message.content.strip()
+        return text, None
+    except Exception as e:
+        return "", f"Qwen-Omni translation error: {e}"
+
+
+def yourvoic_speak(text: str,
+                   target_language: str,
+                   target_config: dict,
+                   api_key: str,
+                   out_dir: str) -> tuple:
+    yourvoic_lang = target_config["yourvoic_lang"]
+    voices_to_try = list(YOURVOIC_VOICE_MAP.get(target_language, ["Peter"]))
+    if "Peter" not in voices_to_try:
+        voices_to_try.append("Peter")
+
+    last_error = None
+    for voice in voices_to_try:
+        payload = {
+            "text": text,
+            "voice": voice,
+            "language": yourvoic_lang,
+            "model": YOURVOIC_MODEL,
+            "speed": 1.0,
+        }
         try:
-            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)
-                silence = np.zeros(int(0.15 * seg_sr), dtype=np.float32)
-                audio_segments.append(silence)
+            resp = http_requests.post(
+                YOURVOIC_TTS_URL,
+                json=payload,
+                headers={"X-API-Key": api_key, "Content-Type": "application/json"},
+                timeout=60,
+            )
+            if resp.status_code != 200:
+                last_error = f"YourVoic {resp.status_code}: {resp.text[:200]}"
+                if "voice" in resp.text.lower() or resp.status_code == 400:
+                    continue
+                return None, last_error
+
+            ctype = resp.headers.get("Content-Type", "")
+            ext = "mp3" if "mp3" in ctype.lower() else "wav"
+            raw_path = os.path.join(out_dir, f"yv_{uuid.uuid4().hex[:8]}.{ext}")
+
+            if "application/json" in ctype:
+                data = resp.json()
+                audio_url = data.get("audio_url") or data.get("url")
+                if not audio_url:
+                    return None, "No audio URL in YourVoic response"
+                audio_resp = http_requests.get(audio_url, timeout=60)
+                with open(raw_path, "wb") as f:
+                    f.write(audio_resp.content)
+            else:
+                with open(raw_path, "wb") as f:
+                    f.write(resp.content)
+
+            wav_path = os.path.join(out_dir, f"yv_{uuid.uuid4().hex[:8]}.wav")
+            subprocess.run(
+                ["ffmpeg", "-y", "-i", raw_path,
+                 "-ar", "24000", "-ac", "1", "-acodec", "pcm_s16le", wav_path],
+                capture_output=True, check=True,
+            )
+            return wav_path, None
 
         except Exception as e:
-            logger.error(f"TTS chunk failed: {e}")
+            last_error = f"YourVoic exception: {e}"
             continue
 
-    if not audio_segments:
-        fallback_sr = output_sr or 16000
-        logger.warning("All TTS chunks failed — returning silence")
-        return np.zeros(int(0.5 * fallback_sr), dtype=np.float32), fallback_sr
+    return None, last_error or "YourVoic failed for all candidate voices"
 
-    return np.concatenate(audio_segments), output_sr
 
+# ==========================================
+# SHARED TRANSLATION (used by both modes)
+# ==========================================
+def translate_audio_file(audio_file: str,
+                         source_language: str,
+                         target_language: str,
+                         qwen_voice_label: str,
+                         work_dir: str) -> tuple:
+    """Run audio_file through the pipeline. Returns (wav_path, transcript, error)."""
+    ds_key = os.environ.get("DASHSCOPE_API_KEY", "")
+    if not ds_key:
+        return None, "", "DASHSCOPE_API_KEY not set"
 
-# =============================================================================
-# QWEN OMNI ENGINE
-# =============================================================================
+    src_config = SOURCE_LANGUAGES[source_language]
+    tgt_config = TARGET_LANGUAGES[target_language]
+    client = OpenAI(api_key=ds_key, base_url=DASHSCOPE_BASE_URL)
 
-QWEN_MODEL = "qwen3.5-omni-plus"
-QWEN_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+    try:
+        norm_path = normalize_audio_file(audio_file, work_dir)
+    except subprocess.CalledProcessError as e:
+        return None, "", f"ffmpeg normalize failed: {(e.stderr or b'').decode()[:200]}"
 
+    engine = tgt_config["engine"]
 
-def _get_client():
-    """Create OpenAI-compatible client for Qwen Dashscope API."""
-    from openai import OpenAI
-    api_key = os.environ.get("DASHSCOPE_API_KEY", "")
-    if not api_key:
-        raise RuntimeError(
-            "DASHSCOPE_API_KEY not set. Add it as a Space secret."
+    if engine == "qwen":
+        voice = voice_name(qwen_voice_label)
+        return omni_audio_to_speech(
+            client, norm_path,
+            src_config["omni_hint"], tgt_config["omni_hint"],
+            voice, work_dir,
         )
-    return OpenAI(api_key=api_key, base_url=QWEN_BASE_URL)
-
-
-def _wav_to_base64(wav_path):
-    """Read WAV file and return base64 string."""
-    with open(wav_path, "rb") as f:
-        return base64.b64encode(f.read()).decode("utf-8")
-
-
-def _base64_to_wav(b64_data, output_path):
-    """Convert raw PCM base64 audio to WAV file (24kHz, mono, 16-bit)."""
-    audio_bytes = base64.b64decode(b64_data)
-    sample_rate = 24000
-    num_channels = 1
-    bits_per_sample = 16
-    byte_rate = sample_rate * num_channels * bits_per_sample // 8
-    block_align = num_channels * bits_per_sample // 8
-    data_size = len(audio_bytes)
-    with open(output_path, "wb") as f:
-        f.write(b"RIFF")
-        f.write(struct.pack("<I", 36 + data_size))
-        f.write(b"WAVE")
-        f.write(b"fmt ")
-        f.write(struct.pack("<I", 16))
-        f.write(struct.pack("<H", 1))
-        f.write(struct.pack("<H", num_channels))
-        f.write(struct.pack("<I", sample_rate))
-        f.write(struct.pack("<I", byte_rate))
-        f.write(struct.pack("<H", block_align))
-        f.write(struct.pack("<H", bits_per_sample))
-        f.write(b"data")
-        f.write(struct.pack("<I", data_size))
-        f.write(audio_bytes)
-
-
-def _extract_audio_chunk(video_path, output_wav, start_sec, duration_sec):
-    """Extract a chunk of audio from video as 16kHz mono WAV."""
-    subprocess.run(
-        ["ffmpeg", "-y", "-ss", str(start_sec), "-t", str(duration_sec),
-         "-i", video_path, "-vn", "-acodec", "pcm_s16le",
-         "-ar", "16000", "-ac", "1", output_wav],
-        capture_output=True, check=True,
-    )
 
+    elif engine == "yourvoic":
+        yv_key = os.environ.get("YOURVOIC_API_KEY", "")
+        if not yv_key:
+            return None, "", "YOURVOIC_API_KEY not set"
+        translated_text, err = omni_audio_to_text(
+            client, norm_path,
+            src_config["omni_hint"], tgt_config["omni_hint"],
+        )
+        if err or not translated_text:
+            return None, translated_text, err or "empty translation"
+        wav, yv_err = yourvoic_speak(
+            translated_text, target_language, tgt_config, yv_key, work_dir,
+        )
+        return wav, translated_text, yv_err
 
-def _get_duration(filepath):
-    """Get media file duration in seconds."""
-    result = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
-         "-of", "default=noprint_wrappers=1:nokey=1", filepath],
-        capture_output=True, text=True,
-    )
-    return float(result.stdout.strip())
+    return None, "", f"Unknown engine '{engine}'"
 
 
-def _concatenate_wavs(wav_files, output_path):
-    """Concatenate WAV files using ffmpeg."""
-    if len(wav_files) == 1:
-        shutil.copy2(wav_files[0], output_path)
+# ==========================================
+# SINGLE-CLIP MODE
+# ==========================================
+def single_clip_translate(audio_input,
+                          source_language: str,
+                          target_language: str,
+                          qwen_voice_label: str):
+    """Yield (audio_path, status_markdown, transcript) as work progresses."""
+    if audio_input is None:
+        yield None, "**Status:** no audio provided.", ""
         return
-    list_file = output_path + ".txt"
-    with open(list_file, "w") as f:
-        for wav in wav_files:
-            f.write(f"file '{wav}'\n")
-    subprocess.run(
-        ["ffmpeg", "-y", "-f", "concat", "-safe", "0",
-         "-i", list_file, "-c", "copy", output_path],
-        capture_output=True, check=True,
-    )
-    os.remove(list_file)
-
-
-def _build_system_prompt(language_name):
-    """Build Qwen system prompt for a target language."""
-    return (
-        f"You are a professional video dubbing translator. You will receive audio in English.\n"
-        f"Your task:\n"
-        f"1. Listen carefully to the English speech.\n"
-        f"2. Translate it into natural, fluent {language_name}.\n"
-        f"3. Respond ONLY with the {language_name} translation spoken aloud — no English, no commentary,\n"
-        f"   no meta-text, no transliteration. Speak entirely in {language_name}.\n"
-        f"4. Match the tone, emotion, and pacing of the original speaker as closely as possible.\n"
-        f"5. If there are pauses or silence in the original audio, maintain similar pacing.\n"
-        f"6. Translate idioms and cultural references into their {language_name} equivalents.\n"
-        f"7. Use clear, professional pronunciation suitable for a broad audience."
-    )
-
-
-def translate_chunk_qwen(wav_path, voice, language_name, chunk_index=0):
-    """
-    Translate a single audio chunk using Qwen Omni.
-    
-    Args:
-        wav_path: Path to input WAV file (English audio)
-        voice: Qwen voice name (e.g. "Ethan", "Cherry")
-        language_name: Full language name for the system prompt
-        chunk_index: For logging
-    
-    Returns:
-        (output_wav_path, transcript) or (None, transcript) if no audio
-    """
-    client = _get_client()
-    audio_b64 = _wav_to_base64(wav_path)
-    output_wav = wav_path.replace(".wav", f"_qwen_{chunk_index}.wav")
-
-    system_prompt = _build_system_prompt(language_name)
-    user_prompt = f"Translate this English speech into {language_name}. Respond only with the spoken {language_name} translation."
 
     t0 = time.time()
-    completion = client.chat.completions.create(
-        model=QWEN_MODEL,
-        messages=[
-            {"role": "system", "content": system_prompt},
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "input_audio",
-                        "input_audio": {
-                            "data": f"data:audio/wav;base64,{audio_b64}",
-                            "format": "wav",
-                        },
-                    },
-                    {"type": "text", "text": user_prompt},
-                ],
-            },
-        ],
-        modalities=["text", "audio"],
-        audio={"voice": voice, "format": "wav"},
-        stream=True,
-        stream_options={"include_usage": True},
+    work_dir = tempfile.mkdtemp(prefix="commentary_single_")
+    yield None, f"**Status:** translating {source_language} -> {target_language}...", ""
+    wav, transcript, err = translate_audio_file(
+        audio_input, source_language, target_language, qwen_voice_label, work_dir,
     )
-
-    audio_chunks = []
-    transcript_parts = []
-
-    for event in completion:
-        if not event.choices:
-            continue
-        delta = event.choices[0].delta
-        if hasattr(delta, "content") and delta.content:
-            transcript_parts.append(delta.content)
-        if hasattr(delta, "audio") and delta.audio:
-            if isinstance(delta.audio, dict):
-                if "data" in delta.audio:
-                    audio_chunks.append(delta.audio["data"])
-            elif hasattr(delta.audio, "data") and delta.audio.data:
-                audio_chunks.append(delta.audio.data)
-
-    transcript = "".join(transcript_parts)
+    if err:
+        yield None, f"**Error:** {err}", transcript or ""
+        return
     elapsed = time.time() - t0
-    logger.info(f"Qwen chunk {chunk_index}: {elapsed:.1f}s, transcript={transcript[:60]}")
-
-    if audio_chunks:
-        full_audio_b64 = "".join(audio_chunks)
-        _base64_to_wav(full_audio_b64, output_wav)
-        return output_wav, transcript
-
-    return None, transcript
-
-
-def dub_video_qwen(video_path, language_name, voice="Ethan", chunk_seconds=120, progress_fn=None):
-    """
-    Full video dubbing pipeline using Qwen Omni.
-    Splits video into chunks, translates each chunk via Qwen API,
-    concatenates results, and muxes back onto video.
-    
-    Args:
-        video_path: Path to input video
-        language_name: Full language name (e.g. "French", "Arabic")
-        voice: Qwen voice name
-        chunk_seconds: Audio chunk duration for API calls
-        progress_fn: Optional gradio progress callback
-    
-    Returns:
-        (output_video_path, log_text)
-    """
-    tmp_dir = tempfile.mkdtemp(prefix=f"qwen_dub_")
-    log = []
+    yield wav, f"**Done in {elapsed:.1f}s** - {source_language} -> {target_language}", transcript or ""
+
+
+# ==========================================
+# CONTINUOUS MODE -- per-session state
+# ==========================================
+@dataclass
+class LiveSession:
+    """Holds per-session state for continuous-mode streaming."""
+    work_dir: str
+    source_language: str
+    target_language: str
+    qwen_voice_label: str
+    buffer: list = field(default_factory=list)     # list of float32 numpy chunks
+    sample_rate: int = 16000
+    last_voice_ts: float = 0.0
+    in_utterance: bool = False
+    utterance_start_ts: float = 0.0
+    output_queue: "queue.Queue" = field(default_factory=queue.Queue)
+    transcripts: list = field(default_factory=list)
+    error_msg: str = ""
+    closed: bool = False
+
+
+def make_session(source_language: str,
+                 target_language: str,
+                 qwen_voice_label: str) -> LiveSession:
+    return LiveSession(
+        work_dir=tempfile.mkdtemp(prefix="commentary_live_"),
+        source_language=source_language,
+        target_language=target_language,
+        qwen_voice_label=qwen_voice_label,
+    )
+
 
+def session_translate_utterance(session: LiveSession, utterance_samples: np.ndarray) -> None:
+    """Background thread: translates one utterance, enqueues result."""
     try:
-        # Duration
-        if progress_fn:
-            progress_fn(0.05, desc="Analyzing video...")
-        total_duration = _get_duration(video_path)
-        log.append(f"**Video:** {total_duration:.1f}s")
-        log.append(f"**Engine:** Qwen 3.5 Omni")
-        log.append(f"**Voice:** {voice}")
-        log.append(f"**Language:** {language_name}")
-
-        if total_duration > 3600:
-            return None, "Video longer than 1 hour — please use a shorter clip."
-
-        # Split into chunks
-        if progress_fn:
-            progress_fn(0.1, desc="Extracting audio chunks...")
-        num_chunks = max(1, int(total_duration // chunk_seconds) + (1 if total_duration % chunk_seconds > 0 else 0))
-        log.append(f"**Chunks:** {num_chunks} ({chunk_seconds}s each)")
-
-        input_chunks = []
-        for i in range(num_chunks):
-            start = i * chunk_seconds
-            duration = min(chunk_seconds, total_duration - start)
-            chunk_path = os.path.join(tmp_dir, f"chunk_{i:03d}.wav")
-            _extract_audio_chunk(video_path, chunk_path, start, duration)
-            input_chunks.append(chunk_path)
-
-        # Translate each chunk
-        output_chunks = []
-        all_transcripts = []
-
-        for i, chunk_path in enumerate(input_chunks):
-            if progress_fn:
-                frac = 0.15 + 0.7 * (i / num_chunks)
-                progress_fn(frac, desc=f"Translating chunk {i+1}/{num_chunks}...")
-
-            result_path, transcript = translate_chunk_qwen(
-                chunk_path, voice, language_name, i
-            )
-            if transcript:
-                all_transcripts.append(f"**[{i+1}]** {transcript}")
+        utt_path = os.path.join(session.work_dir, f"utt_{uuid.uuid4().hex[:8]}.wav")
+        write_wav(utterance_samples, session.sample_rate, utt_path)
 
-            if result_path:
-                output_chunks.append(result_path)
-            else:
-                # Silence fallback
-                duration = _get_duration(chunk_path)
-                silence_path = os.path.join(tmp_dir, f"silence_{i:03d}.wav")
-                subprocess.run(
-                    ["ffmpeg", "-y", "-f", "lavfi",
-                     "-i", "anullsrc=r=24000:cl=mono",
-                     "-t", str(duration), "-acodec", "pcm_s16le", silence_path],
-                    capture_output=True, check=True,
-                )
-                output_chunks.append(silence_path)
-
-        # Concatenate
-        if progress_fn:
-            progress_fn(0.88, desc="Assembling audio...")
-        full_audio = os.path.join(tmp_dir, "full_dubbed.wav")
-        _concatenate_wavs(output_chunks, full_audio)
-
-        # Mux onto video
-        if progress_fn:
-            progress_fn(0.93, desc="Combining audio and video...")
-        output_video = os.path.join(tmp_dir, "dubbed_output.mp4")
-        subprocess.run(
-            ["ffmpeg", "-y", "-i", video_path, "-i", full_audio,
-             "-c:v", "copy", "-map", "0:v:0", "-map", "1:a:0",
-             "-shortest", output_video],
-            capture_output=True, check=True,
+        wav, transcript, err = translate_audio_file(
+            utt_path, session.source_language, session.target_language,
+            session.qwen_voice_label, session.work_dir,
         )
-
-        if progress_fn:
-            progress_fn(1.0, desc="Done!")
-
-        log.append(f"\n**Transcript:**")
-        log.extend(all_transcripts)
-
-        return output_video, "\n".join(log)
-
+        if err:
+            session.error_msg = err
+            return
+        if wav:
+            session.output_queue.put({"wav": wav, "transcript": transcript or ""})
     except Exception as e:
-        logger.exception("Qwen dubbing failed")
-        shutil.rmtree(tmp_dir, ignore_errors=True)
-        return None, f"Error: {str(e)}"
-
-
-# =============================================================================
-# GRADIO APP
-# =============================================================================
+        session.error_msg = f"Background translate error: {e}"
 
-# Load models at startup
-load_models()
 
-# =============================================================================
-# Helper functions
-# =============================================================================
-
-def get_voices_for_language(lang_name):
-    """Get available voices for a language based on its engine."""
-    config = LANGUAGES.get(lang_name, {})
-    engine = config.get("tts_engine", "local")
-    if engine == "qwen":
-        return QWEN_VOICES
-    elif engine == "yourvoic" and config.get("yourvoic_voices"):
-        return config["yourvoic_voices"]
-    elif engine == "local":
-        return ["Peter"]
-    return ["Peter"]
-
-
-def full_pipeline_audio(audio_input, target_language):
-    """Full pipeline: English audio → target language audio."""
-    if audio_input is None:
-        return None, "Please upload or record audio."
-
-    lang_config = LANGUAGES.get(target_language)
-    if not lang_config:
-        return None, f"Language '{target_language}' not configured."
+def session_process_chunk(session: LiveSession,
+                          sample_rate: int,
+                          chunk: np.ndarray) -> None:
+    """Called per streaming audio chunk. Updates session state,
+    fires utterance to background translation when silence detected."""
+    if session.closed:
+        return
 
-    sample_rate, audio_array = audio_input
-    audio_array = audio_array.astype(np.float32)
-    if audio_array.ndim > 1:
-        audio_array = audio_array.mean(axis=1)
-    if audio_array.max() > 1.0 or audio_array.min() < -1.0:
-        max_val = max(abs(audio_array.max()), abs(audio_array.min()))
-        if max_val > 0:
-            audio_array = audio_array / max_val
+    # Normalize to float32 mono
+    if chunk.ndim > 1:
+        chunk = chunk.mean(axis=1)
+    if chunk.dtype == np.int16:
+        chunk = chunk.astype(np.float32) / 32768.0
+    elif chunk.dtype != np.float32:
+        chunk = chunk.astype(np.float32)
+
+    # Resample if mic sample rate != 16kHz (cheap linear interp)
+    if sample_rate != session.sample_rate:
+        ratio = session.sample_rate / sample_rate
+        n_out = int(len(chunk) * ratio)
+        if n_out > 0:
+            chunk = np.interp(
+                np.linspace(0, len(chunk) - 1, n_out),
+                np.arange(len(chunk)),
+                chunk,
+            ).astype(np.float32)
+
+    now = time.time()
+
+    rms = float(np.sqrt(np.mean(chunk ** 2))) if len(chunk) > 0 else 0.0
+    is_voice = rms > VAD_RMS_THRESHOLD
+
+    if is_voice:
+        if not session.in_utterance:
+            session.in_utterance = True
+            session.utterance_start_ts = now
+            session.buffer = []
+        session.last_voice_ts = now
+        session.buffer.append(chunk)
+    else:
+        if session.in_utterance:
+            # Keep recording trailing silence so we don't cut mid-word
+            session.buffer.append(chunk)
 
-    log = []
-    total_start = time.time()
+    if not session.in_utterance:
+        return
 
-    # ASR
-    t0 = time.time()
-    english = transcribe(audio_array, sample_rate)
-    log.append(f"**ASR** ({time.time()-t0:.2f}s)\n{english}")
-    if not english:
-        return None, "ASR returned empty text."
+    utt_dur = now - session.utterance_start_ts
+    silence_dur = now - session.last_voice_ts
 
-    # MT
-    t0 = time.time()
-    nllb_code = lang_config["nllb"]
-    translated, en_sents, tgt_sents = translate_text(english, nllb_code, fast=False)
-    log.append(f"\n**Translation** ({time.time()-t0:.2f}s)")
-    for e, t in zip(en_sents, tgt_sents):
-        log.append(f"  EN: {e}\n  {target_language.upper()}: {t}")
-    if not translated:
-        return None, "Translation returned empty."
-
-    # TTS
-    t0 = time.time()
-    audio_out, sr_out = synthesize_chunked(
-        translated, lang_config
+    should_flush = (
+        utt_dur >= VAD_MAX_UTTERANCE_SEC or
+        (silence_dur >= VAD_SILENCE_SEC and utt_dur >= VAD_MIN_UTTERANCE_SEC)
     )
-    log.append(f"\n**TTS** ({time.time()-t0:.2f}s) = {len(audio_out)/sr_out:.1f}s audio")
-
-    total = time.time() - total_start
-    log.append(f"\n**Total: {total:.2f}s**")
-
-    return (sr_out, audio_out), "\n".join(log)
 
+    if should_flush and session.buffer:
+        all_samples = np.concatenate(session.buffer)
+        session.buffer = []
+        session.in_utterance = False
+        threading.Thread(
+            target=session_translate_utterance,
+            args=(session, all_samples),
+            daemon=True,
+        ).start()
+
+
+# ==========================================
+# CONTINUOUS MODE -- Gradio handlers
+# ==========================================
+def live_start(source_language, target_language, qwen_voice_label):
+    """Click Start: validate keys, create session, reveal mic + drain timer."""
+    ds_key = os.environ.get("DASHSCOPE_API_KEY", "")
+    if not ds_key:
+        return (
+            None,
+            "**Error:** DASHSCOPE_API_KEY not set in Space secrets.",
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=True),
+            gr.update(active=False), "", None,
+        )
+    tgt_engine = TARGET_LANGUAGES.get(target_language, {}).get("engine")
+    if tgt_engine == "yourvoic" and not os.environ.get("YOURVOIC_API_KEY", ""):
+        return (
+            None,
+            f"**Error:** YOURVOIC_API_KEY required for {target_language}.",
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=True),
+            gr.update(active=False), "", None,
+        )
 
-def full_pipeline_text(english_text, target_language, voice_name):
-    """Text-only pipeline: English text → target language audio."""
-    if not english_text or not english_text.strip():
-        return None, "Please enter English text."
-
-    lang_config = LANGUAGES.get(target_language)
-    if not lang_config:
-        return None, f"Language '{target_language}' not configured."
-
-    log = []
-    total_start = time.time()
-
-    # MT
-    t0 = time.time()
-    nllb_code = lang_config["nllb"]
-    translated, en_sents, tgt_sents = translate_text(english_text.strip(), nllb_code, fast=False)
-    log.append(f"**Translation** ({time.time()-t0:.2f}s)")
-    for e, t in zip(en_sents, tgt_sents):
-        log.append(f"  EN: {e}\n  {target_language.upper()}: {t}")
-    if not translated:
-        return None, "Translation returned empty."
-
-    # TTS
-    t0 = time.time()
-    audio_out, sr_out = synthesize_chunked(
-        translated, lang_config
+    session = make_session(source_language, target_language, qwen_voice_label)
+    return (
+        session,
+        f"**Live session active** ({source_language} -> {target_language}). "
+        "Press the record button on the microphone below to begin speaking.",
+        gr.update(visible=True),
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(active=True),
+        "",
+        None,
     )
-    log.append(f"\n**TTS** ({time.time()-t0:.2f}s) = {len(audio_out)/sr_out:.1f}s audio")
-
-    total = time.time() - total_start
-    log.append(f"\n**Total: {total:.2f}s**")
-
-    return (sr_out, audio_out), "\n".join(log)
-
-
-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, YourVoic for others.
-    """
-    if video_path is None:
-        return None, "Please upload a video."
-
-    if not target_languages:
-        return None, "Please select at least one target language."
-
-    results_log = []
-    output_videos = []
-
-    for lang_name in target_languages:
-        lang_config = LANGUAGES.get(lang_name)
-        if not lang_config:
-            results_log.append(f"**{lang_name}**: not configured, skipped")
-            continue
-
-        engine = lang_config.get("tts_engine", "local")
-        results_log.append(f"\n{'='*50}")
-        results_log.append(f"**Dubbing: {lang_name}** (engine: {engine})")
-        results_log.append(f"{'='*50}")
-
-        try:
-            if engine == "qwen":
-                # Qwen Omni: end-to-end speech-to-speech (best for global languages)
-                qwen_lang_name = lang_config.get("qwen_name", lang_name)
-                voice = dub_voice if dub_voice in QWEN_VOICES else "Ethan"
-                out_video, log_text = dub_video_qwen(
-                    video_path, qwen_lang_name, voice=voice,
-                    chunk_seconds=chunk_seconds, progress_fn=progress,
-                )
-                results_log.append(log_text)
-                if out_video:
-                    output_videos.append(out_video)
-
-            else:
-                # Local/YourVoic pipeline: ASR → NLLB → TTS
-                work_dir = tempfile.mkdtemp(prefix=f"dub_{lang_name}_")
-                extracted_audio = os.path.join(work_dir, "audio.wav")
-                tgt_audio_raw = os.path.join(work_dir, "tgt_raw.wav")
-                tgt_audio_aligned = os.path.join(work_dir, "tgt_aligned.wav")
-                output_video = os.path.join(work_dir, f"dubbed_{lang_name}.mp4")
-
-                progress(0.05, desc=f"{lang_name}: extracting audio...")
-                extract_audio_from_video(video_path, extracted_audio)
-                video_duration = get_media_duration(video_path)
-                results_log.append(f"Video: {video_duration:.1f}s")
-
-                audio_array, sr = sf.read(extracted_audio, dtype="float32")
-                if audio_array.ndim > 1:
-                    audio_array = audio_array.mean(axis=1)
-
-                progress(0.15, desc=f"{lang_name}: transcribing...")
-                t0 = time.time()
-                english = transcribe(audio_array, sr)
-                results_log.append(f"ASR: {time.time()-t0:.1f}s")
-                if not english:
-                    results_log.append("ASR empty — skipped")
-                    continue
-
-                progress(0.4, desc=f"{lang_name}: translating...")
-                t0 = time.time()
-                nllb_code = lang_config["nllb"]
-                translated, _, _ = translate_text(english, nllb_code, fast=True)
-                results_log.append(f"MT: {time.time()-t0:.1f}s")
-                if not translated:
-                    results_log.append("Translation empty — skipped")
-                    continue
-
-                progress(0.65, desc=f"{lang_name}: synthesizing...")
-                t0 = time.time()
-                tgt_audio, tgt_sr = synthesize_chunked(
-                    translated, lang_config
-                )
-                sf.write(tgt_audio_raw, tgt_audio, tgt_sr)
-                tgt_duration = len(tgt_audio) / tgt_sr
-                results_log.append(f"TTS: {time.time()-t0:.1f}s ({tgt_duration:.1f}s audio)")
-
-                progress(0.85, desc=f"{lang_name}: aligning...")
-                MAX_STRETCH = 1.2
-                stretch_ratio = tgt_duration / video_duration
-
-                if stretch_ratio <= MAX_STRETCH:
-                    if abs(stretch_ratio - 1.0) > 0.02:
-                        stretch_audio_to_duration(tgt_audio_raw, tgt_audio_aligned, video_duration)
-                    else:
-                        import shutil
-                        shutil.copy(tgt_audio_raw, tgt_audio_aligned)
-                    extend_video = False
-                    final_duration = video_duration
-                else:
-                    shutil.copy(tgt_audio_raw, tgt_audio_aligned)
-                    extend_video = True
-                    final_duration = tgt_duration
-                    results_log.append(f"Audio longer ({stretch_ratio:.1f}x) — extending video")
-
-                progress(0.95, desc=f"{lang_name}: combining...")
-                mux_video_audio(
-                    video_path, tgt_audio_aligned, output_video,
-                    extend_video=extend_video, target_duration=final_duration
-                )
-                output_videos.append(output_video)
-
-        except Exception as e:
-            logger.exception(f"Dubbing {lang_name} failed")
-            results_log.append(f"Error: {str(e)}")
-
-    progress(1.0, desc="Done!")
-    final_video = output_videos[0] if output_videos else None
-    return final_video, "\n".join(results_log)
-
-
-def update_voices(language):
-    """Update voice dropdown when language changes."""
-    voices = get_voices_for_language(language)
-    return gr.update(choices=voices, value=voices[0])
-
-
-# =============================================================================
-# Live Streaming Translation
-# =============================================================================
-
-class LiveStreamState:
-    """Manages audio buffer and transcript for live streaming mode."""
-    def __init__(self, chunk_duration_s=5):
-        self.chunk_duration_s = chunk_duration_s
-        self.audio_buffer = np.array([], dtype=np.float32)
-        self.buffer_sr = 16000
-        self.transcript_pairs = []
-        self.chunk_count = 0
-        self.total_time = 0.0
-        self.target_language = "Spanish"
-        self.target_voice = "Ethan"
 
-    def reset(self):
-        self.audio_buffer = np.array([], dtype=np.float32)
-        self.transcript_pairs = []
-        self.chunk_count = 0
-        self.total_time = 0.0
 
+def live_stop(session: Optional[LiveSession]):
+    """Click Stop: close session, hide mic, stop drain timer."""
+    if session is not None:
+        session.closed = True
+    return (
+        None,
+        "**Status:** session stopped. Click Start to begin a new one.",
+        gr.update(visible=False),
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(active=False),
+    )
 
-def live_stream_process(audio_chunk, target_language, target_voice, state):
-    """
-    Process streaming audio chunks for live translation.
-    Called repeatedly by Gradio's .stream() as mic audio arrives.
-    """
-    if state is None:
-        state = LiveStreamState()
 
-    state.target_language = target_language
-    state.target_voice = target_voice
+def live_on_stream(audio_chunk, session: Optional[LiveSession]):
+    """Called by streaming mic for every chunk. Must return State to keep it alive."""
+    if session is None or audio_chunk is None:
+        return session
+    try:
+        sample_rate, samples = audio_chunk
+    except (TypeError, ValueError):
+        return session
+    if samples is None:
+        return session
+    samples = np.asarray(samples)
+    if samples.size == 0:
+        return session
+    try:
+        session_process_chunk(session, sample_rate, samples)
+    except Exception as e:
+        session.error_msg = f"Stream chunk error: {e}"
+    return session
+
+
+def live_drain(session: Optional[LiveSession]):
+    """gr.Timer tick. Pops at most one finished translation per tick (sequential play)."""
+    if session is None or session.closed:
+        return None, gr.update(), gr.update()
+
+    if session.error_msg:
+        msg = session.error_msg
+        session.error_msg = ""
+        return (
+            None,
+            gr.update(),
+            f"**Background error:** {msg}",
+        )
 
-    if audio_chunk is None:
-        return None, _format_live_log(state), state
+    try:
+        item = session.output_queue.get_nowait()
+    except queue.Empty:
+        if session.in_utterance:
+            status = "**Status:** listening (in utterance)..."
+        else:
+            status = "**Status:** waiting for speech..."
+        return None, gr.update(), gr.update(value=status)
 
-    sample_rate, audio_data = audio_chunk
-    audio_data = audio_data.astype(np.float32)
-    if audio_data.ndim > 1:
-        audio_data = audio_data.mean(axis=1)
-    if len(audio_data) > 0:
-        mx = max(abs(audio_data.max()), abs(audio_data.min()))
-        if mx > 1.0:
-            audio_data = audio_data / mx
+    session.transcripts.append(item["transcript"])
+    transcript_md = "\n\n---\n\n".join(t for t in session.transcripts if t)
+    return item["wav"], transcript_md, "**Status:** playing translation"
 
-    state.buffer_sr = sample_rate
-    state.audio_buffer = np.concatenate([state.audio_buffer, audio_data])
 
-    required_samples = int(state.chunk_duration_s * sample_rate)
+# ==========================================
+# UI
+# ==========================================
+DESCRIPTION = """
+# Live Football Commentary Translator
 
-    if len(state.audio_buffer) < required_samples:
-        buffered_s = len(state.audio_buffer) / sample_rate
-        return None, _format_live_log(state, buffered_s), state
+Translate live commentary between languages.
 
-    chunk = state.audio_buffer[:required_samples]
-    state.audio_buffer = state.audio_buffer[required_samples:]
+**Sources:** English, Scottish English, German, Spanish, Arabic
+**Targets:** all of the above + Swahili, Amharic, Afrikaans
 
-    lang_config = LANGUAGES.get(target_language)
-    if not lang_config:
-        return None, f"Language '{target_language}' not configured.", state
+Two modes -- pick a tab below:
+- **Single clip:** record or upload one clip, get one translation.
+- **Continuous live:** start a session, speak naturally, hear translations queued and played in order.
 
-    t_start = time.time()
-    engine = lang_config.get("tts_engine", "yourvoic")
+Latency on free ZeroGPU: roughly 3-8 seconds per utterance.
+"""
 
-    try:
-        if engine == "qwen":
-            tmp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
-            sf.write(tmp_wav, chunk, sample_rate)
-            qwen_lang = lang_config.get("qwen_name", target_language)
-            voice = target_voice if target_voice in QWEN_VOICES else "Ethan"
-            result_wav, transcript = translate_chunk_qwen(tmp_wav, voice, qwen_lang, state.chunk_count)
-            os.unlink(tmp_wav)
-            english_text = "(Qwen end-to-end)"
-            translated_text = transcript or "(no transcript)"
-            if result_wav:
-                audio_out, sr_out = sf.read(result_wav, dtype="float32")
-            else:
-                audio_out, sr_out = None, None
-        else:
-            english_text = transcribe(chunk, sample_rate)
-            if not english_text:
-                return None, _format_live_log(state), state
-            nllb_code = lang_config["nllb"]
-            translated_text, _, _ = translate_text(english_text, nllb_code, fast=True)
-            if not translated_text:
-                return None, _format_live_log(state), state
-            audio_out, sr_out = synthesize_chunked(translated_text, lang_config)
 
-    except Exception as e:
-        logger.error(f"Live chunk failed: {e}")
-        return None, _format_live_log(state) + f"\n\n**Error:** {e}", state
-
-    elapsed = time.time() - t_start
-    state.chunk_count += 1
-    state.total_time += elapsed
-    state.transcript_pairs.append((english_text, translated_text))
-
-    if audio_out is not None and len(audio_out) > 0:
-        return (sr_out, audio_out), _format_live_log(state), state
-    return None, _format_live_log(state), state
-
-
-def _format_live_log(state, buffered_s=None):
-    lines = [f"**Chunks processed:** {state.chunk_count}"]
-    if state.chunk_count > 0:
-        lines.append(f"**Avg time:** {state.total_time / state.chunk_count:.1f}s/chunk")
-    if buffered_s is not None:
-        lines.append(f"**Buffering:** {buffered_s:.1f}s / {state.chunk_duration_s}s")
-    lines.append("\n---\n**Live transcript:**\n")
-    start = max(0, len(state.transcript_pairs) - 8)
-    for i in range(start, len(state.transcript_pairs)):
-        en, tgt = state.transcript_pairs[i]
-        lines.append(f"**[{i+1}]** EN: {en[:100]}")
-        lines.append(f"    {state.target_language}: {tgt[:100]}\n")
-    return "\n".join(lines)
-
-
-def clear_live_stream():
-    return None, "Stream cleared. Start recording to begin.", LiveStreamState()
-
-
-# =============================================================================
-# Gradio UI
-# =============================================================================
-
-EXAMPLES = [
-    "And it's a brilliant goal from the striker!",
-    "The referee has shown a yellow card. Corner kick for the home team.",
-    "What a save by the goalkeeper! The match is heading into injury time.",
-    "He dribbles past two defenders and shoots! The ball hits the back of the net!",
-]
+def on_target_change(target_lang_choice):
+    cfg = TARGET_LANGUAGES.get(target_lang_choice, {})
+    if cfg.get("engine") == "qwen":
+        return gr.update(visible=True)
+    return gr.update(visible=False)
 
-CSS = """
-.main-header { text-align: center; margin-bottom: 0.5rem; }
-.main-header h1 { font-size: 1.8rem; font-weight: 700; margin: 0; }
-.main-header p { color: #666; font-size: 0.95rem; }
-.lang-group-label { font-weight: 600; font-size: 0.85rem; color: #888; text-transform: uppercase; letter-spacing: 0.05em; margin-top: 0.5rem; }
-"""
 
-with gr.Blocks(
-    title="PlotWeaver — Live Commentary Translation",
-    theme=gr.themes.Soft(),
-    css=CSS,
-) as demo:
+with gr.Blocks(title="Live Football Commentary Translator") as demo:
+    gr.Markdown(DESCRIPTION)
 
-    gr.HTML("""
-    <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">Qwen Omni (11 languages) + YourVoic API + NLLB-200 (27 languages)</p>
-    </div>
-    """)
+    # ===== Shared language controls =====
+    with gr.Row():
+        source_lang = gr.Dropdown(
+            choices=list(SOURCE_LANGUAGES.keys()),
+            value="English",
+            label="Source (what the commentator speaks)",
+        )
+        target_lang = gr.Dropdown(
+            choices=list(TARGET_LANGUAGES.keys()),
+            value="Swahili",
+            label="Target (what you want to hear)",
+        )
+        qwen_voice = gr.Dropdown(
+            choices=QWEN_VOICES,
+            value=QWEN_VOICES[0],
+            label="Voice (Qwen targets only)",
+            visible=False,
+        )
 
+    # ===== Tabs =====
     with gr.Tabs():
 
-        # ====== TAB 1: EVENT MANAGEMENT ======
-        with gr.TabItem("Event Management"):
-            gr.Markdown("### Create new event")
-            gr.Markdown("Configure your live broadcast event with target languages and input source.")
-
+        # ---- Tab 1: Single clip ----
+        with gr.Tab("Single clip"):
             with gr.Row():
-                with gr.Column(scale=2):
-                    event_name = gr.Textbox(
-                        label="Event name",
-                        placeholder="e.g. Premier League: Arsenal vs. Chelsea",
-                    )
-                    with gr.Row():
-                        start_time = gr.Textbox(label="Start time", placeholder="08:30 PM")
-                        end_time = gr.Textbox(label="End time", placeholder="10:30 PM")
-                        event_date = gr.Textbox(label="Date", placeholder="2026-06-06")
-
-                    gr.Markdown("#### Input source")
-                    input_method = gr.Radio(
-                        choices=["RTMP Stream", "WebRTC (Browser)", "Direct Audio Feed"],
-                        value="RTMP Stream",
-                        label="Input method",
-                    )
-
-                    gr.Markdown("#### Target languages")
-                    gr.Markdown("Select languages for simultaneous broadcast. Additional languages consume more stream minutes.")
-
-                    # Language checkboxes grouped by category
-                    target_langs = gr.CheckboxGroup(
-                        choices=ALL_LANGUAGE_NAMES,
-                        label="Languages",
-                        value=["Spanish"],
-                    )
-
-                with gr.Column(scale=1):
-                    gr.Markdown("#### Estimate summary")
-                    estimate_display = gr.Markdown(
-                        value="**Event:** Not configured\n\n**Languages:** 1 selected\n\n**Estimated duration:** --\n\n**Total estimate:** --"
-                    )
-                    create_event_btn = gr.Button("Create Event", variant="primary", size="lg")
-                    event_status = gr.Markdown("")
-
-            def update_estimate(name, langs, start, end):
-                n_langs = len(langs) if langs else 0
-                lang_list = ", ".join(langs) if langs else "None"
-                return (
-                    f"**Event:** {name or 'Not set'}\n\n"
-                    f"**Languages:** {n_langs} selected\n\n"
-                    f"{lang_list}\n\n"
-                    f"**Input:** Configured\n\n"
-                    f"**Rate:** 1x (Standard)"
-                )
-
-            for inp in [event_name, target_langs, start_time, end_time]:
-                inp.change(
-                    fn=update_estimate,
-                    inputs=[event_name, target_langs, start_time, end_time],
-                    outputs=[estimate_display],
-                )
-
-            def create_event(name, langs):
-                if not name:
-                    return "Please enter an event name."
-                if not langs:
-                    return "Please select at least one language."
-                return f"Event **{name}** created with {len(langs)} languages: {', '.join(langs)}"
-
-            create_event_btn.click(
-                fn=create_event,
-                inputs=[event_name, target_langs],
-                outputs=[event_status],
-            )
-
-        # ====== TAB 2: LIVE STUDIO ======
-        with gr.TabItem("Live Studio"):
-            gr.Markdown("### Live Studio")
-
-            with gr.Tabs():
-                # ── Live Streaming Mode ──
-                with gr.TabItem("🔴 Live Translation"):
-                    gr.Markdown(
-                        "**Speak English into the mic** — the pipeline translates and plays back in your target language "
-                        "every 5 seconds. The transcript updates live below."
-                    )
-
-                    live_state = gr.State(LiveStreamState())
-
-                    with gr.Row():
-                        live_lang = gr.Dropdown(
-                            choices=ALL_LANGUAGE_NAMES, value="Spanish",
-                            label="Target language",
-                        )
-                        live_voice = gr.Dropdown(
-                            choices=get_voices_for_language("Spanish"),
-                            value=get_voices_for_language("Spanish")[0],
-                            label="Voice",
-                        )
-
-                    live_lang.change(fn=update_voices, inputs=[live_lang], outputs=[live_voice])
-
-                    with gr.Row():
-                        with gr.Column():
-                            live_mic = gr.Audio(
-                                label="Microphone (streaming)",
-                                type="numpy",
-                                sources=["microphone"],
-                                streaming=True,
+                with gr.Column():
+                    with gr.Tabs():
+                        with gr.Tab("Live microphone"):
+                            mic_input = gr.Audio(
+                                sources=["microphone"], type="filepath",
+                                label="Speak your commentary (short bursts, 5-15s each)",
                             )
-                            live_clear_btn = gr.Button("Clear & Reset", variant="secondary")
-
-                        with gr.Column():
-                            live_audio_out = gr.Audio(
-                                label="Translated output",
-                                type="numpy",
-                                autoplay=True,
+                            mic_btn = gr.Button("Translate microphone clip", variant="primary")
+                        with gr.Tab("Upload file"):
+                            file_input = gr.Audio(
+                                sources=["upload"], type="filepath",
+                                label="Upload an audio clip (.wav, .mp3, .m4a, etc.)",
                             )
-                            live_log = gr.Markdown(value="Click the mic to start recording.")
-
-                    live_mic.stream(
-                        fn=live_stream_process,
-                        inputs=[live_mic, live_lang, live_voice, live_state],
-                        outputs=[live_audio_out, live_log, live_state],
-                        time_limit=600,
-                        stream_every=1.0,
-                    )
+                            file_btn = gr.Button("Translate uploaded clip", variant="primary")
 
-                    live_clear_btn.click(
-                        fn=clear_live_stream,
-                        outputs=[live_audio_out, live_log, live_state],
+                with gr.Column():
+                    single_status = gr.Markdown(value="*Waiting for input...*")
+                    single_audio = gr.Audio(label="Translated audio", type="filepath", autoplay=True)
+                    single_transcript = gr.Textbox(
+                        label="Translated text", lines=4, interactive=False,
                     )
 
-                # ── Batch Upload Mode ──
-                with gr.TabItem("Upload / Record"):
-                    gr.Markdown("Upload or record a full audio clip, then translate it all at once.")
-
-                    with gr.Row():
-                        st_lang = gr.Dropdown(
-                            choices=ALL_LANGUAGE_NAMES, value="Spanish",
-                            label="Target language",
-                        )
-                        st_voice = gr.Dropdown(
-                            choices=get_voices_for_language("Spanish"),
-                            value=get_voices_for_language("Spanish")[0],
-                            label="Voice",
-                        )
-
-                    st_lang.change(fn=update_voices, inputs=[st_lang], outputs=[st_voice])
-
-                    with gr.Row():
-                        with gr.Column():
-                            st_in = gr.Audio(
-                                label="English audio",
-                                type="numpy",
-                                sources=["upload", "microphone"],
-                            )
-                            st_btn = gr.Button("Translate", variant="primary", size="lg")
-                        with gr.Column():
-                            st_out = gr.Audio(label="Translated audio", type="numpy", autoplay=True)
-                            st_log = gr.Markdown()
-
-                    st_btn.click(
-                        fn=full_pipeline_audio,
-                        inputs=[st_in, st_lang],
-                        outputs=[st_out, st_log],
-                    )
+            mic_btn.click(
+                fn=single_clip_translate,
+                inputs=[mic_input, source_lang, target_lang, qwen_voice],
+                outputs=[single_audio, single_status, single_transcript],
+            )
+            file_btn.click(
+                fn=single_clip_translate,
+                inputs=[file_input, source_lang, target_lang, qwen_voice],
+                outputs=[single_audio, single_status, single_transcript],
+            )
 
-        # ====== TAB 3: VIDEO DUBBING ======
-        with gr.TabItem("Video Dubbing"):
-            gr.Markdown("### Video dubbing (English → multi-language)")
+        # ---- Tab 2: Continuous live ----
+        with gr.Tab("Continuous live"):
             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/regional languages** use YourVoic API with NLLB translation."
+                "**How it works:**\n"
+                "1. Pick source and target languages above.\n"
+                "2. Click **Start Live Translation**.\n"
+                "3. Press the record button on the microphone that appears.\n"
+                "4. Speak naturally -- translations chunk at pauses and play in order.\n"
+                "5. Click **Stop** to end the session.\n"
             )
 
             with gr.Row():
                 with gr.Column():
-                    dub_video_in = gr.Video(label="Upload English video", sources=["upload"])
-                    dub_languages = gr.CheckboxGroup(
-                        choices=ALL_LANGUAGE_NAMES,
-                        label="Target languages",
-                        value=["Spanish"],
+                    start_btn = gr.Button("Start Live Translation", variant="primary", size="lg")
+                    stop_btn = gr.Button("Stop", variant="stop", visible=False)
+
+                    live_mic = gr.Audio(
+                        sources=["microphone"],
+                        streaming=True,
+                        type="numpy",
+                        label="Live microphone (press record to begin streaming)",
+                        visible=False,
                     )
-                    with gr.Row():
-                        dub_voice = gr.Dropdown(
-                            choices=QWEN_VOICES,
-                            value="Ethan",
-                            label="Voice (for Qwen languages)",
-                            info="Applies to Arabic, French, Spanish, etc. Local languages use default voice.",
-                        )
-                        dub_chunk_slider = gr.Slider(
-                            minimum=30, maximum=300, value=120, step=10,
-                            label="Chunk duration (seconds)",
-                            info="Shorter = more API calls but less timeout risk.",
-                        )
-                    dub_btn = gr.Button("Dub Video", variant="primary", size="lg")
 
                 with gr.Column():
-                    dub_video_out = gr.Video(label="Dubbed video (download from player)")
-                    dub_log = gr.Markdown(
-                        label="Processing log",
-                        value="Upload a video and select languages to start."
+                    live_status = gr.Markdown(value="*Click Start to begin.*")
+                    live_audio = gr.Audio(
+                        label="Translated audio (auto-plays each chunk in order)",
+                        type="filepath",
+                        autoplay=True,
                     )
-
-            dub_btn.click(
-                fn=dub_video,
-                inputs=[dub_video_in, dub_languages, dub_voice, dub_chunk_slider],
-                outputs=[dub_video_out, dub_log],
+                    live_transcripts = gr.Markdown(value="", label="Translation log")
+
+            # Hidden state + drain timer
+            live_state = gr.State(value=None)
+            drain_timer = gr.Timer(value=OUTPUT_POLL_SEC, active=False)
+
+            start_btn.click(
+                fn=live_start,
+                inputs=[source_lang, target_lang, qwen_voice],
+                outputs=[
+                    live_state, live_status, live_mic, stop_btn, start_btn,
+                    drain_timer, live_transcripts, live_audio,
+                ],
             )
 
-        # ====== TAB 4: TEXT TRANSLATION ======
-        with gr.TabItem("Text \u2192 Audio"):
-            gr.Markdown("### Text to translated speech")
-            gr.Markdown("Type English text, choose a language, and hear the translated audio.")
-
-            with gr.Row():
-                text_language = gr.Dropdown(
-                    choices=ALL_LANGUAGE_NAMES,
-                    value="Spanish",
-                    label="Target language",
-                )
-                text_voice = gr.Dropdown(
-                    choices=get_voices_for_language("Spanish"),
-                    value=get_voices_for_language("Spanish")[0],
-                    label="Voice",
-                )
-
-            text_language.change(
-                fn=update_voices,
-                inputs=[text_language],
-                outputs=[text_voice],
+            stop_btn.click(
+                fn=live_stop,
+                inputs=[live_state],
+                outputs=[
+                    live_state, live_status, live_mic, stop_btn, start_btn, drain_timer,
+                ],
             )
 
-            with gr.Row():
-                with gr.Column():
-                    text_input = gr.Textbox(
-                        label="English text",
-                        placeholder="Type English football commentary here...",
-                        lines=4,
-                    )
-                    text_btn = gr.Button("Translate to speech", variant="primary", size="lg")
-                    gr.Examples(
-                        examples=[[e] for e in EXAMPLES],
-                        inputs=[text_input],
-                        label="Example commentary",
-                    )
-
-                with gr.Column():
-                    text_audio_out = gr.Audio(label="Translated audio", type="numpy", autoplay=True)
-                    text_log = gr.Markdown(label="Pipeline log")
-
-            text_btn.click(
-                fn=full_pipeline_text,
-                inputs=[text_input, text_language, text_voice],
-                outputs=[text_audio_out, text_log],
+            live_mic.stream(
+                fn=live_on_stream,
+                inputs=[live_mic, live_state],
+                outputs=[live_state],
+                show_progress="hidden",
             )
 
-        # ====== TAB 5: RECORDINGS ======
-        with gr.TabItem("Recordings & Clips"):
-            gr.Markdown("### Recordings management")
-            gr.Markdown(
-                "Past dubbed recordings will appear here. "
-                "This feature is coming soon — for now, use Video Dubbing to create new recordings "
-                "and download them from the player."
+            drain_timer.tick(
+                fn=live_drain,
+                inputs=[live_state],
+                outputs=[live_audio, live_transcripts, live_status],
+                show_progress="hidden",
             )
 
-        # ====== TAB 6: VOICE MODELS ======
-        with gr.TabItem("Voice Models"):
-            gr.Markdown("### Voice model library")
-            gr.Markdown("Browse available voices for each language.")
+    # ===== Show/hide Qwen voice based on target =====
+    target_lang.change(fn=on_target_change, inputs=target_lang, outputs=qwen_voice)
+    demo.load(fn=on_target_change, inputs=target_lang, outputs=qwen_voice)
 
-            voice_lang_select = gr.Dropdown(
-                choices=ALL_LANGUAGE_NAMES,
-                value="Spanish",
-                label="Select language",
-            )
-            voice_info = gr.Markdown()
-
-            def show_voice_info(lang):
-                config = LANGUAGES.get(lang, {})
-                engine = config.get("tts_engine", "unknown")
-                voices = config.get("yourvoic_voices", [])
-
-                info = f"### {lang}\n\n"
-                if engine == "qwen":
-                    info += f"**Engine:** Qwen 3.5 Omni (end-to-end speech-to-speech)\n\n"
-                    info += f"This is the highest quality option. Qwen handles ASR + translation + TTS in a single API call, "
-                    info += f"preserving tone, emotion, and pacing from the original speaker.\n\n"
-                    info += f"**Available voices ({len(QWEN_VOICES)}):** {', '.join(QWEN_VOICES[:10])}... and {len(QWEN_VOICES)-10} more\n\n"
-                    info += f"All voices support all Qwen languages."
-                elif engine == "yourvoic":
-                    info += f"**Engine:** YourVoic API (TTS) + NLLB-200 (translation)\n\n"
-                    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:** 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."
-
-                return info
-
-            voice_lang_select.change(fn=show_voice_info, inputs=[voice_lang_select], outputs=[voice_info])
-            demo.load(fn=show_voice_info, inputs=[voice_lang_select], outputs=[voice_info])
-
-    gr.Markdown("""
----
-**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://yourvoic.com) |
-[Qwen Omni](https://www.alibabacloud.com/help/en/model-studio/qwen-omni)
-""")
+    gr.Markdown(
+        "---\n"
+        "**Architecture:** Qwen-Omni (`qwen3.5-omni-plus`) handles audio to speech for "
+        "English / Scottish-EN / German / Spanish / Arabic. For Swahili / Amharic / Afrikaans: "
+        "Omni translates to text, then YourVoic speaks it."
+    )
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(ssr_mode=False, show_api=False)

requirements.txt

@@ -1,10 +1,4 @@
-torch>=2.0.0
-torchaudio>=2.0.0
-transformers>=4.36.0
-accelerate>=0.25.0
-soundfile>=0.12.0
+gradio==5.42.0
+openai>=1.40.0
+requests>=2.31.0
 numpy>=1.24.0
-gradio>=5.0.0
-audioop-lts
-requests>=2.28.0
-openai>=1.0.0