set parakeet model to default asr

src/application/dtos/processing_request_dto.py

@@ -8,7 +8,7 @@ from .audio_upload_dto import AudioUploadDto
 @dataclass
 class ProcessingRequestDto:
     """DTO for pipeline input parameters
-    
+
     Contains all parameters needed to process audio through
     the STT -> Translation -> TTS pipeline.
     """
@@ -19,29 +19,29 @@ class ProcessingRequestDto:
     speed: float = 1.0
     source_language: Optional[str] = None
     additional_params: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Validate the DTO after initialization"""
         self._validate()
         if self.additional_params is None:
             self.additional_params = {}
-    
+
     def _validate(self):
         """Validate processing request parameters"""
         if not isinstance(self.audio, AudioUploadDto):
             raise ValueError("Audio must be an AudioUploadDto instance")
-        
+
         if not self.asr_model:
             raise ValueError("ASR model cannot be empty")
-        
+
         # Validate ASR model options
-        supported_asr_models = ['whisper-small', 'whisper-medium', 'whisper-large', 'parakeet']
+        supported_asr_models = ['parakeet', 'whisper-small', 'whisper-medium', 'whisper-large']
         if self.asr_model not in supported_asr_models:
             raise ValueError(f"Unsupported ASR model: {self.asr_model}. Supported: {supported_asr_models}")
-        
+
         if not self.target_language:
             raise ValueError("Target language cannot be empty")
-        
+
         # Validate language codes (ISO 639-1)
         supported_languages = [
             'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh',
@@ -49,33 +49,33 @@ class ProcessingRequestDto:
         ]
         if self.target_language not in supported_languages:
             raise ValueError(f"Unsupported target language: {self.target_language}. Supported: {supported_languages}")
-        
+
         if self.source_language and self.source_language not in supported_languages:
             raise ValueError(f"Unsupported source language: {self.source_language}. Supported: {supported_languages}")
-        
+
         if not self.voice:
             raise ValueError("Voice cannot be empty")
-        
+
         # Validate voice options
         supported_voices = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
         if self.voice not in supported_voices:
             raise ValueError(f"Unsupported voice: {self.voice}. Supported: {supported_voices}")
-        
+
         # Validate speed range
         if not 0.5 <= self.speed <= 2.0:
             raise ValueError(f"Speed must be between 0.5 and 2.0, got: {self.speed}")
-        
+
         # Validate additional params if provided
         if self.additional_params and not isinstance(self.additional_params, dict):
             raise ValueError("Additional params must be a dictionary")
-    
+
     @property
     def requires_translation(self) -> bool:
         """Check if translation is required"""
         if not self.source_language:
             return True  # Assume translation needed if source not specified
         return self.source_language != self.target_language
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary representation"""
         return {
@@ -88,7 +88,7 @@ class ProcessingRequestDto:
             'requires_translation': self.requires_translation,
             'additional_params': self.additional_params or {}
         }
-    
+
     @classmethod
     def from_dict(cls, data: dict) -> 'ProcessingRequestDto':
         """Create instance from dictionary"""
@@ -102,7 +102,7 @@ class ProcessingRequestDto:
             )
         else:
             audio = audio_data
