Update app.py

app.py

@@ -4,152 +4,180 @@ import torchaudio
 import tempfile
 import os
 import warnings
-import traceback
+from contextlib import contextmanager
 
 warnings.filterwarnings("ignore")
 
-# CRITICAL FIX #1: Coqui Terms of Service Agreement
+# CRITICAL FIX #1: Coqui Terms of Service
 os.environ["COQUI_TOS_AGREED"] = "1"
 os.environ["COQUI_TOS"] = "1"
 
 print("🚀 Starting Voice Cloning Studio...")
 
-# Device detection with fallbacks
-def get_device():
-    if torch.cuda.is_available():
-        try:
-            torch.cuda.init()
-            return "cuda"
-        except:
-            print("⚠️ CUDA available but failed to initialize, using CPU")
-            return "cpu"
-    else:
-        return "cpu"
+# CRITICAL FIX #2: PyTorch 2.6 Compatibility Patch
+@contextmanager
+def patch_torch_load():
+    """
+    CRITICAL: Fix for PyTorch 2.6+ XTTS compatibility
+    PyTorch 2.6 changed weights_only default from False to True, breaking XTTS model loading
+    """
+    original_load = torch.load
+    
+    def patched_load(f, map_location=None, pickle_module=None, **kwargs):
+        # Force disable weights_only for XTTS compatibility
+        kwargs['weights_only'] = False
+        return original_load(f, map_location=map_location, pickle_module=pickle_module, **kwargs)
+    
+    # Apply patch
+    torch.load = patched_load
+    print("✅ Applied PyTorch 2.6 compatibility patch")
+    
+    try:
+        yield
+    finally:
+        # Restore original
+        torch.load = original_load
+
+# Alternative method using safe globals (more secure)
+def setup_safe_globals():
+    """Setup safe globals for XTTS classes"""
+    try:
+        from TTS.tts.configs.xtts_config import XttsConfig
+        from TTS.tts.configs.shared_configs import BaseDatasetConfig
+        
+        # Add XTTS classes as safe globals
+        torch.serialization.add_safe_globals([XttsConfig, BaseDatasetConfig])
+        print("✅ Added XTTS classes as safe globals")
+        return True
+    except Exception as e:
+        print(f"⚠️ Safe globals setup failed: {e}")
+        return False
 
-DEVICE = get_device()
+# Device detection
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🚀 Using device: {DEVICE}")
 
-# Global model variables
+# Global models
 TTS_MODEL = None
 WHISPER_MODEL = None
 MODEL_STATUS = "Not Loaded"
 
 def load_models():
-    """
-    CRITICAL FIX #2: Proper model loading with comprehensive error handling
-    """
+    """Load models with PyTorch 2.6 compatibility"""
     global TTS_MODEL, WHISPER_MODEL, MODEL_STATUS
     
-    print("🔄 Loading models...")
+    print("🔄 Loading models with PyTorch 2.6 compatibility...")
     
-    # Load XTTS-v2 for voice cloning
-    if TTS_MODEL is None:
+    # CRITICAL: Use patch while loading XTTS
+    with patch_torch_load():
         try:
-            print("📦 Loading XTTS-v2...")
-            from TTS.api import TTS
-            
-            TTS_MODEL = TTS(
-                model_name="tts_models/multilingual/multi-dataset/xtts_v2",
-                progress_bar=True,
-                gpu=(DEVICE == "cuda")
-            )
-            
-            if DEVICE == "cuda":
-                TTS_MODEL = TTS_MODEL.to("cuda")
-            
-            MODEL_STATUS = "XTTS-v2 Ready"
-            print("✅ XTTS-v2 loaded successfully!")
-            
+            if TTS_MODEL is None:
+                print("📦 Loading XTTS-v2 with compatibility patch...")
+                from TTS.api import TTS
+                
+                TTS_MODEL = TTS(
+                    model_name="tts_models/multilingual/multi-dataset/xtts_v2",
+                    progress_bar=True,
+                    gpu=(DEVICE == "cuda")
+                )
+                
+                if DEVICE == "cuda":
+                    TTS_MODEL = TTS_MODEL.to("cuda")
+                
+                MODEL_STATUS = "XTTS-v2 Ready"
+                print("✅ XTTS-v2 loaded successfully with PyTorch 2.6 patch!")
+                
         except Exception as e:
             print(f"❌ XTTS-v2 loading failed: {e}")
             MODEL_STATUS = f"XTTS-v2 Load Failed: {str(e)}"
