Update app.py

app.py

@@ -1,5 +1,4 @@
 import gradio as gr
-import torch
 import numpy as np
 import re
 import soundfile as sf
@@ -9,90 +8,62 @@ import nltk
 from nltk.tokenize import sent_tokenize
 import warnings
 import time
-from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan
-from datasets import load_dataset
+from TTS.api import TTS
 
 warnings.filterwarnings("ignore")
 
-# Download required NLTK data including punkt_tab
+# Download required NLTK data
 try:
     nltk.data.find('tokenizers/punkt')
-    nltk.data.find('tokenizers/punkt_tab')  # This is the missing one!
 except LookupError:
-    nltk.download(['punkt', 'punkt_tab'], quiet=True)
+    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):
-        print("🔄 Loading TTS models...")
-        try:
-            # Load SpeechT5 - most reliable for HF Spaces
-            print("Loading SpeechT5 TTS...")
-            self.processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
-            self.model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
-            self.vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
-            # Load speaker embeddings
-            print("Loading speaker embeddings...")
-            embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
-            # Use a different speaker embedding for more variety
-            self.speaker_embeddings = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-            self.model = self.model.to(self.device)
-            self.vocoder = self.vocoder.to(self.device)
-            self.speaker_embeddings = self.speaker_embeddings.to(self.device)
-            print("✅ SpeechT5 loaded successfully!")
-        except Exception as e:
-            print(f"❌ Failed to load SpeechT5: {e}")
-            raise Exception(f"TTS model loading failed: {e}")
+        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"""
-        # Remove extra whitespace
         text = re.sub(r'\s+', ' ', text.strip())
-        # Handle common abbreviations
         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',
+            '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)
-        # Convert numbers to words (enhanced)
         text = re.sub(r'\b(\d{1,4})\b', lambda m: self.number_to_words(int(m.group())), text)
-        # Handle years differently (keep as numbers if between 1000-2100)
         text = re.sub(r'\b(1[0-9]{3}|20[0-9]{2}|2100)\b', lambda m: m.group(), text)
-        # Clean up problematic characters but keep essential punctuation
         text = re.sub(r'[^\w\s\.,!?;:\-\(\)\'"]', ' ', text)
-        text = re.sub(r'\s+', ' ', text)
         return text.strip()
 
     def number_to_words(self, num):
-        """Convert numbers to words"""
-        if num == 0:
-            return "zero"
-        # Keep larger numbers as digits to avoid very long text
-        if num > 9999:
-            return str(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"]
+        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
+                "eighty", "ninety"]
+        if num == 0:
+            return "zero"
         if num < 10:
             return ones[num]
         elif num < 20:
@@ -100,7 +71,7 @@ class LongFormTTS:
         elif num < 100:
             return tens[num // 10] + ("" if num % 10 == 0 else " " + ones[num % 10])
         elif num < 1000:
-            return ones[num // 100] + " hundred" + ("" if num % 100 == 0 else " " + self.number_to_words(num % 100))
+            return ones[num // 100] + " hundred" + (" " + self.number_to_words(num % 100)).strip()
         else:
             thousands = num // 1000
             remainder = num % 1000
@@ -109,102 +80,54 @@ class LongFormTTS:
                 result += " " + self.number_to_words(remainder)
             return result
 
-    def chunk_text(self, text, max_length=400):
-        """Split text into manageable chunks"""
+    def chunk_text(self, text, max_length=200):
         sentences = sent_tokenize(text)
         chunks = []
         current_chunk = ""
         for sentence in sentences:
-            sentence = sentence.strip()
-            if not sentence:
-                continue
-            # If adding this sentence would exceed limit
             if len(current_chunk + " " + sentence) > max_length:
-                # Save current chunk if it exists
                 if current_chunk:
                     chunks.append(current_chunk.strip())
-                # If single sentence is too long, split it
-                if len(sentence) > max_length:
-                    words = sentence.split()
-                    temp_chunk = ""
-                    for word in words:
-                        if len(temp_chunk + " " + word) > max_length:
-                            if temp_chunk:
-                                chunks.append(temp_chunk.strip())
-                                temp_chunk = word
-                            else:
-                                # Single word too long, just add it
-                                chunks.append(word)
-                        else:
-                            temp_chunk = temp_chunk + " " + word if temp_chunk else word
-                    current_chunk = temp_chunk
-                else:
-                    current_chunk = sentence
+                current_chunk = sentence
             else:
                 current_chunk = current_chunk + " " + sentence if current_chunk else sentence
-        # Add the last chunk
         if current_chunk:
             chunks.append(current_chunk.strip())
         return [chunk for chunk in chunks if chunk.strip()]
 
-    def generate_speech_chunk(self, text_chunk):
-        """Generate speech for a single chunk"""
+    def generate_speech_chunk(self, text_chunk, speaker):
         try:
-            # Process text through the model
-            inputs = self.processor(text=text_chunk, return_tensors="pt").to(self.device)
-            with torch.no_grad():
-                speech = self.model.generate_speech(
-                    inputs["input_ids"],
-                    self.speaker_embeddings,
-                    vocoder=self.vocoder
-                )
-            # Convert to numpy and move to CPU
-            if isinstance(speech, torch.Tensor):
-                speech = speech.cpu().numpy()
-            return speech
+            audio = self.tts.tts(text=text_chunk, speaker=speaker)
+            return audio
         except Exception as e:
             print(f"Error generating speech for chunk: {e}")
-            print(f"Chunk text: {text_chunk}")
             return None
 
-    def generate_long_speech(self, text, progress_callback=None):
-        """Generate speech for long text"""
-        # Preprocess text
+    def generate_long_speech(self, text, speaker=None, progress_callback=None):
         processed_text = self.preprocess_text(text)
-        print(f"Original length: {len(text)}, Processed length: {len(processed_text)}")
-        # Split into chunks
         chunks = self.chunk_text(processed_text)
         print(f"Split into {len(chunks)} chunks")
-        if not chunks:
-            return None, None
-        # Generate speech for each chunk
         audio_segments = []
-        sample_rate = 16000  # SpeechT5 uses 16kHz
+        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)
-            if audio_chunk is not None and len(audio_chunk) > 0:
-                # Ensure audio is 1D
-                if len(audio_chunk.shape) > 1:
-                    audio_chunk = np.mean(audio_chunk, axis=0)
-                audio_segments.append(audio_chunk)
-                # Add pause between chunks (400ms)
-                pause_samples = int(0.4 * sample_rate)
-                silence = np.zeros(pause_samples)
+            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)
-            # Small delay to prevent overwhelming the system
             time.sleep(0.1)
+
         if not audio_segments:
             return None, None
-        # Concatenate all segments
+
         final_audio = np.concatenate(audio_segments)
-        # Normalize audio to prevent clipping
         max_val = np.max(np.abs(final_audio))
         if max_val > 0:
             final_audio = final_audio / max_val * 0.95
-        return final_audio, sample_rate
+        return final_audio, self.sample_rate
 
 
 # Global TTS system
@@ -217,43 +140,37 @@ except Exception as e:
     tts_system = None
 
 
-def text_to_speech_interface(text, progress=gr.Progress()):
-    """Main Gradio interface function"""
+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."
-    # Text length check
     if len(text) > 50000:
-        return None, "⚠️ Text is too long. Please keep it under 50,000 characters for optimal performance."
+        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...")
-        # Generate audio
-        audio, sample_rate = tts_system.generate_long_speech(text, progress_callback)
-        if audio is None or len(audio) == 0:
-            return None, "❌ Failed to generate audio. Please try with different text."
+        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...")
-        # Save to temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_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:
-        error_msg = f"❌ Error: {str(e)}"
-        print(f"TTS Error: {e}")
-        return None, error_msg
+        return None, f"❌ Error: {str(e)}"
 
 
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(
-        title="🎤 Long-Form Text-to-Speech",
+        title="🎤 Long-Form Text-to-Speech (Coqui)",
         theme=gr.themes.Soft(),
         css="""
         .main-header {
@@ -264,40 +181,24 @@ def create_interface():
             -webkit-text-fill-color: transparent;
             background-clip: text;
         }
