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

django_cfg/core/constants.py

@@ -0,0 +1,69 @@
+"""Default configurations and constants for django-cfg."""
+
+from typing import List
+
+# Default Django apps installed by django-cfg
+DEFAULT_APPS: List[str] = [
+    # WhiteNoise for static files (must be before django.contrib.staticfiles)
+    "whitenoise.runserver_nostatic",
+    # Unfold Admin
+    "unfold",
+    "unfold.contrib.filters",  # optional, if special filters are needed
+    "unfold.contrib.forms",  # optional, if special form elements are needed
+    "unfold.contrib.inlines",  # optional, if special inlines are needed
+    "import_export",  # django-import-export package
+    "unfold.contrib.import_export",  # optional, if django-import-export package is used
+    "unfold.contrib.guardian",  # optional, if django-guardian package is used
+    "unfold.contrib.simple_history",  # optional, if django-simple-history package is used
+    "unfold.contrib.location_field",  # optional, if django-location-field package is used
+    "unfold.contrib.constance",  # optional, if django-constance package is used
+    # Django Core
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "django.contrib.humanize",
+    # Third-party
+    "corsheaders",
+    "rest_framework",
+    "rest_framework.authtoken",
+    "rest_framework_simplejwt",
+    "rest_framework_simplejwt.token_blacklist",
+    "rest_framework_nested",
+    "rangefilter",
+    "django_filters",
+    "drf_spectacular",
+    "drf_spectacular_sidecar",
+    "django_json_widget",
+    "django_extensions",
+    "constance",
+    "constance.backends.database",
+    # Django CFG Core
+    "django_cfg",
+    "django_revolution",
+]
+
+# Default middleware stack
+DEFAULT_MIDDLEWARE: List[str] = [
+    "django.middleware.security.SecurityMiddleware",
+    "whitenoise.middleware.WhiteNoiseMiddleware",
+    "corsheaders.middleware.CorsMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+]
+
+# Debug apps (added only in development)
+DEBUG_APPS: List[str] = [
+    "debug_toolbar",
+]
+
+# Debug middleware (added only in development)
+DEBUG_MIDDLEWARE: List[str] = [
+    "debug_toolbar.middleware.DebugToolbarMiddleware",
+]

django_cfg/core/environment/__init__.py

@@ -0,0 +1,9 @@
+"""
+Environment detection utilities for django_cfg.
+"""
+
+from .detector import EnvironmentDetector
+
+__all__ = [
+    "EnvironmentDetector",
+]

django_cfg/core/exceptions.py

@@ -1,8 +1,7 @@
 """
-Custom exceptions for django_cfg module.
+Django-CFG Core Exceptions
 
-Following CRITICAL_REQUIREMENTS.md - proper exception handling with specific types.
-No exception suppression, all errors must be properly typed and handled.
+Custom exception classes for django-cfg with enhanced error context.
 """
 
 from typing import Optional, Dict, Any, List
@@ -10,333 +9,81 @@ from typing import Optional, Dict, Any, List
 
 class DjangoCfgException(Exception):
     """
-    Base exception for all django_cfg related errors.
-    
-    All django_cfg exceptions inherit from this base class to allow
-    for specific exception handling patterns.
+    Base exception for django-cfg with enhanced error reporting.
+
+    Supports additional context and actionable suggestions.
     """
-    
+
     def __init__(
-        self, 
-        message: str, 
+        self,
+        message: str,
         context: Optional[Dict[str, Any]] = None,
-        suggestions: Optional[List[str]] = None
-    ) -> None:
+        suggestions: Optional[List[str]] = None,
+        environment: Optional[str] = None,
+        **kwargs
+    ):
         """
-        Initialize exception with detailed context.
-        
+        Initialize exception with enhanced context.
+
         Args:
-            message: Human-readable error message
-            context: Additional context information for debugging
-            suggestions: List of suggested fixes or actions
+            message: Primary error message
+            context: Additional context data
+            suggestions: List of actionable suggestions
+            environment: Environment where error occurred
+            **kwargs: Additional metadata
         """
         super().__init__(message)
         self.message = message
         self.context = context or {}
         self.suggestions = suggestions or []
-    
+        self.environment = environment
+        self.metadata = kwargs
+
     def __str__(self) -> str:
