Uzbek Multi-Engine TTS — Gradio web interface

6 TTS engines (Gemini, Edge, OmniVoice, MMS-TTS, Aisha, ElevenLabs)
with dynamic voice selection (male/female) and single-output UI.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,7 @@
+.env
+out/
+__pycache__/
+*.pyc
+*.wav
+*.mp3
+*.ogg

111.txt

@@ -0,0 +1,31 @@
+Erkak (Sotuvchi): Assalomu alaykum! "Premium Motors" avtosaloni, sotuv bo‘limi menejeri Azizman. Eshitaman?
+
+Ayol (Xaridor): Va alaykum assalom. Yaxshimisiz, Aziz? Men internetdagi e’loningiz bo‘yicha qo‘ng‘iroq qilayotgandim. Oq rangdagi Chevrolet Tracker (Premier pozitsiyasi) bor deb yozilgan ekan. Hozir sotuvda bormi shu model?
+
+Erkak: Ha, albatta. Aynan o‘sha modeldan hozir omborimizda ikkita qoldi. Biri oq, biri qora rangda. Sizni aynan oq rangdagisi qiziqtiryaptimi?
+
+Ayol: Ha, oq rangi ma’qulroq. Narxi e’londa ko‘rsatilganidekmi yoki o‘zgardimi? Va yana bir narsa — agar hozir sotib olsam, rasmiylashtirish qancha vaqt oladi?
+
+Erkak: Narxi hozirgi kunda 285 million so‘m. Bu rasmiy narx. Agar naqd to‘lov yoki pul o‘tkazish yo‘li bilan bo‘lsa, hujjatlarni 1 soat ichida rasmiylashtirib, mashinani o‘sha kunning o‘zida olib ketishingiz mumkin.
+
+Ayol: Tushunarli. Keyin, mashinaning texnik holati haqida so‘ramoqchi edim. Bu 2024 yilgi modelmi? Lyuk va monitorlari bor-a?
+
+Erkak: Juda to‘g‘ri savol berdingiz.
+
+Yili: 2024 yil, mutlaqo yangi.
+
+Komplektatsiya: Premier. Bu eng yuqori pozitsiya. Panoramali lyuk, katta sensorli monitor, orqani ko‘rish kamerasi va o‘rindiqlarni isitish tizimlari hammasi bor.
+
+Kafolat: 3 yil yoki 100 000 km masofaga rasmiy kafolat beramiz.
+
+Ayol: Yaxshi. To‘lov masalasida-chi? Bo‘lib to‘lash yoki avtokreditga imkoniyat bormi?
+
+Erkak: Ha, bor. Biz bir nechta banklar bilan hamkorlik qilamiz. Agar 30% oldindan to‘lov qilsangiz, qolgan summani 3 yilgacha bo‘lib to‘lashingiz mumkin. Faqat buning uchun pasportingiz bo‘lsa kifoya.
+
+Ayol: Juda soz. Men bugun tushdan keyin soat 4 larda borib, mashinani ko‘rsam bo‘ladimi? "Test-drayv" qilib ko‘rish imkoni bormi?
+
+Erkak: Albatta! Biz soat 19:00 gacha ishlaymiz. Kelganingizda ismim Aziz, deb so‘rasangiz, sizni kutib olaman va test-drayv uyushtirib beraman. Mashinani haydab ko‘rib, o‘zingiz baho berasiz.
+
+Ayol: Kelishdik, Aziz. Rahmat sizga, borganda ko‘rishamiz.
+
+Erkak: Salomat bo‘ling, kutamiz!

README.md

@@ -1,12 +1,31 @@
 ---
-title: TTS
-emoji: 🏃
-colorFrom: yellow
-colorTo: pink
+title: Uzbek Multi-Engine TTS
+emoji: 🎙️
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.11.0
+sdk_version: "6.11.0"
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Uzbek Multi-Engine TTS
+
+Compare 6 different TTS engines for Uzbek language speech synthesis:
+
+- **Gemini TTS** — Google Gemini 2.5 Pro Preview TTS
+- **Edge TTS** — Microsoft Edge Read-Aloud (free, no API key)
+- **OmniVoice** — k2-fsa/OmniVoice (600+ languages, open source)
+- **MMS-TTS** — Meta facebook/mms-tts-uzb-script_cyrillic
+- **Aisha Group** — Uzbek TTS REST API
+- **ElevenLabs** — eleven_v3 multilingual model
+
+## Setup
+
+Set the following **Secrets** in your Space settings:
+
+- `GEMINI_API_KEY`
+- `AISHA_API_KEY`
+- `ELEVENLABS_API_KEY`
+
+Edge TTS, MMS-TTS, and OmniVoice work without API keys.

