Update locale_manager.py

locale_manager.py

@@ -1,12 +1,24 @@
 # locale_manager.py
+"""
+Locale Manager - Manages locale files for the system
+"""
+
 import json
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, List, Optional
+from datetime import datetime
+import sys
+
+def log(message: str):
+    timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+    print(f"[{timestamp}] {message}")
+    sys.stdout.flush()
 
 class LocaleManager:
-    """Manages locale files for TTS preprocessing"""
+    """Manages locale files for TTS preprocessing and system-wide language support"""
     
     _cache: Dict[str, Dict] = {}
+    _available_locales: Optional[List[Dict[str, str]]] = None
     
     @classmethod
     def get_locale(cls, language: str) -> Dict:
@@ -33,11 +45,110 @@ class LocaleManager:
         else:
             # Return English as fallback
             fallback_file = base_path / "en.json"
-            with open(fallback_file, 'r', encoding='utf-8') as f:
-                return json.load(f)
+            if fallback_file.exists():
+                with open(fallback_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            else:
+                # Minimal fallback if no locale files exist
+                return {
+                    "code": "en",
+                    "name": "English",
+                    "english_name": "English"
+                }
     
     @classmethod
     def list_available_locales(cls) -> List[str]:
         """List all available locale files"""
         base_path = Path(__file__).parent / "locales"
-        return [f.stem for f in base_path.glob("*.json")]
+        if not base_path.exists():
+            return ["en", "tr"]  # Default locales
+        return [f.stem for f in base_path.glob("*.json")]
+    
+    @classmethod
+    def get_available_locales_with_names(cls) -> List[Dict[str, str]]:
+        """Get list of all available locales with their display names"""
+        if cls._available_locales is not None:
+            return cls._available_locales
+        
+        cls._available_locales = []
+        base_path = Path(__file__).parent / "locales"
+        
+        if not base_path.exists():
+            # Return default locales if directory doesn't exist
+            cls._available_locales = [
+                {
+                    "code": "tr-TR",
+                    "name": "Türkçe",
+                    "english_name": "Turkish"
+                },
+                {
+                    "code": "en-US",
+                    "name": "English",
+                    "english_name": "English (US)"
+                }
+            ]
+            return cls._available_locales
+        
+        # Load all locale files
+        for locale_file in base_path.glob("*.json"):
+            try:
+                locale_code = locale_file.stem
+                locale_data = cls.get_locale(locale_code)
+                
+                cls._available_locales.append({
+                    "code": locale_code,
+                    "name": locale_data.get("name", locale_code),
+                    "english_name": locale_data.get("english_name", locale_code)
+                })
+                
+                log(f"✅ Loaded locale: {locale_code} - {locale_data.get('name', 'Unknown')}")
+                
+            except Exception as e:
+                log(f"❌ Failed to load locale {locale_file}: {e}")
+        
+        # Sort by name for consistent ordering
+        cls._available_locales.sort(key=lambda x: x['name'])
+        
+        return cls._available_locales
+    
+    @classmethod
+    def get_locale_details(cls, locale_code: str) -> Optional[Dict]:
+        """Get detailed info for a specific locale"""
+        try:
+            locale_data = cls.get_locale(locale_code)
+            # Ensure code is in the data
+            locale_data['code'] = locale_code
+            return locale_data
+        except:
+            return None
+    
+    @classmethod
+    def is_locale_supported(cls, locale_code: str) -> bool:
+        """Check if a locale is supported system-wide"""
+        available_codes = [locale['code'] for locale in cls.get_available_locales_with_names()]
+        return locale_code in available_codes
+    
+    @classmethod
+    def validate_project_languages(cls, languages: List[str]) -> List[str]:
+        """Validate that all languages are system-supported, return invalid ones"""
+        available_codes = [locale['code'] for locale in cls.get_available_locales_with_names()]
+        invalid_languages = [
+            lang for lang in languages 
+            if lang not in available_codes
+        ]
+        return invalid_languages
+    
+    @classmethod
+    def get_default_locale(cls) -> str:
+        """Get system default locale"""
+        available_locales = cls.get_available_locales_with_names()
+        
+        # Priority: tr-TR, en-US, first available
+        for preferred in ["tr-TR", "en-US"]:
+            if any(locale['code'] == preferred for locale in available_locales):
+                return preferred
+        
+        # Return first available or fallback
+        if available_locales:
+            return available_locales[0]['code']
+        return "en-US"