Update app.py

app.py

@@ -1,475 +1,340 @@
+import inspect
 import os
-import sys
+import random
 import subprocess
+import sys
 import tempfile
+import threading
 from pathlib import Path
+from typing import Optional
 
 import gradio as gr
 import spaces
-import torch
-
-
-# ============================================================
-# CONFIG
-# ============================================================
 
 MODEL_ID = "IndexTeam/IndexTTS-2"
 MODEL_DIR = Path("/tmp/index-tts-2")
+OUTPUT_DIR = Path(tempfile.gettempdir()) / "index-tts-2-outputs"
 
 os.environ.setdefault("HF_HOME", "/tmp/huggingface")
 os.environ.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
 
+_runtime_lock = threading.Lock()
+_runtime_ready = False
 _tts = None
 
 
-# ============================================================
-# INSTALL OFFICIAL INDEXTTS
-# ============================================================
-
-def install_runtime_dependencies():
-    """
-    Install IndexTTS and its pinned transformers version
-    without allowing pip to modify the HF Space dependency tree.
-    """
-
-    marker = Path("/tmp/index_tts_installed")
-
-    if marker.exists():
+def _install_runtime_dependencies() -> None:
+    """Install the official IndexTTS runtime without changing Space SDK pins."""
+    global _runtime_ready
+    if _runtime_ready:
         return
 
-    print("Installing official IndexTTS...")
-
-    # Official IndexTTS source
-    subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "--no-cache-dir",
-            "--no-deps",
-            "git+https://github.com/index-tts/index-tts.git",
-        ],
-        check=True,
-    )
+    with _runtime_lock:
+        if _runtime_ready:
+            return
+
+        commands = [
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--no-cache-dir",
+                "--no-deps",
+                "tokenizers==0.21.0",
+            ],
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--no-cache-dir",
+                "--no-deps",
+                "transformers==4.52.1",
+            ],
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--no-cache-dir",
+                "--no-deps",
+                "git+https://github.com/index-tts/index-tts.git",
+            ],
+        ]
+
+        for command in commands:
+            subprocess.check_call(command)
+
+        _runtime_ready = True
+
+
+def _download_model() -> Path:
+    """Download the model once, only when the first synthesis request arrives."""
+    from huggingface_hub import snapshot_download
 
-    # IndexTTS uses Transformers 4.52.1.
-    # Install WITHOUT dependencies because HF Space already
-    # provides a newer huggingface-hub required by Gradio.
-    subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "--no-cache-dir",
-            "--no-deps",
-            "transformers==4.52.1",
-        ],
-        check=True,
-    )
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    marker = MODEL_DIR / ".snapshot-complete"
 
-    marker.touch()
+    if not marker.exists():
+        snapshot_download(
+            repo_id=MODEL_ID,
+            local_dir=str(MODEL_DIR),
+        )
+        marker.touch()
+
+    return MODEL_DIR
 
-    print("IndexTTS installation complete.")
 
+def _find_config(model_dir: Path) -> str:
+    candidates = [
+        model_dir / "config.yaml",
+        model_dir / "config.yml",
+        model_dir / "configs" / "inference.yaml",
+        model_dir / "configs" / "config.yaml",
+    ]
 
-# Install before importing indextts
-install_runtime_dependencies()
+    for candidate in candidates:
+        if candidate.is_file():
+            return str(candidate)
 
+    discovered = sorted(model_dir.rglob("*.yaml")) + sorted(model_dir.rglob("*.yml"))
+    if discovered:
+        return str(discovered[0])
 
-# ============================================================
-# LOAD MODEL
-# ============================================================
+    raise FileNotFoundError(f"No IndexTTS configuration file was found under {model_dir}.")
 
-def load_model():
 
+def _get_tts():
     global _tts
 
     if _tts is not None:
         return _tts
 
-    if not torch.cuda.is_available():
-        raise RuntimeError(
-            "CUDA GPU available नहीं है। "
-            "HF Space में ZeroGPU hardware select करें।"
-        )
+    with _runtime_lock:
+        if _tts is not None:
+            return _tts
 
