Update app.py

app.py

@@ -6,7 +6,6 @@ import builtins
 _original_input = builtins.input
 
 def _patched_input(prompt):
-    """Automatically answer 'y' to any license/TOS prompt"""
     license_keywords = ['license', 'agree', 'confirm', 'purchased', 'cpml', 'coqui', '?', '>', 'yes/no', 'y/n']
     if any(keyword in prompt.lower() for keyword in license_keywords):
         print(f"[AUTO-ACCEPT] {prompt.strip()}")
@@ -22,10 +21,8 @@ import tempfile
 import os
 import time
 import numpy as np
-import subprocess
 import librosa
 import soundfile as sf
-from pathlib import Path
 
 # ============================================================
 #  GLOBAL CONFIGURATION
@@ -36,233 +33,114 @@ SUPPORTED_LANGUAGES = [
     "ru", "nl", "cs", "ar", "zh-cn", "ja"
 ]
 
-# Model cache
 _tts = None
 _model_loading = False
 _loading_error = None
 
 # ============================================================
-#  ADVANCED AUDIO PREPROCESSING FOR XTTS
+#  AUDIO PREPROCESSING
 # ============================================================
 
 def preprocess_audio_for_xtts(input_path):
-    """
-    Preprocess audio to the exact format XTTS expects.
-    Returns path to processed audio and diagnostic info.
-    """
     output_path = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
-    
-    # Load audio with librosa
     try:
         y, sr = librosa.load(input_path, sr=None, mono=True)
-        original_duration = len(y) / sr
-        
-        # Resample to 22050 Hz (XTTS expects this)
         target_sr = 22050
         if sr != target_sr:
             y = librosa.resample(y, orig_sr=sr, target_sr=target_sr)
             sr = target_sr
-        
-        # Normalize volume
         y = y / np.max(np.abs(y)) * 0.95
-        
-        # Trim silence from beginning and end
         y, _ = librosa.effects.trim(y, top_db=25)
-        
-        # Ensure minimum length (3 seconds after trimming)
         min_samples = 3 * sr
         if len(y) < min_samples:
-            # Pad with zeros if too short
             y = np.pad(y, (0, min_samples - len(y)))
-        
-        # Save processed audio
         sf.write(output_path, y, sr)
-        
-        processed_duration = len(y) / sr
-        
-        info = {
-            "original_duration": original_duration,
-            "processed_duration": processed_duration,
-            "sample_rate": sr,
-            "status": "success"
-        }
-        
-        return output_path, info
-        
+        return output_path, {"status": "success"}
     except Exception as e:
         return input_path, {"status": "error", "error": str(e)}
 
 def analyze_audio_quality(file_path):
-    """Analyze audio and return quality metrics."""
     try:
         y, sr = librosa.load(file_path, sr=None)
         duration = len(y) / sr
-        
-        # Detect silence percentage
-        energy = np.abs(y)
-        silence_threshold = np.max(energy) * 0.05
-        silence_samples = np.sum(energy < silence_threshold)
-        silence_percentage = (silence_samples / len(y)) * 100
-        
-        # Detect clipping
-        clipping = np.sum(np.abs(y) > 0.99)
-        clipping_percentage = (clipping / len(y)) * 100
-        
-        return {
-            "duration": duration,
-            "sample_rate": sr,
-            "silence_percentage": silence_percentage,
-            "clipping_percentage": clipping_percentage,
-            "is_good": duration >= 6 and silence_percentage < 30 and clipping_percentage < 5
-        }
+        return {"duration": duration, "sample_rate": sr}
     except Exception as e:
-        return {"duration": 0, "is_good": False, "error": str(e)}
+        return {"duration": 0, "error": str(e)}
 
 # ============================================================
 #  MODEL LOADING
 # ============================================================
 
 def is_model_downloaded():
-    """Check if the XTTS-v2 model is already downloaded."""
-    model_path = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
-    return os.path.exists(model_path)
+    path = os.path.expanduser("~/.local/share/tts/tts_models--multilingual--multi-dataset--xtts_v2")
+    return os.path.exists(path)
 
 def get_tts(progress_callback=None):
-    """Lazy-load the XTTS-v2 model with proper error handling."""
     global _tts, _model_loading, _loading_error