app.py

@@ -0,0 +1,272 @@
+"""
+Uzbek Multi-Engine TTS — Gradio Web Interface.
+
+Launch:  python app.py
+Open:    http://localhost:7860
+"""
+
+import os
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()  # loads .env from project root (if present)
+except ImportError:
+    pass  # python-dotenv not installed; rely on system env vars (HF Secrets)
+
+import gradio as gr
+
+from engines import ENGINES
+from engines._common import normalize_uzbek
+
+ROOT = Path(__file__).parent
+DEFAULT_TEXT = ROOT / "111.txt"
+
+try:
+    _raw = DEFAULT_TEXT.read_bytes().decode("utf-8-sig")
+    SAMPLE_TEXT = normalize_uzbek(_raw)
+except Exception:
+    SAMPLE_TEXT = "Assalomu alaykum!"
+
+# ---------------------------------------------------------------------------
+# Engine metadata
+# ---------------------------------------------------------------------------
+ENGINE_INFO = {
+    "gemini": {
+        "label": "Gemini TTS (Pro)",
+        "has_voices": True,
+        "male_voices": ["Charon", "Puck", "Fenrir", "Orus", "Gacrux", "Sadaltager"],
+        "female_voices": ["Kore", "Aoede", "Leda", "Zephyr", "Laomedeia", "Achernar"],
+        "default_male": "Charon",
+        "default_female": "Kore",
+    },
+    "edge": {
+        "label": "Edge TTS (free)",
+        "has_voices": True,
+        "male_voices": ["uz-UZ-SardorNeural"],
+        "female_voices": ["uz-UZ-MadinaNeural"],
+        "default_male": "uz-UZ-SardorNeural",
+        "default_female": "uz-UZ-MadinaNeural",
+    },
+    "omnivoice": {
+        "label": "OmniVoice (CPU, slow!)",
+        "has_voices": True,
+        "male_voices": [
+            "male, middle-aged, moderate pitch",
+            "male, young adult, low pitch",
+            "male, young adult, high pitch",
+            "male, elderly, low pitch",
+        ],
+        "female_voices": [
+            "female, young adult, moderate pitch",
+            "female, middle-aged, high pitch",
+            "female, teenager, high pitch",
+        ],
+        "default_male": "male, middle-aged, moderate pitch",
+        "default_female": "female, young adult, moderate pitch",
+    },
+    "mms": {
+        "label": "MMS-TTS (local)",
+        "has_voices": False,
+        "info": "Single speaker model — same voice for both roles.",
+    },
+    "aisha": {
+        "label": "Aisha Group",
+        "has_voices": False,
+        "info": "Only 'gulnoza' (female) voice available.",
+    },
+    "elevenlabs": {
+        "label": "ElevenLabs",
+        "has_voices": True,
+        "male_voices": ["George", "Brian", "Daniel", "Charlie", "Callum", "Liam"],
+        "female_voices": ["Sarah", "Alice", "Lily", "Laura", "Matilda", "Jessica"],
+        "default_male": "George",
+        "default_female": "Sarah",
+    },
+}
+
+ENGINE_KEYS = list(ENGINE_INFO.keys())
+ENGINE_LABELS = [ENGINE_INFO[k]["label"] for k in ENGINE_KEYS]
+LABEL_TO_KEY = {ENGINE_INFO[k]["label"]: k for k in ENGINE_KEYS}
+
+
+# ---------------------------------------------------------------------------
+# Generation handler
+# ---------------------------------------------------------------------------
+def generate(text, engine_label, male_voice, female_voice,
+             progress=gr.Progress(track_tqdm=True)):
+    text = normalize_uzbek(text.strip())
+    if not text:
+        return None, "**Error:** No text provided.", ""
+    if not engine_label:
+        return None, "**Error:** No engine selected.", ""
+
+    key = LABEL_TO_KEY.get(engine_label)
+    if not key:
+        return None, f"**Error:** Unknown engine '{engine_label}'.", ""
+
+    info = ENGINE_INFO[key]
+    engine = ENGINES[key]
+    progress(0, desc=f"Generating with {engine_label}...")
+
+    # Pick the voice to use. For single-voice engines, use the female voice
+    # or the only available one. The male_voice is available for future
+    # multi-speaker dialogue rendering.
+    voice = female_voice or male_voice
+
+    kwargs = {}
+    if key == "gemini":
+        kwargs["api_key"] = os.environ.get("GEMINI_API_KEY", "")
+        kwargs["voice"] = voice
+    elif key == "edge":
+        kwargs["voice"] = voice
+    elif key == "omnivoice":
+        kwargs["instruct"] = voice
+    elif key == "aisha":
+        kwargs["api_key"] = os.environ.get("AISHA_API_KEY", "")
+    elif key == "elevenlabs":
+        kwargs["api_key"] = os.environ.get("ELEVENLABS_API_KEY", "")
+        kwargs["voice"] = voice
+
+    try:
+        result = engine.synthesize(text=text, **kwargs)
+    except Exception as e:
+        return None, f"**Error:** {e}", f"[{engine_label}] EXCEPTION: {e}"
+
+    if result.error:
+        return None, f"**Error:** {result.error}", f"[{engine_label}] {result.error}"
+
+    meta = (
+        f"**Engine:** {engine_label}  \n"
+        f"**Model:** `{result.model}`  \n"
+        f"**Voice:** {result.voice}  \n"
+        f"**Male voice selected:** {male_voice or 'N/A'}  \n"
+        f"**Female voice selected:** {female_voice or 'N/A'}  \n"
+        f"**Duration:** {result.duration_sec:.1f}s  \n"
+        f"**Generation time:** {result.generation_time_sec:.1f}s  \n"
+        f"**Format:** {result.format}"
+        + (f" @ {result.sample_rate} Hz" if result.sample_rate else "")
+    )
+    log = (f"[{engine_label}] Done — {result.duration_sec:.1f}s audio "
+           f"in {result.generation_time_sec:.1f}s")
+    return result.audio_path, meta, log
+
+
+# ---------------------------------------------------------------------------
+# Dynamic UI: update voice dropdowns when engine changes
+# ---------------------------------------------------------------------------
+def on_engine_change(engine_label):
+    if not engine_label:
+        return (
+            gr.update(visible=False, choices=[], value=None),
+            gr.update(visible=False, choices=[], value=None),
+            gr.update(visible=False, value=""),
+        )
+
+    key = LABEL_TO_KEY.get(engine_label, "")
+    info = ENGINE_INFO.get(key, {})
+    has = info.get("has_voices", False)
+
+    if has:
+        return (
+            gr.update(visible=True,
+                      choices=info["male_voices"],
+                      value=info["default_male"]),
+            gr.update(visible=True,
+                      choices=info["female_voices"],
+                      value=info["default_female"]),
+            gr.update(visible=False, value=""),
+        )
+    else:
+        return (
+            gr.update(visible=False, choices=[], value=None),
+            gr.update(visible=False, choices=[], value=None),
+            gr.update(visible=True, value=info.get("info", "")),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Build Gradio UI
+# ---------------------------------------------------------------------------
+def build_app():
+    with gr.Blocks(title="Uzbek Multi-Engine TTS") as demo:
+        gr.Markdown("# Uzbek Multi-Engine TTS")
+        gr.Markdown("Select an engine, choose voices, and generate speech.")
+
+        with gr.Row():
+            # ---- LEFT COLUMN ----
+            with gr.Column(scale=2):
+                txt_input = gr.Textbox(
+                    label="Uzbek Text",
+                    value=SAMPLE_TEXT,
+                    lines=10,
+                    max_lines=10,
+                    placeholder="Paste Uzbek text here...",
+                )
+
+                engine_selector = gr.Dropdown(
+                    choices=ENGINE_LABELS,
+                    value="Edge TTS (free)",
+                    label="Select Engine",
+                    info="Scroll to browse all available engines",
+                    filterable=True,
+                )
+
+                engine_info_md = gr.Markdown("", visible=False)
+
+                with gr.Row():
+                    male_voice = gr.Dropdown(
+                        choices=["uz-UZ-SardorNeural"],
+                        value="uz-UZ-SardorNeural",
+                        label="Male Voice",
+                        filterable=True,
+                        visible=True,
+                    )
+                    female_voice = gr.Dropdown(
+                        choices=["uz-UZ-MadinaNeural"],
+                        value="uz-UZ-MadinaNeural",
+                        label="Female Voice",
+                        filterable=True,
+                        visible=True,
+                    )
+
+                generate_btn = gr.Button(
+                    "Generate", variant="primary", size="lg",
+                )
+
+            # ---- RIGHT COLUMN: single output ----
+            with gr.Column(scale=3):
+                audio_out = gr.Audio(
+                    label="Output Audio",
+                    type="filepath",
+                )
+                meta_out = gr.Markdown("*Select an engine and click Generate.*")
+                log_out = gr.Textbox(
+                    label="Log",
+                    lines=3,
+                    interactive=False,
+                )
+
+        # ---- Dynamic UI wiring ----
+        engine_selector.change(
+            fn=on_engine_change,
+            inputs=[engine_selector],
+            outputs=[male_voice, female_voice, engine_info_md],
+        )
+
+        generate_btn.click(
+            fn=generate,
+            inputs=[txt_input, engine_selector, male_voice, female_voice],
+            outputs=[audio_out, meta_out, log_out],
+        )
+
+    return demo
+
+
+# ---------------------------------------------------------------------------
+# Launch
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    app = build_app()
+    app.queue(default_concurrency_limit=1)
+    app.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())