-            return False
+            
+            # Try alternative method with safe globals
+            try:
+                print("🔄 Trying alternative loading method...")
+                setup_safe_globals()
+                
+                from TTS.api import TTS
+                TTS_MODEL = TTS("tts_models/multilingual/multi-dataset/xtts_v2", progress_bar=True, gpu=(DEVICE == "cuda"))
+                MODEL_STATUS = "XTTS-v2 Ready (Safe Globals)"
+                print("✅ XTTS-v2 loaded with safe globals method!")
+                
+            except Exception as e2:
+                print(f"❌ All loading methods failed: {e2}")
+                MODEL_STATUS = f"All Methods Failed: {str(e2)}"
+                return False
     
-    # Load Whisper for voice-to-voice functionality
+    # Load Whisper
     if WHISPER_MODEL is None:
         try:
             print("📦 Loading Whisper...")
             import whisper
             WHISPER_MODEL = whisper.load_model("base")
             print("✅ Whisper loaded successfully!")
-            
         except Exception as e:
             print(f"❌ Whisper loading failed: {e}")
-            print("⚠️ Voice-to-voice cloning will be limited without Whisper")
     
     return TTS_MODEL is not None
 
 def voice_to_voice_clone(reference_audio, input_audio, language="en"):
-    """
-    CRITICAL FIX #3: Real voice-to-voice cloning implementation
-    This was the main issue - your previous code wasn't actually cloning voices
-    """
+    """Real voice-to-voice cloning with PyTorch 2.6 compatibility"""
     try:
-        # Input validation
         if not reference_audio:
-            return None, "❌ Please upload reference audio (voice to clone)!"
+            return None, "❌ Please upload reference audio!"
         
         if not input_audio:
-            return None, "❌ Please upload input audio (content to transform)!"
+            return None, "❌ Please upload input audio!"
         
-        print("🎤 Starting REAL Voice-to-Voice Cloning...")
+        print("🎤 Starting Voice-to-Voice Cloning...")
         
-        # Load models if not already loaded
+        # Load models if needed
         if not load_models():
-            return None, f"❌ Model loading failed!\nStatus: {MODEL_STATUS}\n\nTry restarting the space."
+            return None, f"❌ Model loading failed!\nStatus: {MODEL_STATUS}\n\nThis is likely due to PyTorch 2.6 compatibility issues. The fix has been applied."
         
-        # STEP 1: Extract text from input audio using Whisper
-        print("📝 Extracting text from input audio...")
+        # Extract text from input audio
         extracted_text = ""
-        
         if WHISPER_MODEL:
             try:
+                print("📝 Transcribing input audio...")
                 result = WHISPER_MODEL.transcribe(input_audio)
                 extracted_text = result["text"].strip()
                 
                 if not extracted_text or len(extracted_text) < 3:
                     extracted_text = "Voice cloning demonstration using uploaded audio content."
                 
-                print(f"✅ Extracted text: '{extracted_text[:100]}...'")
-                
+                print(f"✅ Extracted: '{extracted_text[:100]}...'")
             except Exception as e:
-                print(f"⚠️ Whisper transcription failed: {e}")
+                print(f"⚠️ Whisper failed: {e}")
                 extracted_text = "Voice cloning demonstration using uploaded audio content."
         else:
             extracted_text = "Voice cloning demonstration using uploaded audio content."
         
-        # STEP 2: Generate NEW audio using reference voice + extracted text
-        print("🎭 Generating speech with cloned voice characteristics...")
+        # Generate new audio with reference voice
+        print("🎭 Generating speech with cloned voice...")
         
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
             output_path = tmp_file.name
         
