Upload 5 files

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+outputs/

README.md

@@ -0,0 +1,16 @@
+---
+title: "12labtts (lightweight build)"
+emoji: "🎤"
+colorFrom: "blue"
+colorTo: "purple"
+sdk: "gradio"
+sdk_version: "4.19.0"
+app_file: "app.py"
+pinned: false
+---
+
+This Space build avoids installing `chatterbox-tts` by default (it pulls heavy build deps that often fail).
+It provides a gTTS fallback so the Space builds quickly and runs. If you want to enable `chatterbox-tts` later,
+add it to `requirements.txt` and ensure the build environment supports its build dependencies.
+
+**If your model `yash184/12labtts` is private**: add `HUGGINGFACE_HUB_TOKEN` in Space settings -> Secrets.

app.py

@@ -0,0 +1,96 @@
+import os
+from pathlib import Path
+from gtts import gTTS
+import tempfile
+
+# Ensure a huggingface-hub version compatible with Gradio's oauth import is installed.
+# This runs at startup and may increase cold-start time.
+import subprocess, sys
+try:
+    import huggingface_hub as _hh
+    # If HfFolder is missing, reinstall a compatible minor version
+    if not hasattr(_hh, "HfFolder"):
+        raise ImportError
+except Exception:
+    print("Installing compatible huggingface-hub version...")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "huggingface-hub==0.14.1"])
+    # reload after install
+    import importlib
+    import huggingface_hub as _hh
+
+import gradio as gr
+import requests
+
+# Try to import chatterbox if user installs it later
+try:
+    import chatterbox_tts as cb_tts
+    chatterbox_available = True
+except Exception:
+    cb_tts = None
+    chatterbox_available = False
+
+def synthesize_with_chatterbox(text, lang="en", reference=None):
+    # Adapter placeholder -- real API call depends on chatterbox-tts
+    if not chatterbox_available:
+        raise RuntimeError("Chatterbox not available")
+    # Example hypothetical API; adapt if you install chatterbox-tts
+    model = cb_tts.load_model(".")
+    out = model.generate(text, lang=lang, reference=reference)
+    # Expecting out to be dict with 'wav' and 'sr' or path; adapt as needed
+    if isinstance(out, dict) and "wav" in out:
+        wav = out["wav"]
+        # Save as WAV via soundfile if available
+        import soundfile as sf
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+        sf.write(tmp.name, wav, out.get("sr", 24000))
+        return tmp.name
+    elif isinstance(out, str) and Path(out).exists():
+        return out
+    else:
+        raise RuntimeError("Unrecognized Chatterbox output format")
+
+def synthesize_with_gtts(text, lang="en"):
+    tts = gTTS(text=text, lang=lang.split("-")[0] if "-" in lang else lang)
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    tts.save(tmp.name)
+    return tmp.name
+
+def synthesize(text, language="English", use_chatterbox=False):
+    if not text.strip():
+        return None, "Text is empty"
+    lang_map = {
+        "English": "en", "Hindi": "hi", "French": "fr", "Spanish": "es", "German": "de"
+    }
+    lang = lang_map.get(language, "en")
+    # Prefer chatterbox if requested and available
+    if use_chatterbox and chatterbox_available:
+        try:
+            path = synthesize_with_chatterbox(text, lang=lang)
+            return path, None
+        except Exception as e:
+            return None, f"Chatterbox error: {e}"
+    # Fallback to gTTS
+    try:
+        path = synthesize_with_gtts(text, lang=lang)
+        return path, None
+    except Exception as e:
+        return None, f"gTTS error: {e}"
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 12labtts — lightweight Space\n\nThis Space uses gTTS as a fallback so it builds quickly on Hugging Face.\n")
+    with gr.Row():
+        txt = gr.Textbox(label="Text", lines=4, value="Hello world! This is a test.")
+        lang = gr.Dropdown(choices=["English","Hindi","French","Spanish","German"], value="English", label="Language")
+        use_cb = gr.Checkbox(label="Use Chatterbox if available", value=False)
+    out = gr.Audio(label="Output", type="filepath")
+    status = gr.Textbox(label="Status", interactive=False)
+    def run(text, language, use_chatterbox):
+        path, err = synthesize(text, language, use_chatterbox)
+        if err:
+            return None, err
+        return path, "OK"
+    btn = gr.Button("Synthesize")
+    btn.click(run, inputs=[txt, lang, use_cb], outputs=[out, status])
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))

huggingface_hub.py

@@ -0,0 +1,79 @@
+
+# Compatibility shim for huggingface_hub to provide HfFolder and whoami for older Gradio expectations.
+# This shim delegates to the installed huggingface_hub where possible but provides fallback
+# implementations for HfFolder and whoami if the installed version is missing them.
+import os, json, pathlib
+try:
+    import huggingface_hub as _real_hf
+except Exception:
+    _real_hf = None
+
+class HfFolder:
+    """
+    Minimal compatibility wrapper exposing methods Gradio expects:
+    - path(): returns the token file path
+    - get_token(): returns token string or None
+    - save_token(token): writes token to file
+    """
+    @staticmethod
+    def path(token_filename=".huggingface/token"):
+        # return token file path (legacy behaviour)
+        home = os.path.expanduser("~")
+        hf_dir = os.path.join(home, ".huggingface")
+        os.makedirs(hf_dir, exist_ok=True)
+        return os.path.join(hf_dir, "token")
+
+    @staticmethod
+    def get_token():
+        # Prefer env var (HUGGINGFACE_HUB_TOKEN or HF_TOKEN)
+        for key in ("HUGGINGFACE_HUB_TOKEN", "HF_TOKEN", "HUGGINGFACE_TOKEN"):
+            v = os.environ.get(key)
+            if v:
+                return v
+        # Try to read token file if present
+        try:
+            p = HfFolder.path()
+            if os.path.exists(p):
+                with open(p, "r", encoding="utf-8") as f:
+                    token = f.read().strip()
+                    if token:
+                        return token
+        except Exception:
+            pass
+        # If upstream provides a method, use it
+        try:
+            if _real_hf and hasattr(_real_hf, "HfFolder") and hasattr(_real_hf.HfFolder, "get_token"):
+                return _real_hf.HfFolder.get_token()
+        except Exception:
+            pass
+        return None
+
+    @staticmethod
+    def save_token(token):
+        try:
+            p = HfFolder.path()
+            with open(p, "w", encoding="utf-8") as f:
+                f.write(token)
+            return p
+        except Exception:
+            return None
+
+# whoami wrapper - try to call the real API if present.
+def whoami(token=None):
+    # If user passed token, try to use real whoami
+    try:
+        if _real_hf and hasattr(_real_hf, "whoami"):
+            # some versions accept token parameter, others use env
+            try:
+                return _real_hf.whoami(token=token) if token is not None else _real_hf.whoami()
+            except TypeError:
+                return _real_hf.whoami()
+    except Exception:
+        pass
+
+    # Fallback: if token available return a minimal dict with 'name' from token file or env
+    tk = token or HfFolder.get_token()
+    if not tk:
+        return {}
+    # Heuristic: token might embed username after 'hf_' not possible; return token presence info
+    return {"ok": True, "token_present": True}

requirements.txt

@@ -0,0 +1,13 @@
+gradio>=6.0.0
+gTTS==2.4.0
+numpy==1.25.2
+wheel
+setuptools
+cython
+torch
+torchaudio
+pydub
+nltk
+huggingface-hub
+requests
+soundfile