Create app.py

app.py

@@ -0,0 +1,198 @@
+import os
+import io
+import uuid
+import re
+import tempfile
+from typing import Optional, List
+
+import gradio as gr
+
+# --- File reading ---
+def read_text_from_file(file_obj) -> str:
+    if file_obj is None:
+        return ""
+    name = getattr(file_obj, "name", "")
+    if not name:
+        return ""
+
+    ext = os.path.splitext(name)[1].lower()
+    if ext == ".txt":
+        return file_obj.read().decode("utf-8", errors="ignore")
+    elif ext == ".docx":
+        # lazy import to keep startup snappy
+        import docx
+        d = docx.Document(file_obj)
+        return "\n".join([p.text for p in d.paragraphs]).strip()
+    else:
+        raise gr.Error("Unsupported file type. Please upload .txt or .docx")
+
+# --- Chunking utility (keeps sentences intact, ~350-500 chars each) ---
+_SENT_SPLIT = re.compile(r"(?<=[\.\!\?\:\;\n])\s+")
+
+def chunk_text(text: str, max_len: int = 450) -> List[str]:
+    # Fast path
+    if len(text) <= max_len:
+        return [text.strip()]
+
+    sentences = [s.strip() for s in _SENT_SPLIT.split(text) if s.strip()]
+    chunks, cur = [], ""
+    for s in sentences:
+        if len(cur) + 1 + len(s) <= max_len:
+            cur = f"{cur} {s}".strip() if cur else s
+        else:
+            if cur:
+                chunks.append(cur)
+            # very long single sentence fallback
+            if len(s) > max_len:
+                for i in range(0, len(s), max_len):
+                    chunks.append(s[i:i+max_len])
+                cur = ""
+            else:
+                cur = s
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+# --- Lazy TTS loader (Coqui XTTS v2) ---
+_TTS = None
+_SR = 22050  # default; will be overwritten after first load if available
+
+def get_tts():
+    global _TTS, _SR
+    if _TTS is None:
+        from TTS.api import TTS
+        # Multilingual, high-quality, supports voice cloning via reference audio
+        _TTS = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
+        try:
+            _SR = getattr(_TTS, "output_sample_rate", 24000) or 24000
+        except Exception:
+            _SR = 24000
+    return _TTS
+
+# --- Synthesis core ---
+def synthesize(
+    text_input: str,
+    file_input,
+    language: str,
+    voice_ref,  # optional reference audio for cloning
+) -> str:
+    # Collect text from inputs
+    user_text = (text_input or "").strip()
+    file_text = read_text_from_file(file_input) if file_input else ""
+    final_text = (user_text + "\n" + file_text).strip()
+
+    if not final_text:
+        raise gr.Error("Please paste/type text or upload a .txt/.docx file.")
+
+    # Clean + limit length to something reasonable for demo
+    final_text = re.sub(r"\s+", " ", final_text).strip()
+    if len(final_text) > 20000:
+        final_text = final_text[:20000] + " ..."
+
+    # Prepare chunks
+    chunks = chunk_text(final_text, max_len=480)
+
+    # TTS model
+    tts = get_tts()
+
+    # Target WAV path
+    out_path = os.path.join(tempfile.gettempdir(), f"tts_{uuid.uuid4().hex}.wav")
+
+    # Synthesize and append to a single WAV
+    import soundfile as sf
+    import numpy as np
+
+    # Create/overwrite file
+    with sf.SoundFile(out_path, mode="w", samplerate=_SR, channels=1, subtype="PCM_16") as f:
+        for i, chunk in enumerate(chunks, start=1):
+            # If a reference voice is provided, use it
+            speaker_wav = None
+            if voice_ref is not None:
+                try:
+                    speaker_wav = voice_ref.name  # temp file path provided by Gradio
+                except Exception:
+                    speaker_wav = None
+
+            # Generate audio as numpy array
+            audio = tts.tts(
+                text=chunk,
+                language=language,
+                speaker_wav=speaker_wav,  # None => default voice
+            )
+            # Ensure mono float32/float64 -> int16
+            audio = np.asarray(audio).flatten()
+            # Normalize if needed
+            if audio.dtype != np.float32 and audio.dtype != np.float64:
+                audio = audio.astype("float32")
+            # write chunk
+            f.write(audio)
+
+    return out_path
+
+# --- Gradio UI ---
+LANG_OPTIONS = [
+    ("English", "en"),
+    ("Spanish", "es"),
+    ("French", "fr"),
+    ("German", "de"),
+    ("Italian", "it"),
+    ("Portuguese", "pt"),
+    ("Polish", "pl"),
+    ("Turkish", "tr"),
+    ("Russian", "ru"),
+    ("Dutch", "nl"),
+    ("Chinese", "zh-cn"),
+    ("Japanese", "ja"),
+    ("Korean", "ko"),
+    ("Arabic", "ar"),
+]
+
+with gr.Blocks(title="High-Quality TTS (XTTS v2)") as demo:
+    gr.Markdown(
+        """
+        # 🔊 High-Quality Text-to-Speech
+        - **Upload** a `.docx` or `.txt`, **or** paste/type text.
+        - Optionally **clone a voice** by uploading a short (10–30s) reference `.wav`.
+        - Choose a **language**, then click **Generate Audio**.
+        """
+    )
+    with gr.Row():
+        text_in = gr.Textbox(
+            label="Type or paste text",
+            lines=8,
+            placeholder="Paste text here… (you can also upload a .docx/.txt below)",
+        )
+    with gr.Row():
+        file_in = gr.File(
+            label="Drag & drop .docx or .txt (optional)",
+            file_types=[".docx", ".txt"],
+        )
+    with gr.Row():
+        voice_ref = gr.File(
+            label="Optional: Voice reference (.wav, 10–30s) for cloning",
+            file_types=[".wav"],
+            visible=True,
+        )
+        lang = gr.Dropdown(
+            choices=[v for _, v in LANG_OPTIONS],
+            value="en",
+            label="Language",
+            info="XTTS v2 is multilingual; pick what fits your input.",
+        )
+
+    btn = gr.Button("🎙️ Generate Audio", variant="primary")
+    audio_out = gr.Audio(label="Result", type="filepath", autoplay=True)
+    download = gr.File(label="Download WAV")
+
+    def run(text_input, file_input, language, voice_ref_file):
+        path = synthesize(text_input, file_input, language, voice_ref_file)
+        return path, path
+
+    btn.click(
+        run,
+        inputs=[text_in, file_in, lang, voice_ref],
+        outputs=[audio_out, download],
+    )
+
+if __name__ == "__main__":
+    demo.launch()