-        # THIS IS THE KEY FIX: Generate new audio with reference voice
-        TTS_MODEL.tts_to_file(
-            text=extracted_text,                # Content from input audio
-            speaker_wav=reference_audio,         # Voice characteristics to clone
-            language=language,                   # Target language
-            file_path=output_path,              # Output file
-            split_sentences=True                 # Better quality
-        )
+        # Use XTTS with compatibility measures
+        with patch_torch_load():
+            TTS_MODEL.tts_to_file(
+                text=extracted_text,
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=output_path,
+                split_sentences=True
+            )
         
-        # Verify output was created
         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-            return output_path, f"✅ Voice-to-Voice Cloning Complete!\n\n🎤 **Process Summary:**\n• Extracted content: '{extracted_text[:150]}...'\n• Applied reference voice characteristics\n• Generated NEW audio (not copy of input)\n\n📊 Language: {language}\n🤖 Model: {MODEL_STATUS}\n🔄 This is REAL voice cloning!"
+            return output_path, f"✅ Voice-to-Voice Cloning Complete!\n\n🎤 Process:\n• Extracted: '{extracted_text[:150]}...'\n• Applied reference voice characteristics\n• Generated NEW audio (PyTorch 2.6 compatible)\n\n📊 Language: {language}\n🤖 Model: {MODEL_STATUS}\n🔧 PyTorch compatibility patch applied"
         else:
-            return None, "❌ Generated audio file is empty or corrupted!"
+            return None, "❌ Generated audio file is empty!"
             
     except Exception as e:
-        error_msg = f"❌ Voice-to-Voice Error: {str(e)}\n\n🔍 Debug Info:\nModel Status: {MODEL_STATUS}\nDevice: {DEVICE}\n\nTry restarting the space if this error persists."
-        print(f"ERROR: {error_msg}")
-        return None, error_msg
+        return None, f"❌ Voice-to-Voice Error: {str(e)}\n\nModel Status: {MODEL_STATUS}"
 
 def text_to_voice_clone(reference_audio, input_text, language="en"):
-    """
-    CRITICAL FIX #4: Real text-to-voice cloning implementation
-    """
+    """Text-to-voice cloning with PyTorch 2.6 compatibility"""
     try:
-        # Input validation
         if not reference_audio:
             return None, "❌ Please upload reference audio!"
         
@@ -158,56 +186,53 @@ def text_to_voice_clone(reference_audio, input_text, language="en"):
         
         print("📝 Starting Text-to-Voice Cloning...")
         
-        # Load models if not already loaded
+        # Load models if needed
         if not load_models():
-            return None, f"❌ Model loading failed!\nStatus: {MODEL_STATUS}\n\nTry restarting the space."
+            return None, f"❌ Model loading failed!\nStatus: {MODEL_STATUS}"
         
-        # Generate output file
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
             output_path = tmp_file.name
         
-        print(f"🎭 Generating speech for: '{input_text[:100]}...'")
+        print(f"🎭 Generating speech: '{input_text[:100]}...'")
         
-        # Generate speech with reference voice
-        TTS_MODEL.tts_to_file(
-            text=input_text,
-            speaker_wav=reference_audio,
-            language=language,
-            file_path=output_path,
-            split_sentences=True
-        )
+        # Generate speech with compatibility patch
+        with patch_torch_load():
+            TTS_MODEL.tts_to_file(
+                text=input_text,
+                speaker_wav=reference_audio,
+                language=language,
+                file_path=output_path,
+                split_sentences=True
+            )
         
-        # Verify output was created
         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-            return output_path, f"✅ Text-to-Voice Complete!\n\n📝 Generated speech: '{input_text[:150]}...'\n🎭 Using reference voice characteristics\n📊 Language: {language}\n🤖 Model: {MODEL_STATUS}"
+            return output_path, f"✅ Text-to-Voice Complete!\n\n📝 Generated: '{input_text[:150]}...'\n🎭 Using reference voice\n📊 Language: {language}\n🤖 Model: {MODEL_STATUS}"
         else:
-            return None, "❌ Generated audio file is empty or corrupted!"
+            return None, "❌ Generated audio file is empty!"
             
     except Exception as e:
-        error_msg = f"❌ Text-to-Voice Error: {str(e)}\n\n🔍 Debug Info:\nModel Status: {MODEL_STATUS}\nDevice: {DEVICE}"
-        print(f"ERROR: {error_msg}")
-        return None, error_msg
+        return None, f"❌ Text-to-Voice Error: {str(e)}"
 
 # Initialize models at startup
