Update app.py

app.py

@@ -2,23 +2,20 @@ import gradio as gr
 import os
 import tempfile
 import soundfile as sf
-from huggingface_hub import hf_hub_download
 import numpy as np
 import re
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import gc
-import onnxruntime as ort
 
 # Fix for OpenMP duplicate library error
 os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
 
-# Import KittenTTS after environment setup
-try:
-    from kittentts import KittenTTS
-except ImportError:
-    print("KittenTTS not found, will try alternative loading method")
-    KittenTTS = None
+# Force CPU usage for ONNX Runtime to avoid GPU issues
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+# Import KittenTTS
+from kittentts import KittenTTS
 
 class KittenTTSGradio:
     def __init__(self):
@@ -29,109 +26,37 @@ class KittenTTSGradio:
             'expr-voice-4-m', 'expr-voice-4-f', 'expr-voice-5-m', 'expr-voice-5-f'
         ]
         self.max_workers = max(1, os.cpu_count() - 1) if os.cpu_count() else 2
-        self.load_model()
+        self.model_loaded = False
+        # Don't load model in __init__, do it on first use
     
-    def download_model_files(self, repo_id="KittenML/kitten-tts-mini-0.1"):
-        """Download model files from Hugging Face Hub"""
-        print(f"Downloading model files from {repo_id}...")
-        
-        # Download config file
-        config_path = hf_hub_download(
-            repo_id=repo_id,
-            filename="config.json",
-            cache_dir="./models"
-        )
-        
-        # Read config to get file names
-        import json
-        with open(config_path, 'r') as f:
-            config = json.load(f)
-        
-        # Download model file
-        model_filename = config.get("model_file", "kitten_tts_mini_v0_1.onnx")
-        model_path = hf_hub_download(
-            repo_id=repo_id,
-            filename=model_filename,
-            cache_dir="./models"
-        )
-        
-        # Download voices file
-        voices_filename = config.get("voices", "voices.npz")
-        voices_path = hf_hub_download(
-            repo_id=repo_id,
-            filename=voices_filename,
-            cache_dir="./models"
-        )
-        
-        print(f"Model files downloaded: {model_path}, {voices_path}")
-        return model_path, voices_path
+    def ensure_model_loaded(self):
+        """Ensure model is loaded before use"""
+        if not self.model_loaded:
+            self.load_model()
     
     def load_model(self):
-        """Load the TTS model with proper file downloading"""
+        """Load the TTS model"""
+        if self.model_loaded:
+            return
+            
         try:
             print("Loading KittenTTS model...")
-            
-            # Try multiple methods to load the model
-            if KittenTTS:
-                # Method 1: Try the standard KittenTTS loading
-                try:
-                    self.model = KittenTTS("KittenML/kitten-tts-mini-0.1")
-                    print("Model loaded successfully using KittenTTS library")
-                    return
-                except Exception as e:
-                    print(f"Standard loading failed: {e}")
-            
-            # Method 2: Manual download and loading
-            try:
-                model_path, voices_path = self.download_model_files("KittenML/kitten-tts-mini-0.1")
-                
-                # If KittenTTS is available, try to use it with local files
-                if KittenTTS:
-                    # This might not work depending on the KittenTTS implementation
-                    # but worth trying
-                    self.model = KittenTTS(model_path)
-                else:
-                    # Fallback: Create a simple wrapper
-                    self.model = self.create_simple_model(model_path, voices_path)
-                
-                print("Model loaded successfully using downloaded files")
-                
-            except Exception as e:
-                print(f"Manual loading failed: {e}")
-                
-                # Method 3: Try the nano model as fallback
-                if KittenTTS:
-                    try:
-                        self.model = KittenTTS("KittenML/kitten-tts-nano-0.2")
-                        print("Loaded nano model as fallback")
-                        return
-                    except Exception as e:
-                        print(f"Nano model loading failed: {e}")
-                
-                raise Exception("All model loading methods failed")
-                
+            # Try the mini model first
+            self.model = KittenTTS("KittenML/kitten-tts-mini-0.1")
+            self.model_loaded = True
+            print("Model loaded successfully!")
         except Exception as e:
-            print(f"Error loading model: {e}")
-            raise e
-    
-    def create_simple_model(self, model_path, voices_path):
-        """Create a simple model wrapper if KittenTTS library fails"""
-        class SimpleKittenTTS:
-            def __init__(self, model_path, voices_path):
-                self.session = ort.InferenceSession(model_path)
-                self.voices = np.load(voices_path)
-                
-            def generate(self, text, voice="expr-voice-2-m", speed=1.0):
-                # This is a placeholder - actual implementation would need
-                # to match the ONNX model's input/output format
-                # For now, generate a simple sine wave as placeholder
-                duration = len(text.split()) * 0.5  # Rough estimate
-                sample_rate = 24000
-                t = np.linspace(0, duration, int(sample_rate * duration))
-                audio = np.sin(2 * np.pi * 440 * t) * 0.3  # 440 Hz sine wave
-                return audio
-        
-        return SimpleKittenTTS(model_path, voices_path)
+            print(f"Failed to load mini model: {e}")
+            # Try the nano model as fallback
+            try:
+                print("Trying nano model as fallback...")
+                self.model = KittenTTS("KittenML/kitten-tts-nano-0.2")
+                self.model_loaded = True
+                print("Nano model loaded successfully!")
+            except Exception as e2:
+                print(f"Failed to load nano model: {e2}")
+                self.model_loaded = False
+                raise Exception("Failed to load any KittenTTS model")
     
     def split_into_sentences(self, text):
         """Split text into sentences"""
