Delete locale_manager.py

locale_manager.py

@@ -1,163 +0,0 @@
-# locale_manager.py
-"""
-Locale Manager - Manages locale files for the system
-"""
-
-import json
-from pathlib import Path
-from typing import Dict, List, Optional
-from datetime import datetime
-import sys
-from logger import log_info, log_error, log_debug, log_warning
-
-class LocaleManager:
-    """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:
-        """Get locale data with caching"""
-        if language not in cls._cache:
-            cls._cache[language] = cls._load_locale(language)
-        return cls._cache[language]
-    
-    @classmethod
-    def _load_locale(cls, language: str) -> Dict:
-        """Load locale from file - accepts both 'tr' and 'tr-TR' formats"""
-        base_path = Path(__file__).parent / "locales"
-        
-        # First try exact match
-        locale_file = base_path / f"{language}.json"
-        
-        # If not found and has region code, try without region (tr-TR -> tr)
-        if not locale_file.exists() and '-' in language:
-            language_code = language.split('-')[0]
-            locale_file = base_path / f"{language_code}.json"
-        
-        if locale_file.exists():
-            try:
-                with open(locale_file, 'r', encoding='utf-8') as f:
-                    data = json.load(f)
-                log_debug(f"✅ Loaded locale file: {locale_file.name}")
-                return data
-            except Exception as e:
-                log_error(f"Failed to load locale file {locale_file}", e)
-        
-        # Try English fallback
-        fallback_file = base_path / "en.json"
-        if fallback_file.exists():
-            try:
-                with open(fallback_file, 'r', encoding='utf-8') as f:
-                    data = json.load(f)
-                log_warning(f"⚠️ Using English fallback for locale: {language}")
-                return data
-            except:
-                pass
-        
-        # Minimal fallback if no locale files exist
-        log_warning(f"⚠️ No locale files found, using minimal fallback")
-        return {
-            "code": "tr",
-            "locale_tag": "tr-TR",
-            "name": "Türkçe",
-            "english_name": "Turkish"
-        }
-    
-    @classmethod
-    def list_available_locales(cls) -> List[str]:
-        """List all available locale files"""
-        base_path = Path(__file__).parent / "locales"
-        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_info(f"✅ Loaded locale: {locale_code} - {locale_data.get('name', 'Unknown')}")
-                
-            except Exception as e:
-                log_error(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"