django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/core/base/config_model.py

@@ -6,8 +6,6 @@ This module contains ONLY the data model definition:
 - Field validators
 - Simple properties
 - NO business logic (moved to builders and services)
-
-Total size: ~350 lines (down from 903 in original config.py)
 """
 
 from pathlib import Path
@@ -15,21 +13,28 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field, PrivateAttr, field_validator, model_validator
 
-from ...apps.ipc import DjangoCfgRPCConfig
+from django_cfg.apps.integrations.centrifugo.services.client.config import DjangoCfgCentrifugoConfig
 from ...models import (
     ApiKeys,
+    AxesConfig,
     CacheConfig,
+    CryptoFieldsConfig,
+    CurrencyConfig,
     DatabaseConfig,
+    DjangoRQConfig,
     DRFConfig,
     EmailConfig,
+    GitHubOAuthConfig,
     LimitsConfig,
     SpectacularConfig,
     TelegramConfig,
+    TwoFactorConfig,
     UnfoldConfig,
 )
+from ...models.api.grpc import GRPCConfig
+from ...models.api.webpush import WebPushConfig
 from ...models.ngrok import NgrokConfig
-from ...models.payments import PaymentsConfig
-from ...models.tasks import TaskConfig
+from ...modules.nextjs_admin import NextJsAdminConfig
 from ..exceptions import ConfigurationError
 from ..types.enums import EnvironmentMode, StartupInfoMode
 
@@ -75,13 +80,10 @@ class DjangoConfig(BaseModel):
         "str_strip_whitespace": True,
     }
 
-    # === Environment Configuration ===
-    env_mode: EnvironmentMode = Field(
-        default=EnvironmentMode.PRODUCTION,
-        description="Environment mode: development, production, or test",
-    )
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                         PROJECT INFORMATION                               ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
 
-    # === Project Information ===
     project_name: str = Field(
         ...,
         description="Human-readable project name",
@@ -89,14 +91,9 @@ class DjangoConfig(BaseModel):
         max_length=100,
     )
 
-    project_logo: str = Field(
-        default="",
-        description="Project logo URL",
-    )
-
     project_version: str = Field(
         default="1.0.0",
-        description="Project version",
+        description="Project version (semver format)",
         pattern=r"^\d+\.\d+\.\d+.*$",
     )
 
@@ -106,54 +103,91 @@ class DjangoConfig(BaseModel):
         max_length=500,
     )
 
-    # === Django CFG Features ===
-    startup_info_mode: StartupInfoMode = Field(
-        default=StartupInfoMode.FULL,
-        description="Startup information display mode: none (minimal), short (essential), full (complete)",
+    project_logo: str = Field(
+        default="",
+        description="Project logo URL",
     )
 
-    enable_support: bool = Field(
-        default=True,
-        description="Enable django-cfg Support application (tickets, messages, chat interface)",
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                         ENVIRONMENT & DEBUG                               ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    env_mode: EnvironmentMode = Field(
+        default=EnvironmentMode.PRODUCTION,
+        description="Environment mode: development, production, or test",
     )
 
-    enable_accounts: bool = Field(
+    debug: bool = Field(
         default=False,
-        description="Enable django-cfg Accounts application (advanced user management, OTP, profiles, activity tracking)",
+        description="Django DEBUG setting",
     )
 
-    enable_newsletter: bool = Field(
+    debug_warnings: bool = Field(
         default=False,
-        description="Enable django-cfg Newsletter application (email campaigns, subscriptions, bulk emails)",
+        description="Enable detailed warnings traceback for debugging",
     )
 
-    enable_leads: bool = Field(
-        default=False,
-        description="Enable django-cfg Leads application (lead collection, contact forms, CRM integration)",
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                              SECURITY                                     ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    secret_key: str = Field(
+        ...,
+        description="Django SECRET_KEY (min 50 chars)",
+        min_length=50,
+        repr=False,  # Don't show in repr for security
     )
 
-    enable_knowbase: bool = Field(
-        default=False,
-        description="Enable django-cfg Knowledge Base application (documents, AI chat, embeddings, search)",
+    security_domains: List[str] = Field(
+        default_factory=lambda: ["localhost", "127.0.0.1"],
+        description="Domains for ALLOWED_HOSTS, CORS, CSRF (auto-configured)",
     )
 
-    enable_agents: bool = Field(
-        default=False,
-        description="Enable django-cfg AI Agents application (agent definitions, executions, workflows, tools)",
+    ssl_redirect: Optional[bool] = Field(
+        default=None,
+        description="Force SSL redirect. None = disabled (proxy handles SSL)",
     )
 
-    enable_maintenance: bool = Field(
-        default=False,
-        description="Enable django-cfg Maintenance application (multi-site maintenance mode with Cloudflare)",
+    cors_allow_headers: List[str] = Field(
+        default_factory=lambda: [
+            "accept",
+            "accept-encoding",
+            "authorization",
+            "content-type",
+            "dnt",
+            "origin",
+            "user-agent",
+            "x-csrftoken",
+            "x-requested-with",
+            "x-api-key",
+            "x-api-token",
+
+            # File transfer / chunked upload headers
+            # For the django_client module, the typescript generator will add the following headers to the request.
+            # These headers are used to track the progress of the file upload.
+            "x-chunk-index",
+            "x-chunk-checksum",
+            "x-is-last",
+            "x-total-chunks",
+
+        ],
+        description="CORS allowed headers",
+    )
+
+    axes: Optional[AxesConfig] = Field(
+        default=None,
+        description="Django-Axes brute-force protection (None = smart defaults)",
     )
 
-    # === Payment System Configuration ===
-    payments: Optional[PaymentsConfig] = Field(
+    crypto_fields: Optional[CryptoFieldsConfig] = Field(
         default=None,
-        description="Universal payment system configuration (providers, subscriptions, API keys, billing)",
+        description="Django Crypto Fields encryption for sensitive data",
     )
 
-    # === URLs ===
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                               URLS                                        ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
     site_url: str = Field(
         default="http://localhost:3000",
         description="Frontend site URL",
@@ -164,192 +198,239 @@ class DjangoConfig(BaseModel):
         description="Backend API URL",
     )
 
-    ticket_url: str = Field(
-        default="{site_url}/support/ticket/{uuid}",
-        description="Support ticket URL template. Use {site_url} and {uuid} placeholders",
+    media_url: str = Field(
+        default="/media/",
+        description="Media URL. Use '__auto__' to derive from api_url",
+    )
+
+    root_urlconf: Optional[str] = Field(
+        default=None,
+        description="Django ROOT_URLCONF (e.g., 'api.urls')",
     )
 
-    otp_url: str = Field(
-        default="{site_url}/auth/otp/{code}",
-        description="OTP verification URL template. Use {site_url} and {code} placeholders",
+    wsgi_application: Optional[str] = Field(
+        default=None,
+        description="Django WSGI_APPLICATION (e.g., 'api.wsgi.application')",
     )
 
-    # === Core Django Settings ===
-    secret_key: str = Field(
-        ...,
-        description="Django SECRET_KEY",
-        min_length=50,
-        repr=False,  # Don't show in repr for security
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                             DATABASE                                      ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    databases: Dict[str, DatabaseConfig] = Field(
+        default_factory=dict,
+        description="Database connections. 'default' is required",
     )
 
-    debug: bool = Field(
+    enable_pool_cleanup: bool = Field(
         default=False,
-        description="Django DEBUG setting",
+        description="Enable explicit connection pool cleanup middleware",
     )
 
-    # === URL Configuration ===
-    root_urlconf: Optional[str] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                               CACHE                                       ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    redis_url: Optional[str] = Field(
         default=None,
-        description="Django ROOT_URLCONF setting",
+        description="Redis URL (redis://host:port/db). Auto-creates cache backend",
     )
 
-    wsgi_application: Optional[str] = Field(
+    cache_default: Optional[CacheConfig] = Field(
         default=None,
-        description="Django WSGI_APPLICATION setting",
+        description="Default cache backend (auto-created from redis_url if not set)",
     )
 
-    # === Custom User Model ===
-    auth_user_model: Optional[str] = Field(
+    cache_sessions: Optional[CacheConfig] = Field(
         default=None,
-        description="Custom user model (AUTH_USER_MODEL). If None and enable_accounts=True, uses 'django_cfg.apps.accounts.CustomUser'",
-        pattern=r"^[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*$",
+        description="Sessions cache backend",
     )
 
-    # === Project Applications ===
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                            APPLICATIONS                                   ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
     project_apps: List[str] = Field(
         default_factory=list,
-        description="List of project-specific Django apps",
+        description="Project-specific Django apps",
     )
 
-    # === Database Configuration ===
-    databases: Dict[str, DatabaseConfig] = Field(
-        default_factory=dict,
-        description="Database connections",
+    custom_middleware: List[str] = Field(
+        default_factory=list,
+        description="Custom middleware classes",
     )
 
-    # === Cache Configuration ===
-    cache_default: Optional[CacheConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                             SERVICES                                      ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    email: Optional[EmailConfig] = Field(
         default=None,
-        description="Default cache backend",
+        description="Email service (SMTP/console backend)",
     )
 
-    cache_sessions: Optional[CacheConfig] = Field(
+    telegram: Optional[TelegramConfig] = Field(
         default=None,
-        description="Sessions cache backend",
+        description="Telegram bot notifications",
     )
 
-    # === Security Configuration ===
-    security_domains: List[str] = Field(
+    admin_emails: List[str] = Field(
         default_factory=list,
-        description="Domains for automatic security configuration (CORS, SSL, etc.)",
+        description="Admin email addresses for notifications (email + telegram)",
     )
 
-    ssl_redirect: Optional[bool] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                        AUTHENTICATION & OAUTH                             ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    github_oauth: Optional[GitHubOAuthConfig] = Field(
         default=None,
-        description=(
-            "Force SSL redirect (SECURE_SSL_REDIRECT). "
-            "None (default) = disabled (assumes reverse proxy handles SSL termination). "
-            "Set to True only if Django handles SSL directly (rare: bare metal without proxy)."
-        ),
+        description="GitHub OAuth for social authentication",
     )
 
-    # === CORS Configuration ===
-    cors_allow_headers: List[str] = Field(
-        default_factory=lambda: [
-            "accept",
-            "accept-encoding",
-            "authorization",
-            "content-type",
-            "dnt",
-            "origin",
-            "user-agent",
-            "x-csrftoken",
-            "x-requested-with",
-            "x-api-key",
-            "x-api-token",
-        ],
-        description="CORS allowed headers with common defaults for API usage",
+    two_factor: Optional[TwoFactorConfig] = Field(
+        default=None,
+        description="Two-Factor Authentication (TOTP) configuration",
     )
 
-    # === Services Configuration ===
-    email: Optional[EmailConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                          ADMIN INTERFACE                                  ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    unfold: Optional[UnfoldConfig] = Field(
         default=None,
-        description="Email service configuration",
+        description="Unfold admin interface configuration",
     )
 
-    telegram: Optional[TelegramConfig] = Field(
+    admin_timezone: Optional[str] = Field(
         default=None,
-        description="Telegram service configuration",
+        description="Admin timezone (e.g., 'Asia/Seoul'). None = auto-detect",
     )
 
-    ngrok: Optional[NgrokConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                               API                                         ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    drf: Optional[DRFConfig] = Field(
         default=None,
-        description="Ngrok tunneling service configuration (for development/webhooks)",
+        description="Django REST Framework configuration",
     )
 
-    # === Admin Interface Configuration ===
-    unfold: Optional[UnfoldConfig] = Field(
+    spectacular: Optional[SpectacularConfig] = Field(
         default=None,
-        description="Unfold admin interface configuration",
+        description="DRF Spectacular OpenAPI configuration",
     )
 
-    # === Frontend Configuration (Tailwind CSS) ===
-    tailwind_app_name: str = Field(
-        default="theme",
-        description="Name of the Tailwind theme app (django-tailwind integration)",
-        min_length=1,
-        max_length=50,
+    grpc: Optional[GRPCConfig] = Field(
+        default=None,
+        description="gRPC server configuration",
     )
 
-    tailwind_version: int = Field(
-        default=4,
-        description="Tailwind CSS version (3 or 4)",
-        ge=3,
-        le=4,
+    webpush: Optional["WebPushConfig"] = Field(
+        default=None,
+        description="Web Push notifications (VAPID protocol)",
     )
 
-    enable_drf_tailwind: bool = Field(
-        default=True,
-        description="Enable modern Tailwind CSS theme for Django REST Framework Browsable API",
+    api_keys: Optional[ApiKeys] = Field(
+        default=None,
+        description="External API keys (OpenAI, OpenRouter, etc.)",
     )
 
-    # === Background Task Processing ===
-    tasks: Optional[TaskConfig] = Field(
+    limits: Optional[LimitsConfig] = Field(
         default=None,
-        description="Background task processing configuration (Dramatiq)",
+        description="Application limits (file uploads, requests, etc.)",
     )
 
-    # === RPC Client Configuration ===
-    django_ipc: Optional[DjangoCfgRPCConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                          BACKGROUND TASKS                                 ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    django_rq: Optional[DjangoRQConfig] = Field(
         default=None,
-        description="Django-CFG RPC Client configuration (WebSocket RPC communication)",
+        description="Django-RQ task queue and scheduler",
     )
 
-    # === API Configuration ===
-    drf: Optional[DRFConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                          CURRENCY & MONEY                                 ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    currency: Optional[CurrencyConfig] = Field(
         default=None,
-        description="Extended Django REST Framework configuration (supplements OpenAPI Client)",
+        description="Currency conversion and exchange rates",
     )
 
-    spectacular: Optional[SpectacularConfig] = Field(
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                           INTEGRATIONS                                    ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    centrifugo: Optional[DjangoCfgCentrifugoConfig] = Field(
         default=None,
-        description="Extended DRF Spectacular configuration (supplements OpenAPI Client)",
+        description="Centrifugo WebSocket pub/sub",
     )
 
-    # === Limits Configuration ===
-    limits: Optional[LimitsConfig] = Field(
+    ngrok: Optional[NgrokConfig] = Field(
         default=None,
-        description="Application limits configuration (file uploads, requests, etc.)",
+        description="Ngrok tunneling for development/webhooks",
     )
 
-    # === API Keys Configuration ===
-    api_keys: Optional[ApiKeys] = Field(
+    nextjs_admin: Optional[NextJsAdminConfig] = Field(
         default=None,
-        description="API keys for external services (OpenAI, OpenRouter, etc.)",
+        description="Next.js admin panel integration",
     )
 
-    # === Middleware Configuration ===
-    custom_middleware: List[str] = Field(
-        default_factory=list,
-        description="Custom middleware classes (standard middleware added automatically)",
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                          FRONTEND / UI                                    ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    enable_frontend: bool = Field(
+        default=True,
+        description="Enable Next.js admin panel static serving",
+    )
+
+    tailwind_app_name: str = Field(
+        default="theme",
+        description="Tailwind theme app name",
+        min_length=1,
+        max_length=50,
+    )
+
+    tailwind_version: int = Field(
+        default=4,
+        description="Tailwind CSS version (3 or 4)",
+        ge=3,
+        le=4,
+    )
+
+    enable_drf_tailwind: bool = Field(
+        default=True,
+        description="Enable Tailwind CSS theme for DRF Browsable API",
+    )
+
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                         DJANGO-CFG SETTINGS                               ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
+    startup_info_mode: StartupInfoMode = Field(
+        default=StartupInfoMode.FULL,
+        description="Startup info: NONE, SHORT, or FULL",
     )
 
-    # === Internal State (Private) ===
+    show_ai_hints: bool = Field(
+        default=True,
+        description="Show AI development hints in startup output",
+    )
+
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                          INTERNAL STATE                                   ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
+
     _base_dir: Optional[Path] = PrivateAttr(default=None)
     _django_settings: Optional[Dict[str, Any]] = PrivateAttr(default=None)
-    _service: Optional[Any] = PrivateAttr(default=None)  # ConfigService instance
+    _service: Optional[Any] = PrivateAttr(default=None)
 
-    # === Field Validators ===
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                            VALIDATORS                                     ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
 
     @field_validator("project_name")
     @classmethod
@@ -369,7 +450,7 @@ class DjangoConfig(BaseModel):
         if len(v) < 50:
             raise ValueError("SECRET_KEY must be at least 50 characters long")
 
-        # Check for common insecure patterns (warning only, not error)
+        # Check for common insecure patterns (warning only)
         insecure_patterns = [
             "django-insecure",
             "change-me",
@@ -381,8 +462,7 @@ class DjangoConfig(BaseModel):
         v_lower = v.lower()
         for pattern in insecure_patterns:
             if pattern in v_lower:
-                # This is a warning, not an error - allow for development
-                break
+                break  # Warning only, allow for development
 
         return v
 
@@ -394,7 +474,6 @@ class DjangoConfig(BaseModel):
             if not app:
                 raise ValueError("Empty app name in project_apps")
 
-            # Basic app name validation
             if not app.replace(".", "").replace("_", "").isalnum():
                 raise ValueError(
                     f"Invalid app name '{app}': must contain only letters, "
@@ -403,9 +482,28 @@ class DjangoConfig(BaseModel):
 
         return v
 
+    @field_validator("media_url", mode="before")
+    @classmethod
+    def validate_media_url(cls, v: str, info) -> str:
+        """Validate and transform media_url."""
+        if v == "__auto__":
+            api_url = info.data.get("api_url", "http://localhost:8000")
+            return f"{api_url.rstrip('/')}/media/"
+
+        if v and not v.endswith("/"):
+            return f"{v}/"
+
+        return v
+
     @model_validator(mode="after")
     def validate_configuration_consistency(self) -> "DjangoConfig":
         """Validate overall configuration consistency."""
+        # In development mode, force media_url to use api_url
+        if self.is_development:
+            dev_media_url = f"{self.api_url.rstrip('/')}/media/"
+            if self.media_url != dev_media_url:
+                object.__setattr__(self, 'media_url', dev_media_url)
+
         # Ensure at least one database is configured
         if not self.databases:
             raise ConfigurationError(
@@ -423,7 +521,7 @@ class DjangoConfig(BaseModel):
 
         # Validate database routing consistency
         referenced_databases = set()
-        for alias, db_config in self.databases.items():
+        for _alias, db_config in self.databases.items():
             if db_config.migrate_to:
                 referenced_databases.add(db_config.migrate_to)
 
@@ -437,24 +535,53 @@ class DjangoConfig(BaseModel):
 
         return self
 
-    def model_post_init(self, __context: Any) -> None:
+    @model_validator(mode="after")
+    def enforce_production_security(self) -> "DjangoConfig":
         """
