Create configuration and dependency injection setup

config.example.json

@@ -0,0 +1,39 @@
+{
+  "tts": {
+    "preferred_providers": ["kokoro", "dia", "cosyvoice2", "dummy"],
+    "default_voice": "default",
+    "default_speed": 1.0,
+    "default_language": "en",
+    "enable_streaming": true,
+    "max_text_length": 10000
+  },
+  "stt": {
+    "preferred_providers": ["whisper", "parakeet"],
+    "default_model": "whisper",
+    "chunk_length_s": 30,
+    "batch_size": 16,
+    "enable_vad": true
+  },
+  "translation": {
+    "default_provider": "nllb",
+    "model_name": "facebook/nllb-200-3.3B",
+    "max_chunk_length": 1000,
+    "batch_size": 8,
+    "cache_translations": true
+  },
+  "processing": {
+    "temp_dir": "/tmp/audio_processing",
+    "cleanup_temp_files": true,
+    "max_file_size_mb": 100,
+    "supported_audio_formats": ["wav", "mp3", "flac", "ogg"],
+    "processing_timeout_seconds": 300
+  },
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "enable_file_logging": false,
+    "log_file_path": "app.log",
+    "max_log_file_size_mb": 10,
+    "backup_count": 5
+  }
+}

src/infrastructure/config/container_setup.py

