Add dialogue-aware multi-voice generation

- Parse Erkak:/Ayol: markers to alternate male/female voices
- Strip speaker prefixes so they aren't read aloud
- Synthesize each turn separately, stitch into one audio file
- Show per-turn progress and detailed log

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

app.py

@@ -17,7 +17,10 @@ except ImportError:
 import gradio as gr
 
 from engines import ENGINES
-from engines._common import normalize_uzbek
+from engines._common import (
+    normalize_uzbek, parse_dialogue, get_temp_path,
+    stitch_wav_files, stitch_mp3_files,
+)
 
 ROOT = Path(__file__).parent
 DEFAULT_TEXT = ROOT / "111.txt"
@@ -91,10 +94,30 @@ LABEL_TO_KEY = {ENGINE_INFO[k]["label"]: k for k in ENGINE_KEYS}
 
 
 # ---------------------------------------------------------------------------
-# Generation handler
+# Generation handler — supports multi-voice dialogue
 # ---------------------------------------------------------------------------
+def _build_kwargs(key, voice, api_key_map):
+    """Build engine-specific kwargs for a single synthesis call."""
+    kwargs = {}
+    if key == "gemini":
+        kwargs["api_key"] = api_key_map.get("gemini", "")
+        kwargs["voice"] = voice
+    elif key == "edge":
+        kwargs["voice"] = voice
+    elif key == "omnivoice":
+        kwargs["instruct"] = voice
+    elif key == "aisha":
+        kwargs["api_key"] = api_key_map.get("aisha", "")
+    elif key == "elevenlabs":
+        kwargs["api_key"] = api_key_map.get("elevenlabs", "")
+        kwargs["voice"] = voice
+    return kwargs
+
+
 def generate(text, engine_label, male_voice, female_voice,
              progress=gr.Progress(track_tqdm=True)):
+    import time
+
     text = normalize_uzbek(text.strip())
     if not text:
         return None, "**Error:** No text provided.", ""
@@ -107,49 +130,82 @@ def generate(text, engine_label, male_voice, female_voice,
 
     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
+    api_keys = {
+        "gemini": os.environ.get("GEMINI_API_KEY", ""),
+        "aisha": os.environ.get("AISHA_API_KEY", ""),
+        "elevenlabs": os.environ.get("ELEVENLABS_API_KEY", ""),
+    }
+
+    # Parse dialogue turns (Erkak → male voice, Ayol → female voice).
+    turns = parse_dialogue(text)
+    has_dialogue = any(role in ("erkak", "ayol") for role, _ in turns)
+
+    # Voice mapping per role.
+    voice_map = {
+        "erkak": male_voice or female_voice,
+        "ayol": female_voice or male_voice,
+        "plain": female_voice or male_voice,
+    }
+
+    t0 = time.time()
+    clip_paths = []
+    log_lines = []
+    output_fmt = None
+
+    for i, (role, line_text) in enumerate(turns):
+        voice = voice_map[role]
+        progress((i / len(turns)), desc=f"Turn {i+1}/{len(turns)} ({role})...")
+
+        kwargs = _build_kwargs(key, voice, api_keys)
+        try:
+            result = engine.synthesize(text=line_text, **kwargs)
+        except Exception as e:
+            log_lines.append(f"  Turn {i+1} ({role}) FAILED: {e}")
+            continue
+
+        if result.error:
+            log_lines.append(f"  Turn {i+1} ({role}) ERROR: {result.error}")
+            continue
+
+        clip_paths.append(result.audio_path)
+        output_fmt = result.format
+        speaker = "Erkak" if role == "erkak" else ("Ayol" if role == "ayol" else "—")
+        log_lines.append(
+            f"  [{i+1:02d}] {speaker:5s} → {voice}  "
+            f"({result.duration_sec:.1f}s)"
+        )
 
-    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
+    total_time = time.time() - t0
 
-    try:
-        result = engine.synthesize(text=text, **kwargs)
-    except Exception as e:
-        return None, f"**Error:** {e}", f"[{engine_label}] EXCEPTION: {e}"
+    if not clip_paths:
+        return None, "**Error:** All turns failed.", "\n".join(log_lines)
 
-    if result.error:
-        return None, f"**Error:** {result.error}", f"[{engine_label}] {result.error}"
+    # Stitch clips into one file.
+    if len(clip_paths) == 1:
+        final_path = clip_paths[0]
+    else:
+        if output_fmt == "wav":
+            final_path = get_temp_path(".wav")
+            stitch_wav_files(clip_paths, final_path)
+        else:
+            final_path = get_temp_path(".mp3")
+            stitch_mp3_files(clip_paths, final_path)
 
     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 "")