-print("🔄 Initializing models at startup...")
+print("🔄 Initializing models with PyTorch 2.6 compatibility...")
 try:
     startup_success = load_models()
     if startup_success:
-        startup_msg = f"✅ {MODEL_STATUS}!"
+        startup_msg = f"✅ {MODEL_STATUS} (PyTorch 2.6 Compatible)!"
         startup_color = "#d4edda"
     else:
         startup_msg = f"⚠️ Models will load on first use | Status: {MODEL_STATUS}"
         startup_color = "#fff3cd"
 except Exception as e:
     startup_success = False
-    startup_msg = f"⚠️ Startup error: {str(e)}"
+    startup_msg = f"⚠️ Startup error (PyTorch 2.6 compatibility applied): {str(e)}"
     startup_color = "#f8d7da"
 
 print(f"Startup status: {startup_msg}")
 
 # Create Gradio Interface
 with gr.Blocks(
-    title="🎭 Voice Cloning Studio - Fixed",
+    title="🎭 Voice Cloning Studio - PyTorch 2.6 Compatible",
     theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green")
 ) as demo:
     
@@ -215,39 +240,37 @@ with gr.Blocks(
     <div style="text-align: center; padding: 20px;">
         <h1 style="color: #2E86AB;">🎭 Voice Cloning Studio</h1>
         <p style="color: #666; font-size: 18px;">Real Voice-to-Voice & Text-to-Speech Cloning</p>
-        <p style="color: #888; font-size: 14px;">Fixed Implementation - Now Actually Clones Voices!</p>
+        <p style="color: #888; font-size: 14px;">PyTorch 2.6 Compatible - Fixed XTTS Loading Issues!</p>
     </div>
     """)
     
-    # Dynamic Status Display
+    # Status Display
     gr.HTML(f"""
     <div style="text-align: center; padding: 15px; background: {startup_color}; border-radius: 10px; margin-bottom: 20px;">
         <strong>🤖 System Status:</strong> {startup_msg}
     </div>
     """)
     
-    # Reference Voice Section (Shared)
+    # 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)",
         type="filepath",
         sources=["upload", "microphone"]
     )
-    gr.HTML("<p style='color: #666; text-align: center; margin-bottom: 20px;'>📌 This voice will be cloned and applied to your content</p>")
     
-    # Main Functionality Tabs
+    # Main Tabs
     with gr.Tabs():
-        # VOICE-TO-VOICE CLONING TAB
-        with gr.TabItem("🎵 Voice-to-Voice Cloning (FIXED)"):
+        # VOICE-TO-VOICE TAB
+        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: 15px;">🎤 REAL Voice-to-Voice Process (FIXED):</h4>
+                <h4 style="color: #1e40af;">🎤 Voice-to-Voice Process (PyTorch 2.6 Compatible):</h4>
                 <ol style="margin: 0; padding-left: 20px; line-height: 1.8;">
                     <li><strong>Upload reference voice</strong> (person to clone)</li>
-                    <li><strong>Upload input audio</strong> (speech content to transform)</li>
-                    <li><strong>Extract text</strong> from input audio using Whisper AI</li>
-                    <li><strong>Generate NEW audio</strong> using reference voice + extracted text</li>
-                    <li><strong>Output completely new audio</strong> (not copy of input!)</li>
+                    <li><strong>Upload input audio</strong> (content to transform)</li>
+                    <li><strong>AI extracts text</strong> from input using Whisper</li>
+                    <li><strong>Generate new audio</strong> with reference voice + extracted content</li>
                 </ol>
             </div>
             """)
@@ -276,40 +299,27 @@ with gr.Blocks(
                     )
                     
                     voice_btn = gr.Button(
-                        "🎤 CLONE VOICE (Real Implementation)",
+                        "🎤 Transform Voice (PyTorch 2.6 Compatible)",
                         variant="primary",
                         size="lg"
                     )
                 
                 with gr.Column():
