django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/models/environment.py

@@ -0,0 +1,276 @@
+"""
+Environment Configuration Model
+
+Core Django environment settings with Pydantic 2.
+"""
+
+import os
+from pathlib import Path
+from typing import List, Dict, Any
+from pydantic import Field, field_validator, computed_field
+from .base import BaseConfig
+
+
+class EnvironmentConfig(BaseConfig):
+    """
+    🌍 Environment Configuration - Core Django Settings
+
+    Handles all core Django environment settings with smart defaults
+    and automatic environment detection.
+    """
+
+    # Core Django settings
+    debug: bool = Field(
+        default=False, description="Enable Django debug mode (True for development)"
+    )
+
+    secret_key: str = Field(
+        min_length=50,
+        description="Django secret key (minimum 50 characters for security)",
+    )
+
+    allowed_hosts: List[str] = Field(
+        default_factory=list, description="List of allowed hosts for Django"
+    )
+
+    # Environment detection
+    environment: str = Field(
+        default="development",
+        description="Environment name (development/production/staging/testing)",
+    )
+
+    # Path settings
+    base_dir: Path = Field(
+        default_factory=lambda: Path.cwd(), description="Application base directory"
+    )
+
+    # Django User Model
+    auth_user_model: str = Field(
+        default="django.contrib.auth.models.User",
+        description="Django user model to use (e.g., 'accounts.CustomUser')",
+    )
+
+    @field_validator("secret_key")
+    @classmethod
+    def validate_secret_key(cls, v: str) -> str:
+        """Ensure secret key is secure."""
+        if len(v) < 50:
+            raise ValueError(
+                "Secret key must be at least 50 characters long for security"
+            )
+
+        # Check for common insecure values
+        insecure_keys = [
+            "change-me",
+            "your-secret-key-here",
+            "dev-secret-key",
+            "django-insecure-",
+            "your-secret-key-change-this",
+        ]
+
+        for insecure in insecure_keys:
+            if insecure in v.lower():
+                raise ValueError(
+                    f"Please change the secret key from default/example value"
+                )
+
+        return v
+
+    @field_validator("allowed_hosts", mode="before")
+    @classmethod
+    def set_default_allowed_hosts(cls, v, info):
+        """Set smart default allowed hosts based on debug mode."""
+        if not v:  # If empty list or None
+            # Try to get debug from field being validated
+            debug = info.data.get("debug", False)
+
+            if debug:
+                return ["localhost", "127.0.0.1", "0.0.0.0", "*"]
+            else:
+                return []
+        return v
+
+    @field_validator("environment")
+    @classmethod
+    def validate_environment(cls, v: str) -> str:
+        """Validate environment name."""
+        allowed = ["development", "production", "testing", "staging"]
+        if v not in allowed:
+            raise ValueError(f"Environment must be one of: {allowed}")
+        return v
+
+    # Computed properties for easy access
+    @computed_field
+    @property
+    def is_production(self) -> bool:
+        """True if running in production environment."""
+        return self.environment == "production" or not self.debug
+
+    @computed_field
+    @property
+    def is_development(self) -> bool:
+        """True if running in development environment."""
+        return self.environment == "development" or self.debug
+
+    @computed_field
+    @property
+    def is_testing(self) -> bool:
+        """True if running in testing environment."""
+        return self.environment == "testing"
+
+    @computed_field
+    @property
+    def is_staging(self) -> bool:
+        """True if running in staging environment."""
+        return self.environment == "staging"
+
+    @computed_field
+    @property
+    def is_docker(self) -> bool:
+        """True if running in Docker container."""
+        return os.path.exists("/.dockerenv")
+
+    # Computed paths
+    @computed_field
+    @property
+    def static_dir(self) -> Path:
+        """Static files directory."""
+        return self.base_dir / "static"
+
+    @computed_field
+    @property
+    def media_dir(self) -> Path:
+        """Media files directory."""
+        return self.base_dir / "media"
+
+    @computed_field
+    @property
+    def templates_dir(self) -> Path:
+        """Templates directory."""
+        return self.base_dir / "templates"
+
+    @computed_field
+    @property
+    def logs_dir(self) -> Path:
+        """Logs directory."""
+        return self.base_dir / "logs"
+
+    def _validate_production(self) -> bool:
+        """Validate production-specific requirements."""
+        errors = []
+
+        # Check secret key security
+        if len(self.secret_key) < 50:
+            errors.append("Secret key must be at least 50 characters in production")
+
+        # Check debug is disabled
+        if self.debug:
+            errors.append("Debug mode must be disabled in production")
+
+        # Check allowed hosts
+        if "*" in self.allowed_hosts:
+            errors.append("Wildcard '*' in ALLOWED_HOSTS is not secure for production")
+
+        if errors:
+            print("❌ Production validation errors:")
+            for error in errors:
+                print(f"   - {error}")
+            return False
+
+        return True
+
+    def to_django_settings(self) -> Dict[str, Any]:
+        """Convert to Django settings with smart defaults."""
+        return {
+            # Core Django settings
+            "DEBUG": self.debug,
+            "SECRET_KEY": self.secret_key,
+            "ALLOWED_HOSTS": self.allowed_hosts,
+            # Paths
+            "BASE_DIR": self.base_dir,
+            # URL and WSGI/ASGI configuration
+            "ROOT_URLCONF": "api.urls",
+            "WSGI_APPLICATION": "api.wsgi.application",
+            "ASGI_APPLICATION": "api.asgi.application",
+            # Static files configuration
+            "STATIC_URL": "/static/",
+            "STATIC_ROOT": self.static_dir,
+            "STATICFILES_STORAGE": "whitenoise.storage.CompressedManifestStaticFilesStorage",
+            "WHITENOISE_USE_FINDERS": True,
+            "WHITENOISE_AUTOREFRESH": self.debug,
+            "WHITENOISE_MAX_AGE": 31536000,  # 1 year
+            # Media files configuration
+            "MEDIA_URL": "/media/",
+            "MEDIA_ROOT": self.media_dir,
+            # Basic Django apps (can be extended by other configs)
+            "INSTALLED_APPS": [
+                "django.contrib.admin",
+                "django.contrib.auth",
+                "django.contrib.contenttypes",
+                "django.contrib.sessions",
+                "django.contrib.messages",
+                "django.contrib.staticfiles",
+                "django.contrib.humanize",
+                "django.contrib.sites",
+                "django.contrib.sitemaps",
+            ],
+            # User model
+            "AUTH_USER_MODEL": self.auth_user_model,
+            # Basic middleware (can be extended by other configs)
+            "MIDDLEWARE": [
+                "django.middleware.security.SecurityMiddleware",
+                "whitenoise.middleware.WhiteNoiseMiddleware",
+                "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",
+            ],
+            # Templates configuration
+            "TEMPLATES": [
+                {
+                    "BACKEND": "django.template.backends.django.DjangoTemplates",
+                    "DIRS": [self.templates_dir],
+                    "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",
+                        ],
+                    },
+                },
+            ],
+            # Auth configuration
+            "AUTH_PASSWORD_VALIDATORS": (
+                []
+                if self.debug
+                else [
+                    {
+                        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+                    },
+                    {
+                        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+                        "OPTIONS": {"min_length": 8},
+                    },
+                    {
+                        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
+                    },
+                    {
+                        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
+                    },
+                ]
+            ),
+            # Internationalization
+            "LANGUAGE_CODE": "en-us",
+            "TIME_ZONE": "UTC",
+            "USE_I18N": True,
+            "USE_L10N": True,
+            "USE_TZ": True,
+            # Miscellaneous
+            "DEFAULT_AUTO_FIELD": "django.db.models.BigAutoField",
+            "DATA_UPLOAD_MAX_NUMBER_FIELDS": 10000,
+            "SITE_ID": 1,
+        }

