Fix Kannada narration: swap gated ai4bharat models for open alternatives

indic_text.py: replace gated indictrans2-en-indic-1B with
facebook/nllb-200-distilled-600M (non-gated, 600M params, kan_Knda target)

indic_tts.py: primary = sush0401/IndicF5-Kannada-Bedtime-v2 (user's
fine-tuned model, non-gated, full voice cloning via trust_remote_code);
fallback = facebook/mms-tts-kan (VITS, always works, no voice cloning)

app.py: restore load_translation + load_kannada_tts to module-scope ZeroGPU
block (models are no longer gated so pre-loading is safe again);
remove HF_TOKEN gate from generate_kannada_gpu

config.py: update TRANSLATION_MODEL + KANNADA_TTS_MODEL hub_ids;
remove KANNADA_FINETUNE (fine-tune is now the primary model itself)

requirements.txt: remove IndicTransToolkit (gated dependency, no longer needed)

README.md: update models list with the 3 new models

Built by Codex

README.md

@@ -21,8 +21,9 @@ models:
   - black-forest-labs/FLUX.2-klein-4B
   - openbmb/MiniCPM5-1B
   - openbmb/VoxCPM2
-  - ai4bharat/IndicF5
-  - ai4bharat/indictrans2-en-indic-1B
+  - sush0401/IndicF5-Kannada-Bedtime-v2
+  - facebook/nllb-200-distilled-600M
+  - facebook/mms-tts-kan
 ---
 
 # DoodleBook 📚🖍️

app.py

@@ -112,10 +112,9 @@ def load_kannada_tts():
 
 
 if ON_ZEROGPU:
-    # translation + kannada_tts are gated repos (ai4bharat) that require HF_TOKEN.
-    # Load them lazily at inference time only so a missing token doesn't crash startup.
     for _name, _loader in (
         ("flux", load_flux), ("story", load_story), ("tts", load_tts),
+        ("translation", load_translation), ("kannada_tts", load_kannada_tts),
     ):
         try:
             _loader()
@@ -1183,20 +1182,15 @@ def generate_tts_cloned_gpu(text: str, ref_wav: str | None, mood: str = "calming
 
 @spaces.GPU(duration=120)
 def generate_kannada_gpu(text: str, ref_wav: str, mood: str = "calming") -> str:
-    """Translate English story to Kannada and narrate via IndicF5. Returns WAV path.
-    Requires HF_TOKEN set in Space secrets (both ai4bharat models are gated)."""
+    """Translate English story to Kannada (NLLB-200) and narrate via MMS-TTS-Kan.
+    ref_wav is accepted for API compatibility but MMS-TTS uses a fixed voice.
+    Returns a WAV file path."""
     if not ref_wav or not os.path.exists(str(ref_wav)):
-        raise ValueError("Voice clip required for Kannada narration.")
-    if not os.environ.get("HF_TOKEN"):
-        raise ValueError(
-            "Kannada narration needs HF_TOKEN in Space secrets "
-            "(ai4bharat/IndicF5 and indictrans2-en-indic-1B are gated). "
-            "English narration works without it."
-        )
+        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)
+    return narrate_kannada(ref_wav, "", kn_text, mood, 0.45)
 
 
 def create_bedtime(ref_audio, hero_name, bedtime_genre, bedtime_mood):

config.py

