Fix Kannada narration: 3-tier TTS + error surfacing + longer English audio

Kannada was silently failing with no diagnostic info. Three changes:

1. Error surfacing: generate_kannada_gpu now logs each step (translation
success/failure, TTS success/failure) and propagates the actual error
message to the UI status bar so the user can see what's going wrong.

2. 3-tier Kannada TTS in indic_tts.py:
- Tier 1: sush0401/IndicF5-Kannada-Bedtime-v2 (user's fine-tuned model)
- Tier 2: facebook/mms-tts-kan (VITS fallback, GPU)
- Tier 3: gTTS Kannada (Google, no GPU, always works)
Each tier logs its result. Tier 3 guarantees Kannada audio is always
produced regardless of GPU model availability.

3. English audio length: voice-cloning sentence cap raised from 6 to 15
(6 sentences gave ~26s; 15 sentences gives ~1-1.5 minutes of audio).

Co-Authored-By: Codex <noreply@codex.ai>

app.py

@@ -1157,9 +1157,9 @@ def generate_tts_cloned_gpu(text: str, ref_wav: str | None, mood: str = "calming
         sentences = [text.strip() or "Sweet dreams."]
 
     has_ref = bool(ref_wav and os.path.exists(str(ref_wav)))
-    # Voice cloning is ~10-15s per sentence — cap at 6 to stay within 180s budget
+    # Voice cloning ~5-8s/sentence; 15 sentences ≈ 75-120s, well within 180s budget
     if has_ref:
-        sentences = sentences[:6]
+        sentences = sentences[:15]
 
     silence = np.zeros(int(0.65 * sr), dtype=np.float32)
     pieces  = []
@@ -1196,9 +1196,19 @@ def generate_kannada_gpu(text: str, ref_wav: str, mood: str = "calming") -> str:
     if not ref_wav or not os.path.exists(str(ref_wav)):
         raise ValueError("Voice clip required to enable Kannada narration.")
     from indic_text import translate_to_kannada
-    from indic_tts import narrate_kannada
-    kn_text = translate_to_kannada(text)
-    return narrate_kannada(ref_wav, "", kn_text, mood, 0.45)
+    from indic_tts import narrate_kannada, _use_indic, _mms_model
+    logger.info(f"Kannada: start. indic={_use_indic}, mms_loaded={_mms_model is not None}")
+    try:
+        kn_text = translate_to_kannada(text)
+    except Exception as te:
+        raise RuntimeError(f"Translation failed: {te}") from te
+    logger.info(f"Kannada: translated {len(kn_text)} chars → {kn_text[:80]!r}")
+    try:
+        path = narrate_kannada(ref_wav, "", kn_text, mood, 0.45)
+    except Exception as te:
+        raise RuntimeError(f"Kannada TTS failed: {te}") from te
+    logger.info(f"Kannada: done → {path}")
+    return path
 
 
 def create_bedtime(ref_audio, hero_name, bedtime_genre, bedtime_mood):
@@ -1237,16 +1247,19 @@ def create_bedtime(ref_audio, hero_name, bedtime_genre, bedtime_mood):
     yield (story_html, f"{title} — {kn_note}", en_audio_path, None)
 
     kn_audio_path = None
+    kn_error      = None
     if ref_audio:
         try:
             kn_audio_path = generate_kannada_gpu(kn_source, ref_audio, mood)
         except Exception as e:
+            kn_error = str(e)
             logger.warning(f"Kannada TTS failed: {e}")
 
     total    = round(time.perf_counter() - t0, 2)
     done_msg = f"Done: {title} · {total}s"
     if ref_audio and not kn_audio_path:
-        done_msg += "  · Kannada narration failed"
+        short_err = (kn_error or "unknown error")[:80]
+        done_msg += f"  · Kannada failed: {short_err}"
     elif not ref_audio:
         done_msg += "  · record your voice to get Kannada narration"
 

indic_tts.py

@@ -1,17 +1,21 @@
-"""Kannada TTS — primary: sush0401/IndicF5-Kannada-Bedtime-v2 (fine-tuned, non-gated).
-Fallback: facebook/mms-tts-kan (VITS, 16kHz, no voice cloning).
+"""Kannada TTS — tier 1: sush0401/IndicF5-Kannada-Bedtime-v2 (fine-tuned).
+Tier 2: facebook/mms-tts-kan (VITS, 16kHz, no voice cloning).
+Tier 3: gTTS (Google, always works, generic Kannada voice).
 
-ZeroGPU pattern: models loaded to CPU at module scope so ZeroGPU packs their
+ZeroGPU pattern: GPU models loaded to CPU at module scope so ZeroGPU packs their
 tensors. Inside inference functions (called from @spaces.GPU), .to("cuda") is
 called and ZeroGPU transfers packed tensors to GPU — no re-download needed.
 """
 from __future__ import annotations
+import logging
 import os
 import re
 import tempfile
 import numpy as np
 import torch
 
+logger = logging.getLogger(__name__)
+
 _FINETUNE_HUB  = "sush0401/IndicF5-Kannada-Bedtime-v2"
 _FALLBACK_HUB  = "facebook/mms-tts-kan"
 
@@ -25,27 +29,35 @@ MMS_SR = 16_000
 def _load_indic():
     global _indic_model, _use_indic
     from transformers import AutoModel
+    logger.info(f"Loading IndicF5 from {_FINETUNE_HUB}")
     # Load to CPU — ZeroGPU packs these tensors.
     _indic_model = AutoModel.from_pretrained(
         _FINETUNE_HUB, trust_remote_code=True,
     )
     _use_indic = True
+    logger.info("IndicF5 loaded OK")
 
 
 def _load_mms():
     global _mms_model, _mms_tok
     from transformers import VitsModel, AutoTokenizer
+    logger.info(f"Loading MMS-TTS from {_FALLBACK_HUB}")
     _mms_tok   = AutoTokenizer.from_pretrained(_FALLBACK_HUB)
     # Load to CPU — ZeroGPU packs these tensors.
     _mms_model = VitsModel.from_pretrained(_FALLBACK_HUB)
+    logger.info("MMS-TTS loaded OK")
 
 
 def _get_model():
     if not _use_indic and _mms_model is None:
         try:
             _load_indic()
-        except Exception:
-            _load_mms()
+        except Exception as e:
+            logger.warning(f"IndicF5 load failed ({e}); trying MMS-TTS")
+            try:
+                _load_mms()
+            except Exception as e2:
+                logger.warning(f"MMS-TTS load failed too ({e2}); will use gTTS fallback")
     return _use_indic
 
 
@@ -73,8 +85,7 @@ def _split(text: str, max_chars: int = 200):
 
 
 def _narrate_indic(ref_wav: str, kannada_text: str) -> tuple[np.ndarray, int]:
-    # Move to GPU — ZeroGPU intercepts this inside @spaces.GPU.
-    model = _indic_model.to("cuda")
+    model = _indic_model.to("cuda")  # ZeroGPU intercepts inside @spaces.GPU
     silence_sr = 24_000
     silence = np.zeros(int(0.55 * silence_sr), dtype=np.float32)
     chunks = []
@@ -87,15 +98,16 @@ def _narrate_indic(ref_wav: str, kannada_text: str) -> tuple[np.ndarray, int]:
         if audio.size:
             chunks.append(audio)
             chunks.append(silence)
-    return np.concatenate(chunks) if chunks else np.array([], dtype=np.float32), silence_sr
+    return (np.concatenate(chunks) if chunks else np.array([], dtype=np.float32)), silence_sr
 
 
 def _narrate_mms(kannada_text: str) -> tuple[np.ndarray, int]:
-    # Move to GPU — ZeroGPU intercepts this inside @spaces.GPU.
-    model = _mms_model.to("cuda")
+    model = _mms_model.to("cuda")  # ZeroGPU intercepts inside @spaces.GPU
     silence = np.zeros(int(0.55 * MMS_SR), dtype=np.float32)
     chunks = []
     for sent in _split(kannada_text):
+        if not sent.strip():
+            continue
         inputs = _mms_tok(sent, return_tensors="pt").to(model.device)
         with torch.no_grad():
             wav = model(**inputs).waveform
@@ -107,25 +119,60 @@ def _narrate_mms(kannada_text: str) -> tuple[np.ndarray, int]:
     return full, MMS_SR
 
 
+def _narrate_gtts(kannada_text: str) -> tuple[np.ndarray, int]:
+    """Last-resort: gTTS Kannada (generic Google voice, no GPU needed)."""
+    import io
+    import librosa
+    from gtts import gTTS
+    logger.info("Using gTTS Kannada fallback")
+    tts = gTTS(text=kannada_text, lang="kn", slow=True)
+    fd, mp3_path = tempfile.mkstemp(suffix=".mp3")
+    os.close(fd)
+    try:
+        tts.save(mp3_path)
+        data, sr = librosa.load(mp3_path, sr=22050, mono=True)
+    finally:
+        try:
+            os.unlink(mp3_path)
+        except OSError:
+            pass
+    return data.astype(np.float32), sr
+
+
 def narrate_kannada(ref_wav: str, ref_text: str, kannada_text: str,
                     mood: str = "", energy: float = 0.45) -> str:
-    """Narrate Kannada text. Uses fine-tuned IndicF5 with voice cloning if available,
-    otherwise MMS-TTS-Kan (generic voice). Returns a temp WAV path."""
+    """Narrate Kannada text. Tries: IndicF5 → MMS-TTS → gTTS. Returns WAV path."""
     text = (kannada_text or "").strip()
     if not text:
-        raise ValueError("Please provide Kannada text to narrate.")
+        raise ValueError("No Kannada text to narrate.")
 
     use_indic = _get_model()
+    full = np.array([], dtype=np.float32)
+    sr   = MMS_SR
 
+    # Tier 1: user's fine-tuned IndicF5
     if use_indic:
         try:
             full, sr = _narrate_indic(ref_wav or "", text)
-        except Exception:
-            if _mms_model is None:
-                _load_mms()
+            logger.info("IndicF5 narration OK")
+        except Exception as e:
+            logger.warning(f"IndicF5 narration failed ({e}); trying MMS-TTS")
+
+    # Tier 2: MMS-TTS-Kan
+    if not full.size and _mms_model is not None:
+        try:
             full, sr = _narrate_mms(text)
-    else:
-        full, sr = _narrate_mms(text)
+            logger.info("MMS-TTS narration OK")
+        except Exception as e:
+            logger.warning(f"MMS-TTS narration failed ({e}); trying gTTS")
+
+    # Tier 3: gTTS (always works, no GPU needed)
+    if not full.size:
+        try:
+            full, sr = _narrate_gtts(text)
+            logger.info("gTTS narration OK")
+        except Exception as e:
+            raise RuntimeError(f"All Kannada TTS tiers failed. Last error: {e}") from e
 
     if not full.size:
         raise RuntimeError("TTS produced no audio.")

requirements.txt

@@ -27,3 +27,4 @@ requests
 huggingface_hub
 soundfile
 librosa>=0.10.0
+gtts