-        """Return formatted error message with context."""
+        """Format error message with context."""
         parts = [self.message]
-        
-        if self.context:
-            context_str = ", ".join(f"{k}={v}" for k, v in self.context.items())
-            parts.append(f"Context: {context_str}")
-        
+
         if self.suggestions:
-            suggestions_str = "; ".join(self.suggestions)
-            parts.append(f"Suggestions: {suggestions_str}")
-        
-        return " | ".join(parts)
+            parts.append("\nSuggestions:")
+            for suggestion in self.suggestions:
+                parts.append(f"  - {suggestion}")
+
+        if self.context:
+            parts.append(f"\nContext: {self.context}")
+
+        return "\n".join(parts)
 
 
 class ConfigurationError(DjangoCfgException):
-    """
-    Raised when configuration is invalid or incomplete.
-    
-    This exception is raised when:
-    - Required configuration fields are missing
-    - Configuration values are invalid
-    - Configuration conflicts are detected
-    - Environment-specific configuration issues
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        field_name: Optional[str] = None,
-        field_value: Optional[Any] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize configuration error.
-        
-        Args:
-            message: Error description
-            field_name: Name of the configuration field causing the error
-            field_value: Value that caused the error
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if field_name is not None:
-            context['field_name'] = field_name
-        if field_value is not None:
-            context['field_value'] = field_value
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.field_name = field_name
-        self.field_value = field_value
+    """Raised when configuration is invalid or incomplete."""
+    pass
 
 
 class ValidationError(DjangoCfgException):
-    """
-    Raised when Pydantic model validation fails.
-    
-    This exception is raised when:
-    - Pydantic model validation fails
-    - Type validation errors occur
-    - Field constraint violations
-    - Custom validation logic fails
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        model_name: Optional[str] = None,
-        validation_errors: Optional[List[Dict[str, Any]]] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize validation error.
-        
-        Args:
-            message: Error description
-            model_name: Name of the Pydantic model that failed validation
-            validation_errors: List of Pydantic validation errors
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if model_name is not None:
-            context['model_name'] = model_name
-        if validation_errors is not None:
-            context['validation_errors'] = validation_errors
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.model_name = model_name
-        self.validation_errors = validation_errors or []
+    """Raised when validation fails."""
+    pass
 
 
 class EnvironmentError(DjangoCfgException):
