Create application services

src/application/services/__init__.py

@@ -0,0 +1,9 @@
+"""Application services package."""
+
+from .audio_processing_service import AudioProcessingApplicationService
+from .configuration_service import ConfigurationApplicationService
+
+__all__ = [
+    'AudioProcessingApplicationService',
+    'ConfigurationApplicationService'
+]

src/application/services/audio_processing_service.py

@@ -0,0 +1,553 @@
+"""Audio Processing Application Service for pipeline orchestration."""
+
+import logging
+import os
+import tempfile
+import time
+import uuid
+from pathlib import Path
+from typing import Optional, Dict, Any
+from contextlib import contextmanager
+
+from ..dtos.audio_upload_dto import AudioUploadDto
+from ..dtos.processing_request_dto import ProcessingRequestDto
+from ..dtos.processing_result_dto import ProcessingResultDto
+from ...domain.interfaces.speech_recognition import ISpeechRecognitionService
+from ...domain.interfaces.translation import ITranslationService
+from ...domain.interfaces.speech_synthesis import ISpeechSynthesisService
+from ...domain.models.audio_content import AudioContent
+from ...domain.models.text_content import TextContent
+from ...domain.models.translation_request import TranslationRequest
+from ...domain.models.speech_synthesis_request import SpeechSynthesisRequest
+from ...domain.models.voice_settings import VoiceSettings
+from ...domain.exceptions import (
+    DomainException,
+    AudioProcessingException,
+    SpeechRecognitionException,
+    TranslationFailedException,
+    SpeechSynthesisException
+)
+from ...infrastructure.config.app_config import AppConfig
+from ...infrastructure.config.dependency_container import DependencyContainer
+
+logger = logging.getLogger(__name__)
+
+
+class AudioProcessingApplicationService:
+    """Application service for orchestrating the complete audio processing pipeline."""
+
+    def __init__(
+        self,
+        container: DependencyContainer,
+        config: Optional[AppConfig] = None
+    ):
+        """
+        Initialize the audio processing application service.
+
+        Args:
+            container: Dependency injection container
+            config: Application configuration (optional, will be resolved from container)
+        """
+        self._container = container
+        self._config = config or container.resolve(AppConfig)
+        self._temp_files: Dict[str, str] = {}  # Track temporary files for cleanup
+        
+        # Setup logging
+        self._setup_logging()
+        
+        logger.info("AudioProcessingApplicationService initialized")
+
+    def _setup_logging(self) -> None:
+        """Setup logging configuration."""
+        try:
+            log_config = self._config.get_logging_config()
+            
+            # Configure logger level
+            logger.setLevel(getattr(logging, log_config['level'].upper(), logging.INFO))
+            
+            # 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}")
+
+    def process_audio_pipeline(self, request: ProcessingRequestDto) -> ProcessingResultDto:
+        """
+        Process audio through the complete pipeline: STT -> Translation -> TTS.
+
+        Args:
+            request: Processing request containing audio and parameters
+
+        Returns:
+            ProcessingResultDto: Result of the complete processing pipeline
+        """
+        correlation_id = str(uuid.uuid4())
+        start_time = time.time()
+        
+        logger.info(f"Starting audio processing pipeline [correlation_id={correlation_id}]")
+        
+        try:
+            # Validate request
+            self._validate_request(request)
+            
+            # Create temporary working directory
+            with self._create_temp_directory(correlation_id) as temp_dir:
+                # Step 1: Convert uploaded audio to domain model
+                audio_content = self._convert_upload_to_audio_content(request.audio, temp_dir)
+                
+                # Step 2: Speech-to-Text
+                original_text = self._perform_speech_recognition(
+                    audio_content, 
+                    request.asr_model,
+                    correlation_id
+                )
+                
+                # Step 3: Translation (if needed)
+                translated_text = self._perform_translation(
+                    original_text,
+                    request.source_language,
+                    request.target_language,
+                    correlation_id
+                ) if request.requires_translation else original_text
+                
+                # Step 4: Text-to-Speech
+                output_audio_path = self._perform_speech_synthesis(
+                    translated_text,
+                    request.voice,
+                    request.speed,
+                    request.target_language,
+                    temp_dir,
+                    correlation_id
+                )
+                
+                # Calculate processing time
+                processing_time = time.time() - start_time
+                
+                # Create successful result
+                result = ProcessingResultDto.success_result(
+                    original_text=original_text.text,
+                    translated_text=translated_text.text if translated_text != original_text else None,
+                    audio_path=output_audio_path,
+                    processing_time=processing_time,
+                    metadata={
+                        'correlation_id': correlation_id,
+                        'asr_model': request.asr_model,
+                        'target_language': request.target_language,
+                        'voice': request.voice,
+                        'speed': request.speed,
+                        'translation_required': request.requires_translation
+                    }
+                )
+                
+                logger.info(
+                    f"Audio processing pipeline completed successfully "
+                    f"[correlation_id={correlation_id}, processing_time={processing_time:.2f}s]"
+                )
+                
+                return result
+                
+        except DomainException as e:
+            processing_time = time.time() - start_time
+            error_code = self._get_error_code_from_exception(e)
+            
+            logger.error(
+                f"Domain error in audio processing pipeline: {e} "
+                f"[correlation_id={correlation_id}, processing_time={processing_time:.2f}s]"
+            )
+            
+            return ProcessingResultDto.error_result(
+                error_message=str(e),
+                error_code=error_code,
+                processing_time=processing_time,
+                metadata={'correlation_id': correlation_id}
+            )
+            
+        except Exception as e:
+            processing_time = time.time() - start_time
+            
+            logger.error(
+                f"Unexpected error in audio processing pipeline: {e} "
+                f"[correlation_id={correlation_id}, processing_time={processing_time:.2f}s]",
+                exc_info=True
+            )
+            
+            return ProcessingResultDto.error_result(
+                error_message=f"System error: {str(e)}",
+                error_code='SYSTEM_ERROR',
+                processing_time=processing_time,
+                metadata={'correlation_id': correlation_id}
+            )
+        
+        finally:
+            # Cleanup temporary files
+            self._cleanup_temp_files()
+
+    def _validate_request(self, request: ProcessingRequestDto) -> None:
+        """
+        Validate processing request.
+
+        Args:
+            request: Processing request to validate
+
+        Raises:
+            ValueError: If request is invalid
+        """
+        if not isinstance(request, ProcessingRequestDto):
+            raise ValueError("Request must be a ProcessingRequestDto instance")
+        
+        # Additional validation beyond DTO validation
+        processing_config = self._config.get_processing_config()
+        
+        # Check file size limits
+        max_size_bytes = processing_config['max_file_size_mb'] * 1024 * 1024
+        if request.audio.size > max_size_bytes:
+            raise ValueError(
+                f"Audio file too large: {request.audio.size} bytes. "
+                f"Maximum allowed: {max_size_bytes} bytes"
+            )
+        
+        # Check supported audio formats
+        supported_formats = processing_config['supported_audio_formats']
+        file_ext = request.audio.file_extension.lstrip('.')
+        if file_ext not in supported_formats:
+            raise ValueError(
+                f"Unsupported audio format: {file_ext}. "
+                f"Supported formats: {supported_formats}"
+            )
+
+    @contextmanager
+    def _create_temp_directory(self, correlation_id: str):
+        """
+        Create temporary directory for processing.
+
+        Args:
+            correlation_id: Correlation ID for tracking
+
+        Yields:
+            str: Path to temporary directory
+        """
+        processing_config = self._config.get_processing_config()
+        base_temp_dir = processing_config['temp_dir']
+        
+        # Create unique temp directory
+        temp_dir = os.path.join(base_temp_dir, f"processing_{correlation_id}")
+        
+        try:
+            os.makedirs(temp_dir, exist_ok=True)
+            logger.debug(f"Created temporary directory: {temp_dir}")
+            yield temp_dir
+            
+        finally:
+            # Cleanup temp directory if configured
+            if processing_config.get('cleanup_temp_files', True):
+                try:
+                    import shutil
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                    logger.debug(f"Cleaned up temporary directory: {temp_dir}")
+                except Exception as e:
+                    logger.warning(f"Failed to cleanup temp directory {temp_dir}: {e}")
+
+    def _convert_upload_to_audio_content(
+        self, 
+        upload: AudioUploadDto, 
+        temp_dir: str
+    ) -> AudioContent:
+        """
+        Convert uploaded audio to domain AudioContent.
+
+        Args:
+            upload: Audio upload DTO
+            temp_dir: Temporary directory for file operations
+
+        Returns:
+            AudioContent: Domain audio content model
+
+        Raises:
+            AudioProcessingException: If conversion fails
+        """
+        try:
+            # Save uploaded content to temporary file
+            temp_file_path = os.path.join(temp_dir, f"input_{upload.filename}")
+            
+            with open(temp_file_path, 'wb') as f:
+                f.write(upload.content)
+            
+            # Track temp file for cleanup
+            self._temp_files[temp_file_path] = temp_file_path
+            
+            # Determine audio format from file extension
+            audio_format = upload.file_extension.lstrip('.').lower()
+            
+            # Create AudioContent (simplified - in real implementation would extract metadata)
+            audio_content = AudioContent(
+                data=upload.content,
+                format=audio_format,
+                sample_rate=16000,  # Default, would be extracted from actual file
+                duration=0.0  # Would be calculated from actual file
+            )
+            
+            logger.debug(f"Converted upload to AudioContent: {upload.filename}")
+            return audio_content
+            
+        except Exception as e:
+            logger.error(f"Failed to convert upload to AudioContent: {e}")
+            raise AudioProcessingException(f"Failed to process uploaded audio: {str(e)}")
+
+    def _perform_speech_recognition(
+        self, 
+        audio: AudioContent, 
+        model: str,
+        correlation_id: str
+    ) -> TextContent:
+        """
+        Perform speech-to-text recognition.
+
+        Args:
+            audio: Audio content to transcribe
+            model: STT model to use
+            correlation_id: Correlation ID for tracking
+
+        Returns:
+            TextContent: Transcribed text
+
+        Raises:
+            SpeechRecognitionException: If STT fails
+        """
+        try:
+            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)
+            
+            # Perform transcription
+            text_content = stt_provider.transcribe(audio, model)
+            
+            logger.info(
+                f"STT completed successfully [correlation_id={correlation_id}, "
+                f"text_length={len(text_content.text)}]"
+            )
+            
+            return text_content
+            
+        except Exception as e:
+            logger.error(f"STT failed: {e} [correlation_id={correlation_id}]")
+            raise SpeechRecognitionException(f"Speech recognition failed: {str(e)}")
+
+    def _perform_translation(
+        self,
+        text: TextContent,
+        source_language: Optional[str],
+        target_language: str,
+        correlation_id: str
+    ) -> TextContent:
+        """
+        Perform text translation.
+
+        Args:
+            text: Text to translate
+            source_language: Source language (optional, auto-detect if None)
+            target_language: Target language
+            correlation_id: Correlation ID for tracking
+
+        Returns:
+            TextContent: Translated text
+
+        Raises:
+            TranslationFailedException: If translation fails
+        """
+        try:
+            logger.debug(
+                f"Starting translation: {source_language or 'auto'} -> {target_language} "
+                f"[correlation_id={correlation_id}]"
+            )
+            
+            # Get translation provider from container
+            translation_provider = self._container.get_translation_provider()
+            
+            # Create translation request
+            translation_request = TranslationRequest(
+                text=text.text,
+                source_language=source_language or 'auto',
+                target_language=target_language
+            )
+            
+            # Perform translation
+            translated_text = translation_provider.translate(translation_request)
+            
+            logger.info(
+                f"Translation completed successfully [correlation_id={correlation_id}, "
+                f"source_length={len(text.text)}, target_length={len(translated_text.text)}]"
+            )
+            
+            return translated_text
+            
+        except Exception as e:
+            logger.error(f"Translation failed: {e} [correlation_id={correlation_id}]")
+            raise TranslationFailedException(f"Translation failed: {str(e)}")
+
+    def _perform_speech_synthesis(
+        self,
+        text: TextContent,
+        voice: str,
+        speed: float,
+        language: str,
+        temp_dir: str,
+        correlation_id: str
+    ) -> str:
+        """
+        Perform text-to-speech synthesis.
+
+        Args:
+            text: Text to synthesize
+            voice: Voice to use
+            speed: Speech speed
+            language: Target language
+            temp_dir: Temporary directory for output
+            correlation_id: Correlation ID for tracking
+
+        Returns:
+            str: Path to generated audio file
+
+        Raises:
+            SpeechSynthesisException: If TTS fails
+        """
+        try:
+            logger.debug(
+                f"Starting TTS with voice: {voice}, speed: {speed} "
+                f"[correlation_id={correlation_id}]"
+            )
+            
+            # Get TTS provider from container
+            tts_provider = self._container.get_tts_provider(voice)
+            
+            # Create voice settings
+            voice_settings = VoiceSettings(
+                voice_id=voice,
+                speed=speed,
+                language=language
+            )
+            
+            # Create synthesis request
+            synthesis_request = SpeechSynthesisRequest(
+                text=text.text,
+                voice_settings=voice_settings
+            )
+            
+            # Perform synthesis
+            audio_content = tts_provider.synthesize(synthesis_request)
+            
+            # Save output to file
+            output_filename = f"output_{correlation_id}.{audio_content.format}"
+            output_path = os.path.join(temp_dir, output_filename)
+            
+            with open(output_path, 'wb') as f:
+                f.write(audio_content.data)
+            
+            # Track temp file for cleanup
+            self._temp_files[output_path] = output_path
+            
+            logger.info(
+                f"TTS completed successfully [correlation_id={correlation_id}, "
+                f"output_file={output_path}]"
+            )
+            
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"TTS failed: {e} [correlation_id={correlation_id}]")
+            raise SpeechSynthesisException(f"Speech synthesis failed: {str(e)}")
+
+    def _get_error_code_from_exception(self, exception: Exception) -> str:
+        """
+        Get error code from exception type.
+
+        Args:
+            exception: Exception instance
+
+        Returns:
+            str: Error code
+        """
+        if isinstance(exception, SpeechRecognitionException):
+            return 'STT_ERROR'
+        elif isinstance(exception, TranslationFailedException):
+            return 'TRANSLATION_ERROR'
+        elif isinstance(exception, SpeechSynthesisException):
+            return 'TTS_ERROR'
+        elif isinstance(exception, ValueError):
+            return 'VALIDATION_ERROR'
+        else:
+            return 'SYSTEM_ERROR'
+
+    def _cleanup_temp_files(self) -> None:
+        """Cleanup tracked temporary files."""
+        for file_path in list(self._temp_files.keys()):
+            try:
+                if os.path.exists(file_path):
+                    os.remove(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:
+                # Remove from tracking regardless of success
+                self._temp_files.pop(file_path, None)
+
+    def get_processing_status(self, correlation_id: str) -> Dict[str, Any]:
+        """
+        Get processing status for a correlation ID.
+
+        Args:
+            correlation_id: Correlation ID to check
+
+        Returns:
+            Dict[str, Any]: Processing status information
+        """
+        # This would be implemented with actual status tracking
+        # For now, return basic info
+        return {
+            'correlation_id': correlation_id,
+            'status': 'unknown',
+            'message': 'Status tracking not implemented'
+        }
+
+    def get_supported_configurations(self) -> Dict[str, Any]:
+        """
+        Get supported configurations for the processing pipeline.
+
+        Returns:
+            Dict[str, Any]: Supported configurations
+        """
+        return {
+            'asr_models': ['whisper-small', 'whisper-medium', 'whisper-large', 'parakeet'],
+            'voices': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
+            'languages': [
+                'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh',
+                'ar', 'hi', 'tr', 'pl', 'nl', 'sv', 'da', 'no', 'fi'
+            ],
+            'audio_formats': self._config.get_processing_config()['supported_audio_formats'],
+            'max_file_size_mb': self._config.get_processing_config()['max_file_size_mb'],
+            'speed_range': {'min': 0.5, 'max': 2.0}
+        }
+
+    def cleanup(self) -> None:
+        """Cleanup application service resources."""
+        logger.info("Cleaning up AudioProcessingApplicationService")
+        
+        # Cleanup temporary files
+        self._cleanup_temp_files()
+        
+        logger.info("AudioProcessingApplicationService cleanup completed")
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with cleanup."""
+        self.cleanup()

src/application/services/configuration_service.py

@@ -0,0 +1,659 @@
+"""Configuration Application Service for settings management."""
+
+import logging
+import os
+import json
+from typing import Dict, List, Any, Optional, Union
+from pathlib import Path
+from dataclasses import asdict
+
+from ...infrastructure.config.app_config import AppConfig, TTSConfig, STTConfig, TranslationConfig, ProcessingConfig, LoggingConfig
+from ...infrastructure.config.dependency_container import DependencyContainer
+from ...domain.exceptions import DomainException
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurationException(DomainException):
+    """Exception raised for configuration-related errors."""
+    pass
+
+
+class ConfigurationApplicationService:
+    """Application service for managing application configuration and settings."""
+
+    def __init__(
+        self,
+        container: DependencyContainer,
+        config: Optional[AppConfig] = None
+    ):
+        """
+        Initialize the configuration application service.
+
+        Args:
+            container: Dependency injection container
+            config: Application configuration (optional, will be resolved from container)
+        """
+        self._container = container
+        self._config = config or container.resolve(AppConfig)
+        
+        logger.info("ConfigurationApplicationService initialized")
+
+    def get_current_configuration(self) -> Dict[str, Any]:
+        """
+        Get the current application configuration.
+
+        Returns:
+            Dict[str, Any]: Current configuration as dictionary
+        """
+        try:
+            return {
+                'tts': self._config.get_tts_config(),
+                'stt': self._config.get_stt_config(),
+                'translation': self._config.get_translation_config(),
+                'processing': self._config.get_processing_config(),
+                'logging': self._config.get_logging_config()
+            }
+        except Exception as e:
+            logger.error(f"Failed to get current configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve configuration: {str(e)}")
+
+    def get_tts_configuration(self) -> Dict[str, Any]:
+        """
+        Get TTS-specific configuration.
+
+        Returns:
+            Dict[str, Any]: TTS configuration
+        """
+        try:
+            return self._config.get_tts_config()
+        except Exception as e:
+            logger.error(f"Failed to get TTS configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve TTS configuration: {str(e)}")
+
+    def get_stt_configuration(self) -> Dict[str, Any]:
+        """
+        Get STT-specific configuration.
+
+        Returns:
+            Dict[str, Any]: STT configuration
+        """
+        try:
+            return self._config.get_stt_config()
+        except Exception as e:
+            logger.error(f"Failed to get STT configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve STT configuration: {str(e)}")
+
+    def get_translation_configuration(self) -> Dict[str, Any]:
+        """
+        Get translation-specific configuration.
+
+        Returns:
+            Dict[str, Any]: Translation configuration
+        """
+        try:
+            return self._config.get_translation_config()
+        except Exception as e:
+            logger.error(f"Failed to get translation configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve translation configuration: {str(e)}")
+
+    def get_processing_configuration(self) -> Dict[str, Any]:
+        """
+        Get processing-specific configuration.
+
+        Returns:
+            Dict[str, Any]: Processing configuration
+        """
+        try:
+            return self._config.get_processing_config()
+        except Exception as e:
+            logger.error(f"Failed to get processing configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve processing configuration: {str(e)}")
+
+    def get_logging_configuration(self) -> Dict[str, Any]:
+        """
+        Get logging-specific configuration.
+
+        Returns:
+            Dict[str, Any]: Logging configuration
+        """
+        try:
+            return self._config.get_logging_config()
+        except Exception as e:
+            logger.error(f"Failed to get logging configuration: {e}")
+            raise ConfigurationException(f"Failed to retrieve logging configuration: {str(e)}")
+
+    def update_tts_configuration(self, updates: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update TTS configuration.
+
+        Args:
+            updates: Configuration updates to apply
+
+        Returns:
+            Dict[str, Any]: Updated TTS configuration
+
+        Raises:
+            ConfigurationException: If update fails or validation fails
+        """
+        try:
+            # Validate updates
+            self._validate_tts_updates(updates)
+            
+            # Apply updates to current config
+            current_config = self._config.get_tts_config()
+            
+            for key, value in updates.items():
+                if key in current_config:
+                    # Update the actual config object
+                    if hasattr(self._config.tts, key):
+                        setattr(self._config.tts, key, value)
+                        logger.debug(f"Updated TTS config: {key} = {value}")
+                else:
+                    logger.warning(f"Unknown TTS configuration key: {key}")
+            
+            # Return updated configuration
+            updated_config = self._config.get_tts_config()
+            logger.info(f"TTS configuration updated: {list(updates.keys())}")
+            
+            return updated_config
+            
+        except Exception as e:
+            logger.error(f"Failed to update TTS configuration: {e}")
+            raise ConfigurationException(f"Failed to update TTS configuration: {str(e)}")
+
+    def update_stt_configuration(self, updates: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update STT configuration.
+
+        Args:
+            updates: Configuration updates to apply
+
+        Returns:
+            Dict[str, Any]: Updated STT configuration
+
+        Raises:
+            ConfigurationException: If update fails or validation fails
+        """
+        try:
+            # Validate updates
+            self._validate_stt_updates(updates)
+            
+            # Apply updates to current config
+            current_config = self._config.get_stt_config()
+            
+            for key, value in updates.items():
+                if key in current_config:
+                    # Update the actual config object
+                    if hasattr(self._config.stt, key):
+                        setattr(self._config.stt, key, value)
+                        logger.debug(f"Updated STT config: {key} = {value}")
+                else:
+                    logger.warning(f"Unknown STT configuration key: {key}")
+            
+            # Return updated configuration
+            updated_config = self._config.get_stt_config()
+            logger.info(f"STT configuration updated: {list(updates.keys())}")
+            
+            return updated_config
+            
+        except Exception as e:
+            logger.error(f"Failed to update STT configuration: {e}")
+            raise ConfigurationException(f"Failed to update STT configuration: {str(e)}")
+
+    def update_translation_configuration(self, updates: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update translation configuration.
+
+        Args:
+            updates: Configuration updates to apply
+
+        Returns:
+            Dict[str, Any]: Updated translation configuration
+
+        Raises:
+            ConfigurationException: If update fails or validation fails
+        """
+        try:
+            # Validate updates
+            self._validate_translation_updates(updates)
+            
+            # Apply updates to current config
+            current_config = self._config.get_translation_config()
+            
+            for key, value in updates.items():
+                if key in current_config:
+                    # Update the actual config object
+                    if hasattr(self._config.translation, key):
+                        setattr(self._config.translation, key, value)
+                        logger.debug(f"Updated translation config: {key} = {value}")
+                else:
+                    logger.warning(f"Unknown translation configuration key: {key}")
+            
+            # Return updated configuration
+            updated_config = self._config.get_translation_config()
+            logger.info(f"Translation configuration updated: {list(updates.keys())}")
+            
+            return updated_config
+            
+        except Exception as e:
+            logger.error(f"Failed to update translation configuration: {e}")
+            raise ConfigurationException(f"Failed to update translation configuration: {str(e)}")
+
+    def update_processing_configuration(self, updates: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update processing configuration.
+
+        Args:
+            updates: Configuration updates to apply
+
+        Returns:
+            Dict[str, Any]: Updated processing configuration
+
+        Raises:
+            ConfigurationException: If update fails or validation fails
+        """
+        try:
+            # Validate updates
+            self._validate_processing_updates(updates)
+            
+            # Apply updates to current config
+            current_config = self._config.get_processing_config()
+            
+            for key, value in updates.items():
+                if key in current_config:
+                    # Update the actual config object
+                    if hasattr(self._config.processing, key):
+                        setattr(self._config.processing, key, value)
+                        logger.debug(f"Updated processing config: {key} = {value}")
+                else:
+                    logger.warning(f"Unknown processing configuration key: {key}")
+            
+            # Return updated configuration
+            updated_config = self._config.get_processing_config()
+            logger.info(f"Processing configuration updated: {list(updates.keys())}")
+            
+            return updated_config
+            
+        except Exception as e:
+            logger.error(f"Failed to update processing configuration: {e}")
+            raise ConfigurationException(f"Failed to update processing configuration: {str(e)}")
+
+    def _validate_tts_updates(self, updates: Dict[str, Any]) -> None:
+        """
+        Validate TTS configuration updates.
+
+        Args:
+            updates: Updates to validate
+
+        Raises:
+            ConfigurationException: If validation fails
+        """
+        valid_providers = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+        valid_languages = ['en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh']
+        
+        for key, value in updates.items():
+            if key == 'preferred_providers':
+                if not isinstance(value, list):
+                    raise ConfigurationException("preferred_providers must be a list")
+                for provider in value:
+                    if provider not in valid_providers:
+                        raise ConfigurationException(f"Invalid TTS provider: {provider}")
+            
+            elif key == 'default_speed':
+                if not isinstance(value, (int, float)) or not (0.1 <= value <= 3.0):
+                    raise ConfigurationException("default_speed must be between 0.1 and 3.0")
+            
+            elif key == 'default_language':
+                if value not in valid_languages:
+                    raise ConfigurationException(f"Invalid language: {value}")
+            
+            elif key == 'enable_streaming':
+                if not isinstance(value, bool):
+                    raise ConfigurationException("enable_streaming must be a boolean")
+            
+            elif key == 'max_text_length':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("max_text_length must be a positive integer")
+
+    def _validate_stt_updates(self, updates: Dict[str, Any]) -> None:
+        """
+        Validate STT configuration updates.
+
+        Args:
+            updates: Updates to validate
+
+        Raises:
+            ConfigurationException: If validation fails
+        """
+        valid_providers = ['whisper', 'parakeet']
+        
+        for key, value in updates.items():
+            if key == 'preferred_providers':
+                if not isinstance(value, list):
+                    raise ConfigurationException("preferred_providers must be a list")
+                for provider in value:
+                    if provider not in valid_providers:
+                        raise ConfigurationException(f"Invalid STT provider: {provider}")
+            
+            elif key == 'default_model':
+                if value not in valid_providers:
+                    raise ConfigurationException(f"Invalid STT model: {value}")
+            
+            elif key == 'chunk_length_s':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("chunk_length_s must be a positive integer")
+            
+            elif key == 'batch_size':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("batch_size must be a positive integer")
+            
+            elif key == 'enable_vad':
+                if not isinstance(value, bool):
+                    raise ConfigurationException("enable_vad must be a boolean")
+
+    def _validate_translation_updates(self, updates: Dict[str, Any]) -> None:
+        """
+        Validate translation configuration updates.
+
+        Args:
+            updates: Updates to validate
+
+        Raises:
+            ConfigurationException: If validation fails
+        """
+        for key, value in updates.items():
+            if key == 'default_provider':
+                if not isinstance(value, str) or not value:
+                    raise ConfigurationException("default_provider must be a non-empty string")
+            
+            elif key == 'model_name':
+                if not isinstance(value, str) or not value:
+                    raise ConfigurationException("model_name must be a non-empty string")
+            
+            elif key == 'max_chunk_length':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("max_chunk_length must be a positive integer")
+            
+            elif key == 'batch_size':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("batch_size must be a positive integer")
+            
+            elif key == 'cache_translations':
+                if not isinstance(value, bool):
+                    raise ConfigurationException("cache_translations must be a boolean")
+
+    def _validate_processing_updates(self, updates: Dict[str, Any]) -> None:
+        """
+        Validate processing configuration updates.
+
+        Args:
+            updates: Updates to validate
+
+        Raises:
+            ConfigurationException: If validation fails
+        """
+        for key, value in updates.items():
+            if key == 'temp_dir':
+                if not isinstance(value, str) or not value:
+                    raise ConfigurationException("temp_dir must be a non-empty string")
+                # Try to create directory to validate path
+                try:
+                    Path(value).mkdir(parents=True, exist_ok=True)
+                except Exception as e:
+                    raise ConfigurationException(f"Invalid temp_dir path: {e}")
+            
+            elif key == 'cleanup_temp_files':
+                if not isinstance(value, bool):
+                    raise ConfigurationException("cleanup_temp_files must be a boolean")
+            
+            elif key == 'max_file_size_mb':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("max_file_size_mb must be a positive integer")
+            
+            elif key == 'supported_audio_formats':
+                if not isinstance(value, list):
+                    raise ConfigurationException("supported_audio_formats must be a list")
+                valid_formats = ['wav', 'mp3', 'flac', 'ogg', 'm4a']
+                for fmt in value:
+                    if fmt not in valid_formats:
+                        raise ConfigurationException(f"Invalid audio format: {fmt}")
+            
+            elif key == 'processing_timeout_seconds':
+                if not isinstance(value, int) or value <= 0:
+                    raise ConfigurationException("processing_timeout_seconds must be a positive integer")
+
+    def save_configuration_to_file(self, file_path: str) -> None:
+        """
+        Save current configuration to file.
+
+        Args:
+            file_path: Path to save configuration file
+
+        Raises:
+            ConfigurationException: If save fails
+        """
+        try:
+            self._config.save_configuration(file_path)
+            logger.info(f"Configuration saved to {file_path}")
+        except Exception as e:
+            logger.error(f"Failed to save configuration to {file_path}: {e}")
+            raise ConfigurationException(f"Failed to save configuration: {str(e)}")
+
+    def load_configuration_from_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Load configuration from file.
+
+        Args:
+            file_path: Path to configuration file
+
+        Returns:
+            Dict[str, Any]: Loaded configuration
+
+        Raises:
+            ConfigurationException: If load fails
+        """
+        try:
+            if not os.path.exists(file_path):
+                raise ConfigurationException(f"Configuration file not found: {file_path}")
+            
+            # Create new config instance with the file
+            new_config = AppConfig(config_file=file_path)
+            
+            # Update current config
+            self._config = new_config
+            
+            # Update container with new config
+            self._container.register_singleton(AppConfig, new_config)
+            
+            logger.info(f"Configuration loaded from {file_path}")
+            
+            return self.get_current_configuration()
+            
+        except Exception as e:
+            logger.error(f"Failed to load configuration from {file_path}: {e}")
+            raise ConfigurationException(f"Failed to load configuration: {str(e)}")
+
+    def reload_configuration(self) -> Dict[str, Any]:
+        """
+        Reload configuration from original sources.
+
+        Returns:
+            Dict[str, Any]: Reloaded configuration
+
+        Raises:
+            ConfigurationException: If reload fails
+        """
+        try:
+            self._config.reload_configuration()
+            logger.info("Configuration reloaded successfully")
+            
+            return self.get_current_configuration()
+            
+        except Exception as e:
+            logger.error(f"Failed to reload configuration: {e}")
+            raise ConfigurationException(f"Failed to reload configuration: {str(e)}")
+
+    def get_provider_availability(self) -> Dict[str, Dict[str, bool]]:
+        """
+        Get availability status of all providers.
+
+        Returns:
+            Dict[str, Dict[str, bool]]: Provider availability by category
+        """
+        try:
+            availability = {
+                'tts': {},
+                'stt': {},
+                'translation': {}
+            }
+            
+            # Check TTS providers
+            tts_factory = self._container.resolve(type(self._container._get_tts_factory()))
+            for provider in ['kokoro', 'dia', 'cosyvoice2', 'dummy']:
+                try:
+                    tts_factory.create_provider(provider)
+                    availability['tts'][provider] = True
+                except Exception:
+                    availability['tts'][provider] = False
+            
+            # Check STT providers
+            stt_factory = self._container.resolve(type(self._container._get_stt_factory()))
+            for provider in ['whisper', 'parakeet']:
+                try:
+                    stt_factory.create_provider(provider)
+                    availability['stt'][provider] = True
+                except Exception:
+                    availability['stt'][provider] = False
+            
+            # Check translation providers
+            translation_factory = self._container.resolve(type(self._container._get_translation_factory()))
+            try:
+                translation_factory.get_default_provider()
+                availability['translation']['nllb'] = True
+            except Exception:
+                availability['translation']['nllb'] = False
+            
+            return availability
+            
+        except Exception as e:
+            logger.error(f"Failed to check provider availability: {e}")
+            raise ConfigurationException(f"Failed to check provider availability: {str(e)}")
+
+    def get_system_info(self) -> Dict[str, Any]:
+        """
+        Get system information and configuration summary.
+
+        Returns:
+            Dict[str, Any]: System information
+        """
+        try:
+            return {
+                'config_file': self._config.config_file,
+                'temp_directory': self._config.processing.temp_dir,
+                'log_level': self._config.logging.level,
+                'provider_availability': self.get_provider_availability(),
+                'supported_languages': [
+                    'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh',
+                    'ar', 'hi', 'tr', 'pl', 'nl', 'sv', 'da', 'no', 'fi'
+                ],
+                'supported_audio_formats': self._config.processing.supported_audio_formats,
+                'max_file_size_mb': self._config.processing.max_file_size_mb,
+                'processing_timeout_seconds': self._config.processing.processing_timeout_seconds
+            }
+        except Exception as e:
+            logger.error(f"Failed to get system info: {e}")
+            raise ConfigurationException(f"Failed to get system info: {str(e)}")
+
+    def validate_configuration(self) -> Dict[str, List[str]]:
+        """
+        Validate current configuration and return any issues.
+
+        Returns:
+            Dict[str, List[str]]: Validation issues by category
+        """
+        issues = {
+            'tts': [],
+            'stt': [],
+            'translation': [],
+            'processing': [],
+            'logging': []
+        }
+        
+        try:
+            # Validate TTS configuration
+            tts_config = self._config.get_tts_config()
+            if not (0.1 <= tts_config['default_speed'] <= 3.0):
+                issues['tts'].append(f"Invalid default_speed: {tts_config['default_speed']}")
+            
+            if tts_config['max_text_length'] <= 0:
+                issues['tts'].append(f"Invalid max_text_length: {tts_config['max_text_length']}")
+            
+            # Validate STT configuration
+            stt_config = self._config.get_stt_config()
+            if stt_config['chunk_length_s'] <= 0:
+                issues['stt'].append(f"Invalid chunk_length_s: {stt_config['chunk_length_s']}")
+            
+            if stt_config['batch_size'] <= 0:
+                issues['stt'].append(f"Invalid batch_size: {stt_config['batch_size']}")
+            
+            # Validate processing configuration
+            processing_config = self._config.get_processing_config()
+            if not os.path.exists(processing_config['temp_dir']):
+                issues['processing'].append(f"Temp directory does not exist: {processing_config['temp_dir']}")
+            
+            if processing_config['max_file_size_mb'] <= 0:
+                issues['processing'].append(f"Invalid max_file_size_mb: {processing_config['max_file_size_mb']}")
+            
+            # Validate logging configuration
+            logging_config = self._config.get_logging_config()
+            valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+            if logging_config['level'].upper() not in valid_levels:
+                issues['logging'].append(f"Invalid log level: {logging_config['level']}")
+            
+        except Exception as e:
+            issues['general'] = [f"Configuration validation error: {str(e)}"]
+        
+        return issues
+
+    def reset_to_defaults(self) -> Dict[str, Any]:
+        """
+        Reset configuration to default values.
+
+        Returns:
+            Dict[str, Any]: Reset configuration
+
+        Raises:
+            ConfigurationException: If reset fails
+        """
+        try:
+            # Create new config with defaults
+            default_config = AppConfig()
+            
+            # Update current config
+            self._config = default_config
+            
+            # Update container with new config
+            self._container.register_singleton(AppConfig, default_config)
+            
+            logger.info("Configuration reset to defaults")
+            
+            return self.get_current_configuration()
+            
+        except Exception as e:
+            logger.error(f"Failed to reset configuration: {e}")
+            raise ConfigurationException(f"Failed to reset configuration: {str(e)}")
+
+    def cleanup(self) -> None:
+        """Cleanup configuration service resources."""
+        logger.info("Cleaning up ConfigurationApplicationService")
+        # No specific cleanup needed for configuration service
+        logger.info("ConfigurationApplicationService cleanup completed")
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with cleanup."""
+        self.cleanup()