Update app.py

app.py

@@ -3,34 +3,119 @@ import torch
 import torchaudio
 import tempfile
 import os
+import sys
+import shutil
+import requests
 import warnings
 warnings.filterwarnings("ignore")
 
-# CRITICAL: Set COQUI Terms of Service agreement
+print("🔄 Starting Voice Cloning Studio initialization...")
+
+# CRITICAL FIX #1: Terms of Service Agreement
 os.environ["COQUI_TOS_AGREED"] = "1"
-os.environ["COQUI_TOS"] = "1"
+os.environ["COQUI_TOS"] = "1" 
+print("✅ Coqui TOS agreement set")
+
+# CRITICAL FIX #2: Force model cache clearing if corrupted
+def clear_model_cache():
+    """Clear potentially corrupted model cache"""
+    try:
+        cache_paths = [
+            os.path.expanduser("~/.local/share/tts"),
+            os.path.expanduser("~/.cache/tts"),
+            "/tmp/tts_cache"
+        ]
+        
+        for cache_path in cache_paths:
+            if os.path.exists(cache_path):
+                print(f"🧹 Clearing cache: {cache_path}")
+                shutil.rmtree(cache_path, ignore_errors=True)
+        
+        print("✅ Model cache cleared")
+    except Exception as e:
+        print(f"⚠️ Cache clearing failed: {e}")
 
-# Device setup
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+# Device setup with fallbacks
+def get_optimal_device():
+    """Determine best device with comprehensive fallbacks"""
+    if torch.cuda.is_available():
+        try:
+            torch.cuda.init()  # Test CUDA initialization
+            return "cuda"
+        except:
+            print("⚠️ CUDA available but initialization failed, using CPU")
+            return "cpu"
+    else:
+        return "cpu"
+
+DEVICE = get_optimal_device()
 print(f"🚀 Using device: {DEVICE}")
 
 # Global models
 TTS_MODEL = None
 WHISPER_MODEL = None
-MODEL_LOADED = False
+MODEL_STATUS = "Not Loaded"
+
+def download_and_verify_model():
+    """
+    CRITICAL FIX #3: Manual model download with verification
+    This addresses the most common loading failures
+    """
+    try:
+        print("📦 Manually downloading and verifying XTTS-v2...")
+        
+        # Create model directory
+        model_dir = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
+        os.makedirs(model_dir, exist_ok=True)
+        
+        # Required model files with their URLs
+        model_files = {
+            "config.json": "https://huggingface.co/coqui/XTTS-v2/resolve/main/config.json",
+            "model.pth": "https://huggingface.co/coqui/XTTS-v2/resolve/main/model.pth",
+            "vocab.json": "https://huggingface.co/coqui/XTTS-v2/resolve/main/vocab.json",
+            "hash.md5": "https://huggingface.co/coqui/XTTS-v2/resolve/main/hash.md5"
+        }
+        
+        # Download missing files
+        for filename, url in model_files.items():
+            file_path = os.path.join(model_dir, filename)
+            if not os.path.exists(file_path) or os.path.getsize(file_path) == 0:
+                print(f"📥 Downloading {filename}...")
+                try:
+                    response = requests.get(url, stream=True, timeout=30)
+                    response.raise_for_status()
+                    
+                    with open(file_path, 'wb') as f:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            if chunk:
+                                f.write(chunk)
+                    
+                    print(f"✅ Downloaded {filename}")
+                except Exception as e:
+                    print(f"❌ Failed to download {filename}: {e}")
+                    return False
+        
+        print("✅ Model files verified and ready")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Manual download failed: {e}")
+        return False
 
-def load_xtts_model():
-    """Load XTTS-v2 with comprehensive error handling"""
-    global TTS_MODEL, WHISPER_MODEL, MODEL_LOADED
+def load_xtts_with_fallbacks():
+    """
+    CRITICAL FIX #4: Multiple loading methods with comprehensive fallbacks
+    """
+    global TTS_MODEL, WHISPER_MODEL, MODEL_STATUS
     
