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

django_cfg/core/generation/core_generators/templates.py

@@ -0,0 +1,141 @@
+"""
+Django TEMPLATES settings generator.
+
+Handles template configuration with auto-discovery of django-cfg app templates.
+Size: ~90 lines (focused on template settings)
+"""
+
+from typing import Dict, Any, List, TYPE_CHECKING
+from pathlib import Path
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class TemplateSettingsGenerator:
+    """
+    Generates Django TEMPLATES setting.
+
+    Responsibilities:
+    - Configure Django template backend
+    - Set up template directories
+    - Auto-discover django-cfg app templates
+    - Configure context processors
+
+    Example:
+        ```python
+        generator = TemplateSettingsGenerator(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 TEMPLATES setting.
+
+        Returns:
+            Dictionary with TEMPLATES configuration
+
+        Example:
+            >>> generator = TemplateSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "TEMPLATES" in settings
+            True
+        """
+        template_dirs = self._discover_template_directories()
+
+        return {
+            "TEMPLATES": [
+                {
+                    "BACKEND": "django.template.backends.django.DjangoTemplates",
+                    "DIRS": template_dirs,
+                    "APP_DIRS": True,
+                    "OPTIONS": {
+                        "context_processors": [
+                            "django.template.context_processors.debug",
+                            "django.template.context_processors.request",
+                            "django.contrib.auth.context_processors.auth",
+                            "django.contrib.messages.context_processors.messages",
+                        ],
+                    },
+                },
+            ]
+        }
+
+    def _discover_template_directories(self) -> List[Path]:
+        """
+        Discover template directories from django-cfg and project.
+
+        Returns:
+            List of Path objects pointing to template directories
+        """
+        template_dirs = []
+
+        # Add project templates directory
+        project_templates = self.config.base_dir / "templates"
+        template_dirs.append(project_templates)
+
+        # Add django-cfg templates directory
+        django_cfg_templates = Path(__file__).parent.parent.parent.parent / "templates"
+        template_dirs.append(django_cfg_templates)
+
+        # Auto-discover app template directories
+        app_templates = self._discover_app_templates()
+        template_dirs.extend(app_templates)
+
+        return template_dirs
+
+    def _discover_app_templates(self) -> List[Path]:
+        """
+        Auto-discover template directories from django-cfg apps.
+
+        Looks for:
+        - app/templates/
+        - app/admin_interface/templates/
+        - app/frontend/templates/
+
+        Returns:
+            List of discovered template directory paths
+        """
+        app_templates = []
+
+        # Find django-cfg apps directory
+        django_cfg_dir = Path(__file__).parent.parent.parent.parent
+        apps_dir = django_cfg_dir / 'apps'
+
+        if not apps_dir.exists():
+            return app_templates
+
+        # Scan each app directory
+        for app_dir in apps_dir.iterdir():
+            if not app_dir.is_dir():
+                continue
+
+            # Skip special directories
+            if app_dir.name.startswith(('@', '_', '.')):
+                continue
+
+            # Look for common template directory patterns
+            possible_template_dirs = [
+                app_dir / 'templates',
+                app_dir / 'admin_interface' / 'templates',
+                app_dir / 'frontend' / 'templates',
+            ]
+
+            for template_dir in possible_template_dirs:
+                if template_dir.exists() and template_dir.is_dir():
+                    app_templates.append(template_dir)
+
+        return app_templates
+
+
+__all__ = ["TemplateSettingsGenerator"]

django_cfg/core/generation/data_generators/__init__.py

@@ -0,0 +1,15 @@
+"""
+Data generators module.
+
+Contains generators for data-related Django settings:
+- Database configuration
+- Cache backends
+"""
+
+from .database import DatabaseSettingsGenerator
+from .cache import CacheSettingsGenerator
+
+__all__ = [
+    "DatabaseSettingsGenerator",
+    "CacheSettingsGenerator",
+]

django_cfg/core/generation/data_generators/cache.py