-        Initialize configuration after Pydantic validation.
+        Enforce security best practices in production mode.
 
-        Auto-detects environment from DJANGO_ENV, ENVIRONMENT, or ENV variables
-        if env_mode was not explicitly set.
+        SECURITY: Production mode ALWAYS disables debug, regardless of configuration.
+        This prevents:
+        - Sensitive data exposure in tracebacks (SECRET_KEY, credentials, paths)
+        - Memory leaks from SQL query logging
+        - Performance degradation
+        - Accidental deployment with debug enabled
+
+        If debug logging is needed in production, use proper logging configuration
+        instead of DEBUG=True.
         """
+        if self.is_production and self.debug:
+            import warnings
+            warnings.warn(
+                "⚠️  SECURITY: DEBUG=True is not allowed in production!\n"
+                f"   Environment: {self.env_mode}\n"
+                "   Forcing DEBUG=False to prevent:\n"
+                "   - Sensitive data exposure in error pages\n"
+                "   - Memory leaks from query logging\n"
+                "   - Performance issues\n"
+                "\n"
+                "   For production debugging, use:\n"
+                "   - LOGGING config for detailed logs\n"
+                "   - Sentry/error tracking services\n"
+                "   - Django Debug Toolbar in staging (not production)",
+                UserWarning,
+                stacklevel=2
+            )
+            # Forcefully disable debug in production
+            object.__setattr__(self, 'debug', False)
+
+        return self
+
+    def model_post_init(self, _context: Any) -> None:
+        """Initialize configuration after Pydantic validation."""
         import os
 
-        # Only auto-detect if using default value (PRODUCTION)
-        # This allows explicit setting to override auto-detection
+        # Auto-detect environment from env variables
         if self.env_mode == EnvironmentMode.PRODUCTION:
-            # Check if any env variable was explicitly set
             env_vars = ['DJANGO_ENV', 'ENVIRONMENT', 'ENV']
             for env_var in env_vars:
                 env_value = os.environ.get(env_var)
                 if env_value:
-                    # Try to map to EnvironmentMode
                     env_normalized = env_value.lower().strip()
                     if env_normalized in ('dev', 'devel', 'develop', 'development', 'local'):
                         object.__setattr__(self, 'env_mode', EnvironmentMode.DEVELOPMENT)
@@ -466,7 +593,9 @@ class DjangoConfig(BaseModel):
                         object.__setattr__(self, 'env_mode', EnvironmentMode.TEST)
                         break
 
-    # === Simple Properties (NO business logic!) ===
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                            PROPERTIES                                     ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
 
     @property
     def is_development(self) -> bool:
@@ -485,32 +614,24 @@ class DjangoConfig(BaseModel):
 
     @property
     def base_dir(self) -> Path:
-        """
-        Get the base directory of the project.
-
-        Looks for manage.py starting from current working directory and going up.
-        Falls back to current working directory if not found.
-        
-        This ensures we find the Django project root, not the django-cfg package location.
-        """
+        """Get the base directory of the project."""
         if self._base_dir is None:
-            # Start from current working directory (where Django runs)
             current_path = Path.cwd().resolve()
 
-            # Look for manage.py in current directory and parents
             for path in [current_path] + list(current_path.parents):
                 manage_py = path / "manage.py"
                 if manage_py.exists() and manage_py.is_file():
                     self._base_dir = path
                     break
 
-            # If still not found, use current working directory
             if self._base_dir is None:
                 self._base_dir = current_path
 
         return self._base_dir
 
-    # === Facade Methods (delegate to service) ===
+    # ╔══════════════════════════════════════════════════════════════════════════╗
+    # ║                              METHODS                                      ║
+    # ╚══════════════════════════════════════════════════════════════════════════╝
 
     @property
     def service(self) -> Any:
@@ -521,33 +642,25 @@ class DjangoConfig(BaseModel):
         return self._service
 
     def get_installed_apps(self) -> List[str]:
-        """Get complete INSTALLED_APPS list (delegates to service)."""
+        """Get complete INSTALLED_APPS list."""
         return self.service.get_installed_apps()
 
     def get_middleware(self) -> List[str]:
-        """Get complete MIDDLEWARE list (delegates to service)."""
+        """Get complete MIDDLEWARE list."""
         return self.service.get_middleware()
 
     def get_allowed_hosts(self) -> List[str]:
-        """Get ALLOWED_HOSTS (delegates to service)."""
+        """Get ALLOWED_HOSTS."""
         return self.service.get_allowed_hosts()
 
     def get_all_settings(self) -> Dict[str, Any]:
-        """
-        Generate complete Django settings dictionary.
-
-        Delegates to SettingsGenerator for actual generation.
-
-        Returns:
-            Complete Django settings ready for use
-
-        Raises:
-            ConfigurationError: If settings generation fails
-        """
-        # Set as current config
+        """Generate complete Django settings dictionary."""
         from ..state.registry import set_current_config
         set_current_config(self)
 
+        from ..debug import setup_warnings_debug
+        setup_warnings_debug()
+
         if self._django_settings is None:
             from ..generation import SettingsGenerator
 
@@ -561,68 +674,12 @@ class DjangoConfig(BaseModel):
 
         return self._django_settings
 
-    def get_ticket_url(self, ticket_uuid: str) -> str:
-        """
-        Generate ticket URL using the configured template.
-
-        Args:
-            ticket_uuid: UUID of the support ticket
-
-        Returns:
-            Complete URL to the ticket
-        """
-        return self.ticket_url.format(
-            site_url=self.site_url,
-            uuid=ticket_uuid,
-        )
-
-    def get_otp_url(self, otp_code: str) -> str:
-        """
-        Generate OTP verification URL using the configured template.
-
-        Args:
-            otp_code: OTP verification code
-
-        Returns:
-            Complete URL to the OTP verification page
-        """
-        return self.otp_url.format(
-            site_url=self.site_url,
-            code=otp_code,
-        )
-
     def invalidate_cache(self) -> None:
-        """
-        Invalidate cached Django settings.
-
-        Forces regeneration of settings on next call to get_all_settings().
-        Useful when configuration has changed and settings need to be regenerated.
-
-        Example:
-            >>> config.invalidate_cache()
-            >>> new_settings = config.get_all_settings()  # Will regenerate
-        """
+        """Invalidate cached Django settings."""
         self._django_settings = None
 
     def model_dump_for_django(self, **kwargs) -> Dict[str, Any]:
-        """
-        Serialize model data in Django-compatible format.
-
-        This method provides a dictionary representation suitable for Django settings,
-        with proper serialization of nested Pydantic models.
-
-        Args:
-            **kwargs: Additional arguments passed to model_dump()
-
-        Returns:
-            Dictionary with serialized configuration data
-
-        Example:
-            >>> config = DjangoConfig(project_name="My Project", ...)
-            >>> dump = config.model_dump_for_django()
-            >>> dump["project_name"]
-            'My Project'
-        """
+        """Serialize model data in Django-compatible format."""
         return self.model_dump(
             mode="python",
             exclude_none=False,
@@ -630,28 +687,11 @@ class DjangoConfig(BaseModel):
             **kwargs
         )
 
-    def should_enable_tasks(self) -> bool:
-        """
-        Determine if background tasks should be enabled.
-
-        Tasks are enabled if:
-        1. Explicitly configured via tasks field
-        2. Knowledge base is enabled (requires background processing)
-        3. Agents are enabled (requires background processing)
-
-        Returns:
-            True if tasks should be enabled, False otherwise
-        """
-        # Check if explicitly configured
-        if hasattr(self, 'tasks') and self.tasks and self.tasks.enabled:
+    def should_enable_rq(self) -> bool:
+        """Determine if Django-RQ should be enabled."""
+        if hasattr(self, 'django_rq') and self.django_rq and self.django_rq.enabled:
             return True
-
-        # Check if features that require tasks are enabled
-        if self.enable_knowbase or self.enable_agents:
-            return True
-
         return False
 
 
-# Export main class
 __all__ = ["DjangoConfig"]