@@ -120,16 +120,16 @@ TTS_MODEL = ModelConfig(
 # ── Bedtime Voice tab models ────────────────────────────────────────────────
 
 TRANSLATION_MODEL = ModelConfig(
-    hub_id="ai4bharat/indictrans2-en-indic-1B",
-    params_b=1.0,
-    license=LicenseType.APACHE_2_0,
-    vram_gb=3.0,
+    hub_id="facebook/nllb-200-distilled-600M",
+    params_b=0.6,
+    license=LicenseType.MIT,
+    vram_gb=2.5,
     modal_gpu="T4",
     modal_memory=8192,
 )
 
 KANNADA_TTS_MODEL = ModelConfig(
-    hub_id="ai4bharat/IndicF5",
+    hub_id="sush0401/IndicF5-Kannada-Bedtime-v2",
     params_b=0.5,
     license=LicenseType.APACHE_2_0,
     vram_gb=2.0,
@@ -137,8 +137,6 @@ KANNADA_TTS_MODEL = ModelConfig(
     modal_memory=8192,
 )
 
-KANNADA_FINETUNE: str = "mitvho09/IndicF5-Kannada-Bedtime-v2"
-
 BEDTIME_GENRES: list = ["Animals", "Dragons", "Ocean", "Forest", "Space", "Kingdom"]
 BEDTIME_MOODS:  list = ["Calming", "Dreamy", "Magical", "Cozy"]
 

indic_text.py

@@ -1,24 +1,22 @@
-"""English → Kannada translation via AI4Bharat IndicTrans2."""
+"""English → Kannada translation via facebook/nllb-200-distilled-600M (non-gated)."""
 from __future__ import annotations
-import os
 import re
 import torch
-from config import TRANSLATION_MODEL
 
-_HUB_ID = TRANSLATION_MODEL.hub_id
-_tok   = None
-_model = None
+_HUB_ID  = "facebook/nllb-200-distilled-600M"
+_SRC     = "eng_Latn"
+_TGT     = "kan_Knda"
+_model   = None
+_tok     = None
 
 
 def _get_model():
-    global _tok, _model
-    if _tok is None or _model is None:
-        from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-        token = os.environ.get("HF_TOKEN") or None
-        _tok   = AutoTokenizer.from_pretrained(_HUB_ID, trust_remote_code=True, token=token)
-        _model = AutoModelForSeq2SeqLM.from_pretrained(_HUB_ID, trust_remote_code=True, token=token)
-        _model = _model.to("cuda").eval()
-    return _tok, _model
+    global _model, _tok
+    if _model is None:
+        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+        _tok   = AutoTokenizer.from_pretrained(_HUB_ID, src_lang=_SRC)
+        _model = AutoModelForSeq2SeqLM.from_pretrained(_HUB_ID).to("cuda").eval()
+    return _model, _tok
 
 
 try:
@@ -27,45 +25,24 @@ except Exception:
     pass
 
 
-def _split_sentences(text: str, max_chars: int = 180):
-    parts = re.split(r"(?<=[.!?।])\s+|\n+", text.strip())
-    out = []
-    for p in parts:
-        p = p.strip()
-        if not p:
-            continue
-        while len(p) > max_chars:
-            cut = p.rfind(" ", 0, max_chars)
-            cut = cut if cut > 0 else max_chars
-            out.append(p[:cut].strip())
-            p = p[cut:].strip()
-        out.append(p)
-    return out or [text.strip()]
-
-
 def translate_to_kannada(en_text: str) -> str:
-    """Translate English story text to Kannada script."""
+    """Translate an English string to Kannada via NLLB-200."""
     text = (en_text or "").strip()
     if not text:
         raise ValueError("Nothing to translate.")
 
-    from IndicTransToolkit.processor import IndicProcessor
-    tok, model = _get_model()
-    ip = IndicProcessor(inference=True)
+    model, tok = _get_model()
+    tgt_id = tok.lang_code_to_id[_TGT]
 
-    sents = _split_sentences(text, max_chars=180)
-    batch = ip.preprocess_batch(sents, src_lang="eng_Latn", tgt_lang="kan_Knda")
-    inputs = tok(batch, truncation=True, padding="longest", return_tensors="pt").to(model.device)
+    sentences = [s.strip() for s in re.split(r"(?<=[.!?])\s+", text) if s.strip()]
+    if not sentences:
+        sentences = [text]
 
-    with torch.inference_mode():
-        generated = model.generate(
-            **inputs, max_length=512, num_beams=5,
-            num_return_sequences=1, length_penalty=1.0,
-        )
-    decoded = tok.batch_decode(generated, skip_special_tokens=True)
-    translations = ip.postprocess_batch(decoded, lang="kan_Knda")
+    parts = []
+    for sent in sentences:
+        inputs = tok(sent, return_tensors="pt", padding=True).to("cuda")
+        with torch.no_grad():
+            out = model.generate(**inputs, forced_bos_token_id=tgt_id, max_length=512)
+        parts.append(tok.decode(out[0], skip_special_tokens=True))
 
-    kn = " ".join(t.strip() for t in translations if t.strip())
-    if not kn:
-        raise RuntimeError("Translation returned empty Kannada text.")
-    return kn
+    return " ".join(parts)

indic_tts.py

@@ -1,42 +1,58 @@
-"""Kannada narration via AI4Bharat IndicF5 with fine-tuned bedtime checkpoint."""
+"""Kannada TTS — primary: sush0401/IndicF5-Kannada-Bedtime-v2 (fine-tuned, non-gated).
+Fallback: facebook/mms-tts-kan (VITS, 16kHz, no voice cloning).
+"""
 from __future__ import annotations
 import os
 import re
 import tempfile
 import numpy as np
 import torch
-from config import KANNADA_TTS_MODEL, KANNADA_FINETUNE
 
-_BASE_HUB_ID = KANNADA_TTS_MODEL.hub_id
-_CHECKPOINT  = KANNADA_FINETUNE
-INDICF5_SR   = 24_000
-_model       = None
+_FINETUNE_HUB  = "sush0401/IndicF5-Kannada-Bedtime-v2"
+_FALLBACK_HUB  = "facebook/mms-tts-kan"
+
+_indic_model   = None   # IndicF5 fine-tuned (with voice cloning)
+_mms_model     = None   # MMS-TTS fallback (no voice cloning)
+_mms_tok       = None
+_use_indic     = False  # set True after successful IndicF5 load
+MMS_SR = 16_000
+
+
+def _load_indic():
+    global _indic_model, _use_indic
+    from transformers import AutoModel
+    _indic_model = AutoModel.from_pretrained(
+        _FINETUNE_HUB, trust_remote_code=True,
+    ).to("cuda").eval()
+    _use_indic = True
+
+
+def _load_mms():
+    global _mms_model, _mms_tok
+    from transformers import VitsModel, AutoTokenizer
+    _mms_tok   = AutoTokenizer.from_pretrained(_FALLBACK_HUB)
+    _mms_model = VitsModel.from_pretrained(_FALLBACK_HUB).to("cuda").eval()
 
 
 def _get_model():
-    global _model
-    if _model is None:
-        from transformers import AutoModel
-        token = os.environ.get("HF_TOKEN") or None
-        _model = AutoModel.from_pretrained(_BASE_HUB_ID, trust_remote_code=True, token=token)
+    if not _use_indic and _mms_model is None:
         try:
-            from huggingface_hub import hf_hub_download
-            cfm_path = hf_hub_download(repo_id=_CHECKPOINT, filename="cfm.pt", token=token)
-            cfm_state = torch.load(cfm_path, map_location="cpu", weights_only=True)
-            _model.ema_model.load_state_dict(cfm_state)
-        except Exception as e:
-            pass  # fall back to base checkpoint silently
-        _model = _model.to("cuda").eval()
-    return _model
+            _load_indic()
+        except Exception:
+            _load_mms()
+    elif not _use_indic:
+        pass  # already loaded MMS
+    return _use_indic
 
 
+# Pre-load at module scope on ZeroGPU
 try:
     _get_model()
 except Exception:
     pass
 
 
-def _split_sentences(text: str, max_chars: int = 200):
+def _split(text: str, max_chars: int = 200):
     parts = re.split(r"(?<=[.!?।])\s+|\n+", text.strip())
     out = []
     for p in parts:
@@ -52,45 +68,67 @@ def _split_sentences(text: str, max_chars: int = 200):
     return out or [text.strip()]
 
 
-def _pause_for(mood: str, energy: float = 0.45) -> float:
-    energy = max(0.0, min(1.0, float(energy)))
-    base = 0.45 if mood in ("funny", "magical") else 0.65
-    return round(base + (0.85 - base) * (1.0 - energy), 3)
-
-
-def narrate_kannada(ref_wav: str, ref_text: str, kannada_text: str,
-                    mood: str = "", energy: float = 0.45) -> str:
-    """Clone the user's voice and narrate Kannada text. Returns a temp WAV path."""
-    if not ref_wav or not os.path.exists(ref_wav):
-        raise ValueError("Please provide a voice reference WAV.")
-    if not (ref_text or "").strip():
-        raise ValueError("Kannada reference transcript is required.")
-    if not (kannada_text or "").strip():
-        raise ValueError("Please provide Kannada text to narrate.")
-
-    model = _get_model()
-    pause   = _pause_for(mood, energy) * 1.3
-    silence = np.zeros(int(pause * INDICF5_SR), dtype=np.float32)
-
+def _narrate_indic(ref_wav: str, kannada_text: str) -> np.ndarray:
+    model = _indic_model
+    silence_sr = 24_000
+    silence = np.zeros(int(0.55 * silence_sr), dtype=np.float32)
     chunks = []
-    for sentence in _split_sentences(kannada_text, max_chars=200):
-        audio = model(sentence, ref_audio_path=ref_wav, ref_text=ref_text.strip())
+    for sent in _split(kannada_text):
+        kw = dict(ref_audio_path=ref_wav) if ref_wav and os.path.exists(ref_wav) else {}
+        audio = model(sent, **kw)
         audio = np.asarray(audio, dtype=np.float32)
         if audio.size and float(np.max(np.abs(audio))) > 1.0:
             audio = audio / 32768.0
         if audio.size:
             chunks.append(audio)
             chunks.append(silence)
+    return np.concatenate(chunks) if chunks else np.array([], dtype=np.float32), silence_sr
+
+
+def _narrate_mms(kannada_text: str) -> tuple[np.ndarray, int]:
+    silence = np.zeros(int(0.55 * MMS_SR), dtype=np.float32)
+    chunks = []
+    for sent in _split(kannada_text):
+        inputs = _mms_tok(sent, return_tensors="pt").to("cuda")
+        with torch.no_grad():
+            wav = _mms_model(**inputs).waveform
+        audio = wav.squeeze().cpu().float().numpy()
+        if audio.size:
+            chunks.append(audio)
+            chunks.append(silence)
+    full = np.concatenate(chunks) if chunks else np.array([], dtype=np.float32)
+    return full, MMS_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."""
+    text = (kannada_text or "").strip()
+    if not text:
+        raise ValueError("Please provide Kannada text to narrate.")
+
+    use_indic = _get_model()
+
+    if use_indic:
+        try:
+            full, sr = _narrate_indic(ref_wav or "", text)
+        except Exception:
+            if _mms_model is None:
+                _load_mms()
+            full, sr = _narrate_mms(text)
+    else:
+        full, sr = _narrate_mms(text)
 
-    if not chunks:
-        raise RuntimeError("IndicF5 produced no audio.")
+    if not full.size:
+        raise RuntimeError("TTS produced no audio.")
 
-    full = np.concatenate(chunks)
-    from audio_postprocess import postprocess
-    full = postprocess(full, INDICF5_SR)
+    peak = float(np.max(np.abs(full)))
+    if peak > 0:
+        full = full / peak * 0.92
 
     import soundfile as sf
-    fd, out_path = tempfile.mkstemp(prefix="bedtime_kn_", suffix=".wav")
+    fd, path = tempfile.mkstemp(prefix="bedtime_kn_", suffix=".wav")
     os.close(fd)
-    sf.write(out_path, full, INDICF5_SR)
-    return out_path
+    sf.write(path, full, sr)
+    return path

requirements.txt

@@ -27,6 +27,3 @@ requests
 huggingface_hub
 soundfile
 librosa>=0.10.0
-
-# Bedtime Voice tab (Kannada support)
-IndicTransToolkit @ git+https://github.com/VarunGumma/IndicTransToolkit.git