engines/__init__.py

@@ -0,0 +1,19 @@
+"""TTS engine registry."""
+
+from . import (
+    engine_gemini,
+    engine_edge,
+    engine_omnivoice,
+    engine_mms,
+    engine_aisha,
+    engine_elevenlabs,
+)
+
+ENGINES = {
+    "gemini": engine_gemini,
+    "edge": engine_edge,
+    "omnivoice": engine_omnivoice,
+    "mms": engine_mms,
+    "aisha": engine_aisha,
+    "elevenlabs": engine_elevenlabs,
+}

engines/_common.py

@@ -0,0 +1,105 @@
+"""Shared utilities for all TTS engine modules."""
+
+import re
+import tempfile
+import wave
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class TTSResult:
+    """Uniform result container returned by every engine."""
+    engine: str
+    model: str
+    voice: str
+    audio_path: str
+    format: str                    # "wav" or "mp3"
+    sample_rate: Optional[int]
+    duration_sec: float
+    generation_time_sec: float
+    error: Optional[str] = None
+
+
+def normalize_uzbek(text: str) -> str:
+    """Normalize curly quotes to standard Uzbek modifier letters."""
+    return text.replace("\u2018", "\u02bb").replace("\u2019", "\u02bc")
+
+
+def get_temp_path(suffix: str) -> str:
+    f = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+    f.close()
+    return f.name
+
+
+def write_wav(path: str, pcm: bytes, channels=1, rate=24000, sample_width=2):
+    with wave.open(path, "wb") as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width)
+        wf.setframerate(rate)
+        wf.writeframes(pcm)
+
+
+def get_wav_duration(path: str) -> float:
+    with wave.open(path, "rb") as wf:
+        return wf.getnframes() / wf.getframerate()
+
+
+def get_audio_duration(path: str, fmt: str) -> float:
+    if fmt == "wav":
+        return get_wav_duration(path)
+    # For mp3, estimate from file size (128 kbps ≈ 16 KB/s)
+    import os
+    size = os.path.getsize(path)
+    return size / 16000.0
+
+
+# ---------------------------------------------------------------------------
+# Latin Uzbek → Cyrillic Uzbek transliteration (for MMS-TTS).
+# ---------------------------------------------------------------------------
+_LAT2CYR_PAIRS = [
+    ("o\u02bb", "\u045e"), ("O\u02bb", "\u040e"),
+    ("g\u02bb", "\u0493"), ("G\u02bb", "\u0492"),
+    ("sh", "\u0448"), ("Sh", "\u0428"), ("SH", "\u0428"),
+    ("ch", "\u0447"), ("Ch", "\u0427"), ("CH", "\u0427"),
+    ("yo", "\u0451"), ("Yo", "\u0401"), ("YO", "\u0401"),
+    ("yu", "\u044e"), ("Yu", "\u042e"), ("YU", "\u042e"),
+    ("ya", "\u044f"), ("Ya", "\u042f"), ("YA", "\u042f"),
+    ("ts", "\u0446"), ("Ts", "\u0426"), ("TS", "\u0426"),
+    ("\u02bc", "\u044a"), ("'", "\u044a"), ("`", "\u044a"),
+    ("a", "\u0430"), ("A", "\u0410"),
+    ("b", "\u0431"), ("B", "\u0411"),
+    ("d", "\u0434"), ("D", "\u0414"),
+    ("e", "\u0435"), ("E", "\u0415"),
+    ("f", "\u0444"), ("F", "\u0424"),
+    ("g", "\u0433"), ("G", "\u0413"),
+    ("h", "\u04b3"), ("H", "\u04b2"),
+    ("i", "\u0438"), ("I", "\u0418"),
+    ("j", "\u0436"), ("J", "\u0416"),
+    ("k", "\u043a"), ("K", "\u041a"),
+    ("l", "\u043b"), ("L", "\u041b"),
+    ("m", "\u043c"), ("M", "\u041c"),
+    ("n", "\u043d"), ("N", "\u041d"),
+    ("o", "\u043e"), ("O", "\u041e"),
+    ("p", "\u043f"), ("P", "\u041f"),
+    ("q", "\u049b"), ("Q", "\u049a"),
+    ("r", "\u0440"), ("R", "\u0420"),
+    ("s", "\u0441"), ("S", "\u0421"),
+    ("t", "\u0442"), ("T", "\u0422"),
+    ("u", "\u0443"), ("U", "\u0423"),
+    ("v", "\u0432"), ("V", "\u0412"),
+    ("x", "\u0445"), ("X", "\u0425"),
+    ("y", "\u0439"), ("Y", "\u0419"),
+    ("z", "\u0437"), ("Z", "\u0417"),
+]
+
+
+def lat_to_cyr(text: str) -> str:
+    """Transliterate Latin Uzbek to Cyrillic Uzbek."""
+    for src, dst in _LAT2CYR_PAIRS:
+        text = text.replace(src, dst)
+    # Word-initial "е" → "э" in Uzbek Cyrillic.
+    cyr_chars = "\u0430-\u044f\u0451\u0410-\u042f\u0401\u045e\u0493\u049b\u04b3\u040e\u0492\u049a\u04b2"
+    text = re.sub(f"(^|[^{cyr_chars}])\u0435", lambda m: m.group(1) + "\u044d", text)
+    text = re.sub(f"(^|[^{cyr_chars}])\u0415", lambda m: m.group(1) + "\u042d", text)
+    return text