@@ -0,0 +1,426 @@
+"""Container setup module for registering all services and dependencies."""
+
+import logging
+from typing import Optional
+
+from .app_config import AppConfig
+from .dependency_container import DependencyContainer, ServiceLifetime
+from ..tts.provider_factory import TTSProviderFactory
+from ..stt.provider_factory import STTProviderFactory
+from ..translation.provider_factory import TranslationProviderFactory
+from ...domain.interfaces.audio_processing import IAudioProcessingService
+from ...domain.interfaces.speech_recognition import ISpeechRecognitionService
+from ...domain.interfaces.translation import ITranslationService
+from ...domain.interfaces.speech_synthesis import ISpeechSynthesisService
+from ...domain.services.audio_processing_service import AudioProcessingService
+from ...application.services.audio_processing_service import AudioProcessingApplicationService
+from ...application.services.configuration_service import ConfigurationApplicationService
+
+logger = logging.getLogger(__name__)
+
+
+def setup_container(config_file: Optional[str] = None) -> DependencyContainer:
+    """
+    Set up and configure the dependency injection container with all services.
+
+    Args:
+        config_file: Optional path to configuration file
+
+    Returns:
+        DependencyContainer: Configured container instance
+    """
+    logger.info("Setting up dependency injection container")
+
+    # Create configuration
+    config = AppConfig(config_file=config_file)
+
+    # Create container with configuration
+    container = DependencyContainer(config)
+
+    # Register core services
+    _register_core_services(container, config)
+
+    # Register domain services
+    _register_domain_services(container)
+
+    # Register application services
+    _register_application_services(container)
+
+    # Register provider services
+    _register_provider_services(container)
+
+    logger.info("Dependency injection container setup completed")
+    return container
+
+
+def _register_core_services(container: DependencyContainer, config: AppConfig) -> None:
+    """
+    Register core infrastructure services.
+
+    Args:
+        container: Dependency container
+        config: Application configuration
+    """
+    logger.debug("Registering core services")
+
+    # Configuration is already registered as singleton in container constructor
+    # But we ensure it's the same instance
+    container.register_singleton(AppConfig, config)
+
+    # Register provider factories as singletons
+    container.register_singleton(
+        TTSProviderFactory,
+        lambda: TTSProviderFactory()
+    )
+
+    container.register_singleton(
+        STTProviderFactory,
+        lambda: STTProviderFactory()
+    )
+
+    container.register_singleton(
+        TranslationProviderFactory,
+        lambda: TranslationProviderFactory()
+    )
+
+    logger.debug("Core services registered")
+
+
+def _register_domain_services(container: DependencyContainer) -> None:
+    """
+    Register domain services.
+
+    Args:
+        container: Dependency container
+    """
+    logger.debug("Registering domain services")
+
+    # Register domain audio processing service as transient
+    # It requires other services to be injected
+    def create_audio_processing_service() -> IAudioProcessingService:
+        """Factory function for creating audio processing service."""
+        # Get provider services from container
+        stt_provider = container.get_stt_provider()
+        translation_provider = container.get_translation_provider()
+        tts_provider = container.get_tts_provider()
+
+        return AudioProcessingService(
+            speech_recognition_service=stt_provider,
+            translation_service=translation_provider,
+            speech_synthesis_service=tts_provider
+        )
+
+    container.register_transient(
+        IAudioProcessingService,
+        create_audio_processing_service
+    )
+
+    logger.debug("Domain services registered")
+
+
+def _register_application_services(container: DependencyContainer) -> None:
+    """
+    Register application services.
+
+    Args:
+        container: Dependency container
+    """
+    logger.debug("Registering application services")
+
+    # Register audio processing application service as scoped
+    # It manages resources and should be scoped to request/session
+    def create_audio_processing_app_service() -> AudioProcessingApplicationService:
+        """Factory function for creating audio processing application service."""
+        return AudioProcessingApplicationService(container)
+
+    container.register_scoped(
+        AudioProcessingApplicationService,
+        create_audio_processing_app_service
+    )
+
+    # Register configuration application service as singleton
+    # Configuration service can be shared across requests
+    def create_configuration_app_service() -> ConfigurationApplicationService:
+        """Factory function for creating configuration application service."""
+        return ConfigurationApplicationService(container)
+
+    container.register_singleton(
+        ConfigurationApplicationService,
+        create_configuration_app_service
+    )
+
+    logger.debug("Application services registered")
+
+
+def _register_provider_services(container: DependencyContainer) -> None:
+    """
+    Register provider services with fallback logic.
+
+    Args:
+        container: Dependency container
+    """
+    logger.debug("Registering provider services")
+
+    # Register TTS provider service as transient with fallback
+    def create_tts_provider() -> ISpeechSynthesisService:
+        """Factory function for creating TTS provider with fallback."""
+        return container.get_tts_provider()
+
+    container.register_transient(
+        ISpeechSynthesisService,
+        create_tts_provider
+    )
+
+    # Register STT provider service as transient with fallback
+    def create_stt_provider() -> ISpeechRecognitionService:
+        """Factory function for creating STT provider with fallback."""
+        return container.get_stt_provider()
+
+    container.register_transient(
+        ISpeechRecognitionService,
+        create_stt_provider
+    )
+
+    # Register translation provider service as transient with fallback
+    def create_translation_provider() -> ITranslationService:
+        """Factory function for creating translation provider with fallback."""
+        return container.get_translation_provider()
+
+    container.register_transient(
+        ITranslationService,
+        create_translation_provider
+    )
+
+    logger.debug("Provider services registered")
+
+
+def configure_logging(config: AppConfig) -> None:
+    """
+    Configure application logging based on configuration.
+
+    Args:
+        config: Application configuration
+    """
+    try:
+        logging_config = config.get_logging_config()
+
+        # Configure root logger
+        root_logger = logging.getLogger()
+        root_logger.setLevel(getattr(logging, logging_config['level'].upper(), logging.INFO))
+
+        # Clear existing handlers
+        for handler in root_logger.handlers[:]:
+            root_logger.removeHandler(handler)
+
+        # Create console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(root_logger.level)
+
+        # Create formatter
+        formatter = logging.Formatter(logging_config['format'])
+        console_handler.setFormatter(formatter)
+
+        # Add console handler
+        root_logger.addHandler(console_handler)
+
+        # Add file handler if enabled
+        if logging_config.get('enable_file_logging', False):
+            from logging.handlers import RotatingFileHandler
+
+            file_handler = RotatingFileHandler(
+                logging_config['log_file_path'],
+                maxBytes=logging_config['max_log_file_size_mb'] * 1024 * 1024,
+                backupCount=logging_config['backup_count']
+            )
+            file_handler.setLevel(root_logger.level)
+            file_handler.setFormatter(formatter)
+
+            root_logger.addHandler(file_handler)
+
+        logger.info(f"Logging configured: level={logging_config['level']}")
+
+    except Exception as e:
+        # Fallback to basic logging configuration
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        logger.warning(f"Failed to configure logging from config, using defaults: {e}")
+
+
+def create_configured_container(config_file: Optional[str] = None) -> DependencyContainer:
+    """
+    Create and configure a complete dependency injection container.
+
+    This is the main entry point for setting up the application's dependency injection.
+
+    Args:
+        config_file: Optional path to configuration file
+
+    Returns:
+        DependencyContainer: Fully configured container
+    """
+    try:
+        # Setup container
+        container = setup_container(config_file)
+
+        # Configure logging
+        config = container.resolve(AppConfig)
+        configure_logging(config)
+
+        # Validate container setup
+        _validate_container_setup(container)
+
+        logger.info("Application container created and configured successfully")
+        return container
+
+    except Exception as e:
+        logger.error(f"Failed to create configured container: {e}")
+        raise
+
+
+def _validate_container_setup(container: DependencyContainer) -> None:
+    """
+    Validate that the container is properly set up.
+
+    Args:
+        container: Container to validate
+
+    Raises:
+        RuntimeError: If validation fails
+    """
+    logger.debug("Validating container setup")
+
+    required_services = [
+        AppConfig,
+        TTSProviderFactory,
+        STTProviderFactory,
+        TranslationProviderFactory,
+        IAudioProcessingService,
+        AudioProcessingApplicationService,
+        ConfigurationApplicationService,
+        ISpeechSynthesisService,
+        ISpeechRecognitionService,
+        ITranslationService
+    ]
+
+    missing_services = []
+
+    for service_type in required_services:
+        if not container.is_registered(service_type):
+            missing_services.append(service_type.__name__)
+
+    if missing_services:
+        raise RuntimeError(f"Container validation failed. Missing services: {missing_services}")
+
+    # Test service resolution
+    try:
+        config = container.resolve(AppConfig)
+        app_service = container.resolve(AudioProcessingApplicationService)
+        config_service = container.resolve(ConfigurationApplicationService)
+
+        logger.debug("Container validation successful")
+
+    except Exception as e:
+        raise RuntimeError(f"Container validation failed during service resolution: {e}")
+
+
+def get_service_registry_info(container: DependencyContainer) -> dict:
+    """
+    Get information about registered services in the container.
+
+    Args:
+        container: Container to inspect
+
+    Returns:
+        dict: Service registry information
+    """
+    try:
+        registered_services = container.get_registered_services()
+
+        # Get provider availability
+        config = container.resolve(AppConfig)
+        tts_factory = container.resolve(TTSProviderFactory)
+        stt_factory = container.resolve(STTProviderFactory)
+        translation_factory = container.resolve(TranslationProviderFactory)
+
+        provider_info = {
+            'tts_providers': tts_factory.get_available_providers(),
+            'stt_providers': stt_factory.get_available_providers(),
+            'translation_providers': [p.value for p in translation_factory.get_available_providers()]
+        }
+
+        return {
+            'registered_services': registered_services,
+            'provider_availability': provider_info,
+            'configuration_summary': {
+                'config_file': config.config_file,
+                'temp_dir': config.processing.temp_dir,
+                'log_level': config.logging.level,
+                'tts_preferred_providers': config.tts.preferred_providers,
+                'stt_default_model': config.stt.default_model,
+                'translation_default_provider': config.translation.default_provider
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to get service registry info: {e}")
+        return {
+            'error': str(e),
+            'registered_services': container.get_registered_services() if container else {}
+        }
+
+
+# Global container instance management
+_global_container: Optional[DependencyContainer] = None
+
+
+def initialize_global_container(config_file: Optional[str] = None) -> DependencyContainer:
+    """
+    Initialize the global container instance.
+
+    Args:
+        config_file: Optional configuration file path
+
+    Returns:
+        DependencyContainer: Global container instance
+    """
+    global _global_container
+
+    if _global_container is not None:
+        logger.warning("Global container already initialized, cleaning up previous instance")
+        _global_container.cleanup()
+
+    _global_container = create_configured_container(config_file)
+    logger.info("Global container initialized")
+
+    return _global_container
+
+
+def get_global_container() -> DependencyContainer:
+    """
+    Get the global container instance.
+
+    Returns:
+        DependencyContainer: Global container instance
+
+    Raises:
+        RuntimeError: If container is not initialized
+    """
+    global _global_container
+
+    if _global_container is None:
+        logger.info("Global container not initialized, creating with defaults")
+        _global_container = create_configured_container()
+
+    return _global_container
+
+
+def cleanup_global_container() -> None:
+    """Cleanup the global container instance."""
+    global _global_container
+
+    if _global_container is not None:
+        _global_container.cleanup()
+        _global_container = None
+        logger.info("Global container cleaned up")

test_dependency_injection.py

@@ -1,58 +1,314 @@
 #!/usr/bin/env python3
-"""Test script for dependency injection implementation."""
+"""Test script for dependency injection and configuration setup."""
 
 import sys
 import os
+import logging
+from pathlib import Path
 
-# 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)
+# Add src to path for imports
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+from infrastructure.config.container_setup import (
+    create_configured_container,
+    get_service_registry_info,
+    initialize_global_container,
+    get_global_container,
+    cleanup_global_container
+)
+from infrastructure.config.app_config import AppConfig
+from infrastructure.config.dependency_container import DependencyContainer
+from application.services.audio_processing_service import AudioProcessingApplicationService
+from application.services.configuration_service import ConfigurationApplicationService
+
+
+def test_configuration_loading():
+    """Test configuration loading from file and environment."""
+    print("=" * 60)
+    print("Testing Configuration Loading")
+    print("=" * 60)
+
+    try:
+        # Test default configuration
+        print("\n1. Testing default configuration...")
+        config = AppConfig()
+        print(f"✓ Default config loaded successfully")
+        print(f"  - TTS preferred providers: {config.tts.preferred_providers}")
+        print(f"  - STT default model: {config.stt.default_model}")
+        print(f"  - Translation provider: {config.translation.default_provider}")
+        print(f"  - Temp directory: {config.processing.temp_dir}")
+        print(f"  - Log level: {config.logging.level}")
+
+        # Test configuration from file
+        print("\n2. Testing configuration from file...")
+        config_file = "config.example.json"
+        if os.path.exists(config_file):
+            config_from_file = AppConfig(config_file=config_file)
+            print(f"✓ Config loaded from {config_file}")
+            print(f"  - TTS preferred providers: {config_from_file.tts.preferred_providers}")
+            print(f"  - Processing timeout: {config_from_file.processing.processing_timeout_seconds}s")
+        else:
+            print(f"⚠ Config file {config_file} not found, skipping file test")
+
+        # Test environment variable override
+        print("\n3. Testing environment variable override...")
+        os.environ['TTS_DEFAULT_SPEED'] = '1.5'
+        os.environ['LOG_LEVEL'] = 'DEBUG'
+
+        config_with_env = AppConfig()
+        print(f"✓ Config with environment overrides loaded")
+        print(f"  - TTS default speed: {config_with_env.tts.default_speed}")
+        print(f"  - Log level: {config_with_env.logging.level}")
+
+        # Clean up environment
+        del os.environ['TTS_DEFAULT_SPEED']
+        del os.environ['LOG_LEVEL']
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Configuration loading failed: {e}")
+        return False
+
+
+def test_dependency_container():
+    """Test dependency container setup and service resolution."""
+    print("\n" + "=" * 60)
+    print("Testing Dependency Container")
+    print("=" * 60)
+
+    try:
+        # Test container creation
+        print("\n1. Testing container creation...")
+        container = create_configured_container()
+        print("✓ Container created successfully")
+
+        # Test service registration info
+        print("\n2. Testing service registry...")
+        registry_info = get_service_registry_info(container)
+        print("✓ Service registry information retrieved")
+        print(f"  - Registered services: {len(registry_info['registered_services'])}")
+
+        for service_name, lifetime in registry_info['registered_services'].items():
+            print(f"    • {service_name}: {lifetime}")
+
+        # Test provider availability
+        print("\n3. Testing provider availability...")
+        provider_info = registry_info['provider_availability']
+        print(f"  - Available TTS providers: {provider_info['tts_providers']}")
+        print(f"  - Available STT providers: {provider_info['stt_providers']}")
+        print(f"  - Available translation providers: {provider_info['translation_providers']}")
+
+        # Test service resolution
+        print("\n4. Testing service resolution...")
+
+        # Resolve configuration
+        config = container.resolve(AppConfig)
+        print("✓ AppConfig resolved successfully")
+
+        # Resolve application services
+        audio_service = container.resolve(AudioProcessingApplicationService)
+        print("✓ AudioProcessingApplicationService resolved successfully")
+
+        config_service = container.resolve(ConfigurationApplicationService)
+        print("✓ ConfigurationApplicationService resolved successfully")
+
+        # Test provider services
+        tts_provider = container.get_tts_provider()
+        print(f"✓ TTS provider resolved: {tts_provider.__class__.__name__}")
+
+        stt_provider = container.get_stt_provider()
+        print(f"✓ STT provider resolved: {stt_provider.__class__.__name__}")
+
+        translation_provider = container.get_translation_provider()
+        print(f"✓ Translation provider resolved: {translation_provider.__class__.__name__}")
+
+        # Test scoped services
+        print("\n5. Testing scoped services...")
+        with container.create_scope() as scope:
+            scoped_audio_service = scope.resolve(AudioProcessingApplicationService)
+            print("✓ Scoped AudioProcessingApplicationService resolved")
+
+        # Cleanup
+        container.cleanup()
+        print("✓ Container cleanup completed")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Dependency container test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_global_container():
+    """Test global container management."""
+    print("\n" + "=" * 60)
+    print("Testing Global Container Management")
+    print("=" * 60)
+
+    try:
+        # Test global container initialization
+        print("\n1. Testing global container initialization...")
+        global_container = initialize_global_container()
+        print("✓ Global container initialized")
+
+        # Test global container access
+        print("\n2. Testing global container access...")
+        retrieved_container = get_global_container()
+        print("✓ Global container retrieved")
+
+        assert global_container is retrieved_container, "Global container instances should be the same"
+        print("✓ Global container instance consistency verified")
+
+        # Test service resolution through global container
+        print("\n3. Testing service resolution through global container...")
+        config = retrieved_container.resolve(AppConfig)
+        print("✓ Configuration resolved through global container")
+
+        # Test global container cleanup
+        print("\n4. Testing global container cleanup...")
+        cleanup_global_container()
+        print("✓ Global container cleaned up")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Global container test failed: {e}")
+        return False
+
+
+def test_configuration_service():
+    """Test configuration application service."""
+    print("\n" + "=" * 60)
+    print("Testing Configuration Application Service")
+    print("=" * 60)
+
+    try:
+        # Create container
+        container = create_configured_container()
+
+        # Get configuration service
+        print("\n1. Testing configuration service resolution...")
+        config_service = container.resolve(ConfigurationApplicationService)
+        print("✓ Configuration service resolved")
+
+        # Test getting current configuration
+        print("\n2. Testing configuration retrieval...")
+        current_config = config_service.get_current_configuration()
+        print("✓ Current configuration retrieved")
+        print(f"  - Configuration sections: {list(current_config.keys())}")
+
+        # Test TTS configuration
+        print("\n3. Testing TTS configuration...")
+        tts_config = config_service.get_tts_configuration()
+        print(f"✓ TTS configuration: {len(tts_config)} settings")
+
+        # Test configuration updates
+        print("\n4. Testing configuration updates...")
+        updated_tts = config_service.update_tts_configuration({
+            'default_speed': 1.2,
+            'enable_streaming': False
+        })
+        print("✓ TTS configuration updated")
+        print(f"  - New default speed: {updated_tts['default_speed']}")
+        print(f"  - Streaming enabled: {updated_tts['enable_streaming']}")
+
+        # Test provider availability
+        print("\n5. Testing provider availability check...")
+        availability = config_service.get_provider_availability()
+        print("✓ Provider availability checked")
+        for category, providers in availability.items():
+            print(f"  - {category.upper()}: {providers}")
+
+        # Test system info
+        print("\n6. Testing system information...")
+        system_info = config_service.get_system_info()
+        print("✓ System information retrieved")
+        print(f"  - Supported languages: {len(system_info['supported_languages'])}")
+        print(f"  - Supported audio formats: {system_info['supported_audio_formats']}")
+
+        # Test configuration validation
+        print("\n7. Testing configuration validation...")
+        validation_issues = config_service.validate_configuration()
+        print("✓ Configuration validation completed")
+
+        total_issues = sum(len(issues) for issues in validation_issues.values())
+        if total_issues == 0:
+            print("  - No validation issues found")
+        else:
+            print(f"  - Found {total_issues} validation issues")
+            for category, issues in validation_issues.items():
+                if issues:
+                    print(f"    • {category}: {issues}")
+
+        # Cleanup
+        container.cleanup()
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Configuration service test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Run all tests."""
+    print("Dependency Injection and Configuration Test Suite")
+    print("=" * 60)
+
+    # Configure basic logging
+    logging.basicConfig(
+        level=logging.WARNING,  # Reduce noise during testing
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    tests = [
+        ("Configuration Loading", test_configuration_loading),
+        ("Dependency Container", test_dependency_container),
+        ("Global Container Management", test_global_container),
+        ("Configuration Service", test_configuration_service)
+    ]
+
+    results = []
+
+    for test_name, test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"\n✗ {test_name} failed with exception: {e}")
+            results.append((test_name, False))
+
+    # Print summary
+    print("\n" + "=" * 60)
+    print("Test Results Summary")
+    print("=" * 60)
+
+    passed = 0
+    failed = 0
+
+    for test_name, result in results:
+        status = "✓ PASSED" if result else "✗ FAILED"
+        print(f"{test_name:<30} {status}")
+
+        if result:
+            passed += 1
+        else:
+            failed += 1
+
+    print(f"\nTotal: {len(results)} tests, {passed} passed, {failed} failed")
+
+    if failed == 0:
+        print("\n🎉 All tests passed!")
+        return 0
+    else:
+        print(f"\n❌ {failed} test(s) failed!")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())