-        .feature-box {
-            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);
-        }
-        .status-box {
-            padding: 1rem;
-            border-radius: 10px;
-            margin: 1rem 0;
-            border-left: 4px solid #28a745;
-            background: #f8f9fa;
-        }
         """
     ) as demo:
         gr.HTML("""
         <div class="main-header">
             <h1>🎤 Long-Form Text-to-Speech Generator</h1>
-            <p style="color: #666; font-size: 1.1em;">Transform any text into natural human-like speech using advanced AI</p>
+            <p style="color: #666; font-size: 1.1em;">Choose a voice and transform any text into expressive human-like speech</p>
         </div>
         """)
-        # System status
         if tts_system:
             gr.HTML("""
-            <div class="status-box">
+            <div style="padding: 1rem; border-radius: 10px; margin: 1rem 0; border-left: 4px solid #28a745; background: #f8f9fa;">
                 <h4>🟢 System Ready</h4>
-                <p>Using <strong>Microsoft SpeechT5</strong> - High quality neural text-to-speech</p>
+                <p>Using <strong>Coqui TTS</strong> with multiple speaker support</p>
             </div>
             """)
         else:
             gr.HTML("""
-            <div class="status-box" style="border-left-color: #dc3545; background: #f8d7da;">
+            <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>
@@ -312,95 +213,52 @@ def create_interface():
                     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>")