engines/engine_aisha.py

@@ -0,0 +1,90 @@
+"""Aisha Group TTS engine — REST API (gulnoza voice only)."""
+
+import re
+import time
+
+import requests
+
+from ._common import TTSResult, get_temp_path
+
+API_URL = "https://back.aisha.group/api/v1/tts/post/"
+
+
+def get_config():
+    return {
+        "name": "Aisha Group",
+        "model": "Aisha TTS API",
+        "voices": {"gulnoza": "female"},
+        "needs_api_key": True,
+        "api_key_env": "AISHA_API_KEY",
+        "output_format": "wav",
+    }
+
+
+def synthesize(text: str, voice: str = "gulnoza", api_key: str = None,
+               mood: str = "neutral", **kwargs) -> TTSResult:
+    if not api_key:
+        return TTSResult(
+            engine="aisha", model="Aisha TTS API", voice=voice,
+            audio_path="", format="wav", sample_rate=None,
+            duration_sec=0, generation_time_sec=0,
+            error="Aisha API key is required.",
+        )
+
+    headers = {
+        "x-api-key": api_key,
+        "X-Channels": "stereo",
+        "X-Quality": "64k",
+        "X-Rate": "16000",
+        "X-Format": "mp3",
+    }
+    data = {"transcript": text, "language": "uz", "model": voice, "mood": mood}
+
+    t0 = time.time()
+    for attempt in range(5):
+        r = requests.post(
+            API_URL, headers=headers,
+            files={k: (None, v) for k, v in data.items()},
+            timeout=120,
+        )
+        if r.status_code == 429:
+            try:
+                wait = int(re.search(r"(\d+)", r.json().get("detail", "")).group(1))
+            except Exception:
+                wait = 10
+            time.sleep(wait + 1)
+            continue
+        break
+    elapsed = time.time() - t0
+
+    if r.status_code not in (200, 201):
+        return TTSResult(
+            engine="aisha", model="Aisha TTS API", voice=voice,
+            audio_path="", format="wav", sample_rate=None,
+            duration_sec=0, generation_time_sec=elapsed,
+            error=f"HTTP {r.status_code}: {r.text[:200]}",
+        )
+
+    j = r.json()
+    url = j.get("audio_path") or j.get("audio_url") or j.get("url")
+    if not url:
+        return TTSResult(
+            engine="aisha", model="Aisha TTS API", voice=voice,
+            audio_path="", format="wav", sample_rate=None,
+            duration_sec=0, generation_time_sec=elapsed,
+            error=f"No audio_path in response: {j}",
+        )
+
+    audio_resp = requests.get(url, timeout=120)
+    audio_resp.raise_for_status()
+
+    out = get_temp_path(".wav")
+    with open(out, "wb") as f:
+        f.write(audio_resp.content)
+    dur = len(audio_resp.content) / (16000 * 2)  # rough estimate
+
+    return TTSResult(
+        engine="aisha", model="Aisha TTS API", voice=voice,
+        audio_path=out, format="wav", sample_rate=None,
+        duration_sec=dur, generation_time_sec=elapsed,
+    )

