Update app.py

app.py

@@ -36,32 +36,23 @@ DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
 print(f"✅ Using device: {DEVICE}")
 
-# ENHANCED: Multi-language model support with speaker configuration
+# SIMPLIFIED: Use only one reliable model that supports both languages
 AVAILABLE_MODELS = {
-    "tacotron2-ddc": {
-        "name": "Tacotron2-DDC",
-        "model_name": "tts_models/en/ljspeech/tacotron2-DDC",
-        "description": "High-quality English TTS (Excellent natural voice)",
-        "languages": ["en"],
-        "voice_cloning": False,
-        "size_mb": 150,
-        "quality": "excellent",
-        "multi_speaker": False  # ADDED: Speaker configuration
-    },
-    "your_tts": {
-        "name": "YourTTS-Multi",
-        "model_name": "tts_models/multilingual/multi-dataset/your_tts",
-        "description": "Multilingual TTS supporting English, Chinese, and more",
-        "languages": ["en", "zh", "fr", "de", "it", "pt", "es"],
+    "xtts": {
+        "name": "XTTS-Multilingual",
+        "model_name": "tts_models/multilingual/multi-dataset/xtts_v2",
+        "description": "High-quality multilingual TTS supporting English and Chinese",
+        "languages": ["en", "zh", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "hu"],
         "voice_cloning": True,
-        "size_mb": 200,
-        "quality": "very_good",
-        "multi_speaker": True,  # ADDED: Speaker configuration
-        "default_speaker": "female_01"  # ADDED: Default speaker for YourTTS
+        "size_mb": 180,
+        "quality": "excellent",
+        "multi_speaker": True,
+        "default_speaker": "Claribel Dervla",
+        "default_language": "en"
     }
 }
 
-# ENHANCED: Expanded voice styles for both English and Chinese with speaker support
+# SIMPLIFIED: Voice styles for XTTS model
 VOICE_STYLES = {
     # English Voice Styles
     "default": {
@@ -69,40 +60,24 @@ VOICE_STYLES = {
         "description": "Clear and natural English voice",
         "gender": "neutral",
         "language": "en",
-        "recommended_model": "tacotron2-ddc",
-        "speaker": None  # ADDED: Tacotron2 doesn't need speaker
+        "recommended_model": "xtts",
+        "speaker": "Claribel Dervla"
     },
     "clear": {
         "name": "Clear English Voice", 
         "description": "Very clear and articulate English voice",
         "gender": "neutral",
         "language": "en",
-        "recommended_model": "tacotron2-ddc",
-        "speaker": None  # ADDED
+        "recommended_model": "xtts",
+        "speaker": "Daisy Studious"
     },
     "professional": {
         "name": "Professional English Voice",
         "description": "Professional and authoritative English voice",
         "gender": "neutral",
         "language": "en",
-        "recommended_model": "tacotron2-ddc",
-        "speaker": None  # ADDED
-    },
-    "warm": {
-        "name": "Warm English Voice",
-        "description": "Friendly and warm English voice",
-        "gender": "female",
-        "language": "en",
-        "recommended_model": "tacotron2-ddc",
-        "speaker": None  # ADDED
-    },
-    "authoritative": {
-        "name": "Authoritative English Voice",
-        "description": "Confident and authoritative English voice",
-        "gender": "male",
-        "language": "en",
-        "recommended_model": "tacotron2-ddc",
-        "speaker": None  # ADDED
+        "recommended_model": "xtts",
+        "speaker": "Gracie Wise"
     },
     
     # Chinese Voice Styles
@@ -111,48 +86,24 @@ VOICE_STYLES = {
         "description": "清晰自然的中文语音",
         "gender": "neutral",
         "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "female_01"  # ADDED: Speaker for YourTTS
+        "recommended_model": "xtts",
+        "speaker": "Claribel Dervla"
     },
     "chinese_clear": {
         "name": "清晰中文语音",
         "description": "非常清晰和标准的中文语音",
         "gender": "neutral",
         "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "female_02"  # ADDED
+        "recommended_model": "xtts",
+        "speaker": "Daisy Studious"
     },
     "chinese_professional": {
         "name": "专业中文语音",
         "description": "专业和正式的中文语音",
         "gender": "neutral",
         "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "male_01"  # ADDED
-    },
-    "chinese_warm": {
-        "name": "温暖中文语音",
-        "description": "友好温暖的中文语音",
-        "gender": "female",
-        "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "female_03"  # ADDED
-    },
-    "chinese_authoritative": {
-        "name": "权威中文语音",
-        "description": "自信权威的中文语音",
-        "gender": "male",
-        "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "male_02"  # ADDED
-    },
-    "chinese_storytelling": {
-        "name": "讲故事中文语音",
-        "description": "适合讲故事和叙述的中文语音",
-        "gender": "neutral",
-        "language": "zh",
-        "recommended_model": "your_tts",
-        "speaker": "female_04"  # ADDED
+        "recommended_model": "xtts",
+        "speaker": "Gracie Wise"
     }
 }
 
@@ -177,7 +128,7 @@ class BatchTTSRequest(BaseModel):
     speed: Optional[float] = 1.0
     language: Optional[str] = "auto"
 
-# ENHANCED: Language detection function
+# Language detection function
 def detect_language(text: str) -> str:
     """Detect if text is Chinese or English"""
     import re
@@ -197,17 +148,12 @@ def detect_language(text: str) -> str:
     else:
         return "en"
 
-# ENHANCED: Get appropriate model based on voice style and language
-def get_model_for_voice_style(voice_style: str, language: str = "auto") -> str:
-    """Determine which model to use based on voice style and language"""
+# Get appropriate model based on voice style
+def get_model_for_voice_style(voice_style: str) -> str:
+    """Determine which model to use based on voice style"""
     if voice_style in VOICE_STYLES:
-        return VOICE_STYLES[voice_style].get("recommended_model", "tacotron2-ddc")
-    
-    # Fallback logic based on language
-    if language == "zh" or (language == "auto" and detect_language("test") == "zh"):
-        return "your_tts"
-    else:
-        return "tacotron2-ddc"
+        return VOICE_STYLES[voice_style].get("recommended_model", "xtts")
+    return "xtts"
 
 # Storage management functions
 def cleanup_old_files():
@@ -254,7 +200,7 @@ def check_storage_usage():
         print(f"⚠️ Storage check error: {e}")
         return True
 
-# ENHANCED: Improved text cleaning with language support
+# Text cleaning with language support
 def clean_text(text, language="auto"):
     """Clean text for TTS generation with language support"""
     import re
@@ -319,8 +265,8 @@ def upload_to_oci(file_path: str, filename: str, project_id: str, file_type="voi
     except Exception as e:
         return None, f"Upload error: {str(e)}"
 
-# FIXED: Improved model loading with speaker support and better error handling
-def load_tts_model(model_type="tacotron2-ddc"):
+# SIMPLIFIED: Model loading with XTTS
+def load_tts_model(model_type="xtts"):
     """Load TTS model with storage optimization"""
     global tts, model_loaded, current_model, model_loading
     
@@ -356,7 +302,7 @@ def load_tts_model(model_type="tacotron2-ddc"):
             model_config = AVAILABLE_MODELS[model_type]
             print(f"🚀 Loading {model_config['name']}...")
             print(f"   Languages: {', '.join(model_config['languages'])}")
-            print(f"   Multi-speaker: {model_config.get('multi_speaker', False)}")  # ADDED: Log speaker info
+            print(f"   Multi-speaker: {model_config.get('multi_speaker', False)}")
             
             # Clear current model from memory first if exists
             if tts is not None:
@@ -370,24 +316,21 @@ def load_tts_model(model_type="tacotron2-ddc"):
             # Load the selected model
             tts = TTS(model_config["model_name"]).to(DEVICE)
             
-            # Test the model with appropriate text
+            # Test the model with BOTH language and speaker parameters
             test_path = "/tmp/test_output.wav"
-            if "zh" in model_config["languages"]:
-                test_text = "你好"  # Chinese test
-            else:
-                test_text = "Hello"  # English test
+            test_speaker = model_config.get('default_speaker', 'Claribel Dervla')
+            test_language = model_config.get('default_language', 'en')
+            test_text = "Hello" if test_language == "en" else "你好"
             
-            # FIXED: For multi-speaker models, provide speaker parameter during test
-            if model_config.get('multi_speaker', False):
-                test_speaker = model_config.get('default_speaker', 'female_01')
-                print(f"   Testing with speaker: {test_speaker}")  # ADDED: Speaker info
-                tts.tts_to_file(
-                    text=test_text, 
-                    file_path=test_path,
-                    speaker=test_speaker  # ADDED: Speaker parameter
-                )
-            else:
-                tts.tts_to_file(text=test_text, file_path=test_path)
+            print(f"   Testing with speaker: {test_speaker}, language: {test_language}")
+            
+            # XTTS requires BOTH language AND speaker parameters
+            tts.tts_to_file(
+                text=test_text, 
+                file_path=test_path,
+                speaker=test_speaker,
+                language=test_language
+            )
             
             if os.path.exists(test_path):
                 os.remove(test_path)
@@ -405,10 +348,6 @@ def load_tts_model(model_type="tacotron2-ddc"):
             
         except Exception as e:
             print(f"❌ Model failed to load: {e}")
-            # Fallback to English model if multilingual fails
-            if model_type == "your_tts":
-                print("🔄 Falling back to English model...")
-                return load_tts_model("tacotron2-ddc")
             return False
                 
         finally:
@@ -420,28 +359,24 @@ def load_tts_model(model_type="tacotron2-ddc"):
     finally:
         model_loading = False
 
-# FIXED: Improved model switching logic with better detection
-def ensure_correct_model(voice_style: str, text: str, language: str = "auto"):
-    """Ensure the correct model is loaded for the requested voice style and language"""
+# Ensure correct model is loaded
+def ensure_correct_model(voice_style: str):
+    """Ensure the correct model is loaded for the requested voice style"""
     global tts, model_loaded, current_model
     
     # Determine target model
-    target_model = get_model_for_voice_style(voice_style, language)
+    target_model = get_model_for_voice_style(voice_style)
     
-    print(f"🔍 Model selection: voice_style={voice_style}, language={language}, target_model={target_model}")
+    print(f"🔍 Model selection: voice_style={voice_style}, target_model={target_model}")
     
     # If no model loaded or wrong model loaded, load the correct one
     if not model_loaded or current_model != target_model:
-        print(f"🔄 Switching to model: {target_model} for voice style: {voice_style}, language: {language}")
-        success = load_tts_model(target_model)
-        if not success and target_model == "your_tts":
-            print("⚠️ Multilingual model failed, falling back to English model")
-            return load_tts_model("tacotron2-ddc")
-        return success
+        print(f"🔄 Switching to model: {target_model} for voice style: {voice_style}")
+        return load_tts_model(target_model)
     
     return True
 
-# FIXED: Enhanced TTS generation with proper language AND speaker handling
+# SIMPLIFIED: TTS generation with XTTS
 @app.post("/api/tts")
 async def generate_tts(request: TTSRequest):
     """Generate TTS with multi-language support"""
@@ -449,18 +384,18 @@ async def generate_tts(request: TTSRequest):
         # Clean up before processing
         cleanup_old_files()
         
-        # ENHANCED: Auto-detect language if not specified
+        # Auto-detect language if not specified
         if request.language == "auto":
             detected_language = detect_language(request.text)
             print(f"🌐 Auto-detected language: {detected_language}")
         else:
             detected_language = request.language
         
-        # ENHANCED: Ensure correct model is loaded
-        if not ensure_correct_model(request.voice_style, request.text, detected_language):
+        # Ensure correct model is loaded
+        if not ensure_correct_model(request.voice_style):
             return {
                 "status": "error",
-                "message": f"Failed to load appropriate TTS model for {detected_language}",
+                "message": "Failed to load TTS model",
                 "requires_tos_acceptance": True,
                 "tos_url": "https://coqui.ai/cpml.txt"
             }
@@ -479,80 +414,31 @@ async def generate_tts(request: TTSRequest):
         # Ensure output directory exists
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
         
-        # ENHANCED: Clean the text with language support
+        # Clean the text with language support
         cleaned_text = clean_text(request.text, detected_language)
         print(f"📝 Text: '{cleaned_text}'")
         
         # Get speaker configuration for the voice style
         voice_config = VOICE_STYLES.get(request.voice_style, {})
-        speaker = voice_config.get('speaker')
-        print(f"🎤 Speaker: {speaker}")  # ADDED: Speaker info
+        speaker = voice_config.get('speaker', 'Claribel Dervla')
+        print(f"🎤 Speaker: {speaker}")
         
         # Generate TTS
         try:
-            # FIXED: Proper language AND speaker handling for multilingual model
-            if current_model == "your_tts":
-                if detected_language == "zh":
-                    print(f"🎯 Using YourTTS for Chinese text with speaker: {speaker}")
-                    tts.tts_to_file(
-                        text=cleaned_text,
-                        file_path=output_path,
-                        language="zh-cn",  # Use zh-cn for Chinese
-                        speaker=speaker    # ADDED: Speaker parameter
-                    )
-                else:
-                    print(f"🎯 Using YourTTS for English text with speaker: {speaker}")
-                    tts.tts_to_file(
-                        text=cleaned_text,
-                        file_path=output_path,
-                        language="en",
-                        speaker=speaker    # ADDED: Speaker parameter
-                    )
-            else:
-                # Tacotron2-DDC for English only
-                if detected_language == "zh":
-                    # If Chinese text but English model, try to switch to multilingual
-                    print("🔄 Chinese text detected with English model, attempting to switch to multilingual...")
-                    if load_tts_model("your_tts"):
-                        # Get speaker for the voice style in multilingual model
-                        multilingual_speaker = VOICE_STYLES.get(request.voice_style, {}).get('speaker', 'female_01')
-                        print(f"🎯 Using YourTTS for Chinese text with speaker: {multilingual_speaker}")
-                        # Retry with multilingual model
-                        tts.tts_to_file(
-                            text=cleaned_text,
-                            file_path=output_path,
-                            language="zh-cn",
-                            speaker=multilingual_speaker  # ADDED: Speaker parameter
-                        )
-                    else:
-                        raise Exception("Chinese text cannot be processed. Multilingual model failed to load.")
-                else:
-                    print("🎯 Using Tacotron2-DDC for English text")
-                    # Tacotron2-DDC doesn't need speaker parameter
-                    tts.tts_to_file(
-                        text=cleaned_text,
-                        file_path=output_path
-                    )
+            # XTTS requires BOTH language AND speaker parameters
+            tts_language = "zh-cn" if detected_language == "zh" else "en"
+            print(f"🎯 Using XTTS with language: {tts_language}, speaker: {speaker}")
+            
+            tts.tts_to_file(
+                text=cleaned_text,
+                file_path=output_path,
+                language=tts_language,
+                speaker=speaker
+            )
+            
         except Exception as tts_error:
             print(f"❌ TTS generation failed: {tts_error}")
-            
-            # FIXED: If it's a speaker error, try with default speaker
-            if "speaker" in str(tts_error).lower() and current_model == "your_tts":
-                print("🔄 Speaker error detected, trying with default speaker...")
-                try:
-                    default_speaker = AVAILABLE_MODELS["your_tts"].get("default_speaker", "female_01")
-                    tts.tts_to_file(
-                        text=cleaned_text,
-                        file_path=output_path,
-                        language="zh-cn" if detected_language == "zh" else "en",
-                        speaker=default_speaker  # Use default speaker
-                    )
-                    print("✅ Success with default speaker!")
-                except Exception as retry_error:
-                    print(f"❌ Retry with default speaker also failed: {retry_error}")
-                    raise tts_error
-            else:
-                raise tts_error
+            raise tts_error
         
         # Verify the file was created
         if not os.path.exists(output_path):
@@ -601,7 +487,7 @@ async def generate_tts(request: TTSRequest):
             "message": f"TTS generation failed: {str(e)}"
         }
 
-# FIXED: Enhanced batch processing with better logging and error handling
+# Batch TTS processing
 @app.post("/api/batch-tts")
 async def batch_generate_tts(request: BatchTTSRequest):
     """Batch TTS with multi-language support"""
@@ -616,7 +502,7 @@ async def batch_generate_tts(request: BatchTTSRequest):
         results = []
         for i, text in enumerate(request.texts):
             try:
-                # ENHANCED: Auto-detect language for each text
+                # Auto-detect language for each text
                 if request.language == "auto":
                     text_language = detect_language(text)
                 else:
@@ -677,7 +563,7 @@ async def batch_generate_tts(request: BatchTTSRequest):
 @app.get("/api/voice-styles")
 async def get_voice_styles():
     """Get available voice styles"""
-    # ENHANCED: Group voice styles by language
+    # Group voice styles by language
     english_styles = {k: v for k, v in VOICE_STYLES.items() if v.get("language") == "en"}
     chinese_styles = {k: v for k, v in VOICE_STYLES.items() if v.get("language") == "zh"}
     
@@ -690,7 +576,7 @@ async def get_voice_styles():
         "supported_languages": ["en", "zh", "auto"]
     }
 
-# ENHANCED: New endpoint to detect language
+# Language detection endpoint
 @app.post("/api/detect-language")
 async def detect_text_language(text: str = Form(...)):
     """Detect the language of input text"""
@@ -752,6 +638,6 @@ if __name__ == "__main__":
     print("🚀 Starting Multi-Language TTS API...")
     print("💾 Storage management enabled")
     print("🌐 Supporting English and Chinese")
-    print("🔊 Using Tacotron2-DDC (English) and YourTTS (Multilingual)")
+    print("🔊 Using XTTS (Multilingual)")
     check_storage_usage()
     uvicorn.run(app, host="0.0.0.0", port=7860)