-    print("Downloading IndexTTS-2 model...")
-
-    from huggingface_hub import snapshot_download
+        try:
+            import torch
+
+            if not torch.cuda.is_available():
+                raise RuntimeError("CUDA GPU is not available in this Space.")
+
+            _install_runtime_dependencies()
+            model_dir = _download_model()
+            from indextts.infer_v2 import IndexTTS2
+
+            _tts = IndexTTS2(
+                cfg_path=_find_config(model_dir),
+                model_dir=str(model_dir),
+                use_fp16=True,
+                device="cuda",
+                use_cuda_kernel=False,
+                use_deepspeed=False,
+                use_accel=False,
+                use_torch_compile=False,
+                use_qwen_emo=True,
+            )
+            return _tts
+        except Exception:
+            _tts = None
+            raise
 
-    MODEL_DIR.mkdir(
-        parents=True,
-        exist_ok=True
-    )
 
-    snapshot_download(
-        repo_id=MODEL_ID,
-        local_dir=str(MODEL_DIR),
-    )
+def _validate_audio(path: Optional[str], label: str) -> str:
+    if not path:
+        raise gr.Error(f"{label} is required.")
 
-    print("Loading IndexTTS-2...")
+    audio = Path(path)
+    if not audio.is_file():
+        raise gr.Error(f"{label} could not be found.")
+    if audio.stat().st_size == 0:
+        raise gr.Error(f"{label} is empty.")
 
-    from indextts.infer_v2 import IndexTTS2
+    return str(audio)
 
-    _tts = IndexTTS2(
-        cfg_path=str(MODEL_DIR / "config.yaml"),
-        model_dir=str(MODEL_DIR),
 
-        use_fp16=True,
+def _set_seed(seed: int) -> None:
+    random.seed(seed)
 
-        device="cuda",
+    try:
+        import numpy as np
 
-        use_cuda_kernel=False,
-        use_deepspeed=False,
-        use_accel=False,
-        use_torch_compile=False,
+        np.random.seed(seed)
+    except ImportError:
+        pass
 
-        use_qwen_emo=True,
-    )
+    try:
+        import torch
 
-    print("IndexTTS-2 loaded successfully.")
+        torch.manual_seed(seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(seed)
+    except ImportError:
+        pass
 
-    return _tts
 
+def _supported_kwargs(function, values: dict) -> dict:
+    """Keep compatibility with small upstream inference API changes."""
+    parameters = inspect.signature(function).parameters
+    if any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters.values()):
+        return values
+    return {key: value for key, value in values.items() if key in parameters}
 
-# ============================================================
-# GENERATION
-# ============================================================
 
 @spaces.GPU(duration=180)
