app.py

import gradio as gr
import numpy as np
import re
import soundfile as sf
import tempfile
import os
import nltk
from nltk.tokenize import sent_tokenize
import warnings
import time
from TTS.api import TTS

warnings.filterwarnings("ignore")

# Download required NLTK data
try:
    nltk.data.find('tokenizers/punkt')
except LookupError:
    nltk.download('punkt')

# Load Coqui TTS model
print("🔄 Loading Coqui TTS models...")
try:
    # This will download the model automatically if not found
    tts = TTS(model_name="tts_models/en/vctk/vits", progress_bar=False, gpu=False)
    print("✅ Coqui TTS loaded successfully!")
    speakers = tts.speakers
    print(f"Available Speakers: {speakers}")
except Exception as e:
    print(f"❌ Failed to load Coqui TTS: {e}")
    tts = None
    speakers = []

class LongFormTTS:
    def __init__(self):
        self.tts = tts
        self.speakers = speakers
        self.sample_rate = 22050  # Coqui default sample rate

    def preprocess_text(self, text):
        """Clean and prepare text for TTS"""
        text = re.sub(r'\s+', ' ', text.strip())
        abbreviations = {
            'Dr.': 'Doctor', 'Mr.': 'Mister', 'Mrs.': 'Missus',
            'Ms.': 'Miss', 'Prof.': 'Professor', 'etc.': 'etcetera',
            'vs.': 'versus', 'e.g.': 'for example', 'i.e.': 'that is',
            'St.': 'Street', 'Ave.': 'Avenue', 'Blvd.': 'Boulevard',
            'Inc.': 'Incorporated', 'Corp.': 'Corporation', 'Ltd.': 'Limited',
            'U.S.': 'United States', 'U.K.': 'United Kingdom',
            'Ph.D.': 'PhD', 'M.D.': 'MD'
        }
        for abbr, full in abbreviations.items():
            text = text.replace(abbr, full)
        text = re.sub(r'\b(\d{1,4})\b', lambda m: self.number_to_words(int(m.group())), text)
        text = re.sub(r'\b(1[0-9]{3}|20[0-9]{2}|2100)\b', lambda m: m.group(), text)
        text = re.sub(r'[^\w\s\.,!?;:\-\(\)\'"]', ' ', text)
        return text.strip()

    def number_to_words(self, num):
        ones = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
        teens = ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
                 "sixteen", "seventeen", "eighteen", "nineteen"]
        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
                "eighty", "ninety"]
        if num == 0:
            return "zero"
        if num < 10:
            return ones[num]
        elif num < 20:
            return teens[num - 10]
        elif num < 100:
            return tens[num // 10] + ("" if num % 10 == 0 else " " + ones[num % 10])
        elif num < 1000:
            return ones[num // 100] + " hundred" + (" " + self.number_to_words(num % 100)).strip()
        else:
            thousands = num // 1000
            remainder = num % 1000
            result = self.number_to_words(thousands) + " thousand"
            if remainder > 0:
                result += " " + self.number_to_words(remainder)
            return result

    def chunk_text(self, text, max_length=200):
        sentences = sent_tokenize(text)
        chunks = []
        current_chunk = ""
        for sentence in sentences:
            if len(current_chunk + " " + sentence) > max_length:
                if current_chunk:
                    chunks.append(current_chunk.strip())
                current_chunk = sentence
            else:
                current_chunk = current_chunk + " " + sentence if current_chunk else sentence
        if current_chunk:
            chunks.append(current_chunk.strip())
        return [chunk for chunk in chunks if chunk.strip()]

    def generate_speech_chunk(self, text_chunk, speaker):
        try:
            audio = self.tts.tts(text=text_chunk, speaker=speaker)
            return audio
        except Exception as e:
            print(f"Error generating speech for chunk: {e}")
            return None

    def generate_long_speech(self, text, speaker=None, progress_callback=None):
        processed_text = self.preprocess_text(text)
        chunks = self.chunk_text(processed_text)
        print(f"Split into {len(chunks)} chunks")
        audio_segments = []
        silence = np.zeros(int(0.4 * self.sample_rate), dtype=np.float32)

        for i, chunk in enumerate(chunks):
            if progress_callback:
                progress_callback(f"Processing chunk {i+1}/{len(chunks)}: {chunk[:40]}{'...' if len(chunk) > 40 else ''}")
            print(f"Processing chunk {i+1}: {chunk}")
            audio_chunk = self.generate_speech_chunk(chunk, speaker)
            if audio_chunk is not None:
                audio_segments.append(np.array(audio_chunk))
                audio_segments.append(silence)
            time.sleep(0.1)

        if not audio_segments:
            return None, None

        final_audio = np.concatenate(audio_segments)
        max_val = np.max(np.abs(final_audio))
        if max_val > 0:
            final_audio = final_audio / max_val * 0.95
        return final_audio, self.sample_rate


# Global TTS system
print("🚀 Initializing TTS system...")
try:
    tts_system = LongFormTTS()
    print("✅ TTS system ready!")
except Exception as e:
    print(f"❌ TTS initialization failed: {e}")
    tts_system = None


def text_to_speech_interface(text, speaker="p225", progress=gr.Progress()):
    if tts_system is None:
        return None, "❌ TTS system is not available. Please check the logs."
    if not text or not text.strip():
        return None, "⚠️ Please enter some text to convert to speech."
    if len(text) > 50000:
        return None, "⚠️ Text is too long. Please keep it under 50,000 characters."

    def progress_callback(message):
        progress(0.5, desc=message)

    try:
        progress(0.1, desc="🔄 Starting text-to-speech conversion...")
        audio, sample_rate = tts_system.generate_long_speech(text, speaker, progress_callback)
        if audio is None:
            return None, "❌ Failed to generate audio."
        progress(0.9, desc="💾 Saving audio file...")
        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
            sf.write(tmp_file.name, audio, sample_rate)
            audio_path = tmp_file.name
        progress(1.0, desc="✅ Complete!")
        duration = len(audio) / sample_rate
        return audio_path, f"✅ Generated {duration:.1f} seconds of audio successfully!"
    except Exception as e:
        return None, f"❌ Error: {str(e)}"


# Create Gradio interface
def create_interface():
    with gr.Blocks(
        title="🎤 Long-Form Text-to-Speech (Coqui)",
        theme=gr.themes.Soft(),
        css="""
        .main-header {
            text-align: center;
            margin-bottom: 2rem;
            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            background-clip: text;
        }
        """
    ) as demo:
        gr.HTML("""
        <div class="main-header">
            <h1>🎤 Long-Form Text-to-Speech Generator</h1>
            <p style="color: #666; font-size: 1.1em;">Choose a voice and transform any text into expressive human-like speech</p>
        </div>
        """)
        if tts_system:
            gr.HTML("""
            <div style="padding: 1rem; border-radius: 10px; margin: 1rem 0; border-left: 4px solid #28a745; background: #f8f9fa;">
                <h4>🟢 System Ready</h4>
                <p>Using <strong>Coqui TTS</strong> with multiple speaker support</p>
            </div>
            """)
        else:
            gr.HTML("""
            <div style="padding: 1rem; border-radius: 10px; margin: 1rem 0; border-left: 4px solid #dc3545; background: #f8d7da;">
                <h4>🔴 System Error</h4>
                <p>TTS system failed to initialize. Please refresh the page.</p>
            </div>
            """)
        with gr.Row():
            with gr.Column(scale=2):
                text_input = gr.Textbox(
                    label="📝 Enter Your Text",
                    placeholder="Type or paste your text here... (Max 50,000 characters)",
                    lines=10,
                    max_lines=20,
                    info="Supports any length text with automatic chunking for optimal quality"
                )
                char_count = gr.HTML("<span style='color: #666;'>Character count: 0 / 50,000</span>")
                speaker_dropdown = gr.Dropdown(choices=tts_system.speakers if tts_system else [], value="p225", label="🗣️ Choose Voice")
                generate_btn = gr.Button("🎯 Generate Speech", variant="primary", size="lg", scale=1)
            with gr.Column(scale=1):
                gr.HTML("""
                <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 1.5rem; border-radius: 15px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.1);">
                    <h3>✨ Key Features</h3>
                    <ul style="margin: 0; padding-left: 1.2em;">
                        <li>🚀 Handles long texts</li>
                        <li>🎭 Multiple human voices</li>
                        <li>⚡ Smart text processing</li>
                        <li>🔧 Auto chunking</li>
                        <li>🎵 Natural-sounding speech</li>
                    </ul>
                </div>
                """)
        status_output = gr.Textbox(label="📊 Status", interactive=False, value="Ready to generate speech! Enter some text above.")
        audio_output = gr.Audio(label="🔊 Generated Speech", type="filepath", show_download_button=True)

        def update_char_count(text):
            count = len(text) if text else 0
            color = "#28a745" if count <= 50000 else "#dc3545"
            return f'<span style="color: {color};">Character count: {count:,} / 50,000</span>'

        text_input.change(fn=update_char_count, inputs=[text_input], outputs=[char_count])

        generate_btn.click(
            fn=text_to_speech_interface,
            inputs=[text_input, speaker_dropdown],
            outputs=[audio_output, status_output],
            show_progress=True
        )

        gr.Examples(
            examples=[
                ["Hello! Welcome to our advanced text-to-speech system. This technology can convert any written text into natural-sounding human speech.", "p225"],
                ["The quick brown fox jumps over the lazy dog. This pangram contains every letter of the English alphabet and is perfect for testing speech synthesis.", "p226"],
                ["Artificial intelligence has revolutionized many aspects of our daily lives.", "p227"],
            ],
            inputs=[text_input, speaker_dropdown],
            label="📚 Try These Examples"
        )

    return demo


# Launch the application
if __name__ == "__main__":
    demo = create_interface()
    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)