attempt fix

src/application/dtos/processing_result_dto.py

@@ -8,7 +8,7 @@ from datetime import datetime
 @dataclass
 class ProcessingResultDto:
     """DTO for pipeline output data
-    
+
     Contains the results of processing audio through the
     STT -> Translation -> TTS pipeline.
     """
@@ -21,7 +21,7 @@ class ProcessingResultDto:
     error_code: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
     timestamp: Optional[datetime] = None
-    
+
     def __post_init__(self):
         """Validate and set defaults after initialization"""
         self._validate()
@@ -29,15 +29,15 @@ class ProcessingResultDto:
             self.metadata = {}
         if self.timestamp is None:
             self.timestamp = datetime.utcnow()
-    
+
     def _validate(self):
         """Validate processing result data"""
         if not isinstance(self.success, bool):
             raise ValueError("Success must be a boolean value")
-        
+
         if self.processing_time < 0:
             raise ValueError("Processing time cannot be negative")
-        
+
         if self.success:
             # For successful processing, we should have some output
             if not self.original_text and not self.translated_text and not self.audio_path:
@@ -46,48 +46,49 @@ class ProcessingResultDto:
             # For failed processing, we should have an error message
             if not self.error_message:
                 raise ValueError("Failed processing must include an error message")
-        
+
         # Validate error code format if provided
         if self.error_code:
             valid_error_codes = [
                 'STT_ERROR', 'TRANSLATION_ERROR', 'TTS_ERROR',
                 'AUDIO_FORMAT_ERROR', 'VALIDATION_ERROR', 'SYSTEM_ERROR',
+                'TYPE_ERROR', 'TIMEOUT_ERROR', 'PERMISSION_ERROR', 'MEMORY_ERROR',
                 'UNKNOWN_ERROR'  # Add missing error code for unexpected errors
             ]
             if self.error_code not in valid_error_codes:
                 raise ValueError(f"Invalid error code: {self.error_code}. Valid codes: {valid_error_codes}")
-        
+
         # Validate metadata if provided
         if self.metadata and not isinstance(self.metadata, dict):
             raise ValueError("Metadata must be a dictionary")
-    
+
     @property
     def has_text_output(self) -> bool:
         """Check if result has text output"""
         return bool(self.original_text or self.translated_text)
-    
+
     @property
     def has_audio_output(self) -> bool:
         """Check if result has audio output"""
         return bool(self.audio_path)
-    
+
     @property
     def is_complete(self) -> bool:
         """Check if processing is complete (success or failure with error)"""
         return self.success or bool(self.error_message)
-    
+
     def add_metadata(self, key: str, value: Any) -> None:
         """Add metadata entry"""
         if self.metadata is None:
             self.metadata = {}
         self.metadata[key] = value
-    
+
     def get_metadata(self, key: str, default: Any = None) -> Any:
         """Get metadata value"""
         if self.metadata is None:
             return default
         return self.metadata.get(key, default)
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary representation"""
         return {
@@ -104,9 +105,9 @@ class ProcessingResultDto:
             'has_audio_output': self.has_audio_output,
             'is_complete': self.is_complete
         }
-    
+
     @classmethod
-    def success_result(cls, original_text: str = None, translated_text: str = None, 
+    def success_result(cls, original_text: str = None, translated_text: str = None,
                       audio_path: str = None, processing_time: float = 0.0,
                       metadata: Dict[str, Any] = None) -> 'ProcessingResultDto':
         """Create a successful processing result"""
@@ -118,7 +119,7 @@ class ProcessingResultDto:
             processing_time=processing_time,
             metadata=metadata
         )
-    
+
     @classmethod
     def error_result(cls, error_message: str, error_code: str = None,
                     processing_time: float = 0.0, metadata: Dict[str, Any] = None) -> 'ProcessingResultDto':
@@ -130,14 +131,14 @@ class ProcessingResultDto:
             processing_time=processing_time,
             metadata=metadata
         )
-    
+
     @classmethod
     def from_dict(cls, data: dict) -> 'ProcessingResultDto':
         """Create instance from dictionary"""
         timestamp = None
         if data.get('timestamp'):
             timestamp = datetime.fromisoformat(data['timestamp'].replace('Z', '+00:00'))
-        
+
         return cls(
             success=data['success'],
             original_text=data.get('original_text'),

src/application/services/audio_processing_service.py

@@ -695,7 +695,7 @@ class AudioProcessingApplicationService:
             retryable_exceptions=[SpeechRecognitionException, ConnectionError, TimeoutError]
         )
 
-        def stt_operation():
+        def stt_operation(*args, **kwargs):
             return self._perform_speech_recognition(audio, model, correlation_id)
 
         try:
@@ -719,7 +719,7 @@ class AudioProcessingApplicationService:
                 )
 
                 fallback_funcs = [
-                    lambda m=fallback_model: self._perform_speech_recognition(audio, m, correlation_id)
+                    lambda *args, m=fallback_model, **kwargs: self._perform_speech_recognition(audio, m, correlation_id)
                     for fallback_model in fallback_models
                 ]
 
@@ -761,7 +761,7 @@ class AudioProcessingApplicationService:
             retryable_exceptions=[TranslationFailedException, ConnectionError, TimeoutError]
         )
 
-        def translation_operation():
+        def translation_operation(*args, **kwargs):
             return self._perform_translation(text, source_language, target_language, correlation_id)
 
         return self._recovery_manager.retry_with_backoff(
@@ -806,14 +806,14 @@ class AudioProcessingApplicationService:
         logger.info(f"Parameters: voice={voice}, speed={speed}, language={language}")
         logger.info(f"Text type: {type(text)}, Text content type: {type(text.text) if hasattr(text, 'text') else 'N/A'}")
 
-        def tts_operation():
+        def tts_operation(*args, **kwargs):
             logger.info(f"Executing TTS operation [correlation_id={correlation_id}]")
             try:
                 result = self._perform_speech_synthesis(text, voice, speed, language, temp_dir, correlation_id)
                 logger.info(f"TTS operation completed successfully [correlation_id={correlation_id}]")
                 return result
             except Exception as e:
-                logger.error(f"TTS operation failed: {str(e)} [correlation_id={correlation_id}]", exc_info=True)
+                logger.error(f"TTS operation failed: {str(e)} [correlation_id={correlation_id}]")
                 raise
 
         try:
@@ -827,7 +827,7 @@ class AudioProcessingApplicationService:
             )
 
         except Exception as e:
-            logger.error(f"Primary TTS failed, trying fallbacks: {str(e)} [correlation_id={correlation_id}]", exc_info=True)
+            logger.error(f"Primary TTS failed, trying fallbacks: {str(e)} [correlation_id={correlation_id}]", context=context, exception=e)
 
             # Try fallback TTS providers
             tts_config = self._config.get_tts_config()
@@ -841,7 +841,7 @@ class AudioProcessingApplicationService:
                 )
 
                 fallback_funcs = [
-                    lambda v=fallback_voice: self._perform_speech_synthesis(
+                    lambda *args, v=fallback_voice, **kwargs: self._perform_speech_synthesis(
                         text, v, speed, language, temp_dir, correlation_id
                     )
                     for fallback_voice in fallback_voices