Update app/utils/model_scanner.py

app/utils/model_scanner.py

@@ -223,96 +223,10 @@ class ModelScanner:
         Returns:
             Dictionary of available TTS languages with voices
         """
-        # ALWAYS return our 13 explicitly supported languages
-        # English uses Coqui LJSpeech model, Indian languages use Piper TTS
-        tts_models = {
-            # English - Uses Coqui LJSpeech Tacotron2 model
-            "en": {
-                "name": "English",
-                "model": "tts_models/en/ljspeech/tacotron2-DDC",
-                "engine": "coqui",
-                "voices": ["LJSpeech Tacotron2-DDC"]
-            },
-            # Indian Languages - All use Piper TTS for better quality
-            "hi": {
-                "name": "Hindi",
-                "model": "piper/hi_IN-swarajya-medium",
-                "engine": "piper",
-                "voices": ["Swarajya Medium"]
-            },
-            "bn": {
-                "name": "Bengali",
-                "model": "piper/bn_BD-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "te": {
-                "name": "Telugu",
-                "model": "piper/te_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "ta": {
-                "name": "Tamil",
-                "model": "piper/ta_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "mr": {
-                "name": "Marathi",
-                "model": "piper/mr_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "gu": {
-                "name": "Gujarati",
-                "model": "piper/gu_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "kn": {
-                "name": "Kannada",
-                "model": "piper/kn_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "ml": {
-                "name": "Malayalam",
-                "model": "piper/ml_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "pa": {
-                "name": "Punjabi",
-                "model": "piper/pa_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "ur": {
-                "name": "Urdu",
-                "model": "piper/ur_PK-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi Medium"]
-            },
-            "as": {
-                "name": "Assamese",
-                "model": "piper/as_IN-multi-medium",
-                "engine": "piper",
-                "voices": ["Multi-speaker Medium (Limited)"]
-            },
-            "or": {
-                "name": "Odia",
-                "model": "piper/or-multi_multispeaker-medium",
-                "engine": "piper",
-                "voices": ["Multi-speaker Medium (Limited)"]
-            },
-        }
+        tts_models = {}
         
-        logger.info("tts_languages_available", 
-                   count=len(tts_models),
-                   languages=list(tts_models.keys()))
+        logger.info("scanning_tts_models")
         
-        # Optionally scan for additional models (but don't override our 13 core languages)
         try:
             # Disable numba cache to avoid librosa caching errors
             import os
@@ -326,10 +240,11 @@ class ModelScanner:
             # Get list of available models using ModelManager
             manager = ModelManager()
             available_models = manager.list_models()
-            logger.info("tts_coqui_models_scanned", count=len(available_models))
+            logger.info("tts_available_models", count=len(available_models))
             
-            # Language name mappings for additional languages
-            additional_language_names = {
+            # Language name mappings - includes English and all major Indian languages
+            language_names = {
+                "en": "English",
                 "es": "Spanish",
                 "fr": "French",
                 "de": "German",
@@ -342,46 +257,86 @@ class ModelScanner:
                 "cs": "Czech",
                 "ar": "Arabic",
                 "zh": "Chinese",
-                "zh-CN": "Chinese (Simplified)",
                 "ja": "Japanese",
                 "ko": "Korean",
                 "hu": "Hungarian",
+                # Indian Languages
+                "hi": "Hindi",
+                "hin": "Hindi",
+                "bn": "Bengali",
+                "ben": "Bengali",
+                "te": "Telugu",
+                "tel": "Telugu",
+                "ta": "Tamil",
+                "tam": "Tamil",
+                "mr": "Marathi",
+                "mar": "Marathi",
+                "gu": "Gujarati",
+                "guj": "Gujarati",
+                "kn": "Kannada",
+                "kan": "Kannada",
+                "ml": "Malayalam",
+                "mal": "Malayalam",
+                "pa": "Punjabi",
+                "pan": "Punjabi",
+                "ur": "Urdu",
+                "urd": "Urdu",
+                "as": "Assamese",
+                "asm": "Assamese",
+                "or": "Odia",
+                "ory": "Odia",
             }
             
-            # Extract language codes from model names (for additional languages only)
+            # Extract language codes from model names
             lang_voices: Dict[str, List[str]] = {}
             for model in available_models:
+                # Extract language code from model name (e.g., "tts_models/en/ljspeech/...")
                 parts = model.split("/")
                 if len(parts) >= 2 and parts[0] == "tts_models":
                     lang_code = parts[1]
-                    # Only add if not already in our core 13 languages
-                    if lang_code not in tts_models:
-                        if lang_code not in lang_voices:
-                            lang_voices[lang_code] = []
-                        lang_voices[lang_code].append(model)
+                    if lang_code not in lang_voices:
+                        lang_voices[lang_code] = []
+                    lang_voices[lang_code].append(model)
             
-            # Add additional discovered languages
+            # Build TTS language dictionary
             for lang_code, voices in lang_voices.items():
-                if lang_code not in tts_models:  # Don't override core languages
-                    tts_models[lang_code] = {
-                        "name": additional_language_names.get(lang_code, lang_code.upper()),
-                        "voices": voices[:5]
-                    }
-                    logger.info("found_additional_tts_language", language=lang_code, voice_count=len(voices))
+                tts_models[lang_code] = {
+                    "name": language_names.get(lang_code, lang_code.upper()),
+                    "voices": voices[:5]  # Limit to first 5 voices
+                }
+                logger.info("found_tts_language", language=lang_code, voice_count=len(voices))
         
         except ImportError:
-            logger.warning("coqui_tts_not_available", message="Coqui TTS not installed, using core 13 languages")
-            # Our core 13 languages are already defined above
+            logger.warning("coqui_tts_not_available")
+            # Fallback: check for downloaded models in filesystem
+            tts_path = Path(settings.coqui_model_path)
+            logger.info("checking_tts_filesystem", path=str(tts_path), exists=tts_path.exists())
+            
+            if tts_path.exists():
+                try:
+                    for item in tts_path.iterdir():
+                        if item.is_dir():
+                            lang_code = item.name.split("_")[0] if "_" in item.name else item.name[:2]
+                            tts_models[lang_code] = {
+                                "name": lang_code.upper(),
+                                "voices": [item.name]
+                            }
+                            logger.info("found_tts_model_filesystem", language=lang_code, model=item.name)
+                except Exception as e:
+                    logger.error("error_reading_tts_directory", error=str(e))
         except RuntimeError as e:
             # Handle numba caching errors
             if "cannot cache function" in str(e):
-                logger.warning("tts_numba_caching_error", error=str(e), message="Using core 13 languages")
+                logger.warning("tts_numba_caching_error_using_fallback", error=str(e))
+                # Return empty dict - models need to be downloaded manually
+                return {}
             else:
-                logger.warning("tts_scan_error", error=str(e), message="Using core 13 languages")
+                raise
         except Exception as e:
-            logger.warning("error_scanning_additional_tts_models", error=str(e), message="Using core 13 languages")
+            logger.error("error_scanning_tts_models", error=str(e), exc_info=True)
+            return {}
         
-        logger.info("tts_scan_complete", total_languages=len(tts_models))
+        logger.info("tts_scan_complete", models_found=len(tts_models))
         return tts_models
     
     @staticmethod