django-cfg 1.3.13__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/core/generation/orchestrator.py

@@ -0,0 +1,285 @@
+"""
+Settings generation orchestrator.
+
+Coordinates all specialized generators to produce complete Django settings.
+Size: ~200 lines (orchestration logic)
+"""
+
+from typing import Dict, Any, List, TYPE_CHECKING
+import logging
+
+from django_cfg.core.exceptions import ConfigurationError
+
+if TYPE_CHECKING:
+    from ..base.config_model import DjangoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsOrchestrator:
+    """
+    Orchestrates Django settings generation from DjangoConfig.
+
+    Responsibilities:
+    - Coordinate all specialized generators
+    - Merge settings in correct order
+    - Apply additional settings
+    - Validate generated settings
+    - Handle errors gracefully
+
+    Example:
+        ```python
+        orchestrator = SettingsOrchestrator(config)
+        settings = orchestrator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize orchestrator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate complete Django settings dictionary.
+
+        Returns:
+            Complete Django settings dictionary
+
+        Raises:
+            ConfigurationError: If settings generation fails
+
+        Example:
+            >>> orchestrator = SettingsOrchestrator(config)
+            >>> settings = orchestrator.generate()
+            >>> "SECRET_KEY" in settings
+            True
+        """
+        try:
+            settings = {}
+
+            # Generate settings in dependency order
+            settings.update(self._generate_core_settings())
+            settings.update(self._generate_template_settings())
+            settings.update(self._generate_static_settings())
+            settings.update(self._generate_database_settings())
+            settings.update(self._generate_cache_settings())
+            settings.update(self._generate_security_settings())
+            settings.update(self._generate_email_settings())
+            settings.update(self._generate_logging_settings())
+            settings.update(self._generate_i18n_settings())
+            settings.update(self._generate_limits_settings())
+            settings.update(self._generate_session_settings())
+            settings.update(self._generate_third_party_settings())
+            settings.update(self._generate_api_settings())
+            settings.update(self._generate_tasks_settings())
+            settings.update(self._generate_tailwind_settings())
+
+            # Apply additional settings (user overrides)
+            settings.update(self._get_additional_settings())
+
+            return settings
+
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate settings: {e}") from e
+
+    def _generate_core_settings(self) -> Dict[str, Any]:
+        """Generate core Django settings."""
+        try:
+            from .core_generators.settings import CoreSettingsGenerator
+            generator = CoreSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate core settings: {e}") from e
+
+    def _generate_template_settings(self) -> Dict[str, Any]:
+        """Generate template settings."""
+        try:
+            from .core_generators.templates import TemplateSettingsGenerator
+            generator = TemplateSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate template settings: {e}") from e
+
+    def _generate_static_settings(self) -> Dict[str, Any]:
+        """Generate static files settings."""
+        try:
+            from .core_generators.static import StaticFilesGenerator
+            generator = StaticFilesGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate static settings: {e}") from e
+
+    def _generate_database_settings(self) -> Dict[str, Any]:
+        """Generate database settings."""
+        try:
+            from .data_generators.database import DatabaseSettingsGenerator
+            generator = DatabaseSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate database settings: {e}") from e
+
+    def _generate_cache_settings(self) -> Dict[str, Any]:
+        """Generate cache settings."""
+        try:
+            from .data_generators.cache import CacheSettingsGenerator
+            generator = CacheSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate cache settings: {e}") from e
+
+    def _generate_security_settings(self) -> Dict[str, Any]:
+        """Generate security settings."""
+        try:
+            from .utility_generators.security import SecuritySettingsGenerator
+            generator = SecuritySettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate security settings: {e}") from e
+
+    def _generate_email_settings(self) -> Dict[str, Any]:
+        """Generate email settings."""
+        try:
+            from .utility_generators.email import EmailSettingsGenerator
+            generator = EmailSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate email settings: {e}") from e
+
+    def _generate_logging_settings(self) -> Dict[str, Any]:
+        """Generate logging settings."""
+        try:
+            from .utility_generators.logging import LoggingSettingsGenerator
+            generator = LoggingSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate logging settings: {e}") from e
+
+    def _generate_i18n_settings(self) -> Dict[str, Any]:
+        """Generate i18n settings."""
+        try:
+            from .utility_generators.i18n import I18nSettingsGenerator
+            generator = I18nSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate i18n settings: {e}") from e
+
+    def _generate_limits_settings(self) -> Dict[str, Any]:
+        """Generate limits settings."""
+        try:
+            from .utility_generators.limits import LimitsSettingsGenerator
+            generator = LimitsSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate limits settings: {e}") from e
+
+    def _generate_session_settings(self) -> Dict[str, Any]:
+        """Generate session settings."""
+        try:
+            from .integration_generators.sessions import SessionSettingsGenerator
+            generator = SessionSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate session settings: {e}") from e
+
+    def _generate_third_party_settings(self) -> Dict[str, Any]:
+        """Generate third-party integration settings."""
+        try:
+            from .integration_generators.third_party import ThirdPartyIntegrationsGenerator
+            generator = ThirdPartyIntegrationsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate third-party settings: {e}") from e
+
+    def _generate_api_settings(self) -> Dict[str, Any]:
+        """Generate API framework settings."""
+        try:
+            from .integration_generators.api import APIFrameworksGenerator
+            generator = APIFrameworksGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate API settings: {e}") from e
+
+    def _generate_tasks_settings(self) -> Dict[str, Any]:
+        """Generate background tasks settings."""
+        try:
+            from .integration_generators.tasks import TasksSettingsGenerator
+            generator = TasksSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate tasks settings: {e}") from e
+
+    def _generate_tailwind_settings(self) -> Dict[str, Any]:
+        """Generate Tailwind CSS settings."""
+        try:
+            from .integration_generators.tailwind import TailwindSettingsGenerator
+            generator = TailwindSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate Tailwind settings: {e}") from e
+
+    def _get_additional_settings(self) -> Dict[str, Any]:
+        """
+        Get additional settings from config (user overrides).
+
+        Returns:
+            Dictionary with additional settings
+        """
+        if hasattr(self.config, "get_additional_settings"):
+            return self.config.get_additional_settings()
+        return {}
+
+    @staticmethod
+    def validate_settings(settings: Dict[str, Any]) -> List[str]:
+        """
+        Validate generated Django settings.
+
+        Args:
+            settings: Generated Django settings
+
+        Returns:
+            List of validation errors (empty if valid)
+
+        Example:
+            >>> errors = SettingsOrchestrator.validate_settings(settings)
+            >>> if errors:
+            ...     print("Validation errors:", errors)
+        """
+        errors = []
+
+        # Required settings validation
+        required_settings = [
+            "SECRET_KEY",
+            "DEBUG",
+            "ALLOWED_HOSTS",
+            "INSTALLED_APPS",
+            "MIDDLEWARE",
+            "DATABASES"
+        ]
+
+        for setting in required_settings:
+            if setting not in settings:
+                errors.append(f"Missing required setting: {setting}")
+
+        # SECRET_KEY validation
+        if "SECRET_KEY" in settings:
+            secret_key = settings["SECRET_KEY"]
+            if not secret_key or len(secret_key) < 50:
+                errors.append("SECRET_KEY must be at least 50 characters long")
+
+        # DATABASES validation
+        if "DATABASES" in settings:
+            databases = settings["DATABASES"]
+            if not databases:
+                errors.append("DATABASES cannot be empty")
+            elif "default" not in databases:
+                errors.append("DATABASES must contain a 'default' database")
+
+        return errors
+
+
+__all__ = ["SettingsOrchestrator"]