+        f"**Model:** `{engine.get_config()['model']}`  \n"
+        f"**Male voice:** {male_voice or 'N/A'}  \n"
+        f"**Female voice:** {female_voice or 'N/A'}  \n"
+        f"**Turns:** {len(clip_paths)} of {len(turns)}  \n"
+        f"**Dialogue mode:** {'Yes' if has_dialogue else 'No (plain text)'}  \n"
+        f"**Total generation time:** {total_time:.1f}s  \n"
+        f"**Format:** {output_fmt}"
     )
-    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
+    log_header = (f"[{engine_label}] {len(clip_paths)} turns, "
+                  f"{total_time:.1f}s total")
+    log = log_header + "\n" + "\n".join(log_lines)
+    return final_path, meta, log
 
 
 # ---------------------------------------------------------------------------

engines/_common.py

@@ -45,6 +45,60 @@ def get_wav_duration(path: str) -> float:
         return wf.getnframes() / wf.getframerate()
 
 
+def parse_dialogue(text: str):
+    """Parse text with Erkak:/Ayol: markers into turns.
+
+    Returns list of (role, clean_text) where role is "erkak" or "ayol".
+    If no markers found, returns [("plain", text)] — meaning no dialogue.
+    """
+    turns = []
+    role = None
+    for line in text.splitlines():
+        s = line.strip()
+        if not s:
+            continue
+        # Detect speaker markers (various forms).
+        if re.match(r"^Erkak\b", s, re.IGNORECASE):
+            role = "erkak"
+            s = re.sub(r"^Erkak[^:]*:\s*", "", s, flags=re.IGNORECASE)
+        elif re.match(r"^Ayol\b", s, re.IGNORECASE):
+            role = "ayol"
+            s = re.sub(r"^Ayol[^:]*:\s*", "", s, flags=re.IGNORECASE)
+        if not s:
+            continue
+        if role:
+            turns.append((role, s))
+        else:
+            turns.append(("plain", s))
+    return turns if turns else [("plain", text)]
+
+
+def stitch_wav_files(paths: list, output_path: str, pause_sec: float = 0.35):
+    """Concatenate multiple WAV files into one with pauses between them."""
+    sr = ch = sw = None
+    pcm_chunks = []
+    for p in paths:
+        with wave.open(p, "rb") as w:
+            cur = (w.getnchannels(), w.getsampwidth(), w.getframerate())
+            if sr is None:
+                ch, sw, sr = cur
+            pcm_chunks.append(w.readframes(w.getnframes()))
+        pcm_chunks.append(b"\x00" * int(pause_sec * sr * ch * sw))
+    with wave.open(output_path, "wb") as out:
+        out.setnchannels(ch)
+        out.setsampwidth(sw)
+        out.setframerate(sr)
+        out.writeframes(b"".join(pcm_chunks))
+
+
+def stitch_mp3_files(paths: list, output_path: str):
+    """Concatenate MP3 files (naive frame concat — works for most players)."""
+    with open(output_path, "wb") as out:
+        for p in paths:
+            with open(p, "rb") as f:
+                out.write(f.read())
+
+
 def get_audio_duration(path: str, fmt: str) -> float:
     if fmt == "wav":
         return get_wav_duration(path)