@@ -0,0 +1,132 @@
+"""
+Cache settings generator.
+
+Handles CACHES configuration and session storage.
+Size: ~90 lines (focused on cache settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+import logging
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class CacheSettingsGenerator:
+    """
+    Generates Django CACHES settings.
+
+    Responsibilities:
+    - Convert CacheConfig models to Django format
+    - Provide default cache backend
+    - Configure sessions cache
+    - Auto-discover additional cache backends
+
+    Example:
+        ```python
+        generator = CacheSettingsGenerator(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 cache settings.
+
+        Returns:
+            Dictionary with CACHES and session configuration
+
+        Example:
+            >>> generator = CacheSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "CACHES" in settings
+            True
+        """
+        settings = {}
+        caches = {}
+
+        # Default cache - always provide one
+        if self.config.cache_default:
+            caches["default"] = self.config.cache_default.to_django_config(
+                self.config.env_mode,
+                self.config.debug,
+                "default"
+            )
+        else:
+            # Create default cache backend
+            caches["default"] = self._get_default_cache_config()
+
+        # Sessions cache
+        if self.config.cache_sessions:
+            caches["sessions"] = self.config.cache_sessions.to_django_config(
+                self.config.env_mode,
+                self.config.debug,
+                "sessions"
+            )
+
+            # Configure Django to use cache for sessions
+            settings["SESSION_ENGINE"] = "django.contrib.sessions.backends.cache"
+            settings["SESSION_CACHE_ALIAS"] = "sessions"
+
+        # Auto-discover additional cache backends
+        additional_caches = self._discover_additional_caches()
+        caches.update(additional_caches)
+
+        if caches:
+            settings["CACHES"] = caches
+
+        return settings
+
+    def _get_default_cache_config(self) -> Dict[str, Any]:
+        """
+        Get default cache configuration.
+
+        Returns:
+            Dictionary with default cache backend configuration
+        """
+        from ....models.infrastructure.cache import CacheConfig
+
+        default_cache = CacheConfig()
+        return default_cache.to_django_config(
+            self.config.env_mode,
+            self.config.debug,
+            "default"
+        )
+
+    def _discover_additional_caches(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Auto-discover additional cache backends.
+
+        Looks for attributes starting with "cache_" (excluding cache_default and cache_sessions).
+
+        Returns:
+            Dictionary of additional cache configurations
+        """
+        additional_caches = {}
+
+        for attr_name in dir(self.config):
+            if attr_name.startswith("cache_") and attr_name not in ["cache_default", "cache_sessions"]:
+                cache_obj = getattr(self.config, attr_name)
+                if hasattr(cache_obj, "to_django_config"):
+                    cache_alias = attr_name.replace("cache_", "")
+                    additional_caches[cache_alias] = cache_obj.to_django_config(
+                        self.config.env_mode,
+                        self.config.debug,
+                        cache_alias
+                    )
+
+        return additional_caches
+
+
+__all__ = ["CacheSettingsGenerator"]

django_cfg/core/generation/data_generators/database.py

@@ -0,0 +1,117 @@
+"""
+Database settings generator.
+
+Handles DATABASES configuration and routing.
+Size: ~100 lines (focused on database settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+import logging
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseSettingsGenerator:
+    """
+    Generates Django DATABASES settings.
+
+    Responsibilities:
+    - Convert DatabaseConfig models to Django format
+    - Apply smart defaults per database engine
+    - Configure database routing
+
+    Example:
+        ```python
+        generator = DatabaseSettingsGenerator(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 database settings.
+
+        Returns:
+            Dictionary with DATABASES and routing configuration
+
+        Example:
+            >>> generator = DatabaseSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "DATABASES" in settings
+            True
+        """
+        settings = {}
+
+        if not self.config.databases:
+            return settings
+
+        # Convert database configurations
+        django_databases = {}
+        for alias, db_config in self.config.databases.items():
+            django_databases[alias] = db_config.to_django_config()
+
+        settings["DATABASES"] = django_databases
+
+        # Apply database defaults for each database based on its engine
+        from ....utils.smart_defaults import SmartDefaults
+
+        for alias, db_config in self.config.databases.items():
+            db_defaults = SmartDefaults.get_database_defaults(
+                self.config.env_mode,
+                self.config.debug,
+                db_config.engine
+            )
+            if db_defaults:
+                # Merge defaults with existing configuration
+                for key, value in db_defaults.items():
+                    if key == "OPTIONS":
+                        # Merge OPTIONS dictionaries
+                        existing_options = django_databases[alias].get("OPTIONS", {})
+                        merged_options = {**value, **existing_options}
+                        django_databases[alias]["OPTIONS"] = merged_options
+                    elif key not in django_databases[alias]:
+                        django_databases[alias][key] = value
+
+        # Configure database routing if needed
+        routing_settings = self._generate_routing_settings()
+        settings.update(routing_settings)
+
+        return settings
+
+    def _generate_routing_settings(self) -> Dict[str, Any]:
+        """
+        Generate database routing configuration.
+
+        Returns:
+            Dictionary with routing settings
+        """
+        routing_rules = {}
+
+        # Check if any database has routing rules
+        for alias, db_config in self.config.databases.items():
+            if db_config.has_routing_rules():
+                for app in db_config.apps:
+                    routing_rules[app] = alias
+
+        if not routing_rules:
+            return {}
+
+        return {
+            "DATABASE_ROUTERS": ["django_cfg.routing.routers.DatabaseRouter"],
+            "DATABASE_ROUTING_RULES": routing_rules,
+        }
+
+
+__all__ = ["DatabaseSettingsGenerator"]

django_cfg/core/generation/generation.py

@@ -0,0 +1,92 @@
+"""
+Django settings generation for django_cfg.
+
+Main facade for settings generation.
+
+Following CRITICAL_REQUIREMENTS.md:
+- No raw Dict/Any usage
+- Proper type annotations
+- Comprehensive error handling
+- Performance-aware generation
+"""
+
+from typing import Dict, List, Any, 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 SettingsGenerator:
+    """
+    Generates complete Django settings from DjangoConfig instances.
+
+    Converts type-safe Pydantic configuration models into Django-compatible
+    settings dictionaries with intelligent defaults and validation.
+
+    This is a facade class that delegates to SettingsOrchestrator for
+    actual generation.
+
+    Example:
+        ```python
+        from django_cfg import DjangoConfig
+        from django_cfg.core.generation import SettingsGenerator
+
+        config = DjangoConfig(project_name="MyProject", secret_key="x"*50)
+        settings = SettingsGenerator.generate(config)
+        ```
+    """
+
+    @classmethod
+    def generate(cls, config: "DjangoConfig") -> Dict[str, Any]:
+        """
+        Generate complete Django settings dictionary.
+
+        Args:
+            config: DjangoConfig instance
+
+        Returns:
+            Complete Django settings dictionary
+
+        Raises:
+            ConfigurationError: If settings generation fails
+
+        Example:
+            >>> from django_cfg import DjangoConfig
+            >>> config = DjangoConfig(project_name="Test", secret_key="x"*50)
+            >>> settings = SettingsGenerator.generate(config)
+            >>> "SECRET_KEY" in settings
+            True
+        """
+        from .orchestrator import SettingsOrchestrator
+
+        orchestrator = SettingsOrchestrator(config)
+        return orchestrator.generate()
+
+    @classmethod
+    def validate_generated_settings(cls, settings: Dict[str, Any]) -> List[str]:
+        """
+        Validate generated Django settings.
+
+        Args:
+            settings: Generated Django settings
+
+        Returns:
+            List of validation errors (empty if valid)
+
+        Example:
+            >>> settings = {"SECRET_KEY": "x"*50, "DEBUG": True}
+            >>> errors = SettingsGenerator.validate_generated_settings(settings)
+            >>> if errors:
+            ...     print("Validation errors:", errors)
+        """
+        from .orchestrator import SettingsOrchestrator
+
+        return SettingsOrchestrator.validate_settings(settings)
+
+
+__all__ = ["SettingsGenerator"]

django_cfg/core/generation/integration_generators/__init__.py

@@ -0,0 +1,21 @@
+"""
+Integration generators module.
+
+Contains generators for third-party integrations and frameworks:
+- Session configuration
+- External services (Telegram, Unfold, Constance)
+- API frameworks (JWT, DRF, Spectacular, Revolution)
+- Background tasks (Dramatiq)
+"""
+
+from .sessions import SessionSettingsGenerator
+from .third_party import ThirdPartyIntegrationsGenerator
+from .api import APIFrameworksGenerator
+from .tasks import TasksSettingsGenerator
+
+__all__ = [
+    "SessionSettingsGenerator",
+    "ThirdPartyIntegrationsGenerator",
+    "APIFrameworksGenerator",
+    "TasksSettingsGenerator",
+]