-        
+
         return cls(
             audio=audio,
             asr_model=data['asr_model'],

src/application/services/audio_processing_service.py

@@ -634,7 +634,7 @@ class AudioProcessingApplicationService:
             Dict[str, Any]: Supported configurations
         """
         return {
-            'asr_models': ['whisper-small', 'whisper-medium', 'whisper-large', 'parakeet'],
+            'asr_models': ['parakeet', 'whisper-small', 'whisper-medium', 'whisper-large'],
             'voices': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
             'languages': [
                 'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh',

tests/integration/test_audio_processing_pipeline.py

@@ -37,7 +37,7 @@ class TestAudioProcessingPipeline:
     def mock_config(self, temp_dir):
         """Create mock configuration for testing."""
         config = Mock(spec=AppConfig)
-        
+
         # Processing configuration
         config.get_processing_config.return_value = {
             'max_file_size_mb': 50,
@@ -45,7 +45,7 @@ class TestAudioProcessingPipeline:
             'temp_dir': temp_dir,
             'cleanup_temp_files': True
         }
-        
+
         # Logging configuration
         config.get_logging_config.return_value = {
             'level': 'INFO',
@@ -53,17 +53,17 @@ class TestAudioProcessingPipeline:
             'log_file_path': os.path.join(temp_dir, 'test.log'),
             'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
         }
-        
+
         # STT configuration
         config.get_stt_config.return_value = {
-            'preferred_providers': ['whisper-small', 'whisper-medium', 'parakeet']
+            'preferred_providers': ['parakeet', 'whisper-small', 'whisper-medium']
         }
-        
+
         # TTS configuration
         config.get_tts_config.return_value = {
             'preferred_providers': ['kokoro', 'dia', 'cosyvoice2', 'dummy']
         }
-        
+
         return config
 
     @pytest.fixture
@@ -71,7 +71,7 @@ class TestAudioProcessingPipeline:
         """Create mock dependency container for testing."""
         container = Mock(spec=DependencyContainer)
         container.resolve.return_value = mock_config
-        
+
         # Mock STT provider
         mock_stt_provider = Mock()
         mock_stt_provider.transcribe.return_value = TextContent(
@@ -79,7 +79,7 @@ class TestAudioProcessingPipeline:
             language="en"
         )
         container.get_stt_provider.return_value = mock_stt_provider
-        
+
         # Mock translation provider
         mock_translation_provider = Mock()
         mock_translation_provider.translate.return_value = TextContent(
@@ -87,7 +87,7 @@ class TestAudioProcessingPipeline:
             language="es"
         )
         container.get_translation_provider.return_value = mock_translation_provider
-        
+
         # Mock TTS provider
         mock_tts_provider = Mock()
         mock_audio_content = AudioContent(
@@ -98,7 +98,7 @@ class TestAudioProcessingPipeline:
         )
         mock_tts_provider.synthesize.return_value = mock_audio_content
         container.get_tts_provider.return_value = mock_tts_provider
-        
+
         return container
 
     @pytest.fixture
@@ -133,7 +133,7 @@ class TestAudioProcessingPipeline:
         """Test successful execution of the complete audio processing pipeline."""
         # Execute the pipeline
         result = audio_service.process_audio_pipeline(sample_processing_request)
-        
+
         # Verify successful result
         assert isinstance(result, ProcessingResultDto)
         assert result.success is True
@@ -156,9 +156,9 @@ class TestAudioProcessingPipeline:
             speed=1.0,
             requires_translation=False
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         assert result.success is True
         assert result.original_text == "Hello, this is a test transcription."
         assert result.translated_text is None  # No translation performed
@@ -175,9 +175,9 @@ class TestAudioProcessingPipeline:
             speed=1.5,
             requires_translation=True
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         assert result.success is True
         assert result.metadata['voice'] == "dia"
         assert result.metadata['speed'] == 1.5
@@ -188,7 +188,7 @@ class TestAudioProcessingPipeline:
         start_time = time.time()
         result = audio_service.process_audio_pipeline(sample_processing_request)
         end_time = time.time()
-        
+
         assert result.success is True
         assert result.processing_time > 0
         assert result.processing_time <= (end_time - start_time) + 0.1  # Allow small margin
@@ -203,7 +203,7 @@ class TestAudioProcessingPipeline:
             content_type="audio/wav",
             size=10 * 1024 * 1024
         )
-        
+
         request = ProcessingRequestDto(
             audio=large_audio,
             asr_model="whisper-small",
@@ -212,9 +212,9 @@ class TestAudioProcessingPipeline:
             speed=1.0,
             requires_translation=True
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         assert result.success is True
         assert result.metadata['file_size'] == 10 * 1024 * 1024
 
@@ -222,12 +222,12 @@ class TestAudioProcessingPipeline:
         """Test that temporary files are properly cleaned up."""
         # Count files before processing
         files_before = len(list(Path(temp_dir).rglob("*")))
-        
+
         result = audio_service.process_audio_pipeline(sample_processing_request)
-        
+
         # Verify processing succeeded
         assert result.success is True
-        
+
         # Verify cleanup occurred (no additional temp files)
         files_after = len(list(Path(temp_dir).rglob("*")))
         assert files_after <= files_before + 1  # Allow for output file
@@ -235,14 +235,14 @@ class TestAudioProcessingPipeline:
     def test_pipeline_correlation_id_tracking(self, audio_service, sample_processing_request):
         """Test that correlation IDs are properly tracked throughout the pipeline."""
         result = audio_service.process_audio_pipeline(sample_processing_request)
-        
+
         assert result.success is True
         assert 'correlation_id' in result.metadata
-        
+
         correlation_id = result.metadata['correlation_id']
         assert isinstance(correlation_id, str)
         assert len(correlation_id) > 0
-        
+
         # Verify correlation ID is used in status tracking
         status = audio_service.get_processing_status(correlation_id)
         assert status['correlation_id'] == correlation_id
@@ -250,29 +250,29 @@ class TestAudioProcessingPipeline:
     def test_pipeline_metadata_completeness(self, audio_service, sample_processing_request):
         """Test that pipeline result contains complete metadata."""
         result = audio_service.process_audio_pipeline(sample_processing_request)
-        
+
         assert result.success is True
         assert result.metadata is not None
-        
+
         expected_metadata_keys = [
-            'correlation_id', 'asr_model', 'target_language', 
+            'correlation_id', 'asr_model', 'target_language',
             'voice', 'speed', 'translation_required'
         ]
-        
+
         for key in expected_metadata_keys:
             assert key in result.metadata
 
     def test_pipeline_supported_configurations(self, audio_service):
         """Test retrieval of supported pipeline configurations."""
         config = audio_service.get_supported_configurations()
-        
+
         assert 'asr_models' in config
         assert 'voices' in config
         assert 'languages' in config
         assert 'audio_formats' in config
         assert 'max_file_size_mb' in config
         assert 'speed_range' in config
-        
+
         assert isinstance(config['asr_models'], list)
         assert isinstance(config['voices'], list)
         assert isinstance(config['languages'], list)
@@ -283,7 +283,7 @@ class TestAudioProcessingPipeline:
         """Test audio service as context manager."""
         with AudioProcessingApplicationService(mock_container, mock_config) as service:
             assert service is not None
-            
+
             # Service should be usable within context
             config = service.get_supported_configurations()
             assert config is not None
@@ -301,18 +301,18 @@ class TestAudioProcessingPipeline:
                 requires_translation=True
             )
             requests.append(request)
-        
+
         results = []
         for request in requests:
             result = audio_service.process_audio_pipeline(request)
             results.append(result)
-        
+
         # Verify all requests succeeded
         for result in results:
             assert result.success is True
             assert result.original_text is not None
             assert result.translated_text is not None
-        
+
         # Verify each request has unique correlation ID
         correlation_ids = [r.metadata['correlation_id'] for r in results]
         assert len(set(correlation_ids)) == 3  # All unique
@@ -321,27 +321,27 @@ class TestAudioProcessingPipeline:
         """Test pipeline behavior under concurrent processing."""
         import threading
         import queue
-        
+
         results_queue = queue.Queue()
-        
+
         def process_request():
             try:
                 result = audio_service.process_audio_pipeline(sample_processing_request)
                 results_queue.put(result)
             except Exception as e:
                 results_queue.put(e)
-        
+
         # Start multiple threads
         threads = []
         for _ in range(3):
             thread = threading.Thread(target=process_request)
             threads.append(thread)
             thread.start()
-        
+
         # Wait for completion
         for thread in threads:
             thread.join()
-        
+
         # Verify all results
         results = []
         while not results_queue.empty():
@@ -349,7 +349,7 @@ class TestAudioProcessingPipeline:
             if isinstance(result, Exception):
                 pytest.fail(f"Concurrent processing failed: {result}")
             results.append(result)
-        
+
         assert len(results) == 3
         for result in results:
             assert result.success is True
@@ -358,18 +358,18 @@ class TestAudioProcessingPipeline:
         """Test pipeline memory usage and cleanup."""
         import psutil
         import os
-        
+
         process = psutil.Process(os.getpid())
         memory_before = process.memory_info().rss
-        
+
         # Process multiple requests
         for _ in range(5):
             result = audio_service.process_audio_pipeline(sample_processing_request)
             assert result.success is True
-        
+
         memory_after = process.memory_info().rss
         memory_increase = memory_after - memory_before
-        
+
         # Memory increase should be reasonable (less than 50MB for test data)
         assert memory_increase < 50 * 1024 * 1024
 
@@ -377,7 +377,7 @@ class TestAudioProcessingPipeline:
         """Test pipeline with streaming TTS synthesis."""
         # Mock streaming TTS provider
         mock_tts_provider = mock_container.get_tts_provider.return_value
-        
+
         def mock_stream():
             for i in range(3):
                 yield AudioContent(
@@ -386,18 +386,18 @@ class TestAudioProcessingPipeline:
                     sample_rate=22050,
                     duration=0.5
                 )
-        
+
         mock_tts_provider.synthesize_stream.return_value = mock_stream()
-        
+
         result = audio_service.process_audio_pipeline(sample_processing_request)
-        
+
         assert result.success is True
         assert result.audio_path is not None
 
     def test_pipeline_configuration_validation(self, audio_service):
         """Test pipeline configuration validation."""
         config = audio_service.get_supported_configurations()
-        
+
         # Verify configuration structure
         assert isinstance(config['asr_models'], list)
         assert isinstance(config['voices'], list)
@@ -405,7 +405,7 @@ class TestAudioProcessingPipeline:
         assert isinstance(config['audio_formats'], list)
         assert isinstance(config['max_file_size_mb'], (int, float))
         assert isinstance(config['speed_range'], dict)
-        
+
         # Verify speed range
         speed_range = config['speed_range']
         assert 'min' in speed_range
@@ -422,10 +422,10 @@ class TestAudioProcessingPipeline:
             SpeechRecognitionException("First attempt failed"),
             TextContent(text="Recovered transcription", language="en")
         ]
-        
+
         with patch('src.application.services.audio_processing_service.logger') as mock_logger:
             result = audio_service.process_audio_pipeline(sample_processing_request)
-            
+
             assert result.success is True
             # Verify error and recovery were logged
             mock_logger.warning.assert_called()
@@ -436,16 +436,16 @@ class TestAudioProcessingPipeline:
         start_time = time.time()
         result = audio_service.process_audio_pipeline(sample_processing_request)
         end_time = time.time()
-        
+
         total_time = end_time - start_time
-        
+
         assert result.success is True
         assert result.processing_time > 0
         assert result.processing_time <= total_time
-        
+
         # For mock providers, processing should be fast
         assert total_time < 5.0  # Should complete within 5 seconds
-        
+
         # Verify timing metadata
         assert 'correlation_id' in result.metadata
         timing_info = result.metadata

tests/integration/test_performance_and_errors.py

@@ -33,7 +33,7 @@ class TestPerformanceAndErrors:
     def mock_config(self, tmp_path):
         """Create mock configuration for testing."""
         config = Mock(spec=AppConfig)
-        
+
         # Processing configuration
         config.get_processing_config.return_value = {
             'max_file_size_mb': 100,
@@ -43,7 +43,7 @@ class TestPerformanceAndErrors:
             'processing_timeout': 300,  # 5 minutes
             'max_concurrent_requests': 10
         }
-        
+
         # Logging configuration
         config.get_logging_config.return_value = {
             'level': 'INFO',
@@ -51,28 +51,28 @@ class TestPerformanceAndErrors:
             'log_file_path': str(tmp_path / 'test.log'),
             'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
         }
-        
+
         # STT configuration
         config.get_stt_config.return_value = {
-            'preferred_providers': ['whisper-small', 'whisper-medium', 'parakeet'],
+            'preferred_providers': ['parakeet', 'whisper-small', 'whisper-medium'],
             'provider_timeout': 60.0,
             'max_retries': 2
         }
-        
+
         # TTS configuration
         config.get_tts_config.return_value = {
             'preferred_providers': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
             'provider_timeout': 30.0,
             'max_retries': 3
         }
-        
+
         # Translation configuration
         config.get_translation_config.return_value = {
             'provider_timeout': 45.0,
             'max_retries': 2,
             'chunk_size': 512
         }
-        
+
         return config
 
     @pytest.fixture
@@ -80,10 +80,10 @@ class TestPerformanceAndErrors:
         """Create mock dependency container."""
         container = Mock(spec=DependencyContainer)
         container.resolve.return_value = mock_config
-        
+
         # Mock providers with configurable behavior
         self._setup_mock_providers(container)
-        
+
         return container
 
     def _setup_mock_providers(self, container):
@@ -95,7 +95,7 @@ class TestPerformanceAndErrors:
             language="en"
         )
         container.get_stt_provider.return_value = mock_stt_provider
-        
+
         # Mock translation provider
         mock_translation_provider = Mock()
         mock_translation_provider.translate.return_value = TextContent(
@@ -103,7 +103,7 @@ class TestPerformanceAndErrors:
             language="es"
         )
         container.get_translation_provider.return_value = mock_translation_provider
-        
+
         # Mock TTS provider
         mock_tts_provider = Mock()
         mock_tts_provider.synthesize.return_value = AudioContent(
@@ -128,7 +128,7 @@ class TestPerformanceAndErrors:
             content_type="audio/wav",
             size=len(b"performance_test_audio_data")
         )
-        
+
         return ProcessingRequestDto(
             audio=audio_upload,
             asr_model="whisper-small",
@@ -142,37 +142,37 @@ class TestPerformanceAndErrors:
         """Test processing time performance benchmarks."""
         # Warm up
         audio_service.process_audio_pipeline(sample_request)
-        
+
         # Measure processing time
         start_time = time.time()
         result = audio_service.process_audio_pipeline(sample_request)
         end_time = time.time()
-        
+
         processing_time = end_time - start_time
-        
+
         assert result.success is True
         assert result.processing_time > 0
         assert result.processing_time <= processing_time + 0.1  # Allow small margin
-        
+
         # Performance benchmark: should complete within reasonable time
         assert processing_time < 5.0  # Should complete within 5 seconds for mock providers
 
     def test_memory_usage_performance(self, audio_service, sample_request):
         """Test memory usage during processing."""
         process = psutil.Process(os.getpid())
-        
+
         # Measure initial memory
         initial_memory = process.memory_info().rss
-        
+
         # Process multiple requests
         for _ in range(10):
             result = audio_service.process_audio_pipeline(sample_request)
             assert result.success is True
-        
+
         # Measure final memory
         final_memory = process.memory_info().rss
         memory_increase = final_memory - initial_memory
-        
+
         # Memory increase should be reasonable (less than 100MB for test data)
         assert memory_increase < 100 * 1024 * 1024
 
@@ -180,7 +180,7 @@ class TestPerformanceAndErrors:
         """Test performance under concurrent load."""
         num_threads = 5
         results_queue = queue.Queue()
-        
+
         def process_request():
             try:
                 start_time = time.time()
@@ -189,26 +189,26 @@ class TestPerformanceAndErrors:
                 results_queue.put((result, end_time - start_time))
             except Exception as e:
                 results_queue.put(e)
-        
+
         # Start concurrent processing
         threads = []
         start_time = time.time()
-        
+
         for _ in range(num_threads):
             thread = threading.Thread(target=process_request)
             threads.append(thread)
             thread.start()
-        
+
         # Wait for completion
         for thread in threads:
             thread.join()
-        
+
         total_time = time.time() - start_time
-        
+
         # Collect results
         results = []
         processing_times = []
-        
+
         while not results_queue.empty():
             item = results_queue.get()
             if isinstance(item, Exception):
@@ -216,12 +216,12 @@ class TestPerformanceAndErrors:
             result, proc_time = item
             results.append(result)
             processing_times.append(proc_time)
-        
+
         # Verify all succeeded
         assert len(results) == num_threads
         for result in results:
             assert result.success is True
-        
+
         # Performance checks
         avg_processing_time = sum(processing_times) / len(processing_times)
         assert avg_processing_time < 10.0  # Average should be reasonable
@@ -231,14 +231,14 @@ class TestPerformanceAndErrors:
         """Test performance with large audio files."""
         # Create large audio file (10MB)
         large_content = b"x" * (10 * 1024 * 1024)
-        
+
         audio_upload = AudioUploadDto(
             filename="large_performance_test.wav",
             content=large_content,
             content_type="audio/wav",
             size=len(large_content)
         )
-        
+
         request = ProcessingRequestDto(
             audio=audio_upload,
             asr_model="whisper-small",
@@ -247,13 +247,13 @@ class TestPerformanceAndErrors:
             speed=1.0,
             requires_translation=True
         )
-        
+
         start_time = time.time()
         result = audio_service.process_audio_pipeline(request)
         end_time = time.time()
-        
+
         processing_time = end_time - start_time
-        
+
         assert result.success is True
         # Large files should still complete within reasonable time
         assert processing_time < 30.0
@@ -261,37 +261,37 @@ class TestPerformanceAndErrors:
     def test_stt_provider_failure_recovery(self, audio_service, sample_request, mock_container):
         """Test recovery from STT provider failures."""
         mock_stt_provider = mock_container.get_stt_provider.return_value
-        
+
         # Mock first call to fail, second to succeed
         mock_stt_provider.transcribe.side_effect = [
             SpeechRecognitionException("STT provider temporarily unavailable"),
             TextContent(text="Recovered transcription", language="en")
         ]
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is True
         assert "Recovered transcription" in result.original_text
 
     def test_translation_provider_failure_recovery(self, audio_service, sample_request, mock_container):
         """Test recovery from translation provider failures."""
         mock_translation_provider = mock_container.get_translation_provider.return_value
-        
+
         # Mock first call to fail, second to succeed
         mock_translation_provider.translate.side_effect = [
             TranslationFailedException("Translation service temporarily unavailable"),
             TextContent(text="Traducción recuperada", language="es")
         ]
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is True
         assert "Traducción recuperada" in result.translated_text
 
     def test_tts_provider_failure_recovery(self, audio_service, sample_request, mock_container):
         """Test recovery from TTS provider failures."""
         mock_tts_provider = mock_container.get_tts_provider.return_value
-        
+
         # Mock first call to fail, second to succeed
         mock_tts_provider.synthesize.side_effect = [
             SpeechSynthesisException("TTS provider temporarily unavailable"),
@@ -302,9 +302,9 @@ class TestPerformanceAndErrors:
                 duration=2.5
             )
         ]
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is True
         assert result.audio_path is not None
 
@@ -314,13 +314,13 @@ class TestPerformanceAndErrors:
         mock_stt_provider = mock_container.get_stt_provider.return_value
         mock_translation_provider = mock_container.get_translation_provider.return_value
         mock_tts_provider = mock_container.get_tts_provider.return_value
-        
+
         mock_stt_provider.transcribe.side_effect = SpeechRecognitionException("STT failed")
         mock_translation_provider.translate.side_effect = TranslationFailedException("Translation failed")
         mock_tts_provider.synthesize.side_effect = SpeechSynthesisException("TTS failed")
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is False
         assert result.error_message is not None
         assert result.error_code is not None
@@ -328,19 +328,19 @@ class TestPerformanceAndErrors:
     def test_timeout_handling(self, audio_service, sample_request, mock_container):
         """Test handling of provider timeouts."""
         mock_stt_provider = mock_container.get_stt_provider.return_value
-        
+
         def slow_transcribe(*args, **kwargs):
             time.sleep(2.0)  # Simulate slow processing
             return TextContent(text="Slow transcription", language="en")
-        
+
         mock_stt_provider.transcribe.side_effect = slow_transcribe
-        
+
         start_time = time.time()
         result = audio_service.process_audio_pipeline(sample_request)
         end_time = time.time()
-        
+
         processing_time = end_time - start_time
-        
+
         # Should complete despite slow provider
         assert result.success is True
         assert processing_time >= 2.0  # Should include the delay
@@ -354,7 +354,7 @@ class TestPerformanceAndErrors:
             content_type="audio/xyz",
             size=len(b"invalid_audio_data")
         )
-        
+
         request = ProcessingRequestDto(
             audio=invalid_audio,
             asr_model="whisper-small",
@@ -363,9 +363,9 @@ class TestPerformanceAndErrors:
             speed=1.0,
             requires_translation=True
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         assert result.success is False
         assert result.error_code is not None
         assert "format" in result.error_message.lower() or "unsupported" in result.error_message.lower()
@@ -374,17 +374,17 @@ class TestPerformanceAndErrors:
         """Test handling of oversized files."""
         # Mock config to have small file size limit
         mock_config.get_processing_config.return_value['max_file_size_mb'] = 1
-        
+
         # Create file larger than limit
         large_content = b"x" * (2 * 1024 * 1024)  # 2MB
-        
+
         oversized_audio = AudioUploadDto(
             filename="oversized.wav",
             content=large_content,
             content_type="audio/wav",
             size=len(large_content)
         )
-        
+
         request = ProcessingRequestDto(
             audio=oversized_audio,
             asr_model="whisper-small",
@@ -393,9 +393,9 @@ class TestPerformanceAndErrors:
             speed=1.0,
             requires_translation=True
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         assert result.success is False
         assert result.error_code is not None
         assert "size" in result.error_message.lower() or "large" in result.error_message.lower()
@@ -408,7 +408,7 @@ class TestPerformanceAndErrors:
             content_type="audio/wav",
             size=len(b"corrupted_data_not_audio")
         )
-        
+
         request = ProcessingRequestDto(
             audio=corrupted_audio,
             asr_model="whisper-small",
@@ -417,25 +417,25 @@ class TestPerformanceAndErrors:
             speed=1.0,
             requires_translation=True
         )
-        
+
         result = audio_service.process_audio_pipeline(request)
-        
+
         # Should handle gracefully (success depends on implementation)
         assert result.error_message is None or "audio" in result.error_message.lower()
 
     def test_network_error_simulation(self, audio_service, sample_request, mock_container):
         """Test handling of network-related errors."""
         mock_translation_provider = mock_container.get_translation_provider.return_value
-        
+
         # Simulate network errors
         mock_translation_provider.translate.side_effect = [
             ConnectionError("Network connection failed"),
             TimeoutError("Request timed out"),
             TextContent(text="Network recovered translation", language="es")
         ]
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         # Should recover from network errors
         assert result.success is True
         assert "Network recovered translation" in result.translated_text
@@ -444,14 +444,14 @@ class TestPerformanceAndErrors:
         """Test handling of resource exhaustion scenarios."""
         # Simulate memory pressure by processing many requests
         results = []
-        
+
         for i in range(20):  # Process many requests
             result = audio_service.process_audio_pipeline(sample_request)
             results.append(result)
-            
+
             # All should succeed despite resource pressure
             assert result.success is True
-        
+
         # Verify all completed successfully
         assert len(results) == 20
         for result in results:
@@ -461,13 +461,13 @@ class TestPerformanceAndErrors:
         """Test error correlation tracking across pipeline stages."""
         mock_stt_provider = mock_container.get_stt_provider.return_value
         mock_stt_provider.transcribe.side_effect = SpeechRecognitionException("STT correlation test error")
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is False
         assert result.metadata is not None
         assert 'correlation_id' in result.metadata
-        
+
         # Verify correlation ID is consistent
         correlation_id = result.metadata['correlation_id']
         assert isinstance(correlation_id, str)
@@ -478,13 +478,13 @@ class TestPerformanceAndErrors:
         # Mock translation to fail but allow STT and TTS to succeed
         mock_translation_provider = mock_container.get_translation_provider.return_value
         mock_translation_provider.translate.side_effect = TranslationFailedException("Translation unavailable")
-        
+
         # Modify request to not require translation
         sample_request.requires_translation = False
         sample_request.target_language = "en"  # Same as source
-        
+
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         # Should succeed without translation
         assert result.success is True
         assert result.translated_text is None  # No translation performed
@@ -492,15 +492,15 @@ class TestPerformanceAndErrors:
     def test_circuit_breaker_behavior(self, audio_service, sample_request, mock_container):
         """Test circuit breaker behavior under repeated failures."""
         mock_tts_provider = mock_container.get_tts_provider.return_value
-        
+
         # Mock repeated failures to trigger circuit breaker
         mock_tts_provider.synthesize.side_effect = SpeechSynthesisException("Repeated TTS failure")
-        
+
         results = []
         for _ in range(5):  # Multiple attempts
             result = audio_service.process_audio_pipeline(sample_request)
             results.append(result)
-        
+
         # All should fail, but circuit breaker should prevent excessive retries
         for result in results:
             assert result.success is False
@@ -509,11 +509,11 @@ class TestPerformanceAndErrors:
     def test_performance_metrics_collection(self, audio_service, sample_request):
         """Test collection of performance metrics."""
         result = audio_service.process_audio_pipeline(sample_request)
-        
+
         assert result.success is True
         assert result.processing_time > 0
         assert result.metadata is not None
-        
+
         # Verify performance-related metadata
         metadata = result.metadata
         assert 'correlation_id' in metadata
@@ -525,26 +525,26 @@ class TestPerformanceAndErrors:
         """Test system behavior under stress conditions."""
         num_requests = 50
         results = []
-        
+
         start_time = time.time()
-        
+
         for i in range(num_requests):
             result = audio_service.process_audio_pipeline(sample_request)
             results.append(result)
-        
+
         end_time = time.time()
         total_time = end_time - start_time
-        
+
         # Verify all requests completed
         assert len(results) == num_requests
-        
+
         # Calculate success rate
         successful_results = [r for r in results if r.success]
         success_rate = len(successful_results) / len(results)
-        
+
         # Should maintain high success rate under stress
         assert success_rate >= 0.95  # At least 95% success rate
-        
+
         # Performance should remain reasonable
         avg_time_per_request = total_time / num_requests
         assert avg_time_per_request < 1.0  # Average less than 1 second per request