Revert "lgos"

This reverts commit 3fea4d942941cf4051eba1a5e19c7e6a670cd135.

DEVELOPER_GUIDE.md

@@ -173,7 +173,7 @@ def _register_default_providers(self):
         self._providers['my_tts'] = MyTTSProvider
         logger.info("Registered MyTTS provider")
     except ImportError as e:
-        logger.info(f"MyTTS provider not available: {e}")
+        logger.debug(f"MyTTS provider not available: {e}")
 ```
 
 ### Step 3: Add Configuration Support
@@ -590,7 +590,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 # Use appropriate log levels
-logger.info("Detailed debugging information")
+logger.debug("Detailed debugging information")
 logger.info("General information about program execution")
 logger.warning("Something unexpected happened")
 logger.error("A serious error occurred")

src/application/dtos/dto_validation.py

@@ -15,13 +15,13 @@ T = TypeVar('T')
 
 class ValidationError(Exception):
     """Custom exception for DTO validation errors"""
-
+    
     def __init__(self, message: str, field: str = None, value: Any = None):
         self.message = message
         self.field = field
         self.value = value
         super().__init__(self.message)
-
+    
     def __str__(self):
         if self.field:
             return f"Validation error for field '{self.field}': {self.message}"
@@ -30,13 +30,13 @@ class ValidationError(Exception):
 
 def validate_dto(dto_instance: Any) -> bool:
     """Validate a DTO instance
-
+    
     Args:
         dto_instance: The DTO instance to validate
-
+        
     Returns:
         bool: True if validation passes
-
+        
     Raises:
         ValidationError: If validation fails
     """
@@ -44,11 +44,11 @@ def validate_dto(dto_instance: Any) -> bool:
         # Call the DTO's validation method if it exists
         if hasattr(dto_instance, '_validate'):
             dto_instance._validate()
-
+        
         # Additional validation can be added here
-        logger.info(f"Successfully validated {type(dto_instance).__name__}")
+        logger.debug(f"Successfully validated {type(dto_instance).__name__}")
         return True
-
+        
     except ValueError as e:
         logger.error(f"Validation failed for {type(dto_instance).__name__}: {e}")
         raise ValidationError(str(e)) from e
@@ -59,10 +59,10 @@ def validate_dto(dto_instance: Any) -> bool:
 
 def validation_required(func: Callable[..., T]) -> Callable[..., T]:
     """Decorator to ensure DTO validation before method execution
-
+    
     Args:
         func: The method to decorate
-
+        
     Returns:
         Decorated function that validates 'self' before execution
     """
@@ -75,23 +75,23 @@ def validation_required(func: Callable[..., T]) -> Callable[..., T]:
             raise
         except Exception as e:
             raise ValidationError(f"Error in {func.__name__}: {e}") from e
-
+    
     return wrapper
 
 
-def validate_field(value: Any, field_name: str, validator: Callable[[Any], bool],
+def validate_field(value: Any, field_name: str, validator: Callable[[Any], bool], 
                   error_message: str = None) -> Any:
     """Validate a single field value
-
+    
     Args:
         value: The value to validate
         field_name: Name of the field being validated
         validator: Function that returns True if value is valid
         error_message: Custom error message
-
+        
     Returns:
         The validated value
-
+        
     Raises:
         ValidationError: If validation fails
     """
@@ -108,37 +108,37 @@ def validate_field(value: Any, field_name: str, validator: Callable[[Any], bool]
 
 def validate_required(value: Any, field_name: str) -> Any:
     """Validate that a field is not None or empty
-
+    
     Args:
         value: The value to validate
         field_name: Name of the field being validated
-
+        
     Returns:
         The validated value
-
+        
     Raises:
         ValidationError: If field is None or empty
     """
     if value is None:
         raise ValidationError(f"Field '{field_name}' is required", field_name, value)
-
+    
     if isinstance(value, (str, list, dict)) and len(value) == 0:
         raise ValidationError(f"Field '{field_name}' cannot be empty", field_name, value)
-
+    
     return value
 
 
 def validate_type(value: Any, field_name: str, expected_type: Union[type, tuple]) -> Any:
     """Validate that a field is of the expected type
-
+    
     Args:
         value: The value to validate
         field_name: Name of the field being validated
         expected_type: Expected type or tuple of types
-
+        
     Returns:
         The validated value
-
+        
     Raises:
         ValidationError: If type doesn't match
     """
@@ -148,30 +148,30 @@ def validate_type(value: Any, field_name: str, expected_type: Union[type, tuple]
             expected_str = " or ".join(type_names)
         else:
             expected_str = expected_type.__name__
-
+        
         actual_type = type(value).__name__
         raise ValidationError(
             f"Field '{field_name}' must be of type {expected_str}, got {actual_type}",
             field_name, value
         )
-
+    
     return value
 
 
-def validate_range(value: Union[int, float], field_name: str,
-                  min_value: Union[int, float] = None,
+def validate_range(value: Union[int, float], field_name: str, 
+                  min_value: Union[int, float] = None, 
                   max_value: Union[int, float] = None) -> Union[int, float]:
     """Validate that a numeric value is within a specified range
-
+    
     Args:
         value: The numeric value to validate
         field_name: Name of the field being validated
         min_value: Minimum allowed value (inclusive)
         max_value: Maximum allowed value (inclusive)
-
+        
     Returns:
         The validated value
-
+        
     Raises:
         ValidationError: If value is outside the range
     """
@@ -180,27 +180,27 @@ def validate_range(value: Union[int, float], field_name: str,
             f"Field '{field_name}' must be >= {min_value}, got {value}",
             field_name, value
         )
-
+    
     if max_value is not None and value > max_value:
         raise ValidationError(
             f"Field '{field_name}' must be <= {max_value}, got {value}",
             field_name, value
         )
-
+    
     return value
 
 
 def validate_choices(value: Any, field_name: str, choices: list) -> Any:
     """Validate that a value is one of the allowed choices
-
+    
     Args:
         value: The value to validate
         field_name: Name of the field being validated
         choices: List of allowed values
-
+        
     Returns:
         The validated value
-
+        
     Raises:
         ValidationError: If value is not in choices
     """
@@ -209,5 +209,5 @@ def validate_choices(value: Any, field_name: str, choices: list) -> Any:
             f"Field '{field_name}' must be one of {choices}, got '{value}'",
             field_name, value
         )
-
+    
     return value

src/application/error_handling/error_mapper.py

@@ -249,7 +249,7 @@ class ErrorMapper:
             if context:
                 mapping = self._enhance_mapping_with_context(mapping, exception, context)
 
-            logger.info(f"Mapped {type(exception).__name__} to {mapping.error_code}")
+            logger.debug(f"Mapped {type(exception).__name__} to {mapping.error_code}")
             return mapping
 
         except Exception as e:

src/application/error_handling/structured_logger.py

@@ -124,7 +124,7 @@ class StructuredLogger:
         """Log debug message."""
         if self.logger.isEnabledFor(logging.DEBUG):
             log_data = self._get_log_data(message, LogLevel.DEBUG.value, context, extra)
-            self.logger.info(message, extra=log_data)
+            self.logger.debug(message, extra=log_data)
 
     def info(self, message: str, context: Optional[LogContext] = None,
             extra: Optional[Dict[str, Any]] = None) -> None:

src/application/services/audio_processing_service.py

@@ -51,39 +51,39 @@ class AudioProcessingApplicationService:
             container: Dependency injection container
             config: Application configuration (optional, will be resolved from container)
         """
-        try:
-            logger.info("Initializing AudioProcessingApplicationService...")
-
-            self._container = container
-            self._config = config or container.resolve(AppConfig)
-            self._temp_files: Dict[str, str] = {}  # Track temporary files for cleanup
+        self._container = container
+        self._config = config or container.resolve(AppConfig)
+        self._temp_files: Dict[str, str] = {}  # Track temporary files for cleanup
 
-            # Initialize error handling components
-            self._error_mapper = ErrorMapper()
-            self._recovery_manager = RecoveryManager()
+        # Initialize error handling components
+        self._error_mapper = ErrorMapper()
+        self._recovery_manager = RecoveryManager()
 
-            # Setup logging
-            self._setup_logging()
+        # Setup logging
+        self._setup_logging()
 
-            logger.info("AudioProcessingApplicationService initialized successfully")
-
-        except Exception as e:
-            logger.error(f"Failed to initialize AudioProcessingApplicationService: {e}", exc_info=True)
-            raise
+        logger.info("AudioProcessingApplicationService initialized")
 
     def _setup_logging(self) -> None:
         """Setup logging configuration."""
         try:
-            logger.info("Setting up logging configuration...")
             log_config = self._config.get_logging_config()
 
             # Configure logger level
             logger.setLevel(getattr(logging, log_config['level'].upper(), logging.INFO))
-            logger.info("Logging configuration completed")
+
+            # Add file handler if enabled
+            if log_config.get('enable_file_logging', False):
+                file_handler = logging.FileHandler(log_config['log_file_path'])
+                file_handler.setLevel(logger.level)
+
+                formatter = logging.Formatter(log_config['format'])
+                file_handler.setFormatter(formatter)
+
+                logger.addHandler(file_handler)
 
         except Exception as e:
             logger.warning(f"Failed to setup logging configuration: {e}")
-            # Continue with default logging
 
     def process_audio_pipeline(self, request: ProcessingRequestDto) -> ProcessingResultDto:
         """
@@ -332,7 +332,7 @@ class AudioProcessingApplicationService:
 
         try:
             os.makedirs(temp_dir, exist_ok=True)
-            logger.info(f"Created temporary directory: {temp_dir}")
+            logger.debug(f"Created temporary directory: {temp_dir}")
             yield temp_dir
 
         finally:
@@ -341,7 +341,7 @@ class AudioProcessingApplicationService:
                 try:
                     import shutil
                     shutil.rmtree(temp_dir, ignore_errors=True)
-                    logger.info(f"Cleaned up temporary directory: {temp_dir}")
+                    logger.debug(f"Cleaned up temporary directory: {temp_dir}")
                 except Exception as e:
                     logger.warning(f"Failed to cleanup temp directory {temp_dir}: {e}")
 
@@ -384,7 +384,7 @@ class AudioProcessingApplicationService:
                 duration=0.0  # Would be calculated from actual file
             )
 
-            logger.info(f"Converted upload to AudioContent: {upload.filename}")
+            logger.debug(f"Converted upload to AudioContent: {upload.filename}")
             return audio_content
 
         except Exception as e:
@@ -412,7 +412,7 @@ class AudioProcessingApplicationService:
             SpeechRecognitionException: If STT fails
         """
         try:
-            logger.info(f"Starting STT with model: {model} [correlation_id={correlation_id}]")
+            logger.debug(f"Starting STT with model: {model} [correlation_id={correlation_id}]")
 
             # Get STT provider from container
             stt_provider = self._container.get_stt_provider(model)
@@ -454,7 +454,7 @@ class AudioProcessingApplicationService:
             TranslationFailedException: If translation fails
         """
         try:
-            logger.info(
+            logger.debug(
                 f"Starting translation: {source_language or 'auto'} -> {target_language} "
                 f"[correlation_id={correlation_id}]"
             )
@@ -510,7 +510,7 @@ class AudioProcessingApplicationService:
             SpeechSynthesisException: If TTS fails
         """
         try:
-            logger.info(
+            logger.debug(
                 f"Starting TTS with voice: {voice}, speed: {speed} "
                 f"[correlation_id={correlation_id}]"
             )
@@ -582,7 +582,7 @@ class AudioProcessingApplicationService:
             try:
                 if os.path.exists(file_path):
                     os.remove(file_path)
-                    logger.info(f"Cleaned up temp file: {file_path}")
+                    logger.debug(f"Cleaned up temp file: {file_path}")
             except Exception as e:
                 logger.warning(f"Failed to cleanup temp file {file_path}: {e}")
             finally:

src/application/services/configuration_service.py

@@ -153,7 +153,7 @@ class ConfigurationApplicationService:
                     # Update the actual config object
                     if hasattr(self._config.tts, key):
                         setattr(self._config.tts, key, value)
-                        logger.info(f"Updated TTS config: {key} = {value}")
+                        logger.debug(f"Updated TTS config: {key} = {value}")
                 else:
                     logger.warning(f"Unknown TTS configuration key: {key}")
 
@@ -192,7 +192,7 @@ class ConfigurationApplicationService:
                     # Update the actual config object
                     if hasattr(self._config.stt, key):
                         setattr(self._config.stt, key, value)
-                        logger.info(f"Updated STT config: {key} = {value}")
+                        logger.debug(f"Updated STT config: {key} = {value}")
                 else:
                     logger.warning(f"Unknown STT configuration key: {key}")
 
@@ -231,7 +231,7 @@ class ConfigurationApplicationService:
                     # Update the actual config object
                     if hasattr(self._config.translation, key):
                         setattr(self._config.translation, key, value)
-                        logger.info(f"Updated translation config: {key} = {value}")
+                        logger.debug(f"Updated translation config: {key} = {value}")
                 else:
                     logger.warning(f"Unknown translation configuration key: {key}")
 
@@ -270,7 +270,7 @@ class ConfigurationApplicationService:
                     # Update the actual config object
                     if hasattr(self._config.processing, key):
                         setattr(self._config.processing, key, value)
-                        logger.info(f"Updated processing config: {key} = {value}")
+                        logger.debug(f"Updated processing config: {key} = {value}")
                 else:
                     logger.warning(f"Unknown processing configuration key: {key}")
 

src/infrastructure/base/file_utils.py

@@ -27,7 +27,7 @@ class FileManager:
             self.base_dir = Path(tempfile.gettempdir()) / "tts_app"
 
         self.base_dir.mkdir(exist_ok=True)
-        logger.info(f"FileManager initialized with base directory: {self.base_dir}")
+        logger.debug(f"FileManager initialized with base directory: {self.base_dir}")
 
     def create_temp_file(self, suffix: str = ".tmp", prefix: str = "temp", content: bytes = None) -> Path:
         """
@@ -51,7 +51,7 @@ class FileManager:
         else:
             file_path.touch()
 
-        logger.info(f"Created temporary file: {file_path}")
+        logger.debug(f"Created temporary file: {file_path}")
         return file_path
 
     def create_unique_filename(self, base_name: str, extension: str = "", content_hash: bool = False, content: bytes = None) -> str:
@@ -103,7 +103,7 @@ class FileManager:
         with open(file_path, 'wb') as f:
             f.write(audio_data)
 
-        logger.info(f"Saved audio file: {file_path} ({len(audio_data)} bytes)")
+        logger.debug(f"Saved audio file: {file_path} ({len(audio_data)} bytes)")
         return file_path
 
     def save_text_file(self, text_content: str, encoding: str = "utf-8", prefix: str = "text") -> Path:
@@ -124,7 +124,7 @@ class FileManager:
         with open(file_path, 'w', encoding=encoding) as f:
             f.write(text_content)
 
-        logger.info(f"Saved text file: {file_path} ({len(text_content)} characters)")
+        logger.debug(f"Saved text file: {file_path} ({len(text_content)} characters)")
         return file_path
 
     def cleanup_file(self, file_path: Union[str, Path]) -> bool:
@@ -141,7 +141,7 @@ class FileManager:
             path = Path(file_path)
             if path.exists() and path.is_file():
                 path.unlink()
-                logger.info(f"Cleaned up file: {path}")
+                logger.debug(f"Cleaned up file: {path}")
                 return True
             return False
         except Exception as e:
@@ -223,7 +223,7 @@ class FileManager:
         """
         path = Path(dir_path)
         path.mkdir(parents=True, exist_ok=True)
-        logger.info(f"Ensured directory exists: {path}")
+        logger.debug(f"Ensured directory exists: {path}")
         return path
 
     def get_disk_usage(self) -> dict:
@@ -282,7 +282,7 @@ class AudioFileGenerator:
                 wav_file.setframerate(sample_rate)
                 wav_file.writeframes(audio_data)
 
-            logger.info(f"Saved WAV file: {path} (sample_rate={sample_rate}, channels={channels})")
+            logger.debug(f"Saved WAV file: {path} (sample_rate={sample_rate}, channels={channels})")
             return path
 
         except Exception as e:
@@ -318,7 +318,7 @@ class AudioFileGenerator:
 
             sf.write(str(path), audio_array, sample_rate)
 
-            logger.info(f"Converted numpy array to WAV: {path}")
+            logger.debug(f"Converted numpy array to WAV: {path}")
             return path
 
         except ImportError:
@@ -406,4 +406,4 @@ class ErrorHandler:
             debug_msg += f" ({context})"
         debug_msg += f": {message}"
 
-        self.logger.info(debug_msg)
+        self.logger.debug(debug_msg)

src/infrastructure/base/stt_provider_base.py

@@ -145,7 +145,7 @@ class STTProviderBase(ISpeechRecognitionService, ABC):
             # Convert to required format if needed
             processed_file = self._convert_audio_format(temp_file, audio)
 
-            logger.info(f"Audio preprocessed and saved to: {processed_file}")
+            logger.debug(f"Audio preprocessed and saved to: {processed_file}")
             return processed_file
 
         except Exception as e:
@@ -191,7 +191,7 @@ class STTProviderBase(ISpeechRecognitionService, ABC):
             # Export converted audio
             standardized_audio.export(output_path, format="wav")
 
-            logger.info(f"Audio converted from {audio.format} to WAV: {output_path}")
+            logger.debug(f"Audio converted from {audio.format} to WAV: {output_path}")
             return output_path
 
         except ImportError:
@@ -273,7 +273,7 @@ class STTProviderBase(ISpeechRecognitionService, ABC):
         try:
             if file_path.exists():
                 file_path.unlink()
-                logger.info(f"Cleaned up temp file: {file_path}")
+                logger.debug(f"Cleaned up temp file: {file_path}")
         except Exception as e:
             logger.warning(f"Failed to cleanup temp file {file_path}: {str(e)}")
 
@@ -294,7 +294,7 @@ class STTProviderBase(ISpeechRecognitionService, ABC):
                     file_age = current_time - file_path.stat().st_mtime
                     if file_age > max_age_seconds:
                         file_path.unlink()
-                        logger.info(f"Cleaned up old temp file: {file_path}")
+                        logger.debug(f"Cleaned up old temp file: {file_path}")
 
         except Exception as e:
             logger.warning(f"Failed to cleanup old temp files: {str(e)}")

src/infrastructure/base/translation_provider_base.py

@@ -56,7 +56,7 @@ class TranslationProviderBase(ITranslationService, ABC):
             # Translate each chunk
             translated_chunks = []
             for i, chunk in enumerate(text_chunks):
-                logger.info(f"Translating chunk {i+1}/{len(text_chunks)}")
+                logger.debug(f"Translating chunk {i+1}/{len(text_chunks)}")
                 translated_chunk = self._translate_chunk(
                     chunk,
                     request.source_text.language,
@@ -160,7 +160,7 @@ class TranslationProviderBase(ITranslationService, ABC):
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
 
-        logger.info(f"Text chunked into {len(chunks)} pieces")
+        logger.debug(f"Text chunked into {len(chunks)} pieces")
         return chunks
 
     def _split_into_sentences(self, text: str) -> List[str]:

src/infrastructure/base/tts_provider_base.py

@@ -322,7 +322,7 @@ class TTSProviderBase(ISpeechSynthesisService, ABC):
                     file_age = current_time - file_path.stat().st_mtime
                     if file_age > max_age_seconds:
                         file_path.unlink()
-                        logger.info(f"Cleaned up old temp file: {file_path}")
+                        logger.debug(f"Cleaned up old temp file: {file_path}")
 
         except Exception as e:
             logger.warning(f"Failed to cleanup temp files: {str(e)}")

src/infrastructure/config/container_setup.py

@@ -131,14 +131,7 @@ def _register_application_services(container: DependencyContainer) -> None:
     # It manages resources and should be scoped to request/session
     def create_audio_processing_app_service() -> AudioProcessingApplicationService:
         """Factory function for creating audio processing application service."""
-        try:
-            logger.info("Creating AudioProcessingApplicationService...")
-            service = AudioProcessingApplicationService(container)
-            logger.info("AudioProcessingApplicationService created successfully")
-            return service
-        except Exception as e:
-            logger.error(f"Failed to create AudioProcessingApplicationService: {e}", exc_info=True)
-            raise
+        return AudioProcessingApplicationService(container)
 
     container.register_scoped(
         AudioProcessingApplicationService,

src/infrastructure/config/dependency_container.py

@@ -67,12 +67,12 @@ class DependencyContainer:
         self._singletons: Dict[Type, Any] = {}
         self._scoped_instances: Dict[Type, Any] = {}
         self._lock = Lock()
-
+        
         # Provider factories
         self._tts_factory: Optional[TTSProviderFactory] = None
         self._stt_factory: Optional[STTProviderFactory] = None
         self._translation_factory: Optional[TranslationProviderFactory] = None
-
+        
         # Register default services
         self._register_default_services()
 
@@ -80,7 +80,7 @@ class DependencyContainer:
         """Register default service implementations."""
         # Register configuration as singleton
         self.register_singleton(AppConfig, self._config)
-
+        
         # Register provider factories as singletons
         self.register_singleton(TTSProviderFactory, self._get_tts_factory)
         self.register_singleton(STTProviderFactory, self._get_stt_factory)
@@ -104,7 +104,7 @@ class DependencyContainer:
             # If implementation is already an instance, store it directly
             if not (isinstance(implementation, type) or callable(implementation)):
                 self._singletons[service_type] = implementation
-                logger.info(f"Registered singleton instance for {service_type.__name__}")
+                logger.debug(f"Registered singleton instance for {service_type.__name__}")
                 return
 
             descriptor = ServiceDescriptor(
@@ -114,7 +114,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.info(f"Registered singleton service: {service_type.__name__}")
+            logger.debug(f"Registered singleton service: {service_type.__name__}")
 
     def register_transient(
         self,
@@ -138,7 +138,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.info(f"Registered transient service: {service_type.__name__}")
+            logger.debug(f"Registered transient service: {service_type.__name__}")
 
     def register_scoped(
         self,
@@ -162,7 +162,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.info(f"Registered scoped service: {service_type.__name__}")
+            logger.debug(f"Registered scoped service: {service_type.__name__}")
 
     def resolve(self, service_type: Type[T]) -> T:
         """
@@ -208,7 +208,7 @@ class DependencyContainer:
 
         instance = self._create_instance(descriptor)
         self._singletons[service_type] = instance
-        logger.info(f"Created singleton instance for {service_type.__name__}")
+        logger.debug(f"Created singleton instance for {service_type.__name__}")
         return instance
 
     def _create_scoped(self, service_type: Type[T], descriptor: ServiceDescriptor) -> T:
@@ -218,13 +218,13 @@ class DependencyContainer:
 
         instance = self._create_instance(descriptor)
         self._scoped_instances[service_type] = instance
-        logger.info(f"Created scoped instance for {service_type.__name__}")
+        logger.debug(f"Created scoped instance for {service_type.__name__}")
         return instance
 
     def _create_transient(self, descriptor: ServiceDescriptor) -> T:
         """Create new transient instance."""
         instance = self._create_instance(descriptor)
-        logger.info(f"Created transient instance for {descriptor.service_type.__name__}")
+        logger.debug(f"Created transient instance for {descriptor.service_type.__name__}")
         return instance
 
     def _create_instance(self, descriptor: ServiceDescriptor) -> T:
@@ -246,21 +246,21 @@ class DependencyContainer:
         """Get or create TTS provider factory."""
         if self._tts_factory is None:
             self._tts_factory = TTSProviderFactory()
-            logger.info("Created TTS provider factory")
+            logger.debug("Created TTS provider factory")
         return self._tts_factory
 
     def _get_stt_factory(self) -> STTProviderFactory:
         """Get or create STT provider factory."""
         if self._stt_factory is None:
             self._stt_factory = STTProviderFactory()
-            logger.info("Created STT provider factory")
+            logger.debug("Created STT provider factory")
         return self._stt_factory
 
     def _get_translation_factory(self) -> TranslationProviderFactory:
         """Get or create translation provider factory."""
         if self._translation_factory is None:
             self._translation_factory = TranslationProviderFactory()
-            logger.info("Created translation provider factory")
+            logger.debug("Created translation provider factory")
         return self._translation_factory
 
     def get_tts_provider(self, provider_name: Optional[str] = None, **kwargs) -> ISpeechSynthesisService:
@@ -275,7 +275,7 @@ class DependencyContainer:
             ISpeechSynthesisService: TTS provider instance
         """
         factory = self.resolve(TTSProviderFactory)
-
+        
         if provider_name:
             return factory.create_provider(provider_name, **kwargs)
         else:
@@ -293,7 +293,7 @@ class DependencyContainer:
             ISpeechRecognitionService: STT provider instance
         """
         factory = self.resolve(STTProviderFactory)
-
+        
         if provider_name:
             return factory.create_provider(provider_name)
         else:
@@ -316,7 +316,7 @@ class DependencyContainer:
             ITranslationService: Translation provider instance
         """
         factory = self.resolve(TranslationProviderFactory)
-
+        
         if provider_type:
             return factory.create_provider(provider_type, config)
         else:
@@ -328,9 +328,9 @@ class DependencyContainer:
             # Cleanup scoped instances if they have cleanup methods
             for instance in self._scoped_instances.values():
                 self._cleanup_instance(instance)
-
+            
             self._scoped_instances.clear()
-            logger.info("Cleared scoped instances")
+            logger.debug("Cleared scoped instances")
 
     def _cleanup_instance(self, instance: Any) -> None:
         """Cleanup instance if it has cleanup methods."""
@@ -342,7 +342,7 @@ class DependencyContainer:
                     method = getattr(instance, method_name)
                     if callable(method):
                         method()
-                        logger.info(f"Called {method_name} on {type(instance).__name__}")
+                        logger.debug(f"Called {method_name} on {type(instance).__name__}")
                         break
         except Exception as e:
             logger.warning(f"Failed to cleanup instance {type(instance).__name__}: {e}")
@@ -351,33 +351,33 @@ class DependencyContainer:
         """Cleanup all managed resources."""
         with self._lock:
             logger.info("Starting dependency container cleanup")
-
+            
             # Cleanup scoped instances
             self.clear_scoped_instances()
-
+            
             # Cleanup singleton instances
             for instance in self._singletons.values():
                 self._cleanup_instance(instance)
-
+            
             # Cleanup provider factories
             if self._tts_factory:
                 try:
                     self._tts_factory.cleanup_providers()
                 except Exception as e:
                     logger.warning(f"Failed to cleanup TTS factory: {e}")
-
+            
             if self._translation_factory:
                 try:
                     self._translation_factory.clear_cache()
                 except Exception as e:
                     logger.warning(f"Failed to cleanup translation factory: {e}")
-
+            
             # Clear all references
             self._singletons.clear()
             self._tts_factory = None
             self._stt_factory = None
             self._translation_factory = None
-
+            
             logger.info("Dependency container cleanup completed")
 
     def is_registered(self, service_type: Type) -> bool:
@@ -402,16 +402,16 @@ class DependencyContainer:
         """
         with self._lock:
             services_info = {}
-
+            
             # Add singleton instances
             for service_type in self._singletons.keys():
                 services_info[service_type.__name__] = "singleton (instance)"
-
+            
             # Add registered services
             for service_type, descriptor in self._services.items():
                 if service_type not in self._singletons:
                     services_info[service_type.__name__] = descriptor.lifetime.value
-
+            
             return services_info
 
     def create_scope(self) -> 'DependencyScope':
@@ -465,7 +465,7 @@ class DependencyScope:
             instance = self._parent.resolve(service_type)
 
             # If it's a scoped service, store it in this scope
-            if (service_type in self._parent._services and
+            if (service_type in self._parent._services and 
                 self._parent._services[service_type].lifetime == ServiceLifetime.SCOPED):
                 self._scoped_instances[service_type] = instance
 
@@ -500,12 +500,12 @@ def get_container() -> DependencyContainer:
         DependencyContainer: Global container instance
     """
     global _global_container
-
+    
     with _container_lock:
         if _global_container is None:
             _global_container = DependencyContainer()
             logger.info("Created global dependency container")
-
+        
         return _global_container
 
 
@@ -517,11 +517,11 @@ def set_container(container: DependencyContainer) -> None:
         container: Container instance to set as global
     """
     global _global_container
-
+    
     with _container_lock:
         if _global_container is not None:
             _global_container.cleanup()
-
+        
         _global_container = container
         logger.info("Set global dependency container")
 
@@ -529,7 +529,7 @@ def set_container(container: DependencyContainer) -> None:
 def cleanup_container() -> None:
     """Cleanup the global dependency container."""
     global _global_container
-
+    
     with _container_lock:
         if _global_container is not None:
             _global_container.cleanup()

src/infrastructure/stt/provider_factory.py

@@ -36,21 +36,21 @@ class STTProviderFactory:
             SpeechRecognitionException: If provider is not available or creation fails
         """
         provider_name = provider_name.lower()
-
+        
         if provider_name not in cls._providers:
             raise SpeechRecognitionException(f"Unknown STT provider: {provider_name}")
 
         provider_class = cls._providers[provider_name]
-
+        
         try:
             provider = provider_class()
-
+            
             if not provider.is_available():
                 raise SpeechRecognitionException(f"STT provider {provider_name} is not available")
-
+            
             logger.info(f"Created STT provider: {provider_name}")
             return provider
-
+            
         except Exception as e:
             logger.error(f"Failed to create STT provider {provider_name}: {str(e)}")
             raise SpeechRecognitionException(f"Failed to create STT provider {provider_name}: {str(e)}") from e
@@ -79,7 +79,7 @@ class STTProviderFactory:
         for provider_name in cls._fallback_order:
             if provider_name.lower() == preferred_provider.lower():
                 continue  # Skip the preferred provider we already tried
-
+                
             try:
                 logger.info(f"Trying fallback STT provider: {provider_name}")
                 return cls.create_provider(provider_name)
@@ -98,15 +98,15 @@ class STTProviderFactory:
             list[str]: List of available provider names
         """
         available = []
-
+        
         for provider_name, provider_class in cls._providers.items():
             try:
                 provider = provider_class()
                 if provider.is_available():
                     available.append(provider_name)
             except Exception as e:
-                logger.info(f"Provider {provider_name} not available: {str(e)}")
-
+                logger.debug(f"Provider {provider_name} not available: {str(e)}")
+                
         return available
 
     @classmethod
@@ -121,12 +121,12 @@ class STTProviderFactory:
             Optional[dict]: Provider information or None if not found
         """
         provider_name = provider_name.lower()
-
+        
         if provider_name not in cls._providers:
             return None
 
         provider_class = cls._providers[provider_name]
-
+        
         try:
             provider = provider_class()
             return {
@@ -137,7 +137,7 @@ class STTProviderFactory:
                 "default_model": provider.get_default_model() if provider.is_available() else None
             }
         except Exception as e:
-            logger.info(f"Failed to get info for provider {provider_name}: {str(e)}")
+            logger.debug(f"Failed to get info for provider {provider_name}: {str(e)}")
             return {
                 "name": provider_name,
                 "available": False,
@@ -160,15 +160,15 @@ class STTProviderFactory:
 # Legacy compatibility - create an ASRFactory alias
 class ASRFactory:
     """Legacy ASRFactory for backward compatibility."""
-
+    
     @staticmethod
     def get_model(model_name: str = "parakeet") -> STTProviderBase:
         """
         Get STT provider by model name (legacy interface).
-
+        
         Args:
             model_name: Name of the model/provider to use
-
+            
         Returns:
             STTProviderBase: The provider instance
         """
@@ -178,9 +178,9 @@ class ASRFactory:
             "parakeet": "parakeet",
             "faster-whisper": "whisper"
         }
-
+        
         provider_name = provider_mapping.get(model_name.lower(), model_name.lower())
-
+        
         try:
             return STTProviderFactory.create_provider(provider_name)
         except SpeechRecognitionException:

src/infrastructure/stt/whisper_provider.py

@@ -36,7 +36,7 @@ class WhisperSTTProvider(STTProviderBase):
         except ImportError:
             # Fallback to CPU if torch is not available
             self._device = "cpu"
-
+        
         self._compute_type = "float16" if self._device == "cuda" else "int8"
         logger.info(f"Whisper provider initialized with device: {self._device}, compute_type: {self._compute_type}")
 
@@ -57,7 +57,7 @@ class WhisperSTTProvider(STTProviderBase):
                 self._load_model(model)
 
             logger.info(f"Starting Whisper transcription with model {model}")
-
+            
             # Perform transcription
             segments, info = self.model.transcribe(
                 str(audio_path),
@@ -72,7 +72,7 @@ class WhisperSTTProvider(STTProviderBase):
             result_text = ""
             for segment in segments:
                 result_text += segment.text + " "
-                logger.info(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
+                logger.debug(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
 
             result = result_text.strip()
             logger.info("Whisper transcription completed successfully")
@@ -90,18 +90,18 @@ class WhisperSTTProvider(STTProviderBase):
         """
         try:
             from faster_whisper import WhisperModel as FasterWhisperModel
-
+            
             logger.info(f"Loading Whisper model: {model_name}")
             logger.info(f"Using device: {self._device}, compute_type: {self._compute_type}")
-
+            
             self.model = FasterWhisperModel(
                 model_name,
                 device=self._device,
                 compute_type=self._compute_type
             )
-
+            
             logger.info(f"Whisper model {model_name} loaded successfully")
-
+            
         except ImportError as e:
             raise SpeechRecognitionException(
                 "faster-whisper not available. Please install with: pip install faster-whisper"
@@ -134,7 +134,7 @@ class WhisperSTTProvider(STTProviderBase):
             "tiny",
             "tiny.en",
             "base",
-            "base.en",
+            "base.en", 
             "small",
             "small.en",
             "medium",

src/infrastructure/translation/nllb_provider.py

@@ -430,7 +430,7 @@ class NLLBTranslationProvider(TranslationProviderBase):
             # For simplicity, assume all languages can translate to all other languages
             # In practice, you might want to be more specific about supported pairs
             supported_languages[lang_code] = [
-                target for target in self.LANGUAGE_MAPPINGS.keys()
+                target for target in self.LANGUAGE_MAPPINGS.keys() 
                 if target != lang_code
             ]
 
@@ -465,7 +465,7 @@ class NLLBTranslationProvider(TranslationProviderBase):
             source_nllb = self._map_language_code(source_language)
             target_nllb = self._map_language_code(target_language)
 
-            logger.info(f"Translating chunk from {source_nllb} to {target_nllb}")
+            logger.debug(f"Translating chunk from {source_nllb} to {target_nllb}")
 
             # Tokenize with source language specification
             inputs = self._tokenizer(
@@ -490,7 +490,7 @@ class NLLBTranslationProvider(TranslationProviderBase):
             # Post-process the translation
             translated = self._postprocess_text(translated)
 
-            logger.info(f"Chunk translation completed: {len(text)} -> {len(translated)} chars")
+            logger.debug(f"Chunk translation completed: {len(text)} -> {len(translated)} chars")
             return translated
 
         except Exception as e:

src/infrastructure/translation/provider_factory.py

@@ -67,7 +67,7 @@ class TranslationProviderFactory:
 
             # Return cached instance if available and requested
             if use_cache and cache_key in self._provider_cache:
-                logger.info(f"Returning cached {provider_type.value} provider")
+                logger.debug(f"Returning cached {provider_type.value} provider")
                 return self._provider_cache[cache_key]
 
             # Check if provider type is registered
@@ -86,7 +86,7 @@ class TranslationProviderFactory:
                 final_config.update(config)
 
             logger.info(f"Creating {provider_type.value} translation provider")
-            logger.info(f"Provider config: {final_config}")
+            logger.debug(f"Provider config: {final_config}")
 
             # Create provider instance
             provider = provider_class(**final_config)
@@ -258,7 +258,7 @@ class TranslationProviderFactory:
             # Cache the result
             self._availability_cache[provider_type] = is_available
 
-            logger.info(f"Provider {provider_type.value} availability: {is_available}")
+            logger.debug(f"Provider {provider_type.value} availability: {is_available}")
             return is_available
 
         except Exception as e:

src/infrastructure/tts/provider_factory.py

@@ -20,7 +20,7 @@ class TTSProviderFactory:
     def _register_default_providers(self):
         """Register all available TTS providers."""
         # Import providers dynamically to avoid import errors if dependencies are missing
-
+        
         # Always register dummy provider as fallback
         from .dummy_provider import DummyTTSProvider
         self._providers['dummy'] = DummyTTSProvider
@@ -31,7 +31,7 @@ class TTSProviderFactory:
             self._providers['kokoro'] = KokoroTTSProvider
             logger.info("Registered Kokoro TTS provider")
         except ImportError as e:
-            logger.info(f"Kokoro TTS provider not available: {e}")
+            logger.debug(f"Kokoro TTS provider not available: {e}")
 
         # Try to register Dia provider
         try:
@@ -39,7 +39,7 @@ class TTSProviderFactory:
             self._providers['dia'] = DiaTTSProvider
             logger.info("Registered Dia TTS provider")
         except ImportError as e:
-            logger.info(f"Dia TTS provider not available: {e}")
+            logger.debug(f"Dia TTS provider not available: {e}")
 
         # Try to register CosyVoice2 provider
         try:
@@ -47,7 +47,7 @@ class TTSProviderFactory:
             self._providers['cosyvoice2'] = CosyVoice2TTSProvider
             logger.info("Registered CosyVoice2 TTS provider")
         except ImportError as e:
-            logger.info(f"CosyVoice2 TTS provider not available: {e}")
+            logger.debug(f"CosyVoice2 TTS provider not available: {e}")
 
     def get_available_providers(self) -> List[str]:
         """Get list of available TTS providers."""
@@ -68,10 +68,10 @@ class TTSProviderFactory:
                 # Check if provider is available
                 if self._provider_instances[name].is_available():
                     available.append(name)
-
+                    
             except Exception as e:
                 logger.warning(f"Failed to check availability of {name} provider: {e}")
-
+                
         return available
 
     def create_provider(self, provider_name: str, **kwargs) -> TTSProviderBase:
@@ -96,7 +96,7 @@ class TTSProviderFactory:
 
         try:
             provider_class = self._providers[provider_name]
-
+            
             # Create instance with appropriate parameters
             if provider_name in ['kokoro', 'dia', 'cosyvoice2']:
                 lang_code = kwargs.get('lang_code', 'z')
@@ -133,7 +133,7 @@ class TTSProviderFactory:
             preferred_providers = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
 
         available_providers = self.get_available_providers()
-
+        
         # Try preferred providers in order
         for provider_name in preferred_providers:
             if provider_name in available_providers:
@@ -177,7 +177,7 @@ class TTSProviderFactory:
                     self._provider_instances[provider_name] = provider_class()
 
             provider = self._provider_instances[provider_name]
-
+            
             return {
                 "available": provider.is_available(),
                 "name": provider.provider_name,
@@ -199,6 +199,6 @@ class TTSProviderFactory:
                     provider._cleanup_temp_files()
             except Exception as e:
                 logger.warning(f"Failed to cleanup provider {provider.provider_name}: {e}")
-
+        
         self._provider_instances.clear()
         logger.info("Cleaned up TTS provider instances")

tests/unit/application/error_handling/test_structured_logger.py

@@ -60,7 +60,7 @@ class TestStructuredLogger:
         context = LogContext(correlation_id="test-123", operation="test_op")
 
         with patch.object(self.logger.logger, 'debug') as mock_debug:
-            self.logger.info("Test debug message", context=context)
+            self.logger.debug("Test debug message", context=context)
 
             mock_debug.assert_called_once()
             args, kwargs = mock_debug.call_args

utils/stt.py

@@ -16,17 +16,17 @@ from pydub import AudioSegment
 
 class ASRModel(ABC):
     """Base class for ASR models"""
-
+    
     @abstractmethod
     def load_model(self):
         """Load the ASR model"""
         pass
-
+    
     @abstractmethod
     def transcribe(self, audio_path):
         """Transcribe audio to text"""
         pass
-
+    
     def preprocess_audio(self, audio_path):
         """Convert audio to required format"""
         logger.info("Converting audio format")
@@ -42,7 +42,7 @@ class ASRModel(ABC):
 
 class WhisperModel(ASRModel):
     """Faster Whisper ASR model implementation"""
-
+    
     def __init__(self):
         self.model = None
         # Check for CUDA availability without torch dependency
@@ -53,13 +53,13 @@ class WhisperModel(ASRModel):
             # Fallback to CPU if torch is not available
             self.device = "cpu"
         self.compute_type = "float16" if self.device == "cuda" else "int8"
-
+        
     def load_model(self):
         """Load Faster Whisper model"""
         logger.info("Loading Faster Whisper model")
         logger.info(f"Using device: {self.device}")
         logger.info(f"Using compute type: {self.compute_type}")
-
+        
         # Use large-v3 model with appropriate compute type based on device
         self.model = FasterWhisperModel(
             "large-v3",
@@ -67,14 +67,14 @@ class WhisperModel(ASRModel):
             compute_type=self.compute_type
         )
         logger.info("Faster Whisper model loaded successfully")
-
+    
     def transcribe(self, audio_path):
         """Transcribe audio using Faster Whisper"""
         if self.model is None:
             self.load_model()
-
+            
         wav_path = self.preprocess_audio(audio_path)
-
+        
         # Transcription with Faster Whisper
         logger.info("Generating transcription with Faster Whisper")
         segments, info = self.model.transcribe(
@@ -83,15 +83,15 @@ class WhisperModel(ASRModel):
             language="en",
             task="transcribe"
         )
-
+        
         logger.info(f"Detected language '{info.language}' with probability {info.language_probability}")
-
+        
         # Collect all segments into a single text
         result_text = ""
         for segment in segments:
             result_text += segment.text + " "
-            logger.info(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
-
+            logger.debug(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
+        
         result = result_text.strip()
         logger.info(f"Transcription completed successfully")
         return result
@@ -99,10 +99,10 @@ class WhisperModel(ASRModel):
 
 class ParakeetModel(ASRModel):
     """Parakeet ASR model implementation"""
-
+    
     def __init__(self):
         self.model = None
-
+        
     def load_model(self):
         """Load Parakeet model"""
         try:
@@ -113,14 +113,14 @@ class ParakeetModel(ASRModel):
         except ImportError:
             logger.error("Failed to import nemo_toolkit. Please install with: pip install -U 'nemo_toolkit[asr]'")
             raise
-
+    
     def transcribe(self, audio_path):
         """Transcribe audio using Parakeet"""
         if self.model is None:
             self.load_model()
-
+            
         wav_path = self.preprocess_audio(audio_path)
-
+        
         # Transcription
         logger.info("Generating transcription with Parakeet")
         output = self.model.transcribe([wav_path])
@@ -131,7 +131,7 @@ class ParakeetModel(ASRModel):
 
 class ASRFactory:
     """Factory for creating ASR model instances"""
-
+    
     @staticmethod
     def get_model(model_name="parakeet"):
         """
@@ -160,11 +160,11 @@ def transcribe_audio(audio_path, model_name="parakeet"):
         Transcribed English text
     """
     logger.info(f"Starting transcription for: {audio_path} using {model_name} model")
-
+    
     try:
         # Get the appropriate model
         asr_model = ASRFactory.get_model(model_name)
-
+        
         # Transcribe audio
         result = asr_model.transcribe(audio_path)
         logger.info(f"transcription: %s" % result)