engines/engine_edge.py

@@ -0,0 +1,48 @@
+"""Edge TTS engine — Microsoft Edge Read-Aloud (free, no API key)."""
+
+import asyncio
+import os
+import time
+
+import edge_tts
+
+from ._common import TTSResult, get_temp_path
+
+
+def get_config():
+    return {
+        "name": "Edge TTS",
+        "model": "Microsoft Edge Read-Aloud (Azure Neural)",
+        "voices": {"uz-UZ-SardorNeural": "male", "uz-UZ-MadinaNeural": "female"},
+        "needs_api_key": False,
+        "output_format": "mp3",
+    }
+
+
+def synthesize(text: str, voice: str = "uz-UZ-MadinaNeural", **kwargs) -> TTSResult:
+    out = get_temp_path(".mp3")
+
+    async def _do():
+        comm = edge_tts.Communicate(text=text, voice=voice)
+        await comm.save(out)
+
+    t0 = time.time()
+    try:
+        asyncio.get_running_loop()
+        # Inside a running loop (unlikely in Gradio thread pool, but safe).
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            pool.submit(lambda: asyncio.run(_do())).result()
+    except RuntimeError:
+        asyncio.run(_do())
+    elapsed = time.time() - t0
+
+    size = os.path.getsize(out)
+    # MP3 128 kbps ≈ 16 KB/s
+    dur = size / 16000.0
+
+    return TTSResult(
+        engine="edge", model="Edge Read-Aloud (Azure Neural)",
+        voice=voice, audio_path=out, format="mp3",
+        sample_rate=None, duration_sec=dur, generation_time_sec=elapsed,
+    )