-def generate_voice(
-    reference_audio,
-    text,
-    emotion_audio,
-    emotion_strength,
-    use_text_emotion,
+def synthesize(
+    reference_audio: Optional[str],
+    text: str,
+    permission: bool,
+    emotion_audio: Optional[str],
+    emotion_strength: float,
+    use_text_emotion: bool,
     seed,
 ):
-    # --------------------------------------------------------
-    # Validate reference audio
-    # --------------------------------------------------------
-
-    if not reference_audio:
-        raise gr.Error(
-            "Reference voice upload करें।"
-        )
-
-    # --------------------------------------------------------
-    # Validate text
-    # --------------------------------------------------------
-
-    if not text or not text.strip():
-        raise gr.Error(
-            "English text लिखें।"
-        )
+    if not permission:
+        raise gr.Error("Please confirm that you have permission to use the reference voice.")
 
-    # --------------------------------------------------------
-    # Permission
-    # --------------------------------------------------------
+    reference_audio = _validate_audio(reference_audio, "Reference audio")
+    text = (text or "").strip()
 
-    # Permission is checked by the UI wrapper below.
-    # --------------------------------------------------------
+    if not text:
+        raise gr.Error("English text is required.")
+    if len(text) > 2000:
+        raise gr.Error("Please keep the English text to 2,000 characters or fewer.")
 
     try:
-        seed = int(seed)
-    except Exception:
-        seed = 1234
-
-    # --------------------------------------------------------
-    # Seed
-    # --------------------------------------------------------
-
-    torch.manual_seed(seed)
-
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(seed)
-
-    # --------------------------------------------------------
-    # Load model
-    # --------------------------------------------------------
+        numeric_seed = float(seed)
+        if not numeric_seed.is_integer() or numeric_seed < 0:
+            raise ValueError
+        numeric_seed = int(numeric_seed)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise gr.Error("Seed must be a non-negative integer.") from exc
 
     try:
-        tts = load_model()
+        emotion_strength = float(emotion_strength)
+    except (TypeError, ValueError) as exc:
+        raise gr.Error("Emotion strength must be a number between 0 and 1.") from exc
 
-    except Exception as e:
-        raise gr.Error(
-            "Model loading failed:\n"
-            + str(e)
-        )
+    if not 0 <= emotion_strength <= 1:
+        raise gr.Error("Emotion strength must be between 0 and 1.")
 
-    # --------------------------------------------------------
-    # Output path
-    # --------------------------------------------------------
+    if not isinstance(use_text_emotion, bool):
+        raise gr.Error("Use text emotion must be a boolean.")
 
-    output_path = (
-        Path(tempfile.gettempdir())
-        / "index_tts2_output.wav"
-    )
+    emotion_audio = _validate_audio(emotion_audio, "Emotion audio") if emotion_audio else None
+    output_dir = OUTPUT_DIR
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / "index-tts-2-output.wav"
 
-    # Remove previous file
     if output_path.exists():
-        try:
-            output_path.unlink()
-        except Exception:
-            pass
-
-    # --------------------------------------------------------
-    # Inference arguments
-    # --------------------------------------------------------
-
-    kwargs = {
-        "spk_audio_prompt": reference_audio,
-        "text": text.strip(),
-        "output_path": str(output_path),
-        "verbose": False,
-        "use_random": False,
-    }
-
-    # --------------------------------------------------------
-    # Emotion reference
-    # --------------------------------------------------------
-
-    if emotion_audio:
-
-        kwargs["emo_audio_prompt"] = emotion_audio
-
-        kwargs["emo_alpha"] = float(
-            emotion_strength
-        )
-
-    # --------------------------------------------------------
-    # Text emotion
-    # --------------------------------------------------------
-
-    if use_text_emotion:
-
-        kwargs["use_emo_text"] = True
-
-        kwargs["emo_alpha"] = min(
-            float(emotion_strength),
-            0.6
-        )
-
-    # --------------------------------------------------------
-    # Generate
-    # --------------------------------------------------------
-
-    print("Generating voice...")
+        output_path.unlink()
 
     try:
+        _set_seed(numeric_seed)
+        tts = _get_tts()
+
+        values = {
+            "spk_audio_prompt": reference_audio,
+            "text": text,
+            "output_path": str(output_path),
+            "use_random": False,
+        }
+
+        if emotion_audio:
+            values.update(
+                {
+                    "emo_audio_prompt": emotion_audio,
+                    "emo_alpha": emotion_strength,
+                }
+            )
 
-        tts.infer(
-            **kwargs
-        )
-
-    except Exception as e:
+        if use_text_emotion:
+            values.update(
+                {
+                    "use_emo_text": True,
+                    "emo_alpha": min(emotion_strength, 0.6),
+                }
+            )
 
-        raise gr.Error(
-            "IndexTTS-2 inference failed:\n"
-            + str(e)
-        )
+        tts.infer(**_supported_kwargs(tts.infer, values))
 
-    # --------------------------------------------------------
-    # Check output
-    # --------------------------------------------------------
+        if not output_path.is_file() or output_path.stat().st_size == 0:
+            raise RuntimeError("IndexTTS-2 returned without creating an audio file.")
 
-    if not output_path.exists():
+        return str(output_path)
+    except gr.Error:
+        raise
+    except Exception as exc:
+        raise gr.Error(f"Synthesis failed: {type(exc).__name__}: {exc}") from exc
 
-        raise gr.Error(
-            "Audio output नहीं बना।"
-        )
 
-    print(
-        "Generated:",
-        output_path
+with gr.Blocks(title="Offex IndexTTS-2 Voice Clone") as demo:
+    gr.Markdown(
+        "# Offex IndexTTS-2 Voice Clone\n"
+        "Generate English speech from a permitted reference voice."
     )
 
-    return str(output_path)
-
-
-# ============================================================
-# PERMISSION WRAPPER
-# ============================================================
-
-def guarded_generate(
-    reference_audio,
-    text,
-    emotion_audio,
-    emotion_strength,
-    use_text_emotion,
-    seed,
-    permission,
-):
-
-    if not permission:
-
-        raise gr.Error(
-            "पहले confirm करें कि आपको इस reference voice "
-            "का इस्तेमाल करने की अनुमति है।"
+    with gr.Row():
+        reference_audio = gr.Audio(
+            label="Reference voice",
+            sources=["upload", "microphone"],
+            type="filepath",
+        )
+        emotion_audio = gr.Audio(
+            label="Optional emotion reference",
+            sources=["upload", "microphone"],
+            type="filepath",
         )
 
-    return generate_voice(
-        reference_audio,
-        text,
-        emotion_audio,
-        emotion_strength,
-        use_text_emotion,
-        seed,
+    text = gr.Textbox(
+        label="English text",
+        placeholder="Enter the English text to synthesize...",
+        lines=6,
     )
 
-
-# ============================================================
-# UI
-# ============================================================
-
-with gr.Blocks(
-    title="Offex IndexTTS-2 Voice Clone"
-) as demo:
-
-    gr.Markdown(
-        """
-# 🎙️ Offex IndexTTS-2 Voice Clone
-
-### Real zero-shot voice cloning powered by IndexTTS-2
-
-Reference voice upload करें और English text को उसी voice
-के style में generate करें।
-
-> केवल ऐसी आवाज़ इस्तेमाल करें जिसके उपयोग की आपको अनुमति है।
-"""
+    permission = gr.Checkbox(
+        label="I have permission to use this reference voice",
+        value=False,
     )
 
-    # --------------------------------------------------------
-    # MAIN ROW
-    # --------------------------------------------------------
-
     with gr.Row():
+        emotion_strength = gr.Slider(
+            minimum=0,
+            maximum=1,
+            value=0.6,
+            step=0.05,
+            label="Emotion strength",
+        )
+        use_text_emotion = gr.Checkbox(
+            label="Use emotion information from text",
+            value=False,
+        )
+        seed = gr.Number(
+            label="Seed",
+            value=1234,
+            precision=0,
+            minimum=0,
+        )
 
-        # ====================================================
-        # LEFT
-        # ====================================================
-
-        with gr.Column():
-
-            reference = gr.Audio(
-                label="🎤 Reference Voice",
-                sources=[
-                    "upload",
-                    "microphone",
-                ],
-                type="filepath",
-            )
-
-            text = gr.Textbox(
-                label="📝 English Text",
-                lines=7,
-                placeholder=(
-                    "Hello! This is a voice cloning test. "
-                    "The generated voice should sound natural."
-                ),
-            )
-
-            permission = gr.Checkbox(
-                label=(
-                    "I have permission to use this "
-                    "reference voice."
-                ),
-                value=False,
-            )
-
-            gr.Markdown(
-                "### 🎭 Emotion"
-            )
-
-            emotion = gr.Audio(
-                label="Optional Emotion Reference",
-                sources=[
-                    "upload",
-                    "microphone",
-                ],
-                type="filepath",
-            )
-
-            emotion_strength = gr.Slider(
-                minimum=0,
-                maximum=1,
-                value=0.6,
-                step=0.05,
-                label="Emotion Strength",
-            )
-
-            text_emotion = gr.Checkbox(
-                label="Use emotion information from text",
-                value=False,
-            )
-
-            gr.Markdown(
-                "### ⚙️ Generation"
-            )
-
-            seed = gr.Number(
-                label="Seed",
-                value=1234,
-                precision=0,
-            )
-
-            button = gr.Button(
-                "🎧 Generate Voice",
-                variant="primary",
-                size="lg",
-            )
-
-        # ====================================================
-        # RIGHT
-        # ====================================================
-
-        with gr.Column():
-
-            output = gr.Audio(
-                label="🔊 Generated Voice",
-                type="filepath",
-            )
-
-            gr.Markdown(
-                """
-### Tips
-
-- Reference voice साफ और कम noise वाली रखें।
-- English reference voice बेहतर परिणाम दे सकती है।
-- लगभग 10–30 सेकंड की अच्छी reference recording इस्तेमाल करें।
-- Emotion reference optional है।
-"""
-            )
-
-    # --------------------------------------------------------
-    # BUTTON
-    # --------------------------------------------------------
-
-    button.click(
-        fn=guarded_generate,
+    generate = gr.Button("Generate Voice", variant="primary", size="lg")
+    output = gr.Audio(label="Generated voice", type="filepath", autoplay=True)
 
+    generate.click(
+        fn=synthesize,
         inputs=[
-            reference,
+            reference_audio,
             text,
-            emotion,
+            permission,
+            emotion_audio,
             emotion_strength,
-            text_emotion,
+            use_text_emotion,
             seed,
-            permission,
         ],
-
         outputs=output,
     )
 
 
-# ============================================================
-# LAUNCH
-# ============================================================
-
 if __name__ == "__main__":
-
-    demo.queue(
-        max_size=4
-    ).launch()
+    demo.queue(max_size=4).launch()