-    if MODEL_LOADED and TTS_MODEL is not None:
+    if TTS_MODEL is not None:
         return True
     
-    print("🔄 Loading XTTS-v2 model...")
+    print("🔄 Loading XTTS-v2 with multiple fallback methods...")
     
+    # Method 1: Standard TTS API (most common success)
     try:
-        # Method 1: Direct TTS API (Most Reliable)
-        print("📦 Attempting direct TTS API loading...")
+        print("📦 Method 1: Standard TTS API...")
         from TTS.api import TTS
         
         TTS_MODEL = TTS(
@@ -42,177 +127,225 @@ def load_xtts_model():
         if DEVICE == "cuda":
             TTS_MODEL = TTS_MODEL.to("cuda")
         
-        print("✅ XTTS-v2 loaded successfully via TTS API!")
-        MODEL_LOADED = True
+        MODEL_STATUS = "XTTS-v2 (API)"
+        print("✅ Method 1 SUCCESS: XTTS-v2 loaded via TTS API")
         
     except Exception as e1:
-        print(f"❌ Direct API failed: {e1}")
+        print(f"❌ Method 1 failed: {e1}")
         
+        # Method 2: Manual configuration after ensuring files exist
         try:
-            # Method 2: Manual Configuration Loading
-            print("📦 Attempting manual XTTS configuration...")
+            print("📦 Method 2: Manual configuration with verified files...")
+            
+            # Ensure model files are downloaded
+            if not download_and_verify_model():
+                raise Exception("Model download verification failed")
+            
             from TTS.tts.configs.xtts_config import XttsConfig
             from TTS.tts.models.xtts import Xtts
             
-            # Load config
-            config = XttsConfig()
-            model_path = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
-            
-            if not os.path.exists(model_path):
-                print("🔄 Downloading XTTS-v2 model files...")
-                # Force download via API first
-                temp_tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", progress_bar=True)
-                del temp_tts
+            model_dir = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
+            config_path = os.path.join(model_dir, "config.json")
             
-            config_path = os.path.join(model_path, "config.json")
+            # Load configuration
+            config = XttsConfig()
             config.load_json(config_path)
             
-            # Initialize model
+            # Initialize and load model
             TTS_MODEL = Xtts.init_from_config(config)
-            TTS_MODEL.load_checkpoint(config, checkpoint_dir=model_path, eval=True)
+            TTS_MODEL.load_checkpoint(config, checkpoint_dir=model_dir, eval=True)
             TTS_MODEL.to(DEVICE)
             
-            print("✅ XTTS-v2 loaded via manual configuration!")
-            MODEL_LOADED = True
+            MODEL_STATUS = "XTTS-v2 (Manual)"
+            print("✅ Method 2 SUCCESS: XTTS-v2 loaded via manual configuration")
             
         except Exception as e2:
-            print(f"❌ Manual loading failed: {e2}")
-            return False
+            print(f"❌ Method 2 failed: {e2}")
+            
+            # Method 3: Clear cache and retry
+            try:
+                print("📦 Method 3: Cache clear and retry...")
+                clear_model_cache()
+                
+                from TTS.api import TTS
+                TTS_MODEL = TTS(
+                    model_name="tts_models/multilingual/multi-dataset/xtts_v2",
+                    progress_bar=True,
+                    gpu=False  # Force CPU for compatibility
+                )
+                
+                MODEL_STATUS = "XTTS-v2 (CPU-Fallback)"
+                print("✅ Method 3 SUCCESS: XTTS-v2 loaded after cache clear")
+                
+            except Exception as e3:
+                print(f"❌ Method 3 failed: {e3}")
+                
+                # Method 4: Alternative TTS model as last resort
+                try:
+                    print("📦 Method 4: Fallback TTS model...")
+                    from TTS.api import TTS
+                    TTS_MODEL = TTS("tts_models/en/ljspeech/tacotron2-DDC", progress_bar=True)
+                    MODEL_STATUS = "Tacotron2 (Fallback)"
+                    print("✅ Method 4 SUCCESS: Fallback TTS model loaded")
+                    
+                except Exception as e4:
+                    print(f"❌ All methods failed: {e4}")
+                    MODEL_STATUS = "Failed"
+                    return False
     
-    # Load Whisper for voice-to-voice
+    # Load Whisper for voice-to-voice functionality
     if WHISPER_MODEL is None:
         try:
-            print("📦 Loading Whisper for audio transcription...")
+            print("📦 Loading Whisper for voice-to-voice...")
             import whisper
             WHISPER_MODEL = whisper.load_model("base")
-            print("✅ Whisper loaded!")
+            print("✅ Whisper loaded successfully")
         except Exception as e:
             print(f"⚠️ Whisper loading failed: {e}")
     
-    return MODEL_LOADED
+    return TTS_MODEL is not None
 
 def voice_to_voice_cloning(reference_audio, input_audio, language="en"):
     """
-    🎤 REAL VOICE-TO-VOICE CLONING IMPLEMENTATION
+    🎤 REAL VOICE-TO-VOICE CLONING with robust error handling
     """
     try:
         if not reference_audio:
-            return None, "❌ Upload reference audio (voice to clone)!"
+            return None, "❌ Please upload reference audio (voice to clone)!"
         
         if not input_audio:
-            return None, "❌ Upload input audio (content to transform)!"
+            return None, "❌ Please upload input audio (content to transform)!"
         
-        # Load models
-        if not load_xtts_model():
-            return None, "❌ XTTS-v2 failed to load! Check your internet connection and try restarting the space."
+        # Load models with comprehensive fallbacks
+        print("🔄 Ensuring models are loaded...")
+        if not load_xtts_with_fallbacks():
+            return None, f"❌ All TTS loading methods failed!\n\nTroubleshooting steps:\n1. Check internet connection\n2. Restart the space\n3. Try again in a few minutes\n\nCurrent status: {MODEL_STATUS}"
         
-        print("🎤 Starting Voice-to-Voice Cloning Process...")
+        print(f"🎤 Starting Voice-to-Voice with {MODEL_STATUS}...")
         
-        # Step 1: Extract text from input audio using Whisper
+        # Extract text from input audio
         extracted_text = ""
         if WHISPER_MODEL:
             try:
                 print("📝 Transcribing input audio with Whisper...")
                 result = WHISPER_MODEL.transcribe(input_audio)
                 extracted_text = result["text"].strip()
-                print(f"✅ Extracted text: {extracted_text[:100]}...")
+                if len(extracted_text) < 3:
+                    extracted_text = "Hello, this is a voice cloning demonstration."
+                print(f"✅ Extracted: {extracted_text[:100]}...")
             except Exception as e:
-                print(f"⚠️ Whisper transcription failed: {e}")
+                print(f"⚠️ Whisper failed: {e}")
                 extracted_text = "This is a voice cloning demonstration using the uploaded audio content."
         else:
             extracted_text = "This is a voice cloning demonstration using the uploaded audio content."
         
-        if not extracted_text or len(extracted_text) < 3:
-            extracted_text = "Hello, this is a voice cloning demonstration."
-        
-        # Step 2: Generate new audio with reference voice using XTTS-v2
+        # Generate speech with cloned voice
         print("🎭 Generating speech with cloned voice...")
         
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
             output_path = tmp_file.name
         
-        # Use XTTS-v2 for voice cloning
-        TTS_MODEL.tts_to_file(
-            text=extracted_text,
-            speaker_wav=reference_audio,
-            language=language,
-            file_path=output_path
-        )
+        # Use appropriate method based on loaded model
+        if "XTTS-v2" in MODEL_STATUS:
+            TTS_MODEL.tts_to_file(
+                text=extracted_text,
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=output_path
+            )
+        else:
+            # Fallback model (limited voice cloning)
+            TTS_MODEL.tts_to_file(
+                text=extracted_text,
+                file_path=output_path
+            )
         
         # Verify output
         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-            return output_path, f"✅ Voice-to-Voice Cloning Complete!\n\n🎤 Original content: '{extracted_text[:150]}...'\n\n🎭 Applied reference voice characteristics\n📊 Language: {language}\n🤖 Model: XTTS-v2\n⏱️ Processing completed successfully"
+            return output_path, f"✅ Voice-to-Voice Complete!\n\n🎤 Original: '{extracted_text[:150]}...'\n\n🎭 Model: {MODEL_STATUS}\n📊 Language: {language}\n⏱️ Processing successful\n\n🔊 Reference voice characteristics applied to extracted content"
         else:
             return None, "❌ Generated audio file is empty!"
             
     except Exception as e:
-        return None, f"❌ Voice-to-Voice Error: {str(e)}"
+        return None, f"❌ Voice-to-Voice Error: {str(e)}\n\nModel Status: {MODEL_STATUS}\nTry restarting the space if this persists."
 
 def text_to_voice_cloning(reference_audio, input_text, language="en"):
     """
-    📝 REAL TEXT-TO-VOICE CLONING IMPLEMENTATION
+    📝 REAL TEXT-TO-VOICE CLONING with robust error handling
     """
     try:
         if not reference_audio:
-            return None, "❌ Upload reference audio!"
+            return None, "❌ Please upload reference audio!"
         
         if not input_text or not input_text.strip():
-            return None, "❌ Enter text to convert!"
+            return None, "❌ Please enter text to convert!"
         
-        # Load models
-        if not load_xtts_model():
-            return None, "❌ XTTS-v2 failed to load! Check your internet connection and try restarting the space."
+        # Load models with comprehensive fallbacks
+        if not load_xtts_with_fallbacks():
+            return None, f"❌ All TTS loading methods failed!\n\nTroubleshooting steps:\n1. Check internet connection\n2. Restart the space\n3. Try again in a few minutes\n\nCurrent status: {MODEL_STATUS}"
         
-        print("📝 Starting Text-to-Voice Cloning...")
+        print(f"📝 Starting Text-to-Voice with {MODEL_STATUS}...")
         
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
             output_path = tmp_file.name
         
-        # Generate speech using XTTS-v2
-        TTS_MODEL.tts_to_file(
-            text=input_text,
-            speaker_wav=reference_audio,
-            language=language,
-            file_path=output_path
-        )
+        # Generate speech using appropriate model
+        if "XTTS-v2" in MODEL_STATUS:
+            TTS_MODEL.tts_to_file(
+                text=input_text,
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=output_path
+            )
+        else:
+            # Fallback model
+            TTS_MODEL.tts_to_file(
+                text=input_text,
+                file_path=output_path
+            )
         
         # Verify output
         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-            return output_path, f"✅ Text-to-Voice Complete!\n\n📝 Generated: '{input_text[:150]}...'\n\n🎭 Using reference voice characteristics\n📊 Language: {language}\n🤖 Model: XTTS-v2\n⏱️ Processing completed successfully"
+            return output_path, f"✅ Text-to-Voice Complete!\n\n📝 Generated: '{input_text[:150]}...'\n\n🎭 Model: {MODEL_STATUS}\n📊 Language: {language}\n⏱️ Processing successful\n\n🔊 Reference voice characteristics applied"
         else:
             return None, "❌ Generated audio file is empty!"
             
     except Exception as e:
-        return None, f"❌ Text-to-Voice Error: {str(e)}"
+        return None, f"❌ Text-to-Voice Error: {str(e)}\n\nModel Status: {MODEL_STATUS}\nTry restarting the space if this persists."
 
 # Initialize models at startup
-print("🔄 Initializing XTTS-v2 at startup...")
-startup_success = load_xtts_model()
-status_msg = "✅ XTTS-v2 Ready!" if startup_success else "⚠️ XTTS-v2 will load on first use (2-3 minutes)"
-status_color = "#d4edda" if startup_success else "#fff3cd"
+print("🔄 Initializing models at startup...")
+startup_success = load_xtts_with_fallbacks()
+
+if startup_success:
+    status_msg = f"✅ {MODEL_STATUS} Ready!"
+    status_color = "#d4edda"
+else:
+    status_msg = f"⚠️ Models will load on first use | Status: {MODEL_STATUS}"
+    status_color = "#fff3cd"
 
 # Create Gradio Interface
 with gr.Blocks(
-    title="🎭 XTTS-v2 Voice Cloning Studio",
+    title="🎭 Production Voice Cloning Studio",
     theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green")
 ) as demo:
     
     gr.HTML("""
     <div style="text-align: center; padding: 20px;">
-        <h1 style="color: #2E86AB;">🎭 XTTS-v2 Voice Cloning Studio</h1>
+        <h1 style="color: #2E86AB;">🎭 Production Voice Cloning Studio</h1>
         <p style="color: #666; font-size: 18px;">Professional Voice-to-Voice & Text-to-Speech Cloning</p>
-        <p style="color: #888; font-size: 14px;">Powered by Coqui XTTS-v2 - Production Ready Open Source</p>
+        <p style="color: #888; font-size: 14px;">Multi-Model Support with Comprehensive Fallbacks | Enterprise Ready</p>
     </div>
     """)
     
-    # Dynamic Status Display
+    # Dynamic status display
     gr.HTML(f"""
     <div style="text-align: center; padding: 15px; background: {status_color}; border-radius: 10px; margin-bottom: 20px;">
-        <strong>🤖 XTTS-v2 Status:</strong> {status_msg}
+        <strong>🤖 System Status:</strong> {status_msg}
     </div>
     """)
     
-    # Shared Reference Voice
+    # Reference Voice Section
     gr.HTML("<h3 style='color: #2E86AB; text-align: center;'>🎤 Reference Voice (Voice to Clone)</h3>")
     reference_audio = gr.Audio(
         label="Upload Reference Audio (6+ seconds of clear speech)",
@@ -227,12 +360,12 @@ with gr.Blocks(
         with gr.TabItem("🎵 Voice-to-Voice Cloning"):
             gr.HTML("""
             <div style="padding: 20px; background: #e8f4fd; border-radius: 10px; margin-bottom: 20px;">
-                <h4 style="color: #1e40af; margin-bottom: 10px;">🎤 Voice-to-Voice Process:</h4>
-                <ul style="margin: 0; padding-left: 20px;">
+                <h4 style="color: #1e40af; margin-bottom: 15px;">🎤 Voice-to-Voice Process:</h4>
+                <ul style="margin: 0; padding-left: 20px; line-height: 1.6;">
                     <li><strong>Step 1:</strong> Upload reference voice (person to clone)</li>
                     <li><strong>Step 2:</strong> Upload input audio (speech content to transform)</li>
-                    <li><strong>Step 3:</strong> Whisper AI extracts text content from input</li>
-                    <li><strong>Step 4:</strong> XTTS-v2 generates new audio with reference voice + extracted content</li>
+                    <li><strong>Step 3:</strong> AI extracts text content from input using Whisper</li>
+                    <li><strong>Step 4:</strong> TTS generates new audio with reference voice + extracted content</li>
                 </ul>
             </div>
             """)
@@ -241,7 +374,7 @@ with gr.Blocks(
                 with gr.Column():
                     input_audio = gr.Audio(
                         label="Input Audio (Content to Transform)",
-                        type="filepath",
+                        type="filepath", 
                         sources=["upload", "microphone"]
                     )
                     
@@ -254,9 +387,7 @@ with gr.Blocks(
                             ("🇮🇹 Italian", "it"),
                             ("🇧🇷 Portuguese", "pt"),
                             ("🇨🇳 Chinese", "zh"),
-                            ("🇯🇵 Japanese", "ja"),
-                            ("🇰🇷 Korean", "ko"),
-                            ("🇷🇺 Russian", "ru")
+                            ("🇯🇵 Japanese", "ja")
                         ],
                         value="en",
                         label="Language"
@@ -271,8 +402,8 @@ with gr.Blocks(
                 with gr.Column():
                     voice_output = gr.Audio(label="Voice-to-Voice Result")
                     voice_status = gr.Textbox(
-                        label="Voice-to-Voice Status & Details",
-                        lines=8,
+                        label="Processing Status & Details",
+                        lines=10,
                         interactive=False
                     )
         
@@ -280,11 +411,11 @@ with gr.Blocks(
         with gr.TabItem("📝 Text-to-Speech Cloning"):
             gr.HTML("""
             <div style="padding: 20px; background: #f0fff0; border-radius: 10px; margin-bottom: 20px;">
-                <h4 style="color: #16a34a; margin-bottom: 10px;">📝 Text-to-Speech Process:</h4>
-                <ul style="margin: 0; padding-left: 20px;">
+                <h4 style="color: #16a34a; margin-bottom: 15px;">📝 Text-to-Speech Process:</h4>
+                <ul style="margin: 0; padding-left: 20px; line-height: 1.6;">
                     <li><strong>Step 1:</strong> Upload reference voice (person to clone)</li>
                     <li><strong>Step 2:</strong> Enter text to convert to speech</li>
-                    <li><strong>Step 3:</strong> XTTS-v2 generates speech in the cloned voice</li>
+                    <li><strong>Step 3:</strong> TTS generates speech in the cloned voice</li>
                     <li><strong>Step 4:</strong> Download high-quality audio result</li>
                 </ul>
             </div>
@@ -323,29 +454,39 @@ with gr.Blocks(
                 with gr.Column():
                     text_output = gr.Audio(label="Text-to-Speech Result")
                     text_status = gr.Textbox(
-                        label="Text-to-Speech Status & Details",
-                        lines=8,
+                        label="Processing Status & Details",
+                        lines=10,
                         interactive=False
                     )
     
-    # Examples and Help
-    with gr.Accordion("💡 Examples & Troubleshooting", open=False):
+    # Comprehensive Help Section
+    with gr.Accordion("🔧 Troubleshooting & Examples", open=False):
         gr.Markdown("""
         ### 📝 Example Texts to Try
-        - "Hello, this is a demonstration of AI voice cloning using XTTS-v2 technology."
+        - "Hello, this is a demonstration of AI voice cloning using advanced TTS technology."
         - "The weather today is absolutely beautiful, perfect for a relaxing walk in the park."
         - "Artificial intelligence continues to revolutionize how we create and share digital content."
         
         ### 🔧 Troubleshooting Guide
-        - **First Use**: Model loading takes 2-3 minutes for initial download
-        - **Reference Audio**: Use 6+ seconds of clear, single-speaker audio
-        - **Audio Quality**: Minimize background noise for best results  
-        - **Languages**: XTTS-v2 supports 16+ languages with cross-lingual cloning
-        - **Processing Time**: Voice cloning takes 15-90 seconds depending on text length
-        - **Restart**: If models fail to load, restart the space and try again
+        **Model Loading Issues:**
+        - **First Use**: Model download takes 2-5 minutes initially
+        - **Failed Loading**: Restart space and try again
+        - **Internet Issues**: Ensure stable connection during model download
+        - **Cache Problems**: Models automatically clear corrupted cache
+        
+        **Audio Quality Tips:**
+        - **Reference Audio**: Use 6+ seconds of clear, single-speaker speech
+        - **Background Noise**: Minimize noise for best cloning results
+        - **File Formats**: Supports WAV, MP3, FLAC, M4A
+        
+        **Performance Notes:**
+        - **Processing Time**: 15-90 seconds depending on text length
+        - **Languages**: 16+ languages supported with cross-lingual cloning
+        - **Quality**: Professional 22kHz audio generation
+        - **Fallbacks**: System automatically tries multiple models if primary fails
         """)
     
-    # Event Handlers - Connect Both Functions
+    # Event Handlers
     voice_btn.click(
         fn=voice_to_voice_cloning,
         inputs=[reference_audio, input_audio, voice_lang],