engines/engine_elevenlabs.py

@@ -0,0 +1,86 @@
+"""ElevenLabs TTS engine — eleven_v3 multilingual (REST API, bypass buggy SDK)."""
+
+import os
+import time
+
+import requests
+
+from ._common import TTSResult, get_temp_path
+
+MODEL_ID = "eleven_v3"
+OUTPUT_FMT = "mp3_44100_128"
+
+VOICES = {
+    "George": ("JBFqnCBsd6RMkjVDRZzb", "male"),
+    "Sarah": ("EXAVITQu4vr4xnSDxMaL", "female"),
+    "Alice": ("Xb7hH8MSUJpSbSDYk0k2", "female"),
+    "Brian": ("nPczCjzI2devNBz1zQrb", "male"),
+    "Lily": ("pFZP5JQG7iQjIQuC4Bku", "female"),
+    "Callum": ("N2lVS1w4EtoT3dr4eOWO", "male"),
+    "Charlie": ("IKne3meq5aSn9XLyUdCD", "male"),
+    "Laura": ("FGY2WhTYpPnrIDTdsKH5", "female"),
+    "Matilda": ("XrExE9yKIg1WjnnlVkGX", "female"),
+    "Daniel": ("onwK4e9ZLuTAKqWW03F9", "male"),
+}
+
+
+def get_config():
+    return {
+        "name": "ElevenLabs",
+        "model": MODEL_ID,
+        "voices": {name: info[1] for name, info in VOICES.items()},
+        "needs_api_key": True,
+        "api_key_env": "ELEVENLABS_API_KEY",
+        "output_format": "mp3",
+    }
+
+
+def synthesize(text: str, voice: str = "Sarah", api_key: str = None, **kwargs) -> TTSResult:
+    if not api_key:
+        return TTSResult(
+            engine="elevenlabs", model=MODEL_ID, voice=voice,
+            audio_path="", format="mp3", sample_rate=44100,
+            duration_sec=0, generation_time_sec=0,
+            error="ElevenLabs API key is required.",
+        )
+
+    voice_id = VOICES.get(voice, (None,))[0]
+    if not voice_id:
+        return TTSResult(
+            engine="elevenlabs", model=MODEL_ID, voice=voice,
+            audio_path="", format="mp3", sample_rate=44100,
+            duration_sec=0, generation_time_sec=0,
+            error=f"Unknown voice '{voice}'. Choose from: {list(VOICES.keys())}",
+        )
+
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    headers = {"xi-api-key": api_key, "Content-Type": "application/json"}
+    payload = {
+        "text": text,
+        "model_id": MODEL_ID,
+        "output_format": OUTPUT_FMT,
+    }
+
+    t0 = time.time()
+    r = requests.post(url, headers=headers, json=payload, timeout=120)
+    elapsed = time.time() - t0
+
+    if r.status_code != 200:
+        return TTSResult(
+            engine="elevenlabs", model=MODEL_ID, voice=voice,
+            audio_path="", format="mp3", sample_rate=44100,
+            duration_sec=0, generation_time_sec=elapsed,
+            error=f"HTTP {r.status_code}: {r.text[:200]}",
+        )
+
+    out = get_temp_path(".mp3")
+    with open(out, "wb") as f:
+        f.write(r.content)
+
+    dur = os.path.getsize(out) / 16000.0
+
+    return TTSResult(
+        engine="elevenlabs", model=MODEL_ID, voice=voice,
+        audio_path=out, format="mp3", sample_rate=44100,
+        duration_sec=dur, generation_time_sec=elapsed,
+    )