-    
     if _tts is not None:
         return _tts
-    
     if _loading_error is not None:
         raise Exception(_loading_error)
-    
     if _model_loading:
         raise Exception("Model is still loading")
     
     try:
         _model_loading = True
-        
-        if not is_model_downloaded():
-            if progress_callback:
-                progress_callback(0.1, desc="📥 Downloading 4GB model... (2-5 minutes)")
-            print("=" * 60)
-            print("Downloading XTTS-v2 model (4GB)...")
-            print("This will take 2-5 minutes on first run.")
-            print("=" * 60)
+        if not is_model_downloaded() and progress_callback:
+            progress_callback(0.1, desc="Downloading 4GB model (2-5 minutes)...")
         
         from TTS.api import TTS
-        
         if progress_callback:
-            progress_callback(0.3, desc="🔄 Loading model into memory...")
+            progress_callback(0.3, desc="Loading model...")
         
         _tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=torch.cuda.is_available())
         
         if torch.cuda.is_available():
             _tts.to("cuda")
-            if progress_callback:
-                progress_callback(0.8, desc="✅ Model loaded on GPU")
-            print("Model loaded on GPU")
-        else:
-            if progress_callback:
-                progress_callback(0.8, desc="⚠️ Model loaded on CPU (slower)")
-            print("Model loaded on CPU")
         
         _model_loading = False
         return _tts
-        
     except Exception as e:
         _loading_error = str(e)
         _model_loading = False
         raise Exception(str(e))
 
 # ============================================================
-#  MAIN SYNTHESIS FUNCTION
+#  SYNTHESIS FUNCTIONS
 # ============================================================
 
-def synthesize(
-    text: str, 
-    reference_audio, 
-    language: str = "en", 
-    speed: float = 1.0,
-    progress=gr.Progress()
-):
-    """Synthesize speech using zero-shot voice cloning."""
+def synthesize(text, reference_audio, language="en", speed=1.0, progress=gr.Progress()):
+    progress(0, desc="Validating inputs...")
     
-    progress(0, desc="🔍 Validating inputs...")
-    
-    # Validate text
     if not text or not text.strip():
         raise gr.Error("Please enter some text to synthesize.")
-    
     if len(text) > MAX_TEXT_LENGTH:
         raise gr.Error(f"Text exceeds {MAX_TEXT_LENGTH} characters.")
-    
-    # Validate audio
     if reference_audio is None:
         raise gr.Error("Please upload a reference audio file.")
-    
     if not os.path.exists(reference_audio):
-        raise gr.Error("Audio file not found. Please upload again.")
+        raise gr.Error("Audio file not found.")
     
-    # Analyze audio quality
-    progress(0.05, desc="🔊 Analyzing audio quality...")
     quality = analyze_audio_quality(reference_audio)
-    
     if quality.get("error"):
         raise gr.Error(f"Cannot read audio file: {quality['error']}")
-    
-    # Check audio duration
     if quality["duration"] < 3:
-        raise gr.Error(
-            f"❌ Audio is too short ({quality['duration']:.1f} seconds).\n\n"
-            f"Please upload an audio file that is at least 6 seconds long "
-            f"with clear speech and no background noise."
-        )
-    
-    if quality["duration"] < 6:
-        gr.Warning(f"⚠️ Audio is only {quality['duration']:.1f} seconds. For best results, use 6-10 seconds.")
-    
-    # Check for too much silence
-    if quality.get("silence_percentage", 0) > 50:
-        gr.Warning(
-            f"⚠️ Audio has {quality['silence_percentage']:.1f}% silence. "
-            f"Trim silence for better results."
-        )
-    
-    # Show audio diagnostics
-    print(f"\n📊 Audio Analysis:")
-    print(f"  - Duration: {quality['duration']:.1f} seconds")
-    print(f"  - Sample rate: {quality['sample_rate']} Hz")
-    print(f"  - Silence: {quality.get('silence_percentage', 0):.1f}%")
+        raise gr.Error(f"Audio is too short ({quality['duration']:.1f}s). Minimum 6 seconds required.")
     
     try:
-        # Show download warning if first time
         if not is_model_downloaded():