django_cfg/core/generation/protocols.py

@@ -0,0 +1,30 @@
+"""
+Generator protocols for type safety.
+
+Defines interfaces that all settings generators must implement.
+"""
+
+from typing import Protocol, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..base.config_model import DjangoConfig
+
+
+class SettingsGeneratorProtocol(Protocol):
+    """Protocol for all settings generators."""
+
+    def __init__(self, config: "DjangoConfig") -> None:
+        """Initialize generator with configuration."""
+        ...
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate Django settings dictionary.
+
+        Returns:
+            Dictionary of Django settings
+        """
+        ...
+
+
+__all__ = ["SettingsGeneratorProtocol"]

django_cfg/core/generation/utility_generators/__init__.py

@@ -0,0 +1,24 @@
+"""
+Utility generators module.
+
+Contains generators for utility Django settings:
+- Email configuration
+- Logging settings
+- Internationalization (i18n/l10n)
+- Application limits
+- Security settings
+"""
+
+from .email import EmailSettingsGenerator
+from .logging import LoggingSettingsGenerator
+from .i18n import I18nSettingsGenerator
+from .limits import LimitsSettingsGenerator
+from .security import SecuritySettingsGenerator
+
+__all__ = [
+    "EmailSettingsGenerator",
+    "LoggingSettingsGenerator",
+    "I18nSettingsGenerator",
+    "LimitsSettingsGenerator",
+    "SecuritySettingsGenerator",
+]

django_cfg/core/generation/utility_generators/email.py

@@ -0,0 +1,58 @@
+"""
+Email settings generator.
+
+Handles Django email configuration.
+Size: ~50 lines (focused on email settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class EmailSettingsGenerator:
+    """
+    Generates email settings.
+
+    Responsibilities:
+    - EMAIL_BACKEND configuration
+    - SMTP settings
+    - Email authentication
+
+    Example:
+        ```python
+        generator = EmailSettingsGenerator(config)
+        settings = generator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize generator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate email settings.
+
+        Returns:
+            Dictionary with email configuration
+
+        Example:
+            >>> generator = EmailSettingsGenerator(config)
+            >>> settings = generator.generate()
+        """
+        if not self.config.email:
+            return {}
+
+        email_settings = self.config.email.to_django_settings()
+
+        return email_settings
+
+
+__all__ = ["EmailSettingsGenerator"]

django_cfg/core/generation/utility_generators/i18n.py

@@ -0,0 +1,66 @@
+"""
+Internationalization settings generator.
+
+Handles Django i18n/l10n configuration.
+Size: ~60 lines (focused on i18n settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class I18nSettingsGenerator:
+    """
+    Generates internationalization settings.
+
+    Responsibilities:
+    - LANGUAGE_CODE, TIME_ZONE
+    - USE_I18N, USE_TZ flags
+    - Localization settings
+
+    Example:
+        ```python
+        generator = I18nSettingsGenerator(config)
+        settings = generator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize generator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate i18n settings.
+
+        Returns:
+            Dictionary with i18n configuration
+
+        Example:
+            >>> generator = I18nSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "LANGUAGE_CODE" in settings
+            True
+        """
+        settings = {
+            "LANGUAGE_CODE": "en-us",
+            "TIME_ZONE": "UTC",
+            "USE_I18N": True,
+            "USE_TZ": True,
+        }
+
+        # Adjust for different environments
+        if self.config.env_mode == "development":
+            settings["USE_L10N"] = True  # Deprecated but sometimes needed
+
+        return settings
+
+
+__all__ = ["I18nSettingsGenerator"]

django_cfg/core/generation/utility_generators/limits.py

@@ -0,0 +1,58 @@
+"""
+Application limits settings generator.
+
+Handles request limits and rate limiting configuration.
+Size: ~50 lines (focused on limits settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class LimitsSettingsGenerator:
+    """
+    Generates application limits settings.
+
+    Responsibilities:
+    - DATA_UPLOAD_MAX_MEMORY_SIZE
+    - FILE_UPLOAD_MAX_MEMORY_SIZE
+    - Rate limiting configuration
+
+    Example:
+        ```python
+        generator = LimitsSettingsGenerator(config)
+        settings = generator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize generator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate limits settings.
+
+        Returns:
+            Dictionary with limits configuration
+
+        Example:
+            >>> generator = LimitsSettingsGenerator(config)
+            >>> settings = generator.generate()
+        """
+        if not self.config.limits:
+            return {}
+
+        limits_settings = self.config.limits.to_django_settings()
+
+        return limits_settings
+
+
+__all__ = ["LimitsSettingsGenerator"]

django_cfg/core/generation/utility_generators/logging.py

@@ -0,0 +1,66 @@
+"""
+Logging settings generator.
+
+Handles Django logging configuration.
+Size: ~60 lines (focused on logging settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class LoggingSettingsGenerator:
+    """
+    Generates logging settings.
+
+    Responsibilities:
+    - LOGGING configuration
+    - Environment-specific log levels
+    - Log handlers and formatters
+
+    Example:
+        ```python
+        generator = LoggingSettingsGenerator(config)
+        settings = generator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize generator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate logging settings.
+
+        Returns:
+            Dictionary with logging configuration
+
+        Example:
+            >>> generator = LoggingSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "LOGGING" in settings
+            True
+        """
+        from ....utils.smart_defaults import SmartDefaults
+
+        # Generate logging defaults based on environment
+        logging_defaults = SmartDefaults.get_logging_defaults(
+            self.config.env_mode,
+            self.config.debug
+        )
+
+        if not logging_defaults:
+            return {}
+
+        return {"LOGGING": logging_defaults}
+
+
+__all__ = ["LoggingSettingsGenerator"]

django_cfg/core/generation/utility_generators/security.py

@@ -0,0 +1,101 @@
+"""
+Security settings generator.
+
+Handles Django security configuration.
+Size: ~100 lines (focused on security settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class SecuritySettingsGenerator:
+    """
+    Generates security settings.
+
+    Responsibilities:
+    - CORS configuration
+    - SSL/HTTPS settings
+    - Security headers
+    - Production security hardening
+
+    Example:
+        ```python
+        generator = SecuritySettingsGenerator(config)
+        settings = generator.generate()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize generator with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate security settings.
+
+        Returns:
+            Dictionary with security configuration
+
+        Example:
+            >>> generator = SecuritySettingsGenerator(config)
+            >>> settings = generator.generate()
+        """
+        settings = {}
+
+        # Generate security defaults if domains or SSL redirect are configured
+        if self.config.security_domains or self.config.ssl_redirect is not None:
+            security_defaults = self._get_security_defaults()
+            settings.update(security_defaults)
+
+        # Additional security settings for production
+        if self.config.env_mode == "production":
+            production_security = self._get_production_security()
+            settings.update(production_security)
+
+        return settings
+
+    def _get_security_defaults(self) -> Dict[str, Any]:
+        """
+        Get security defaults based on configuration.
+
+        Returns:
+            Dictionary with security defaults
+        """
+        from ....utils.smart_defaults import SmartDefaults
+
+        security_defaults = SmartDefaults.get_security_defaults(
+            self.config.security_domains,
+            self.config.env_mode,
+            self.config.debug,
+            self.config.ssl_redirect,
+            self.config.cors_allow_headers
+        )
+
+        return security_defaults
+
+    def _get_production_security(self) -> Dict[str, Any]:
+        """
+        Get production-specific security settings.
+
+        Returns:
+            Dictionary with production security settings
+        """
+        return {
+            "SECURE_SSL_REDIRECT": True,
+            "SECURE_HSTS_SECONDS": 31536000,  # 1 year
+            "SECURE_HSTS_INCLUDE_SUBDOMAINS": True,
+            "SECURE_HSTS_PRELOAD": True,
+            "SESSION_COOKIE_SECURE": True,
+            "CSRF_COOKIE_SECURE": True,
+        }
+
+
+__all__ = ["SecuritySettingsGenerator"]