Added test config loader and fixed linting

Author: bram

python_gpt_po/main.py

@@ -9,6 +9,7 @@
 import sys
 import traceback
 from argparse import Namespace
+from dataclasses import dataclass
 from typing import Dict, List, Optional
 
 from .models.config import TranslationConfig, TranslationFlags
@@ -137,33 +138,40 @@ def get_appropriate_model(
     return default_model
 
 
-def process_translations(config: TranslationConfig, folder: str,
-                         languages: List[str], detail_languages: Dict[str, str],
-                         batch_size: int, respect_gitignore: bool = True):
+@dataclass
+class TranslationTask:
+    """Parameters for translation processing."""
+    config: TranslationConfig
+    folder: str
+    languages: List[str]
+    detail_languages: Dict[str, str]
+    batch_size: int
+    respect_gitignore: bool = True
+
+
+def process_translations(task: TranslationTask):
     """
-    Process translations for the given languages and directory.
+    Process translations for the given task parameters.
 
     Args:
-        config (TranslationConfig): The translation configuration
-        folder (str): Directory containing .po files
-        languages (List[str]): List of language codes to process
-        detail_languages (Dict[str, str]): Mapping of language codes to detailed names
-        batch_size (int): Size of batches for bulk translation
+        task: TranslationTask containing all processing parameters
     """
     # Initialize translation service
-    translation_service = TranslationService(config, batch_size)
+    translation_service = TranslationService(task.config, task.batch_size)
 
     # Validate provider connection
     if not translation_service.validate_provider_connection():
         logging.error(
-            "%s connection failed. Please check your API key and network connection.", config.provider.value
+            "%s connection failed. Please check your API key and network connection.", task.config.provider.value
         )
         sys.exit(1)
 
     # Start processing files
     logging.info("Starting translation with %s using model %s in folder %s",
-                 config.provider.value, config.model, folder)
-    translation_service.scan_and_process_po_files(folder, languages, detail_languages, respect_gitignore)
+                 task.config.provider.value, task.config.model, task.folder)
+    translation_service.scan_and_process_po_files(
+        task.folder, task.languages, task.detail_languages, task.respect_gitignore
+    )
     logging.info("Translation completed successfully")
 
 
@@ -230,7 +238,15 @@ def main():
 
         # Process translations
         respect_gitignore = not args.no_gitignore  # Invert the flag
-        process_translations(config, args.folder, languages, detail_languages, args.bulksize, respect_gitignore)
+        task = TranslationTask(
+            config=config,
+            folder=args.folder,
+            languages=languages,
+            detail_languages=detail_languages,
+            batch_size=args.bulksize,
+            respect_gitignore=respect_gitignore
+        )
+        process_translations(task)
 
     except KeyboardInterrupt:
         logging.info("\nTranslation cancelled.")

python_gpt_po/services/language_detector.py

@@ -138,41 +138,26 @@ def _detect_from_metadata(folder: str) -> List[str]:
     @staticmethod
     def _is_language_code(code: str) -> bool:
         """Check if a string looks like a language code."""
-        if not code or len(code) > 10:  # Reasonable limit
+        # Basic validation
+        if not code or len(code) < 2 or len(code) > 10 or not code[0].isalpha():
             return False
 
         # Common language code patterns:
         # - 2-letter codes: en, fr, de, etc.
         # - 2+2 codes: en_US, fr_FR, etc.
         # - Special codes: zh_Hans, sr_Latn, be@tarask, etc.
 
-        # Basic checks
-        if len(code) < 2:
-            return False
-
-        # Must start with letters
-        if not code[0].isalpha():
-            return False
-
-        # Common patterns
-        # Standard patterns: en, en_US, zh_Hans, be@tarask
-        if re.match(r'^[a-z]{2,3}(_[A-Z][a-z]+|_[A-Z]{2}|@[a-z]+)?$', code):
-            return True
-
-        # Some special cases used in Django
+        # Special cases used in Django
         special_codes = {
             'zh-hans', 'zh-hant', 'sr-latn', 'sr-cyrl', 'az-latn', 'az-cyrl',
             'uz-latn', 'uz-cyrl', 'kk-latn', 'kk-cyrl', 'ky-latn', 'ky-cyrl'
         }
 