-            progress(0.1, desc="⚠️ FIRST RUN: Downloading 4GB model (2-5 minutes)...")
-        
-        # Preprocess audio
-        progress(0.15, desc="🔄 Preprocessing audio for XTTS...")
-        processed_audio, audio_info = preprocess_audio_for_xtts(reference_audio)
+            progress(0.1, desc="First run: downloading model...")
         
-        if audio_info.get("status") == "error":
-            gr.Warning(f"Audio preprocessing warning: {audio_info.get('error')}")
+        progress(0.15, desc="Preprocessing audio...")
+        processed_audio, _ = preprocess_audio_for_xtts(reference_audio)
         
-        # Load TTS model
-        progress(0.25, desc="🔄 Loading TTS model...")
+        progress(0.25, desc="Loading TTS model...")
         tts = get_tts(progress_callback=progress)
         
-        # Create output file
-        progress(0.45, desc="📝 Preparing synthesis...")
-        timestamp = int(time.time())
-        output_path = tempfile.NamedTemporaryFile(
-            suffix=f"_{timestamp}.wav", 
-            delete=False
-        ).name
-        
-        # Generate speech
-        progress(0.6, desc="🎤 Synthesizing speech (10-30 seconds)...")
+        progress(0.45, desc="Preparing synthesis...")
+        output_path = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
         