-    """
-    Raised when environment detection or configuration fails.
-    
-    This exception is raised when:
-    - Environment cannot be detected
-    - Environment-specific configuration is missing
-    - Environment configuration conflicts
-    - YAML configuration file issues
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        environment: Optional[str] = None,
-        config_file: Optional[str] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize environment error.
-        
-        Args:
-            message: Error description
-            environment: Environment name that caused the error
-            config_file: Configuration file that caused the error
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if environment is not None:
-            context['environment'] = environment
-        if config_file is not None:
-            context['config_file'] = config_file
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.environment = environment
-        self.config_file = config_file
-
-
-class IntegrationError(DjangoCfgException):
-    """
-    Raised when third-party integration fails.
-    
-    This exception is raised when:
-    - Django REST Framework integration issues
-    - Revolution API zone configuration problems
-    - Unfold dashboard configuration errors
-    - Other third-party package integration failures
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        integration_name: Optional[str] = None,
-        package_name: Optional[str] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize integration error.
-        
-        Args:
-            message: Error description
-            integration_name: Name of the integration that failed
-            package_name: Name of the third-party package
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if integration_name is not None:
-            context['integration_name'] = integration_name
-        if package_name is not None:
-            context['package_name'] = package_name
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.integration_name = integration_name
-        self.package_name = package_name
-
-
-class DatabaseError(DjangoCfgException):
-    """
-    Raised when database configuration or connection issues occur.
-    
-    This exception is raised when:
-    - Database connection configuration is invalid
-    - Database routing rules conflict
-    - Database connection testing fails
-    - Multi-database setup issues
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        database_alias: Optional[str] = None,
-        connection_params: Optional[Dict[str, Any]] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize database error.
-        
-        Args:
-            message: Error description
-            database_alias: Database alias that caused the error
-            connection_params: Database connection parameters
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if database_alias is not None:
-            context['database_alias'] = database_alias
-        if connection_params is not None:
-            context['connection_params'] = connection_params
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.database_alias = database_alias
-        self.connection_params = connection_params
+    """Raised when environment-related errors occur."""
+    pass
 
 
 class CacheError(DjangoCfgException):
-    """
-    Raised when cache configuration or connection issues occur.
-    
-    This exception is raised when:
-    - Cache backend configuration is invalid
-    - Redis connection issues
-    - Cache backend selection problems
-    - Cache key or timeout configuration errors
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        cache_alias: Optional[str] = None,
-        backend_type: Optional[str] = None,
-        **kwargs
-    ) -> None:
-        """
-        Initialize cache error.
-        
-        Args:
-            message: Error description
-            cache_alias: Cache alias that caused the error
-            backend_type: Cache backend type (redis, memory, etc.)
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if cache_alias is not None:
-            context['cache_alias'] = cache_alias
-        if backend_type is not None:
-            context['backend_type'] = backend_type
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.cache_alias = cache_alias
-        self.backend_type = backend_type
+    """Raised when cache configuration or operations fail."""
+    pass
 
 
-class SecurityError(DjangoCfgException):
-    """
-    Raised when security configuration issues occur.
-    
-    This exception is raised when:
-    - Security settings are insufficient for production
-    - CORS configuration conflicts
-    - SSL/TLS configuration problems
-    - Security domain validation failures
-    """
-    
-    def __init__(
-        self,
-        message: str,
-        security_setting: Optional[str] = None,
-        severity: str = "medium",
-        **kwargs
-    ) -> None:
-        """
-        Initialize security error.
-        
-        Args:
-            message: Error description
-            security_setting: Security setting that caused the error
-            severity: Error severity (low, medium, high, critical)
-            **kwargs: Additional context passed to base class
-        """
-        context = kwargs.get('context', {})
-        if security_setting is not None:
-            context['security_setting'] = security_setting
-        context['severity'] = severity
-        
-        kwargs['context'] = context
-        super().__init__(message, **kwargs)
-        
-        self.security_setting = security_setting
-        self.severity = severity
+class DatabaseError(DjangoCfgException):
+    """Raised when database configuration or connection issues occur."""
+    pass
 
 
-# Exception hierarchy for easy catching
 __all__ = [
     "DjangoCfgException",
-    "ConfigurationError", 
+    "ConfigurationError",
     "ValidationError",
     "EnvironmentError",
-    "IntegrationError",
-    "DatabaseError",
     "CacheError",
-    "SecurityError",
+    "DatabaseError",
 ]

django_cfg/core/generation/__init__.py

@@ -0,0 +1,51 @@
+"""
+Django settings generation module.
+
+Provides settings generation from DjangoConfig instances.
+
+Main Components:
+- SettingsGenerator: Main facade for settings generation
+- SettingsOrchestrator: Coordinates specialized generators
+- Specialized generators: Core, Data, Integration, Utility
+
+Architecture:
+    DjangoConfig
+        |
+        v
+    SettingsGenerator (facade)
+        |
+        v
+    SettingsOrchestrator
+        |
+        +-> CoreSettingsGenerator
+        +-> TemplateSettingsGenerator
+        +-> StaticFilesGenerator
+        +-> DatabaseSettingsGenerator
+        +-> CacheSettingsGenerator
+        +-> SecuritySettingsGenerator
+        +-> EmailSettingsGenerator
+        +-> LoggingSettingsGenerator
+        +-> I18nSettingsGenerator
+        +-> LimitsSettingsGenerator
+        +-> SessionSettingsGenerator
+        +-> ThirdPartyIntegrationsGenerator
+        +-> APIFrameworksGenerator
+        +-> TasksSettingsGenerator
+
+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)
+    ```
+"""
+
+from .generation import SettingsGenerator
+from .orchestrator import SettingsOrchestrator
+
+__all__ = [
+    "SettingsGenerator",
+    "SettingsOrchestrator",
+]

django_cfg/core/generation/core_generators/settings.py

@@ -0,0 +1,90 @@
+"""
+Core Django settings generator.
+
+Generates fundamental Django settings like SECRET_KEY, DEBUG, INSTALLED_APPS, etc.
+Size: ~120 lines (focused on core settings)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class CoreSettingsGenerator:
+    """
+    Generates core Django settings.
+
+    Responsibilities:
+    - SECRET_KEY, DEBUG
+    - INSTALLED_APPS (via config.get_installed_apps())
+    - MIDDLEWARE (via config.get_middleware())
+    - ALLOWED_HOSTS (via config.get_allowed_hosts())
+    - ROOT_URLCONF, WSGI_APPLICATION
+    - AUTH_USER_MODEL
+    - BASE_DIR
+    - DEFAULT_AUTO_FIELD
+
+    Example:
+        ```python
+        generator = CoreSettingsGenerator(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 core Django settings.
+
+        Returns:
+            Dictionary with core Django settings
+
+        Example:
+            >>> config = DjangoConfig(project_name="Test", secret_key="x"*50)
+            >>> generator = CoreSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> "SECRET_KEY" in settings
+            True
+        """
+        settings = {
+            "SECRET_KEY": self.config.secret_key,
+            "DEBUG": self.config.debug,
+            "ALLOWED_HOSTS": self.config.get_allowed_hosts(),
+            "INSTALLED_APPS": self.config.get_installed_apps(),
+            "MIDDLEWARE": self.config.get_middleware(),
+        }
+
+        # Add URL configuration
+        if self.config.root_urlconf:
+            settings["ROOT_URLCONF"] = self.config.root_urlconf
+
+        if self.config.wsgi_application:
+            settings["WSGI_APPLICATION"] = self.config.wsgi_application
+
+        # Add custom user model
+        if self.config.auth_user_model:
+            settings["AUTH_USER_MODEL"] = self.config.auth_user_model
+        elif self.config.enable_accounts:
+            # Auto-use django-cfg accounts CustomUser if accounts is enabled
+            settings["AUTH_USER_MODEL"] = "django_cfg_accounts.CustomUser"
+
+        # Add base directory
+        if self.config._base_dir:
+            settings["BASE_DIR"] = self.config._base_dir
+
+        # Add default auto field
+        settings["DEFAULT_AUTO_FIELD"] = "django.db.models.BigAutoField"
+
+        return settings
+
+
+__all__ = ["CoreSettingsGenerator"]

django_cfg/core/generation/core_generators/static.py

@@ -0,0 +1,82 @@
+"""
+Static files settings generator.
+
+Handles STATIC_*, MEDIA_*, and WhiteNoise configuration.
+Size: ~70 lines (focused on static files)
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class StaticFilesGenerator:
+    """
+    Generates static files settings.
+
+    Responsibilities:
+    - STATIC_URL, STATIC_ROOT, STATICFILES_DIRS
+    - MEDIA_URL, MEDIA_ROOT
+    - WhiteNoise configuration
+    - Static files finders
+
+    Example:
+        ```python
+        generator = StaticFilesGenerator(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 static files settings.
+
+        Returns:
+            Dictionary with static files configuration
+
+        Example:
+            >>> generator = StaticFilesGenerator(config)
+            >>> settings = generator.generate()
+            >>> "STATIC_URL" in settings
+            True
+        """
+        settings = {
+            "STATIC_URL": "/static/",
+            "MEDIA_URL": "/media/",
+            # WhiteNoise configuration
+            "STATICFILES_STORAGE": "whitenoise.storage.CompressedManifestStaticFilesStorage",
+            "WHITENOISE_USE_FINDERS": True,
+            "WHITENOISE_AUTOREFRESH": self.config.debug,
+            "WHITENOISE_MAX_AGE": 0 if self.config.debug else 3600,  # No cache in debug, 1 hour in prod
+        }
+
+        # Set paths relative to base directory
+        if self.config._base_dir:
+            settings.update({
+                "STATIC_ROOT": self.config._base_dir / "staticfiles",
+                "MEDIA_ROOT": self.config._base_dir / "media",
+                "STATICFILES_DIRS": [
+                    self.config._base_dir / "static",
+                ],
+            })
+
+        # Static files finders
+        settings["STATICFILES_FINDERS"] = [
+            "django.contrib.staticfiles.finders.FileSystemFinder",
+            "django.contrib.staticfiles.finders.AppDirectoriesFinder",
+        ]
+
+        return settings
+
+
+__all__ = ["StaticFilesGenerator"]