engines/engine_gemini.py

@@ -0,0 +1,97 @@
+"""Gemini TTS engine — Google Gemini 2.5 Pro/Flash Preview TTS."""
+
+import time
+
+from google import genai
+from google.genai import types
+
+from ._common import TTSResult, get_temp_path, write_wav
+
+VOICES = [
+    "Zephyr", "Puck", "Charon", "Kore", "Fenrir", "Leda",
+    "Orus", "Aoede", "Callirrhoe", "Autonoe", "Enceladus", "Iapetus",
+    "Umbriel", "Algieba", "Despina", "Erinome", "Algenib", "Rasalgethi",
+    "Laomedeia", "Achernar", "Alnilam", "Schedar", "Gacrux", "Pulcherrima",
+    "Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat",
+]
+
+MODEL = "gemini-2.5-pro-preview-tts"
+
+
+def get_config():
+    return {
+        "name": "Gemini TTS",
+        "model": MODEL,
+        "voices": {v: "" for v in VOICES},
+        "needs_api_key": True,
+        "api_key_env": "GEMINI_API_KEY",
+        "output_format": "wav",
+    }
+
+
+def synthesize(text: str, voice: str = "Kore", api_key: str = None, **kwargs) -> TTSResult:
+    if not api_key:
+        return TTSResult(
+            engine="gemini", model=MODEL, voice=voice,
+            audio_path="", format="wav", sample_rate=24000,
+            duration_sec=0, generation_time_sec=0,
+            error="Gemini API key is required.",
+        )
+
+    client = genai.Client(api_key=api_key)
+    cfg = types.GenerateContentConfig(
+        response_modalities=["AUDIO"],
+        speech_config=types.SpeechConfig(
+            voice_config=types.VoiceConfig(
+                prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                    voice_name=voice,
+                ),
+            ),
+        ),
+    )
+
+    prompt = f"Read the following Uzbek text naturally and clearly:\n\n{text}"
+
+    t0 = time.time()
+    last_err = None
+    response = None
+    for attempt in range(3):
+        try:
+            response = client.models.generate_content(
+                model=MODEL, contents=prompt, config=cfg,
+            )
+            break
+        except Exception as e:
+            last_err = e
+            time.sleep(2 + attempt * 3)
+
+    elapsed = time.time() - t0
+
+    if response is None:
+        return TTSResult(
+            engine="gemini", model=MODEL, voice=voice,
+            audio_path="", format="wav", sample_rate=24000,
+            duration_sec=0, generation_time_sec=elapsed,
+            error=f"API call failed after 3 retries: {last_err}",
+        )
+
+    cand = response.candidates[0]
+    if cand.content is None:
+        return TTSResult(
+            engine="gemini", model=MODEL, voice=voice,
+            audio_path="", format="wav", sample_rate=24000,
+            duration_sec=0, generation_time_sec=elapsed,
+            error=f"Empty response (finish_reason={cand.finish_reason}). "
+                  "Uzbek may not be fully supported.",
+        )
+
+    pcm = cand.content.parts[0].inline_data.data
+    out = get_temp_path(".wav")
+    write_wav(out, pcm, channels=1, rate=24000, sample_width=2)
+    dur = len(pcm) / (24000 * 2)
+
+    return TTSResult(
+        engine="gemini", model=MODEL, voice=voice,
+        audio_path=out, format="wav", sample_rate=24000,
+        duration_sec=dur, generation_time_sec=elapsed,
+    )