-                generate_btn = gr.Button(
-                    "🎯 Generate Speech",
-                    variant="primary",
-                    size="lg",
-                    scale=1
-                )
+                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 class="feature-box">
+                <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>🎭 Natural human voice</li>
+                        <li>🎭 Multiple human voices</li>
                         <li>⚡ Smart text processing</li>
                         <li>🔧 Auto chunking</li>
-                        <li>🆓 Completely free</li>
-                        <li>📱 Mobile friendly</li>
-                        <li>🎵 High quality audio</li>
+                        <li>🎵 Natural-sounding speech</li>
                     </ul>
                 </div>
                 """)
-        # Status and output
-        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
-        )
-        # Character counter
+        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 button click
+
+        text_input.change(fn=update_char_count, inputs=[text_input], outputs=[char_count])
+
         generate_btn.click(
             fn=text_to_speech_interface,
-            inputs=[text_input],
+            inputs=[text_input, speaker_dropdown],
             outputs=[audio_output, status_output],
             show_progress=True
         )
-        # Example texts
+
         gr.Examples(
             examples=[
-                ["Hello! Welcome to our advanced text-to-speech system. This technology can convert any written text into natural-sounding human speech."],
-                ["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."],
-                ["In the beginning was the Word, and the Word was with God, and the Word was God. This famous opening from the Gospel of John demonstrates the power of language."],
-                ["Artificial intelligence has revolutionized many aspects of our daily lives. From voice assistants to recommendation systems, AI technologies are becoming increasingly sophisticated and accessible to everyone."],
-                ["Once upon a time, in a land far away, there lived a wise old wizard who possessed the power to transform written words into spoken language. This magical ability brought stories to life for all who listened."]
+                ["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],
+            inputs=[text_input, speaker_dropdown],
             label="📚 Try These Examples"
         )
-        # Information section
-        gr.HTML("""
-        <div style="margin-top: 2rem; padding: 1.5rem; background: #f8f9fa; border-radius: 10px; border-left: 4px solid #007bff;">
-            <h4>🔧 How It Works</h4>
-            <ol style="margin: 0.5rem 0; padding-left: 1.5rem;">
-                <li><strong>Text Processing:</strong> Automatically cleans and normalizes your input text</li>
-                <li><strong>Smart Chunking:</strong> Splits long text at natural sentence boundaries</li>
-                <li><strong>Neural Synthesis:</strong> Uses Microsoft's SpeechT5 model for speech generation</li>
-                <li><strong>Audio Assembly:</strong> Combines all chunks with natural pauses</li>
-            </ol>
-            <h4 style="margin-top: 1rem;">💡 Tips for Best Results</h4>
-            <ul style="margin: 0.5rem 0; padding-left: 1.5rem;">
-                <li>Use proper punctuation for natural pauses and intonation</li>
-                <li>Spell out abbreviations if you want them pronounced fully</li>
-                <li>Well-formatted text produces the most natural speech</li>
-                <li>The system automatically handles common abbreviations and numbers</li>
-            </ul>
-        </div>
-        """)
+
     return demo
 
 
 # Launch the application
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        ssr_mode=False
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)