+        progress(0.6, desc="Synthesizing speech...")
         tts.tts_to_file(
             text=text.strip(),
             speaker_wav=processed_audio,
@@ -271,139 +149,65 @@ def synthesize(
             speed=speed,
         )
         
-        # Verify output
-        progress(0.9, desc="✅ Finalizing...")
-        if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
-            raise Exception("Output file was not created")
-        
-        # Clean up temp file
         if processed_audio != reference_audio and os.path.exists(processed_audio):
             try:
                 os.unlink(processed_audio)
             except:
                 pass
         
-        progress(1.0, desc="✨ Complete!")
+        progress(1.0, desc="Complete!")
         return output_path
-        
     except Exception as e:
-        error_msg = str(e)
-        
-        if "list index out of range" in error_msg:
-            raise gr.Error(
-                "❌ Voice cloning failed - XTTS couldn't extract a speaker embedding.\n\n"
-                "This usually happens when:\n"
-                "1. Your audio doesn't contain clear, isolated speech\n"
-                "2. There's too much background noise\n"
-                "3. The audio is too short (< 6 seconds)\n"
-                "4. Multiple speakers are present\n\n"
-                "Try this test audio:\n"
-                "1. Record yourself saying \"Hello, this is my voice\" for 6-10 seconds\n"
-                "2. Save as WAV file\n"
-                "3. Upload and try again\n\n"
-                "If it still fails, please check the container logs for details."
-            )
+        if "list index out of range" in str(e):
+            raise gr.Error("Voice cloning failed. Try a cleaner audio file (6-10 seconds, clear speech, no noise).")
         else:
-            raise gr.Error(f"❌ Synthesis failed: {error_msg[:200]}")
+            raise gr.Error(f"Synthesis failed: {str(e)[:200]}")
 
-# ============================================================
-#  BATCH SYNTHESIS
-# ============================================================
-
-def synthesize_batch(
-    text: str,
-    reference_audio,
-    language: str = "en",
-    speed: float = 1.0,
-    chunk_size: int = 500,
-    progress=gr.Progress()
-):
-    """Synthesize long text by splitting into chunks."""
+def synthesize_batch(text, reference_audio, language="en", speed=1.0, chunk_size=500, progress=gr.Progress()):
     if not text or not text.strip():
-        raise gr.Error("Please enter some text to synthesize.")
-    
+        raise gr.Error("Please enter some text.")
     if len(text) <= MAX_TEXT_LENGTH:
         return synthesize(text, reference_audio, language, speed, progress)
     
-    progress(0.05, desc="📝 Splitting text...")
-    
-    # Split into sentences
+    progress(0.05, desc="Splitting text...")
     sentences = text.replace('\n', ' ').split('. ')
     chunks = []
-    current_chunk = ""
-    
+    current = ""
     for sentence in sentences:
-        if len(current_chunk) + len(sentence) + 2 <= chunk_size:
-            if current_chunk:
-                current_chunk += ". " + sentence
-            else:
-                current_chunk = sentence
+        if len(current) + len(sentence) + 2 <= chunk_size:
+            current += (". " + sentence) if current else sentence
         else:
-            if current_chunk:
-                chunks.append(current_chunk)
-            current_chunk = sentence
-    
-    if current_chunk:
-        chunks.append(current_chunk)
-    
-    if not chunks:
-        raise gr.Error("Could not split text into chunks.")
-    
-    progress(0.1, desc=f"📊 {len(chunks)} chunks created")
+            if current:
+                chunks.append(current)
+            current = sentence
+    if current:
+        chunks.append(current)
     
-    # Preprocess audio once
+    progress(0.1, desc=f"{len(chunks)} chunks created")
     processed_audio, _ = preprocess_audio_for_xtts(reference_audio)
-    
-    # Synthesize chunks
     audio_files = []
-    total_chunks = len(chunks)
     
     for i, chunk in enumerate(chunks):
-        chunk_progress = 0.1 + (0.7 * (i / total_chunks))
-        progress(chunk_progress, desc=f"🎤 Chunk {i+1}/{total_chunks}...")
-        
-        with tempfile.NamedTemporaryFile(suffix=f"_chunk_{i}.wav", delete=False) as f:
-            chunk_path = f.name
-        
+        progress(0.1 + (0.7 * i / len(chunks)), desc=f"Chunk {i+1}/{len(chunks)}...")
+        chunk_path = tempfile.NamedTemporaryFile(suffix=f"_chunk_{i}.wav", delete=False).name
         tts = get_tts()
-        tts.tts_to_file(
-            text=chunk.strip(),
-            speaker_wav=processed_audio,
-            language=language,
-            file_path=chunk_path,
-            speed=speed,
-        )
+        tts.tts_to_file(text=chunk.strip(), speaker_wav=processed_audio, language=language, file_path=chunk_path, speed=speed)
         audio_files.append(chunk_path)
     
-    # Combine
-    progress(0.85, desc="🔊 Combining...")
-    
+    progress(0.85, desc="Combining audio...")
     try:
         from pydub import AudioSegment
-        
         combined = AudioSegment.empty()
-        for audio_file in audio_files:
-            segment = AudioSegment.from_wav(audio_file)
-            combined += segment
-        
+        for f in audio_files:
+            combined += AudioSegment.from_wav(f)
         output_path = tempfile.NamedTemporaryFile(suffix="_combined.wav", delete=False).name
         combined.export(output_path, format="wav")
-        
-        # Cleanup
-        for audio_file in audio_files:
+        for f in audio_files:
             try:
-                os.unlink(audio_file)
+                os.unlink(f)
             except:
                 pass
-        if processed_audio != reference_audio and os.path.exists(processed_audio):
-            try:
-                os.unlink(processed_audio)
-            except:
-                pass
-        
-        progress(1.0, desc="✨ Complete!")
         return output_path
-        
     except Exception as e:
         raise gr.Error(f"Failed to combine: {str(e)}")
 
@@ -416,130 +220,79 @@ def clear_cache():
     _tts = None
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-    return "🗑️ Cache cleared"
+    return "Cache cleared"
 
 def get_model_status():
     if _tts is not None:
-        device = "GPU" if torch.cuda.is_available() else "CPU"
-        return f"✅ Loaded on {device}"
+        return f"Loaded on {'GPU' if torch.cuda.is_available() else 'CPU'}"
     elif _model_loading:
-        return "⏳ Loading..."
+        return "Loading..."
     elif _loading_error:
-        return f"❌ {_loading_error[:50]}"
+        return f"Error: {_loading_error[:50]}"
     elif not is_model_downloaded():
-        return "📥 Will download on first use (4GB)"
-    else:
-        return "🔄 Not loaded"
+        return "Will download on first use (4GB)"
+    return "Not loaded"
 
 def estimate_duration(text, speed=1.0):
-    if not text:
-        return 0
-    chars_per_second = 150 * speed
-    return round(len(text) / chars_per_second, 1)
+    return round(len(text) / (150 * speed), 1) if text else 0
 
 # ============================================================
-#  UI
+#  UI - NO TRIPLE QUOTES
 # ============================================================
 
 with gr.Blocks(title="VoxForge TTS", theme=gr.themes.Soft()) as demo:
     
-    gr.Markdown("""
-    # 🎙️ VoxForge TTS - Voice Cloning
-    
-    **Upload a 6-10 second WAV file** of any voice and make it speak any text.
-    
-    ⚠️ **First use**: Downloads 4GB model (2-5 minutes). Please wait!
-    """)
+    gr.Markdown("# 🎙️ VoxForge TTS - Voice Cloning")
+    gr.Markdown("**Upload a 6-10 second WAV file** of any voice and make it speak any text.")
+    gr.Markdown("⚠️ **First use**: Downloads 4GB model (2-5 minutes). Please wait!")
     
     with gr.Tabs():
-        # TAB 1: Standard
+        
+        # TAB 1
         with gr.Tab("🎤 Standard"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    text_input = gr.Textbox(
-                        label="Text",
-                        lines=6,
-                        max_length=2000,
-                        placeholder="Enter text to synthesize..."
-                    )
-                    
+                    text_input = gr.Textbox(label="Text to Synthesize", lines=6, max_length=2000, placeholder="Enter text to synthesize... (max 2000 characters)")
                     with gr.Row():
                         char_count = gr.Label("0/2000")
                         est_duration = gr.Label("Est. 0s")
-                    
-                    ref_audio = gr.Audio(
-                        label="Reference Voice (6-10 sec, WAV)",
-                        type="filepath",
-                        sources=["upload"]
-                    )
-                    
+                    ref_audio = gr.Audio(label="Reference Voice (6-10 seconds)", type="filepath", sources=["upload"])
                     with gr.Row():
-                        language = gr.Dropdown(
-                            choices=SUPPORTED_LANGUAGES,
-                            value="en",
-                            label="Language"
-                        )
+                        language = gr.Dropdown(choices=SUPPORTED_LANGUAGES, value="en", label="Language")
                         speed = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="Speed")
-                    
                     with gr.Row():
-                        generate_btn = gr.Button("Generate", variant="primary")
+                        generate_btn = gr.Button("Generate Speech", variant="primary")
                         clear_btn = gr.Button("Clear", variant="secondary")
-                    
                     with gr.Accordion("Advanced", open=False):
                         model_status = gr.Label(get_model_status())
-                        clear_cache_btn = gr.Button("Clear Cache")
+                        clear_cache_btn = gr.Button("Clear Model Cache")
                 
                 with gr.Column(scale=1):
                     audio_output = gr.Audio(label="Generated Speech", type="filepath")
-                    
-                    gr.Markdown("""
-                    ### 📝 Tips
-                    
-                    1. **Audio**: 6-10 seconds, clear speech, no noise
-                    2. **Format**: WAV recommended (MP3 works too)
-                    3. **Language**: Match reference voice language
-                    
-                    ### Test audio
-                    If it fails, record yourself saying:
-                    > "Hello, this is my voice. Testing one, two, three."
-                    """)
+                    gr.Markdown("### Tips")
+                    gr.Markdown("1. Use 6-10 seconds of clear speech, no background noise")
+                    gr.Markdown("2. WAV format at 22050Hz mono recommended")
+                    gr.Markdown("3. Match the language of your reference voice")
             
             def update_count(t):
                 return f"{len(t)}/2000" if t else "0/2000"
-            
             def update_dur(t, s):
                 return f"Est. {estimate_duration(t, s)}s" if t else "Est. 0s"
             
             text_input.change(update_count, [text_input], [char_count])
             text_input.change(update_dur, [text_input, speed], [est_duration])
             speed.change(update_dur, [text_input, speed], [est_duration])
-            
-            generate_btn.click(
-                synthesize,
-                [text_input, ref_audio, language, speed],
-                [audio_output]
-            )
-            
-            clear_btn.click(
-                lambda: ("", None, "en", 1.0),
-                None,
-                [text_input, ref_audio, language, speed]
-            )
-            
-            clear_cache_btn.click(clear_cache, None, [model_status]).then(
-                lambda: get_model_status(), None, [model_status]
-            )
-        
-        # TAB 2: Batch
-        with gr.Tab("📚 Batch (Long Text)"):
+            generate_btn.click(synthesize, [text_input, ref_audio, language, speed], [audio_output])
+            clear_btn.click(lambda: ("", None, "en", 1.0), None, [text_input, ref_audio, language, speed])
+            clear_cache_btn.click(clear_cache, None, [model_status]).then(lambda: get_model_status(), None, [model_status])
+        
+        # TAB 2
+        with gr.Tab("📚 Batch"):
+            gr.Markdown("### Long Text Synthesis")
+            gr.Markdown("Automatically splits long texts (over 2000 characters) into smaller chunks.")
             with gr.Row():
                 with gr.Column(scale=1):
-                    long_text = gr.Textbox(
-                        label="Long Text",
-                        lines=12,
-                        max_length=10000,
-                        placeholder="Paste long text here (up to 10000 chars)..."
-                    )
+                    long_text = gr.Textbox(label="Long Text", lines=12, max_length=10000, placeholder="Paste long text here (up to 10000 characters)...")
                     chunk_size = gr.Slider(300, 800, value=500, step=50, label="Chunk Size")
                     ref_audio_batch = gr.Audio(label="Reference Voice", type="filepath", sources=["upload"])
                     with gr.Row():
@@ -549,41 +302,38 @@ with gr.Blocks(title="VoxForge TTS", theme=gr.themes.Soft()) as demo:
                 with gr.Column(scale=1):
                     batch_output = gr.Audio(label="Generated Speech", type="filepath")
             
-            batch_btn.click(
-                synthesize_batch,
-                [long_text, ref_audio_batch, lang_batch, speed_batch, chunk_size],
-                [batch_output]
-            )
+            batch_btn.click(synthesize_batch, [long_text, ref_audio_batch, lang_batch, speed_batch, chunk_size], [batch_output])
         
-        # TAB 3: Help
+        # TAB 3
         with gr.Tab("❓ Help"):
-            gr.Markdown("""
-            ## Quick Start
-            
-            1. **Record test audio**: Say "Hello, this is my voice" for 6-10 seconds
-            2. **Save as WAV** (use Audacity or any recorder)
-            3. **Upload** to the Space
-            4. **Enter text** you want to synthesize
-            5. **Click Generate**
-            
-            ## Common Issues
-            
-            ### "list index out of range" error
-            - Your audio doesn't have clear speech
-            - Try a cleaner recording
-            - Use 6-10 seconds minimum
-            - Remove background noise
-            
-            ### First synthesis is slow
-            - Normal! Downloads 4GB model
-            - Takes 2-5 minutes
-            - Subsequent uses are fast
-            
-            ## Fixing Your Audio
-            
-            ```bash
-            # Convert to correct format
-            ffmpeg -i input.mp3 -ac 1 -ar 22050 output.wav
-            
-            # Trim silence
-            ffmpeg -i input.wav -af silenceremove=1:0:-50dB output.wav
+            gr.Markdown("## Quick Start")
+            gr.Markdown("1. Record a 6-10 second clip of yourself speaking clearly")
+            gr.Markdown("2. Save as WAV file")
+            gr.Markdown("3. Upload to the Space")
+            gr.Markdown("4. Enter text you want to synthesize")
+            gr.Markdown("5. Click Generate")
+            gr.Markdown("")
+            gr.Markdown("## Common Issues")
+            gr.Markdown("### Voice cloning fails")
+            gr.Markdown("- Your audio may not contain clear speech")
+            gr.Markdown("- Try a different audio file with cleaner voice")
+            gr.Markdown("- Make sure audio is at least 6 seconds long")
+            gr.Markdown("- Convert to WAV: `ffmpeg -i input.mp3 -ac 1 -ar 22050 output.wav`")
+            gr.Markdown("")
+            gr.Markdown("### First synthesis is slow")
+            gr.Markdown("- Normal! Downloads 4GB model (2-5 minutes)")
+            gr.Markdown("- Subsequent uses are fast (10-30 seconds)")
+            gr.Markdown("- Enable GPU in Space Settings for faster performance")
+            gr.Markdown("")
+            gr.Markdown("## Need Help?")
+            gr.Markdown("Check container logs in Space Settings.")
+    
+    gr.Markdown("---")
+    gr.Markdown("**Powered by Coqui XTTS-v2** | Non-commercial use only")
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        show_error=True
+    )