Create provider factories with dependency injection

src/infrastructure/config/__init__.py

@@ -0,0 +1,6 @@
+"""Configuration and dependency injection module."""
+
+from .dependency_container import DependencyContainer
+from .app_config import AppConfig
+
+__all__ = ['DependencyContainer', 'AppConfig']

src/infrastructure/config/app_config.py

@@ -0,0 +1,375 @@
+"""Application configuration management."""
+
+import os
+import logging
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TTSConfig:
+    """Configuration for TTS providers."""
+    preferred_providers: List[str] = field(default_factory=lambda: ['kokoro', 'dia', 'cosyvoice2', 'dummy'])
+    default_voice: str = 'default'
+    default_speed: float = 1.0
+    default_language: str = 'en'
+    enable_streaming: bool = True
+    max_text_length: int = 10000
+
+
+@dataclass
+class STTConfig:
+    """Configuration for STT providers."""
+    preferred_providers: List[str] = field(default_factory=lambda: ['whisper', 'parakeet'])
+    default_model: str = 'whisper'
+    chunk_length_s: int = 30
+    batch_size: int = 16
+    enable_vad: bool = True
+
+
+@dataclass
+class TranslationConfig:
+    """Configuration for translation providers."""
+    default_provider: str = 'nllb'
+    model_name: str = 'facebook/nllb-200-3.3B'
+    max_chunk_length: int = 1000
+    batch_size: int = 8
+    cache_translations: bool = True
+
+
+@dataclass
+class ProcessingConfig:
+    """Configuration for audio processing pipeline."""
+    temp_dir: str = '/tmp/audio_processing'
+    cleanup_temp_files: bool = True
+    max_file_size_mb: int = 100
+    supported_audio_formats: List[str] = field(default_factory=lambda: ['wav', 'mp3', 'flac', 'ogg'])
+    processing_timeout_seconds: int = 300
+
+
+@dataclass
+class LoggingConfig:
+    """Configuration for logging."""
+    level: str = 'INFO'
+    format: str = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    enable_file_logging: bool = False
+    log_file_path: str = 'app.log'
+    max_log_file_size_mb: int = 10
+    backup_count: int = 5
+
+
+class AppConfig:
+    """Centralized application configuration management."""
+
+    def __init__(self, config_file: Optional[str] = None):
+        """
+        Initialize application configuration.
+
+        Args:
+            config_file: Optional path to configuration file
+        """
+        self.config_file = config_file
+        self._config_data: Dict[str, Any] = {}
+        
+        # Initialize configuration sections
+        self.tts = TTSConfig()
+        self.stt = STTConfig()
+        self.translation = TranslationConfig()
+        self.processing = ProcessingConfig()
+        self.logging = LoggingConfig()
+        
+        # Load configuration
+        self._load_configuration()
+
+    def _load_configuration(self) -> None:
+        """Load configuration from environment variables and config file."""
+        try:
+            # Load from environment variables first
+            self._load_from_environment()
+            
+            # Load from config file if provided
+            if self.config_file and os.path.exists(self.config_file):
+                self._load_from_file()
+                
+            # Validate configuration
+            self._validate_configuration()
+            
+            logger.info("Configuration loaded successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to load configuration: {e}")
+            # Use default configuration
+            logger.info("Using default configuration")
+
+    def _load_from_environment(self) -> None:
+        """Load configuration from environment variables."""
+        # TTS Configuration
+        if os.getenv('TTS_PREFERRED_PROVIDERS'):
+            self.tts.preferred_providers = os.getenv('TTS_PREFERRED_PROVIDERS').split(',')
+        if os.getenv('TTS_DEFAULT_VOICE'):
+            self.tts.default_voice = os.getenv('TTS_DEFAULT_VOICE')
+        if os.getenv('TTS_DEFAULT_SPEED'):
+            self.tts.default_speed = float(os.getenv('TTS_DEFAULT_SPEED'))
+        if os.getenv('TTS_DEFAULT_LANGUAGE'):
+            self.tts.default_language = os.getenv('TTS_DEFAULT_LANGUAGE')
+        if os.getenv('TTS_ENABLE_STREAMING'):
+            self.tts.enable_streaming = os.getenv('TTS_ENABLE_STREAMING').lower() == 'true'
+
+        # STT Configuration
+        if os.getenv('STT_PREFERRED_PROVIDERS'):
+            self.stt.preferred_providers = os.getenv('STT_PREFERRED_PROVIDERS').split(',')
+        if os.getenv('STT_DEFAULT_MODEL'):
+            self.stt.default_model = os.getenv('STT_DEFAULT_MODEL')
+        if os.getenv('STT_CHUNK_LENGTH'):
+            self.stt.chunk_length_s = int(os.getenv('STT_CHUNK_LENGTH'))
+        if os.getenv('STT_BATCH_SIZE'):
+            self.stt.batch_size = int(os.getenv('STT_BATCH_SIZE'))
+
+        # Translation Configuration
+        if os.getenv('TRANSLATION_DEFAULT_PROVIDER'):
+            self.translation.default_provider = os.getenv('TRANSLATION_DEFAULT_PROVIDER')
+        if os.getenv('TRANSLATION_MODEL_NAME'):
+            self.translation.model_name = os.getenv('TRANSLATION_MODEL_NAME')
+        if os.getenv('TRANSLATION_MAX_CHUNK_LENGTH'):
+            self.translation.max_chunk_length = int(os.getenv('TRANSLATION_MAX_CHUNK_LENGTH'))
+
+        # Processing Configuration
+        if os.getenv('PROCESSING_TEMP_DIR'):
+            self.processing.temp_dir = os.getenv('PROCESSING_TEMP_DIR')
+        if os.getenv('PROCESSING_CLEANUP_TEMP_FILES'):
+            self.processing.cleanup_temp_files = os.getenv('PROCESSING_CLEANUP_TEMP_FILES').lower() == 'true'
+        if os.getenv('PROCESSING_MAX_FILE_SIZE_MB'):
+            self.processing.max_file_size_mb = int(os.getenv('PROCESSING_MAX_FILE_SIZE_MB'))
+        if os.getenv('PROCESSING_TIMEOUT_SECONDS'):
+            self.processing.processing_timeout_seconds = int(os.getenv('PROCESSING_TIMEOUT_SECONDS'))
+
+        # Logging Configuration
+        if os.getenv('LOG_LEVEL'):
+            self.logging.level = os.getenv('LOG_LEVEL')
+        if os.getenv('LOG_FORMAT'):
+            self.logging.format = os.getenv('LOG_FORMAT')
+        if os.getenv('LOG_FILE_PATH'):
+            self.logging.log_file_path = os.getenv('LOG_FILE_PATH')
+
+    def _load_from_file(self) -> None:
+        """Load configuration from file (JSON or YAML)."""
+        try:
+            import json
+            
+            with open(self.config_file, 'r') as f:
+                if self.config_file.endswith('.json'):
+                    self._config_data = json.load(f)
+                elif self.config_file.endswith(('.yml', '.yaml')):
+                    try:
+                        import yaml
+                        self._config_data = yaml.safe_load(f)
+                    except ImportError:
+                        logger.warning("PyYAML not installed, cannot load YAML config file")
+                        return
+                else:
+                    logger.warning(f"Unsupported config file format: {self.config_file}")
+                    return
+
+            # Apply configuration from file
+            self._apply_config_data()
+            
+        except Exception as e:
+            logger.error(f"Failed to load config file {self.config_file}: {e}")
+
+    def _apply_config_data(self) -> None:
+        """Apply configuration data from loaded file."""
+        if not self._config_data:
+            return
+
+        # Apply TTS configuration
+        tts_config = self._config_data.get('tts', {})
+        if 'preferred_providers' in tts_config:
+            self.tts.preferred_providers = tts_config['preferred_providers']
+        if 'default_voice' in tts_config:
+            self.tts.default_voice = tts_config['default_voice']
+        if 'default_speed' in tts_config:
+            self.tts.default_speed = tts_config['default_speed']
+        if 'default_language' in tts_config:
+            self.tts.default_language = tts_config['default_language']
+        if 'enable_streaming' in tts_config:
+            self.tts.enable_streaming = tts_config['enable_streaming']
+
+        # Apply STT configuration
+        stt_config = self._config_data.get('stt', {})
+        if 'preferred_providers' in stt_config:
+            self.stt.preferred_providers = stt_config['preferred_providers']
+        if 'default_model' in stt_config:
+            self.stt.default_model = stt_config['default_model']
+        if 'chunk_length_s' in stt_config:
+            self.stt.chunk_length_s = stt_config['chunk_length_s']
+        if 'batch_size' in stt_config:
+            self.stt.batch_size = stt_config['batch_size']
+
+        # Apply Translation configuration
+        translation_config = self._config_data.get('translation', {})
+        if 'default_provider' in translation_config:
+            self.translation.default_provider = translation_config['default_provider']
+        if 'model_name' in translation_config:
+            self.translation.model_name = translation_config['model_name']
+        if 'max_chunk_length' in translation_config:
+            self.translation.max_chunk_length = translation_config['max_chunk_length']
+
+        # Apply Processing configuration
+        processing_config = self._config_data.get('processing', {})
+        if 'temp_dir' in processing_config:
+            self.processing.temp_dir = processing_config['temp_dir']
+        if 'cleanup_temp_files' in processing_config:
+            self.processing.cleanup_temp_files = processing_config['cleanup_temp_files']
+        if 'max_file_size_mb' in processing_config:
+            self.processing.max_file_size_mb = processing_config['max_file_size_mb']
+        if 'processing_timeout_seconds' in processing_config:
+            self.processing.processing_timeout_seconds = processing_config['processing_timeout_seconds']
+
+        # Apply Logging configuration
+        logging_config = self._config_data.get('logging', {})
+        if 'level' in logging_config:
+            self.logging.level = logging_config['level']
+        if 'format' in logging_config:
+            self.logging.format = logging_config['format']
+        if 'log_file_path' in logging_config:
+            self.logging.log_file_path = logging_config['log_file_path']
+
+    def _validate_configuration(self) -> None:
+        """Validate configuration values."""
+        # Validate TTS configuration
+        if not (0.1 <= self.tts.default_speed <= 3.0):
+            logger.warning(f"Invalid TTS speed {self.tts.default_speed}, using default 1.0")
+            self.tts.default_speed = 1.0
+
+        if self.tts.max_text_length <= 0:
+            logger.warning(f"Invalid max text length {self.tts.max_text_length}, using default 10000")
+            self.tts.max_text_length = 10000
+
+        # Validate STT configuration
+        if self.stt.chunk_length_s <= 0:
+            logger.warning(f"Invalid chunk length {self.stt.chunk_length_s}, using default 30")
+            self.stt.chunk_length_s = 30
+
+        if self.stt.batch_size <= 0:
+            logger.warning(f"Invalid batch size {self.stt.batch_size}, using default 16")
+            self.stt.batch_size = 16
+
+        # Validate Translation configuration
+        if self.translation.max_chunk_length <= 0:
+            logger.warning(f"Invalid max chunk length {self.translation.max_chunk_length}, using default 1000")
+            self.translation.max_chunk_length = 1000
+
+        # Validate Processing configuration
+        if self.processing.max_file_size_mb <= 0:
+            logger.warning(f"Invalid max file size {self.processing.max_file_size_mb}, using default 100")
+            self.processing.max_file_size_mb = 100
+
+        if self.processing.processing_timeout_seconds <= 0:
+            logger.warning(f"Invalid timeout {self.processing.processing_timeout_seconds}, using default 300")
+            self.processing.processing_timeout_seconds = 300
+
+        # Ensure temp directory exists
+        try:
+            Path(self.processing.temp_dir).mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            logger.warning(f"Failed to create temp directory {self.processing.temp_dir}: {e}")
+            self.processing.temp_dir = '/tmp/audio_processing'
+            Path(self.processing.temp_dir).mkdir(parents=True, exist_ok=True)
+
+    def get_tts_config(self) -> Dict[str, Any]:
+        """Get TTS configuration as dictionary."""
+        return {
+            'preferred_providers': self.tts.preferred_providers,
+            'default_voice': self.tts.default_voice,
+            'default_speed': self.tts.default_speed,
+            'default_language': self.tts.default_language,
+            'enable_streaming': self.tts.enable_streaming,
+            'max_text_length': self.tts.max_text_length
+        }
+
+    def get_stt_config(self) -> Dict[str, Any]:
+        """Get STT configuration as dictionary."""
+        return {
+            'preferred_providers': self.stt.preferred_providers,
+            'default_model': self.stt.default_model,
+            'chunk_length_s': self.stt.chunk_length_s,
+            'batch_size': self.stt.batch_size,
+            'enable_vad': self.stt.enable_vad
+        }
+
+    def get_translation_config(self) -> Dict[str, Any]:
+        """Get translation configuration as dictionary."""
+        return {
+            'default_provider': self.translation.default_provider,
+            'model_name': self.translation.model_name,
+            'max_chunk_length': self.translation.max_chunk_length,
+            'batch_size': self.translation.batch_size,
+            'cache_translations': self.translation.cache_translations
+        }
+
+    def get_processing_config(self) -> Dict[str, Any]:
+        """Get processing configuration as dictionary."""
+        return {
+            'temp_dir': self.processing.temp_dir,
+            'cleanup_temp_files': self.processing.cleanup_temp_files,
+            'max_file_size_mb': self.processing.max_file_size_mb,
+            'supported_audio_formats': self.processing.supported_audio_formats,
+            'processing_timeout_seconds': self.processing.processing_timeout_seconds
+        }
+
+    def get_logging_config(self) -> Dict[str, Any]:
+        """Get logging configuration as dictionary."""
+        return {
+            'level': self.logging.level,
+            'format': self.logging.format,
+            'enable_file_logging': self.logging.enable_file_logging,
+            'log_file_path': self.logging.log_file_path,
+            'max_log_file_size_mb': self.logging.max_log_file_size_mb,
+            'backup_count': self.logging.backup_count
+        }
+
+    def reload_configuration(self) -> None:
+        """Reload configuration from sources."""
+        logger.info("Reloading configuration")
+        self._load_configuration()
+
+    def save_configuration(self, output_file: str) -> None:
+        """
+        Save current configuration to file.
+
+        Args:
+            output_file: Path to output configuration file
+        """
+        try:
+            config_dict = {
+                'tts': self.get_tts_config(),
+                'stt': self.get_stt_config(),
+                'translation': self.get_translation_config(),
+                'processing': self.get_processing_config(),
+                'logging': self.get_logging_config()
+            }
+
+            import json
+            with open(output_file, 'w') as f:
+                json.dump(config_dict, f, indent=2)
+
+            logger.info(f"Configuration saved to {output_file}")
+
+        except Exception as e:
+            logger.error(f"Failed to save configuration to {output_file}: {e}")
+            raise
+
+    def __str__(self) -> str:
+        """String representation of configuration."""
+        return (
+            f"AppConfig(\n"
+            f"  TTS: {self.tts}\n"
+            f"  STT: {self.stt}\n"
+            f"  Translation: {self.translation}\n"
+            f"  Processing: {self.processing}\n"
+            f"  Logging: {self.logging}\n"
+            f")"
+        )