engines/engine_mms.py

@@ -0,0 +1,55 @@
+"""MMS-TTS engine — Meta facebook/mms-tts-uzb-script_cyrillic (local VITS)."""
+
+import time
+
+import numpy as np
+import soundfile as sf
+import torch
+
+from ._common import TTSResult, get_temp_path, lat_to_cyr
+
+MODEL_ID = "facebook/mms-tts-uzb-script_cyrillic"
+_model = None
+_tokenizer = None
+
+
+def _load():
+    global _model, _tokenizer
+    if _model is None:
+        from transformers import AutoTokenizer, VitsModel
+        _tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+        _model = VitsModel.from_pretrained(MODEL_ID)
+        _model.eval()
+
+
+def get_config():
+    return {
+        "name": "MMS-TTS",
+        "model": MODEL_ID,
+        "voices": {"default": "single speaker"},
+        "needs_api_key": False,
+        "output_format": "wav",
+    }
+
+
+def synthesize(text: str, **kwargs) -> TTSResult:
+    _load()
+    cyr = lat_to_cyr(text)
+    sr = _model.config.sampling_rate
+
+    t0 = time.time()
+    inputs = _tokenizer(cyr, return_tensors="pt")
+    with torch.no_grad():
+        wav = _model(**inputs).waveform[0].cpu().numpy().astype(np.float32)
+    elapsed = time.time() - t0
+
+    out = get_temp_path(".wav")
+    sf.write(out, wav, sr)
+    dur = len(wav) / sr
+
+    return TTSResult(
+        engine="mms", model=MODEL_ID,
+        voice="uzb-script_cyrillic (single speaker)",
+        audio_path=out, format="wav", sample_rate=sr,
+        duration_sec=dur, generation_time_sec=elapsed,
+    )

engines/engine_omnivoice.py

@@ -0,0 +1,62 @@
+"""OmniVoice engine — k2-fsa/OmniVoice (local, 600+ lang, CPU-slow)."""
+
+import time
+
+import soundfile as sf
+import torch
+
+from ._common import TTSResult, get_temp_path
+
+MODEL_ID = "k2-fsa/OmniVoice"
+SAMPLE_RATE = 24000
+_model = None
+
+VALID_INSTRUCTS = [
+    "male", "female", "child", "teenager", "young adult", "middle-aged",
+    "elderly", "low pitch", "moderate pitch", "high pitch", "very low pitch",
+    "very high pitch", "whisper", "american accent", "british accent",
+    "australian accent", "indian accent", "russian accent",
+]
+
+
+def _load():
+    global _model
+    if _model is None:
+        from omnivoice import OmniVoice
+        _model = OmniVoice.from_pretrained(
+            MODEL_ID, device_map="cpu", dtype=torch.float32,
+        )
+
+
+def get_config():
+    return {
+        "name": "OmniVoice",
+        "model": MODEL_ID,
+        "voices": {},  # free-form instruct
+        "needs_api_key": False,
+        "output_format": "wav",
+        "instruct_mode": True,
+        "valid_instructs": VALID_INSTRUCTS,
+        "slow_warning": "~60-90s per sentence on CPU",
+    }
+
+
+def synthesize(text: str, instruct: str = "female, young adult, moderate pitch",
+               **kwargs) -> TTSResult:
+    _load()
+
+    t0 = time.time()
+    audio_list = _model.generate(text=text, instruct=instruct)
+    wav = audio_list[0]  # (1, T) at 24 kHz
+    elapsed = time.time() - t0
+
+    out = get_temp_path(".wav")
+    sf.write(out, wav.squeeze(0).cpu().numpy(), SAMPLE_RATE)
+    dur = wav.shape[-1] / SAMPLE_RATE
+
+    return TTSResult(
+        engine="omnivoice", model=MODEL_ID,
+        voice=f'instruct="{instruct}"',
+        audio_path=out, format="wav", sample_rate=SAMPLE_RATE,
+        duration_sec=dur, generation_time_sec=elapsed,
+    )

requirements.txt

@@ -0,0 +1,10 @@
+gradio>=6.0
+google-genai>=1.0
+edge-tts>=7.0
+transformers>=4.33
+torch
+soundfile
+requests
+python-dotenv
+numpy
+omnivoice