django_cfg/models/limits.py

@@ -10,7 +10,7 @@ Following CRITICAL_REQUIREMENTS.md:
 
 from typing import Optional, Dict, Any, List
 from pydantic import BaseModel, Field, field_validator, model_validator
-from django_cfg.exceptions import ConfigurationError
+from django_cfg.core.exceptions import ConfigurationError
 
 
 class LimitsConfig(BaseModel):

django_cfg/models/logging.py

@@ -0,0 +1,366 @@
+"""
+Logging Configuration Model
+
+Django logging settings with Pydantic 2.
+"""
+
+from typing import Dict, Any, List, Optional
+from pathlib import Path
+from pydantic import Field, field_validator
+from .base import BaseConfig
+
+
+class LoggerConfig(BaseConfig):
+    """Configuration for a single logger."""
+    
+    name: str = Field(
+        description="Logger name"
+    )
+    
+    level: str = Field(
+        default="INFO",
+        description="Log level"
+    )
+    
+    handlers: List[str] = Field(
+        default_factory=list,
+        description="Handler names for this logger"
+    )
+    
+    propagate: bool = Field(
+        default=True,
+        description="Whether to propagate to parent loggers"
+    )
+    
+    @field_validator('level')
+    @classmethod
+    def validate_level(cls, v: str) -> str:
+        """Validate log level."""
+        valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+        if v.upper() not in valid_levels:
+            raise ValueError(f"Log level must be one of: {valid_levels}")
+        return v.upper()
+
+
+class HandlerConfig(BaseConfig):
+    """Configuration for a log handler."""
+    
+    name: str = Field(
+        description="Handler name"
+    )
+    
+    class_name: str = Field(
+        description="Handler class"
+    )
+    
+    level: str = Field(
+        default="INFO", 
+        description="Handler log level"
+    )
+    
+    formatter: str = Field(
+        default="verbose",
+        description="Formatter name"
+    )
+    
+    filename: Optional[str] = Field(
+        default=None,
+        description="Log file path (for file handlers)"
+    )
+    
+    max_bytes: int = Field(
+        default=10485760,  # 10MB
+        description="Max bytes for rotating file handler"
+    )
+    
+    backup_count: int = Field(
+        default=5,
+        description="Backup count for rotating file handler"
+    )
+    
+    @field_validator('level')
+    @classmethod
+    def validate_level(cls, v: str) -> str:
+        """Validate log level."""
+        valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+        if v.upper() not in valid_levels:
+            raise ValueError(f"Log level must be one of: {valid_levels}")
+        return v.upper()
+
+
+class FormatterConfig(BaseConfig):
+    """Configuration for a log formatter."""
+    
+    name: str = Field(
+        description="Formatter name"
+    )
+    
+    format_string: str = Field(
+        description="Log format string"
+    )
+    
+    date_format: Optional[str] = Field(
+        default=None,
+        description="Date format string"
+    )
+
+
+class LoggingConfig(BaseConfig):
+    """
+    📝 Logging Configuration - Structured Logging
+    
+    Complete logging configuration with formatters, handlers,
+    and loggers for Django applications.
+    """
+    
+    # Global settings
+    version: int = Field(
+        default=1,
+        description="Logging config version"
+    )
+    
+    disable_existing_loggers: bool = Field(
+        default=False,
+        description="Disable existing loggers"
+    )
+    
+    # Log level settings
+    root_level: str = Field(
+        default="INFO",
+        description="Root logger level"
+    )
+    
+    django_level: str = Field(
+        default="INFO",
+        description="Django logger level"
+    )
+    
+    # File settings
+    log_dir: Optional[str] = Field(
+        default=None,
+        description="Directory for log files"
+    )
+    
+    # Console settings
+    console_enabled: bool = Field(
+        default=True,
+        description="Enable console logging"
+    )
+    
+    # File logging settings
+    file_enabled: bool = Field(
+        default=True,
+        description="Enable file logging"
+    )
+    
+    # Rotating file settings
+    rotating_enabled: bool = Field(
+        default=True,
+        description="Enable rotating file logging"
+    )
+    
+    max_file_size: int = Field(
+        default=10485760,  # 10MB
+        description="Maximum log file size in bytes"
+    )
+    
+    backup_count: int = Field(
+        default=5,
+        description="Number of backup log files to keep"
+    )
+    
+    # Custom loggers, handlers, formatters
+    custom_loggers: List[LoggerConfig] = Field(
+        default_factory=list,
+        description="Custom logger configurations"
+    )
+    
+    custom_handlers: List[HandlerConfig] = Field(
+        default_factory=list,
+        description="Custom handler configurations"
+    )
+    
+    custom_formatters: List[FormatterConfig] = Field(
+        default_factory=list,
+        description="Custom formatter configurations"
+    )
+    
+    @field_validator('root_level', 'django_level')
+    @classmethod
+    def validate_levels(cls, v: str) -> str:
+        """Validate log levels."""
+        valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+        if v.upper() not in valid_levels:
+            raise ValueError(f"Log level must be one of: {valid_levels}")
+        return v.upper()
+    
+    def get_log_directory(self) -> Path:
+        """Get log directory path."""
+        if self.log_dir:
+            return Path(self.log_dir)
+        
+        # Default to logs/ in current directory
+        return Path.cwd() / "logs"
+    
+    def get_default_formatters(self) -> Dict[str, Any]:
+        """Get default log formatters."""
+        formatters = {
+            'verbose': {
+                'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
+                'style': '{',
+                'datefmt': '%Y-%m-%d %H:%M:%S',
+            },
+            'simple': {
+                'format': '{levelname} {message}',
+                'style': '{',
+            },
+            'django.server': {
+                'format': '{asctime} {message}',
+                'style': '{',
+                'datefmt': '%Y-%m-%d %H:%M:%S',
+            },
+        }
+        
+        # Add custom formatters
+        for formatter in self.custom_formatters:
+            formatters[formatter.name] = {
+                'format': formatter.format_string,
+                'style': '{',
+            }
+            if formatter.date_format:
+                formatters[formatter.name]['datefmt'] = formatter.date_format
+        
+        return formatters
+    
+    def get_default_handlers(self) -> Dict[str, Any]:
+        """Get default log handlers."""
+        handlers = {}
+        
+        # Console handler
+        if self.console_enabled:
+            handlers['console'] = {
+                'level': 'INFO',
+                'class': 'logging.StreamHandler',
+                'formatter': 'simple',
+            }
+        
+        # File handler
+        if self.file_enabled:
+            log_dir = self.get_log_directory()
+            log_dir.mkdir(exist_ok=True)
+            
+            handlers['file'] = {
+                'level': 'INFO',
+                'class': 'logging.FileHandler',
+                'filename': str(log_dir / 'django.log'),
+                'formatter': 'verbose',
+            }
+        
+        # Rotating file handler
+        if self.rotating_enabled:
+            log_dir = self.get_log_directory()
+            log_dir.mkdir(exist_ok=True)
+            
+            handlers['rotating_file'] = {
+                'level': 'INFO',
+                'class': 'logging.handlers.RotatingFileHandler',
+                'filename': str(log_dir / 'django_rotating.log'),
+                'maxBytes': self.max_file_size,
+                'backupCount': self.backup_count,
+                'formatter': 'verbose',
+            }
+        
+        # Error file handler
+        if self.file_enabled:
+            log_dir = self.get_log_directory()
+            log_dir.mkdir(exist_ok=True)
+            
+            handlers['error_file'] = {
+                'level': 'ERROR',
+                'class': 'logging.FileHandler',
+                'filename': str(log_dir / 'django_errors.log'),
+                'formatter': 'verbose',
+            }
+        
+        # Add custom handlers
+        for handler in self.custom_handlers:
+            handler_config = {
+                'level': handler.level,
+                'class': handler.class_name,
+                'formatter': handler.formatter,
+            }
+            
+            if handler.filename:
+                handler_config['filename'] = handler.filename
+            
+            if 'RotatingFileHandler' in handler.class_name:
+                handler_config['maxBytes'] = handler.max_bytes
+                handler_config['backupCount'] = handler.backup_count
+            
+            handlers[handler.name] = handler_config
+        
+        return handlers
+    
+    def get_default_loggers(self) -> Dict[str, Any]:
+        """Get default logger configurations."""
+        # Determine available handlers
+        available_handlers = []
+        if self.console_enabled:
+            available_handlers.append('console')
+        if self.file_enabled:
+            available_handlers.extend(['file', 'error_file'])
+        if self.rotating_enabled:
+            available_handlers.append('rotating_file')
+        
+        loggers = {
+            'django': {
+                'handlers': available_handlers,
+                'level': self.django_level,
+                'propagate': False,
+            },
+            'django.request': {
+                'handlers': available_handlers,
+                'level': 'ERROR',
+                'propagate': False,
+            },
+            'django.server': {
+                'handlers': ['console'] if self.console_enabled else [],
+                'level': 'INFO',
+                'propagate': False,
+            },
+        }
+        
+        # Add custom loggers
+        for logger in self.custom_loggers:
+            loggers[logger.name] = {
+                'handlers': logger.handlers,
+                'level': logger.level,
+                'propagate': logger.propagate,
+            }
+        
+        return loggers
+    
+    def to_django_settings(self) -> Dict[str, Any]:
+        """Convert to Django LOGGING setting."""
+        # Determine root handlers
+        root_handlers = []
+        if self.console_enabled:
+            root_handlers.append('console')
+        if self.file_enabled:
+            root_handlers.append('file')
+        
+        logging_config = {
+            'version': self.version,
+            'disable_existing_loggers': self.disable_existing_loggers,
+            'formatters': self.get_default_formatters(),
+            'handlers': self.get_default_handlers(),
+            'root': {
+                'level': self.root_level,
+                'handlers': root_handlers,
+            },
+            'loggers': self.get_default_loggers(),
+        }
+        
+        return {
+            'LOGGING': logging_config
+        }