-        if code.lower() in special_codes:
-            return True
-
-        # Handle some edge cases
-        if re.match(r'^[a-z]{2,3}$', code):  # Basic 2-3 letter codes
-            return True
-
-        return False
+        # Check all valid patterns
+        pattern_match = re.match(r'^[a-z]{2,3}(_[A-Z][a-z]+|_[A-Z]{2}|@[a-z]+)?$', code) is not None
+        in_special = code.lower() in special_codes
+        basic_match = re.match(r'^[a-z]{2,3}$', code) is not None
+        return pattern_match or in_special or basic_match
 
     @staticmethod
     def validate_or_detect_languages(folder: str, lang_arg: str = None,

python_gpt_po/services/model_manager.py

@@ -4,24 +4,20 @@
 """
 import logging
 from typing import List
-
 from ..models.enums import ModelProvider
 from ..models.provider_clients import ProviderClients
 from .providers.registry import ProviderRegistry
 
 
 class ModelManager:
     """Class to manage models from different providers."""
-
     @staticmethod
     def get_available_models(provider_clients: ProviderClients, provider: ModelProvider) -> List[str]:
         """Retrieve available models from a specific provider."""
         provider_impl = ProviderRegistry.get_provider(provider)
-
         if not provider_impl:
             logging.error("Provider %s not registered", provider.value)
             return []
-
         try:
             return provider_impl.get_models(provider_clients)
         except Exception as e:
@@ -33,12 +29,10 @@ def validate_model(provider_clients: ProviderClients, provider: ModelProvider, m
         """
         Validates whether the specified model is available for the given provider.
         Uses prefix matching so that a shorthand (e.g. "claude") will match a full model name.
-
         Args:
             provider_clients (ProviderClients): The initialized provider clients
             provider (ModelProvider): The provider to check against
             model (str): The model name/ID to validate
-
         Returns:
             bool: True if the model is valid, False otherwise
         """
@@ -51,19 +45,15 @@ def validate_model(provider_clients: ProviderClients, provider: ModelProvider, m
     def get_default_model(provider: ModelProvider) -> str:
         """
         Returns the default model for a given provider.
-
         Args:
             provider (ModelProvider): The provider to get the default model for
-
         Returns:
             str: The default model ID
         """
         provider_impl = ProviderRegistry.get_provider(provider)
-
         if not provider_impl:
             logging.warning("Provider %s not registered, returning empty default", provider.value)
             return ""
-
         return provider_impl.get_default_model()
 
     @staticmethod
@@ -75,57 +65,18 @@ def verify_model_capabilities(
     ) -> bool:
         """
         Verifies if a model has the required capabilities.
-
         Args:
             provider_clients (ProviderClients): The initialized provider clients
             provider (ModelProvider): The provider to check against
             model (str): The model to verify
             required_capability (str): The capability to check for
-
         Returns:
             bool: True if the model has the required capability, False otherwise
         """
         # This is a simplified implementation - in a real-world scenario,
         # you might want to check model specifications/documentation
-
         # For now, assume all models support translation
         # In the future, this could check model specs for specific capabilities
         if required_capability == "translation":
             return ModelManager.validate_model(provider_clients, provider, model)
-
         return False
-
-    @staticmethod
-    def suggest_model(provider_clients: ProviderClients, provider: ModelProvider,
-                      task: str = "translation") -> str:
-        """
-        Suggests the best model for a given task and provider.
-
-        Args:
-            provider_clients (ProviderClients): The initialized provider clients
-            provider (ModelProvider): The provider to use
-            task (str): The task the model will be used for
-
-        Returns:
-            str: The suggested model ID
-        """
-        provider_impl = ProviderRegistry.get_provider(provider)
-
-        if not provider_impl:
-            logging.warning("Provider %s not registered", provider.value)
-            return ""
-
-        preferred_models = provider_impl.get_preferred_models(task)
-        available_models = ModelManager.get_available_models(provider_clients, provider)
-
-        # Try to find a match from the preferred models list
-        for preferred in preferred_models:
-            for available in available_models:
-                if preferred in available.lower():
-                    return available
-
-        # Fall back to the first available model or the default
-        if available_models:
-            return available_models[0]
-
-        return provider_impl.get_default_model()