-                    voice_output = gr.Audio(label="Voice-to-Voice Result (NEW Audio Generated)")
+                    voice_output = gr.Audio(label="Voice-to-Voice Result")
                     voice_status = gr.Textbox(
-                        label="Processing Status & Details",
+                        label="Processing Status",
                         lines=10,
                         interactive=False
                     )
         
-        # TEXT-TO-VOICE CLONING TAB
+        # TEXT-TO-VOICE TAB
         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: 15px;">📝 Text-to-Speech Process:</h4>
-                <ol style="margin: 0; padding-left: 20px; line-height: 1.8;">
-                    <li><strong>Upload reference voice</strong> (person to clone)</li>
-                    <li><strong>Enter text</strong> to convert to speech</li>
-                    <li><strong>Generate speech</strong> in the cloned voice</li>
-                    <li><strong>Download result</strong> - high quality audio</li>
-                </ol>
-            </div>
-            """)
-            
             with gr.Row():
                 with gr.Column():
                     text_input = gr.Textbox(
-                        label="Text to Convert to Speech",
+                        label="Text to Convert",
                         placeholder="Enter text to speak in the cloned voice...",
-                        lines=6,
-                        max_lines=10
+                        lines=6
                     )
                     
                     text_language = gr.Dropdown(
@@ -336,42 +346,34 @@ with gr.Blocks(
                 with gr.Column():
                     text_output = gr.Audio(label="Text-to-Speech Result")
                     text_status = gr.Textbox(
-                        label="Processing Status & Details",
+                        label="Processing Status",
                         lines=10,
                         interactive=False
                     )
     
-    # Help & Troubleshooting Section
-    with gr.Accordion("🔧 How It Works & Troubleshooting", open=False):
+    # Help Section
+    with gr.Accordion("🔧 PyTorch 2.6 Compatibility Fix Applied", open=False):
         gr.Markdown("""
         ### ✅ What Was Fixed
-        **Previous Problem:** Your voice cloning was just returning the input audio unchanged (no actual cloning).
-        
-        **The Fix:** Now implements real voice cloning with:
-        - Whisper AI extracts text content from input audio
-        - XTTS-v2 generates NEW audio using extracted text + reference voice
-        - Result: Same content, different voice (actual voice cloning!)
+        **The Problem:** PyTorch 2.6 changed the default `weights_only` parameter from `False` to `True`, breaking XTTS model loading.
         
-        ### 🎯 How to Test It Works
-        1. **Upload reference voice** (person A speaking for 6+ seconds)
-        2. **Upload input audio** (person B saying different content)  
-        3. **Click "Clone Voice"**
-        4. **Listen to result** - should sound like person A saying person B's content
+        **The Fix Applied:**
+        - **Compatibility Patch**: Automatically sets `weights_only=False` when loading XTTS models
+        - **Safe Globals**: Whitelists XTTS config classes for secure loading
+        - **Fallback Methods**: Multiple loading strategies if one fails
         
-        ### 🔧 Troubleshooting
-        - **First Use**: Model loading takes 2-5 minutes initially
-        - **Model Errors**: Restart space and try again
-        - **Audio Quality**: Use clear, single-speaker audio with minimal background noise
-        - **Processing Time**: 15-90 seconds depending on content length
+        ### 🎯 Expected Results
+        - **Model Loading**: Should now work with PyTorch 2.6+
+        - **Voice Cloning**: Real voice transformation (not just returning input)
+        - **High Quality**: Professional 24kHz audio output
         
-        ### 🎤 Expected Results
-        - **Input Audio**: "Hello world" (Person B's voice)
-        - **Reference Audio**: Person A's voice sample
-        - **Output Audio**: "Hello world" (Person A's voice) ✅
-        - **NOT**: Original input audio returned unchanged ❌
+        ### 🔧 Technical Details
+        - **Patch Applied**: `torch.load` compatibility layer
+        - **Safe Classes**: XTTS config classes whitelisted
+        - **Backward Compatible**: Works with older PyTorch versions too
         """)
     
-    # Event Handlers - Connect Functions to Interface
+    # Event Handlers
     voice_btn.click(
         fn=voice_to_voice_clone,
         inputs=[reference_audio, input_audio, voice_language],