src/infrastructure/config/dependency_container.py

@@ -0,0 +1,537 @@
+"""Dependency injection container for managing component lifecycles."""
+
+import logging
+from typing import Dict, Any, Optional, TypeVar, Type, Callable, Union
+from enum import Enum
+from threading import Lock
+import weakref
+
+from .app_config import AppConfig
+from ..tts.provider_factory import TTSProviderFactory
+from ..stt.provider_factory import STTProviderFactory
+from ..translation.provider_factory import TranslationProviderFactory, TranslationProviderType
+from ...domain.interfaces.speech_synthesis import ISpeechSynthesisService
+from ...domain.interfaces.speech_recognition import ISpeechRecognitionService
+from ...domain.interfaces.translation import ITranslationService
+from ...domain.interfaces.audio_processing import IAudioProcessingService
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+
+class ServiceLifetime(Enum):
+    """Service lifetime management options."""
+    SINGLETON = "singleton"
+    TRANSIENT = "transient"
+    SCOPED = "scoped"
+
+
+class ServiceDescriptor:
+    """Describes how a service should be created and managed."""
+
+    def __init__(
+        self,
+        service_type: Type[T],
+        implementation: Union[Type[T], Callable[..., T]],
+        lifetime: ServiceLifetime = ServiceLifetime.TRANSIENT,
+        factory_args: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize service descriptor.
+
+        Args:
+            service_type: The service interface type
+            implementation: The implementation class or factory function
+            lifetime: Service lifetime management
+            factory_args: Arguments to pass to the factory/constructor
+        """
+        self.service_type = service_type
+        self.implementation = implementation
+        self.lifetime = lifetime
+        self.factory_args = factory_args or {}
+
+
+class DependencyContainer:
+    """Dependency injection container for managing component lifecycles."""
+
+    def __init__(self, config: Optional[AppConfig] = None):
+        """
+        Initialize the dependency container.
+
+        Args:
+            config: Application configuration instance
+        """
+        self._config = config or AppConfig()
+        self._services: Dict[Type, ServiceDescriptor] = {}
+        self._singletons: Dict[Type, Any] = {}
+        self._scoped_instances: Dict[Type, Any] = {}
+        self._lock = Lock()
+        
+        # Provider factories
+        self._tts_factory: Optional[TTSProviderFactory] = None
+        self._stt_factory: Optional[STTProviderFactory] = None
+        self._translation_factory: Optional[TranslationProviderFactory] = None
+        
+        # Register default services
+        self._register_default_services()
+
+    def _register_default_services(self) -> None:
+        """Register default service implementations."""
+        # Register configuration as singleton
+        self.register_singleton(AppConfig, self._config)
+        
+        # Register provider factories as singletons
+        self.register_singleton(TTSProviderFactory, self._get_tts_factory)
+        self.register_singleton(STTProviderFactory, self._get_stt_factory)
+        self.register_singleton(TranslationProviderFactory, self._get_translation_factory)
+
+    def register_singleton(
+        self,
+        service_type: Type[T],
+        implementation: Union[Type[T], Callable[..., T], T],
+        factory_args: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Register a service as singleton.
+
+        Args:
+            service_type: The service interface type
+            implementation: The implementation class, factory function, or instance
+            factory_args: Arguments to pass to the factory/constructor
+        """
+        with self._lock:
+            # If implementation is already an instance, store it directly
+            if not (isinstance(implementation, type) or callable(implementation)):
+                self._singletons[service_type] = implementation
+                logger.debug(f"Registered singleton instance for {service_type.__name__}")
+                return
+
+            descriptor = ServiceDescriptor(
+                service_type=service_type,
+                implementation=implementation,
+                lifetime=ServiceLifetime.SINGLETON,
+                factory_args=factory_args
+            )
+            self._services[service_type] = descriptor
+            logger.debug(f"Registered singleton service: {service_type.__name__}")
+
+    def register_transient(
+        self,
+        service_type: Type[T],
+        implementation: Union[Type[T], Callable[..., T]],
+        factory_args: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Register a service as transient (new instance each time).
+
+        Args:
+            service_type: The service interface type
+            implementation: The implementation class or factory function
+            factory_args: Arguments to pass to the factory/constructor
+        """
+        with self._lock:
+            descriptor = ServiceDescriptor(
+                service_type=service_type,
+                implementation=implementation,
+                lifetime=ServiceLifetime.TRANSIENT,
+                factory_args=factory_args
+            )
+            self._services[service_type] = descriptor
+            logger.debug(f"Registered transient service: {service_type.__name__}")
+
+    def register_scoped(
+        self,
+        service_type: Type[T],
+        implementation: Union[Type[T], Callable[..., T]],
+        factory_args: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Register a service as scoped (one instance per scope).
+
+        Args:
+            service_type: The service interface type
+            implementation: The implementation class or factory function
+            factory_args: Arguments to pass to the factory/constructor
+        """
+        with self._lock:
+            descriptor = ServiceDescriptor(
+                service_type=service_type,
+                implementation=implementation,
+                lifetime=ServiceLifetime.SCOPED,
+                factory_args=factory_args
+            )
+            self._services[service_type] = descriptor
+            logger.debug(f"Registered scoped service: {service_type.__name__}")
+
+    def resolve(self, service_type: Type[T]) -> T:
+        """
+        Resolve a service instance.
+
+        Args:
+            service_type: The service type to resolve
+
+        Returns:
+            T: The service instance
+
+        Raises:
+            ValueError: If service is not registered
+            Exception: If service creation fails
+        """
+        with self._lock:
+            # Check if already a singleton instance
+            if service_type in self._singletons:
+                return self._singletons[service_type]
+
+            # Check if service is registered
+            if service_type not in self._services:
+                raise ValueError(f"Service {service_type.__name__} is not registered")
+
+            descriptor = self._services[service_type]
+
+            try:
+                if descriptor.lifetime == ServiceLifetime.SINGLETON:
+                    return self._create_singleton(service_type, descriptor)
+                elif descriptor.lifetime == ServiceLifetime.SCOPED:
+                    return self._create_scoped(service_type, descriptor)
+                else:  # TRANSIENT
+                    return self._create_transient(descriptor)
+
+            except Exception as e:
+                logger.error(f"Failed to resolve service {service_type.__name__}: {e}")
+                raise
+
+    def _create_singleton(self, service_type: Type[T], descriptor: ServiceDescriptor) -> T:
+        """Create or return existing singleton instance."""
+        if service_type in self._singletons:
+            return self._singletons[service_type]
+
+        instance = self._create_instance(descriptor)
+        self._singletons[service_type] = instance
+        logger.debug(f"Created singleton instance for {service_type.__name__}")
+        return instance
+
+    def _create_scoped(self, service_type: Type[T], descriptor: ServiceDescriptor) -> T:
+        """Create or return existing scoped instance."""
+        if service_type in self._scoped_instances:
+            return self._scoped_instances[service_type]
+
+        instance = self._create_instance(descriptor)
+        self._scoped_instances[service_type] = instance
+        logger.debug(f"Created scoped instance for {service_type.__name__}")
+        return instance
+
+    def _create_transient(self, descriptor: ServiceDescriptor) -> T:
+        """Create new transient instance."""
+        instance = self._create_instance(descriptor)
+        logger.debug(f"Created transient instance for {descriptor.service_type.__name__}")
+        return instance
+
+    def _create_instance(self, descriptor: ServiceDescriptor) -> T:
+        """Create service instance using descriptor."""
+        implementation = descriptor.implementation
+        factory_args = descriptor.factory_args
+
+        # If implementation is a callable (factory function)
+        if callable(implementation) and not isinstance(implementation, type):
+            return implementation(**factory_args)
+
+        # If implementation is a class
+        if isinstance(implementation, type):
+            return implementation(**factory_args)
+
+        raise ValueError(f"Invalid implementation type for {descriptor.service_type.__name__}")
+
+    def _get_tts_factory(self) -> TTSProviderFactory:
+        """Get or create TTS provider factory."""
+        if self._tts_factory is None:
+            self._tts_factory = TTSProviderFactory()
+            logger.debug("Created TTS provider factory")
+        return self._tts_factory
+
+    def _get_stt_factory(self) -> STTProviderFactory:
+        """Get or create STT provider factory."""
+        if self._stt_factory is None:
+            self._stt_factory = STTProviderFactory()
+            logger.debug("Created STT provider factory")
+        return self._stt_factory
+
+    def _get_translation_factory(self) -> TranslationProviderFactory:
+        """Get or create translation provider factory."""
+        if self._translation_factory is None:
+            self._translation_factory = TranslationProviderFactory()
+            logger.debug("Created translation provider factory")
+        return self._translation_factory
+
+    def get_tts_provider(self, provider_name: Optional[str] = None, **kwargs) -> ISpeechSynthesisService:
+        """
+        Get TTS provider with fallback logic.
+
+        Args:
+            provider_name: Specific provider name or None for default
+            **kwargs: Additional provider arguments
+
+        Returns:
+            ISpeechSynthesisService: TTS provider instance
+        """
+        factory = self.resolve(TTSProviderFactory)
+        
+        if provider_name:
+            return factory.create_provider(provider_name, **kwargs)
+        else:
+            preferred_providers = self._config.tts.preferred_providers
+            return factory.get_provider_with_fallback(preferred_providers, **kwargs)
+
+    def get_stt_provider(self, provider_name: Optional[str] = None) -> ISpeechRecognitionService:
+        """
+        Get STT provider with fallback logic.
+
+        Args:
+            provider_name: Specific provider name or None for default
+
+        Returns:
+            ISpeechRecognitionService: STT provider instance
+        """
+        factory = self.resolve(STTProviderFactory)
+        
+        if provider_name:
+            return factory.create_provider(provider_name)
+        else:
+            preferred_provider = self._config.stt.default_model
+            return factory.create_provider_with_fallback(preferred_provider)
+
+    def get_translation_provider(
+        self,
+        provider_type: Optional[TranslationProviderType] = None,
+        config: Optional[Dict[str, Any]] = None
+    ) -> ITranslationService:
+        """
+        Get translation provider with fallback logic.
+
+        Args:
+            provider_type: Specific provider type or None for default
+            config: Optional provider configuration
+
+        Returns:
+            ITranslationService: Translation provider instance
+        """
+        factory = self.resolve(TranslationProviderFactory)
+        
+        if provider_type:
+            return factory.create_provider(provider_type, config)
+        else:
+            return factory.get_default_provider(config)
+
+    def clear_scoped_instances(self) -> None:
+        """Clear all scoped instances."""
+        with self._lock:
+            # Cleanup scoped instances if they have cleanup methods
+            for instance in self._scoped_instances.values():
+                self._cleanup_instance(instance)
+            
+            self._scoped_instances.clear()
+            logger.debug("Cleared scoped instances")
+
+    def _cleanup_instance(self, instance: Any) -> None:
+        """Cleanup instance if it has cleanup methods."""
+        try:
+            # Try common cleanup method names
+            cleanup_methods = ['cleanup', 'dispose', 'close', '__del__']
+            for method_name in cleanup_methods:
+                if hasattr(instance, method_name):
+                    method = getattr(instance, method_name)
+                    if callable(method):
+                        method()
+                        logger.debug(f"Called {method_name} on {type(instance).__name__}")
+                        break
+        except Exception as e:
+            logger.warning(f"Failed to cleanup instance {type(instance).__name__}: {e}")
+
+    def cleanup(self) -> None:
+        """Cleanup all managed resources."""
+        with self._lock:
+            logger.info("Starting dependency container cleanup")
+            
+            # Cleanup scoped instances
+            self.clear_scoped_instances()
+            
+            # Cleanup singleton instances
+            for instance in self._singletons.values():
+                self._cleanup_instance(instance)
+            
+            # Cleanup provider factories
+            if self._tts_factory:
+                try:
+                    self._tts_factory.cleanup_providers()
+                except Exception as e:
+                    logger.warning(f"Failed to cleanup TTS factory: {e}")
+            
+            if self._translation_factory:
+                try:
+                    self._translation_factory.clear_cache()
+                except Exception as e:
+                    logger.warning(f"Failed to cleanup translation factory: {e}")
+            
+            # Clear all references
+            self._singletons.clear()
+            self._tts_factory = None
+            self._stt_factory = None
+            self._translation_factory = None
+            
+            logger.info("Dependency container cleanup completed")
+
+    def is_registered(self, service_type: Type) -> bool:
+        """
+        Check if a service type is registered.
+
+        Args:
+            service_type: The service type to check
+
+        Returns:
+            bool: True if registered, False otherwise
+        """
+        with self._lock:
+            return service_type in self._services or service_type in self._singletons
+
+    def get_registered_services(self) -> Dict[str, str]:
+        """
+        Get information about all registered services.
+
+        Returns:
+            Dict[str, str]: Mapping of service names to their lifetime
+        """
+        with self._lock:
+            services_info = {}
+            
+            # Add singleton instances
+            for service_type in self._singletons.keys():
+                services_info[service_type.__name__] = "singleton (instance)"
+            
+            # Add registered services
+            for service_type, descriptor in self._services.items():
+                if service_type not in self._singletons:
+                    services_info[service_type.__name__] = descriptor.lifetime.value
+            
+            return services_info
+
+    def create_scope(self) -> 'DependencyScope':
+        """
+        Create a new dependency scope.
+
+        Returns:
+            DependencyScope: New scope instance
+        """
+        return DependencyScope(self)
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with cleanup."""
+        self.cleanup()
+
+
+class DependencyScope:
+    """Scoped dependency container for managing scoped service lifetimes."""
+
+    def __init__(self, parent_container: DependencyContainer):
+        """
+        Initialize dependency scope.
+
+        Args:
+            parent_container: Parent dependency container
+        """
+        self._parent = parent_container
+        self._scoped_instances: Dict[Type, Any] = {}
+        self._lock = Lock()
+
+    def resolve(self, service_type: Type[T]) -> T:
+        """
+        Resolve service within this scope.
+
+        Args:
+            service_type: The service type to resolve
+
+        Returns:
+            T: The service instance
+        """
+        with self._lock:
+            # Check if we have a scoped instance
+            if service_type in self._scoped_instances:
+                return self._scoped_instances[service_type]
+
+            # Resolve from parent container
+            instance = self._parent.resolve(service_type)
+
+            # If it's a scoped service, store it in this scope
+            if (service_type in self._parent._services and 
+                self._parent._services[service_type].lifetime == ServiceLifetime.SCOPED):
+                self._scoped_instances[service_type] = instance
+
+            return instance
+
+    def cleanup(self) -> None:
+        """Cleanup scoped instances."""
+        with self._lock:
+            for instance in self._scoped_instances.values():
+                self._parent._cleanup_instance(instance)
+            self._scoped_instances.clear()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with cleanup."""
+        self.cleanup()
+
+
+# Global container instance
+_global_container: Optional[DependencyContainer] = None
+_container_lock = Lock()
+
+
+def get_container() -> DependencyContainer:
+    """
+    Get the global dependency container instance.
+
+    Returns:
+        DependencyContainer: Global container instance
+    """
+    global _global_container
+    
+    with _container_lock:
+        if _global_container is None:
+            _global_container = DependencyContainer()
+            logger.info("Created global dependency container")
+        
+        return _global_container
+
+
+def set_container(container: DependencyContainer) -> None:
+    """
+    Set the global dependency container instance.
+
+    Args:
+        container: Container instance to set as global
+    """
+    global _global_container
+    
+    with _container_lock:
+        if _global_container is not None:
+            _global_container.cleanup()
+        
+        _global_container = container
+        logger.info("Set global dependency container")
+
+
+def cleanup_container() -> None:
+    """Cleanup the global dependency container."""
+    global _global_container
+    
+    with _container_lock:
+        if _global_container is not None:
+            _global_container.cleanup()
+            _global_container = None
+            logger.info("Cleaned up global dependency container")

test_dependency_injection.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Test script for dependency injection implementation."""
+
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+try:
+    from infrastructure.config.dependency_container import DependencyContainer, get_container
+    from infrastructure.config.app_config import AppConfig
+    from infrastructure.tts.provider_factory import TTSProviderFactory
+    from infrastructure.stt.provider_factory import STTProviderFactory
+    from infrastructure.translation.provider_factory import TranslationProviderFactory
+
+    print("🧪 Testing Dependency Injection Implementation...")
+    print()
+
+    # Test basic container functionality
+    container = DependencyContainer()
+    print('✅ DependencyContainer created successfully')
+
+    # Test configuration resolution
+    config = container.resolve(AppConfig)
+    print(f'✅ AppConfig resolved: {type(config).__name__}')
+
+    # Test factory resolution
+    tts_factory = container.resolve(TTSProviderFactory)
+    stt_factory = container.resolve(STTProviderFactory)
+    translation_factory = container.resolve(TranslationProviderFactory)
+
+    print(f'✅ TTSProviderFactory resolved: {type(tts_factory).__name__}')
+    print(f'✅ STTProviderFactory resolved: {type(stt_factory).__name__}')
+    print(f'✅ TranslationProviderFactory resolved: {type(translation_factory).__name__}')
+
+    # Test global container
+    global_container = get_container()
+    print(f'✅ Global container retrieved: {type(global_container).__name__}')
+
+    # Test service registration info
+    services = container.get_registered_services()
+    print(f'✅ Registered services: {len(services)} services')
+    for service_name, lifetime in services.items():
+        print(f'   - {service_name}: {lifetime}')
+
+    # Test cleanup
+    container.cleanup()
+    print('✅ Container cleanup completed')
+
+    print()
+    print('🎉 All dependency injection tests passed!')
+
+except Exception as e:
+    print(f'❌ Test failed: {e}')
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)