@@ -174,6 +99,9 @@ class KittenTTSGradio:
     
     def safe_generate_audio(self, text, voice, speed):
         """Generate audio with fallback strategies"""
+        # Ensure model is loaded
+        self.ensure_model_loaded()
+        
         if not self.model:
             raise Exception("Model not loaded")
         
@@ -212,8 +140,11 @@ class KittenTTSGradio:
     
     def convert_text_to_speech(self, text, voice, speed, use_multithreading, progress=gr.Progress()):
         """Main conversion function for Gradio"""
-        if not self.model:
-            raise gr.Error("Model not loaded. Please refresh the page.")
+        # Ensure model is loaded
+        try:
+            self.ensure_model_loaded()
+        except Exception as e:
+            raise gr.Error(f"Failed to load model: {str(e)}")
         
         if not text or not text.strip():
             raise gr.Error("Please enter some text to convert.")
@@ -300,9 +231,10 @@ class KittenTTSGradio:
         except Exception as e:
             raise gr.Error(f"Conversion failed: {str(e)}")
 
-# Initialize the app
-print("Initializing KittenTTS...")
+# Initialize the app - don't load model yet
+print("Initializing KittenTTS app...")
 app = KittenTTSGradio()
+print("App initialized, model will load on first use")
 
 # Create Gradio interface
 def create_interface():
@@ -310,10 +242,15 @@ def create_interface():
         gr.Markdown("""
         # 🎙️ KittenTTS Text-to-Speech Converter
         
-        Convert text to natural-sounding speech using KittenTTS. This app processes text sentence by sentence
-        for better quality and supports multithreading for faster processing.
+        Convert text to natural-sounding speech using KittenTTS - a lightweight TTS model that runs on CPU.
+        
+        **Features:**
+        - 8 different voice options (male and female)
+        - Adjustable speech speed
+        - Sentence-by-sentence processing for better quality
+        - Multithreading support for faster processing
         
-        **Note:** First run may take a moment to download the model files.
+        **Note:** The model will load on first use (~170MB download).
         """)
         
         with gr.Row():
@@ -322,7 +259,8 @@ def create_interface():
                     label="Text to Convert",
                     placeholder="Enter your text here or upload a file...",
                     lines=10,
-                    max_lines=20
+                    max_lines=20,
+                    value=""  # Start with empty text
                 )
                 
                 with gr.Row():
@@ -331,6 +269,8 @@ def create_interface():
                         file_types=[".txt"],
                         type="filepath"
                     )
+                    
+                    clear_btn = gr.Button("Clear Text", size="sm")
                 
                 # File upload handler
                 def load_file(file_path):
@@ -348,11 +288,20 @@ def create_interface():
                             return f"Error loading file: {str(e)}"
                     return ""
                 
+                def clear_text():
+                    return ""
+                
                 file_upload.change(
                     fn=load_file,
                     inputs=[file_upload],
                     outputs=[text_input]
                 )
+                
+                clear_btn.click(
+                    fn=clear_text,
+                    inputs=[],
+                    outputs=[text_input]
+                )
             
             with gr.Column(scale=1):
                 voice_dropdown = gr.Dropdown(
@@ -384,17 +333,16 @@ def create_interface():
                 )
         
         with gr.Row():
-            audio_output = gr.Audio(
-                label="Generated Audio",
-                type="filepath",
-                autoplay=False
-            )
-        
-        with gr.Row():
-            status_output = gr.Markdown(
-                value="Ready to convert text to speech.",
-                label="Status"
-            )
+            with gr.Column():
+                audio_output = gr.Audio(
+                    label="Generated Audio",
+                    type="filepath",
+                    autoplay=False
+                )
+                
+                status_output = gr.Markdown(
+                    value="Ready to convert text to speech."
+                )
         
         # Examples
         gr.Examples(
@@ -416,19 +364,34 @@ def create_interface():
         
         gr.Markdown("""
         ---
-        ### 📝 Notes:
-        - The app processes text sentence by sentence for better quality
-        - Longer texts will take more time to process
-        - Enable multithreading for faster processing of long texts
-        - Maximum recommended text length: ~5000 words for optimal performance
-        - First run will download model files (~170MB for mini model)
+        ### 📝 Tips:
+        - **Chunk Size**: Set to 1 for maximum quality (processes each sentence separately). Increase for faster processing of long texts.
+        - **Trade-offs**: Larger chunks = faster processing but may have less natural pauses between sentences
+        - Processing time depends on text length, chunk size, and multithreading setting
+        - Each voice has different characteristics - try them out!
+        - The model runs entirely on CPU - no GPU required
+        - First conversion will take longer as the model loads
+        
+        ### 🎭 Available Voices:
+        - **expr-voice-2-m/f**: Expressive male/female voices
+        - **expr-voice-3-m/f**: Natural male/female voices  
+        - **expr-voice-4-m/f**: Clear male/female voices
+        - **expr-voice-5-m/f**: Warm male/female voices
+        
+        ### ⚙️ Chunk Size Guide:
+        - **1 sentence**: Best quality, natural pauses (recommended for short texts)
+        - **2-3 sentences**: Good balance of speed and quality
+        - **5+ sentences**: Faster processing for long texts (may sound more continuous)
         """)
     
     return demo
 
 # Create and launch the interface
+print("Creating Gradio interface...")
+demo = create_interface()
+print("Launching app...")
+
 if __name__ == "__main__":
-    demo = create_interface()
     demo.queue(max_size=5)
     demo.launch(
         share=False,