django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/core/debug/example_config.py

@@ -0,0 +1,63 @@
+"""
+Example configuration with debug_warnings enabled.
+
+This shows how to enable warnings traceback through DjangoConfig.
+"""
+
+from django_cfg import DjangoConfig, DatabaseConfig
+
+
+class DebugConfig(DjangoConfig):
+    """
+    Example configuration with warnings debug enabled.
+
+    Usage:
+        # In your settings.py or config.py
+        from path.to.config import DebugConfig
+
+        config = DebugConfig()
+        settings = config.get_all_settings()
+    """
+
+    # Project basics
+    project_name: str = "Debug Example"
+    secret_key: str = "django-insecure-example-key-change-in-production"
+
+    # Enable debug mode for development
+    debug: bool = True
+
+    # Enable warnings traceback for debugging
+    # This will show full stack trace for RuntimeWarnings about:
+    # - Database access during app initialization
+    # - APPS_NOT_READY warnings
+    # - Other app initialization issues
+    debug_warnings: bool = True
+
+    # Database configuration
+    databases: dict[str, DatabaseConfig] = {
+        "default": DatabaseConfig(
+            engine="django.db.backends.sqlite3",
+            name=":memory:",
+        )
+    }
+
+
+# Alternative: Enable only in development
+class SmartDebugConfig(DjangoConfig):
+    """Automatically enable debug_warnings in development mode."""
+
+    project_name: str = "Smart Debug Example"
+    secret_key: str = "django-insecure-example-key"
+
+    # Auto-enable debug_warnings in development
+    @property
+    def debug_warnings(self) -> bool:
+        """Enable warnings debug only in development."""
+        return self.env_mode.is_development
+
+    databases: dict[str, DatabaseConfig] = {
+        "default": DatabaseConfig(
+            engine="django.db.backends.sqlite3",
+            name=":memory:",
+        )
+    }

django_cfg/core/debug/warnings_helper.py

@@ -0,0 +1,121 @@
+"""
+Warnings debug helper for Django-CFG.
+
+Shows full traceback for specific warnings to help identify the source.
+
+Usage:
+    Set environment variable:
+    export DJANGO_CFG_DEBUG_WARNINGS=1
+
+    Or call manually in manage.py/wsgi.py BEFORE django.setup():
+    from django_cfg.core.debug import setup_warnings_debug
+    setup_warnings_debug()
+"""
+
+import os
+import sys
+import traceback
+import warnings
+
+
+def warning_with_traceback(message, category, filename, lineno, file=None, line=None):
+    """
+    Custom warning handler that shows full stack traceback.
+
+    This helps identify WHERE in the code the warning is triggered from.
+    """
+    log = file if hasattr(file, 'write') else sys.stderr
+
+    # Print separator for clarity
+    log.write("\n" + "="*80 + "\n")
+    log.write(f"⚠️  WARNING TRACEBACK (to help find the source)\n")
+    log.write("="*80 + "\n")
+
+    # Print the full stack trace
+    traceback.print_stack(file=log)
+
+    # Print the actual warning
+    log.write("\n" + "-"*80 + "\n")
+    log.write(f"⚠️  WARNING MESSAGE:\n")
+    log.write(warnings.formatwarning(message, category, filename, lineno, line))
+    log.write("="*80 + "\n\n")
+
+
+def setup_warnings_debug(
+    enabled: bool = None,
+    categories: list = None,
+    patterns: list = None
+):
+    """
+    Setup warnings to show full traceback.
+
+    Args:
+        enabled: Whether to enable debug mode. If None, checks:
+                 1. DjangoConfig.debug_warnings setting (if config exists)
+                 2. DJANGO_CFG_DEBUG_WARNINGS environment variable
+        categories: List of warning categories to track (default: [RuntimeWarning])
+        patterns: List of regex patterns to match in warning messages
+                 (default: ['.*database.*', '.*APPS_NOT_READY.*'])
+
+    Example:
+        # Enable all RuntimeWarnings with traceback
+        setup_warnings_debug(enabled=True)
+
+        # Enable only specific warnings
+        setup_warnings_debug(
+            enabled=True,
+            categories=[RuntimeWarning, DeprecationWarning],
+            patterns=['.*database.*']
+        )
+
+        # In your config.py:
+        class MyConfig(DjangoConfig):
+            debug_warnings: bool = True  # Enable warnings traceback
+    """
+    # Check if enabled (priority: explicit param > config > env var)
+    if enabled is None:
+        # Try to get from config first (if available)
+        try:
+            from django_cfg.core.config import get_current_config
+            config = get_current_config()
+            if config and hasattr(config, 'debug_warnings'):
+                enabled = config.debug_warnings
+            else:
+                enabled = False
+        except Exception:
+            # Config not available yet, check env var
+            enabled = False
+
+        # Fallback to environment variable
+        if not enabled:
+            enabled = os.environ.get('DJANGO_CFG_DEBUG_WARNINGS', '').lower() in ('1', 'true', 'yes')
+
+    if not enabled:
+        return
+
+    # Default categories
+    if categories is None:
+        categories = [RuntimeWarning]
+
+    # Default patterns
+    if patterns is None:
+        patterns = [
+            '.*database.*',
+            '.*APPS_NOT_READY.*',
+            '.*app.*initialization.*',
+        ]
+
+    # Install custom warning handler
+    warnings.showwarning = warning_with_traceback
+
+    # Configure filters for each category and pattern
+    for category in categories:
+        for pattern in patterns:
+            warnings.filterwarnings(
+                'default',
+                category=category,
+                message=pattern
+            )
+
+    print(f"🔍 Django-CFG Warnings Debug enabled for: {[c.__name__ for c in categories]}")
+    print(f"   Patterns: {patterns}")

django_cfg/core/generation/core_generators/static.py

@@ -68,6 +68,11 @@ class StaticFilesGenerator:
 
         # Set paths relative to base directory (always set, auto-detects from manage.py)
         base_dir = self.config.base_dir
+
+        # Note: Next.js admin static files are copied to static/nextjs_admin/
+        # during generate_client command (if auto_build=True)
+        # No need to add separate path to STATICFILES_DIRS
+
         settings.update({
             "STATIC_ROOT": base_dir / "staticfiles",
             "MEDIA_ROOT": base_dir / "media",

django_cfg/core/generation/core_generators/templates.py

@@ -96,42 +96,57 @@ class TemplateSettingsGenerator:
 
     def _discover_app_templates(self) -> List[Path]:
         """
-        Auto-discover template directories from django-cfg apps.
+        Auto-discover template directories from django-cfg apps and modules.
 
         Looks for:
         - app/templates/
         - app/admin_interface/templates/
         - app/frontend/templates/
+        - modules/*/templates/
 
         Returns:
             List of discovered template directory paths
         """
         app_templates = []
 
-        # Find django-cfg apps directory
+        # Find django-cfg 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:
+        # Scan apps directory
+        apps_dir = django_cfg_dir / 'apps'
+        if apps_dir.exists():
+            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)
+
+        # Scan modules directory for templates
+        modules_dir = django_cfg_dir / 'modules'
+        if modules_dir.exists():
+            for module_dir in modules_dir.iterdir():
+                if not module_dir.is_dir():
+                    continue
+
+                # Skip special directories
+                if module_dir.name.startswith(('@', '_', '.')):
+                    continue
+
+                # Check if module has templates directory
+                template_dir = module_dir / 'templates'
                 if template_dir.exists() and template_dir.is_dir():
                     app_templates.append(template_dir)
 

django_cfg/core/generation/data_generators/cache.py

@@ -58,13 +58,18 @@ class CacheSettingsGenerator:
 
         # Default cache - always provide one
         if self.config.cache_default:
+            # User explicitly configured cache_default
             caches["default"] = self.config.cache_default.to_django_config(
                 self.config.env_mode,
                 self.config.debug,
                 "default"
             )
+        elif self.config.redis_url:
+            # Auto-create Redis cache from redis_url
+            logger.info(f"Auto-creating Redis cache from redis_url: {self.config.redis_url}")
+            caches["default"] = self._get_redis_cache_config()
         else:
-            # Create default cache backend
+            # Fallback to default cache backend (LocMem/FileBased depending on env)
             caches["default"] = self._get_default_cache_config()
 
         # Sessions cache
@@ -88,9 +93,30 @@ class CacheSettingsGenerator:
 
         return settings
 
+    def _get_redis_cache_config(self) -> Dict[str, Any]:
+        """
+        Auto-create Redis cache from config.redis_url.
+
+        Returns:
+            Dictionary with Redis cache backend configuration
+        """
+        from ....models.infrastructure.cache import CacheConfig
+
+        redis_cache = CacheConfig(
+            redis_url=self.config.redis_url,
+            timeout=300,  # 5 minutes default
+            max_connections=50,
+            key_prefix=self.config.project_name.lower().replace(" ", "_") if self.config.project_name else "django",
+        )
+        return redis_cache.to_django_config(
+            self.config.env_mode,
+            self.config.debug,
+            "default"
+        )
+
     def _get_default_cache_config(self) -> Dict[str, Any]:
         """
-        Get default cache configuration.
+        Get default cache configuration (fallback when no redis_url).
 
         Returns:
             Dictionary with default cache backend configuration

django_cfg/core/generation/integration_generators/__init__.py

@@ -5,17 +5,18 @@ Contains generators for third-party integrations and frameworks:
 - Session configuration
 - External services (Telegram, Unfold, Constance)
 - API frameworks (JWT, DRF, Spectacular, OpenAPI Client)
-- Background tasks (Dramatiq)
+- Task scheduling (django-rq)
+- Tailwind CSS configuration
 """
 
 from .api import APIFrameworksGenerator
+from .django_rq import DjangoRQSettingsGenerator
 from .sessions import SessionSettingsGenerator
-from .tasks import TasksSettingsGenerator
 from .third_party import ThirdPartyIntegrationsGenerator
 
 __all__ = [
     "SessionSettingsGenerator",
     "ThirdPartyIntegrationsGenerator",
     "APIFrameworksGenerator",
-    "TasksSettingsGenerator",
+    "DjangoRQSettingsGenerator",
 ]

django_cfg/core/generation/integration_generators/api.py

@@ -219,6 +219,15 @@ class APIFrameworksGenerator:
         Returns:
             Dictionary with Spectacular settings
         """
+        # Import authentication extension to register it with drf-spectacular
+        # Only import if apps are ready to avoid warnings
+        try:
+            from django.apps import apps
+            if apps.ready:
+                from django_cfg.middleware import authentication  # noqa: F401
+        except (ImportError, RuntimeError):
+            pass
+
         # Check if Spectacular settings exist (from OpenAPI Client or elsewhere)
         if not hasattr(self, '_has_spectacular_settings'):
             return {}

django_cfg/core/generation/integration_generators/django_rq.py

@@ -0,0 +1,80 @@
+"""
+Django-RQ Settings Generator.
+
+Generates Django settings for django-rq task queue and scheduler.
+Converts DjangoRQConfig Pydantic model to Django RQ_QUEUES and related settings.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ....models.django.django_rq import DjangoRQConfig
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class DjangoRQSettingsGenerator:
+    """
+    Settings generator for Django-RQ task queue.
+
+    Converts DjangoRQConfig to Django settings:
+    - RQ_QUEUES: Queue configurations
+    - RQ_SHOW_ADMIN_LINK: Show link in admin
+    - RQ_EXCEPTION_HANDLERS: Exception handlers
+    - RQ_API_TOKEN: API authentication token
+
+    Usage:
+        >>> from django_cfg.models.django.django_rq import DjangoRQConfig
+        >>> config = DjangoRQConfig(enabled=True)
+        >>> generator = DjangoRQSettingsGenerator(config)
+        >>> settings = generator.generate()
+        >>> 'RQ_QUEUES' in settings
+        True
+    """
+
+    def __init__(self, config: DjangoRQConfig, parent_config: Optional["DjangoConfig"] = None):
+        """
+        Initialize Django-RQ settings generator.
+
+        Args:
+            config: DjangoRQConfig instance
+            parent_config: Parent DjangoConfig for accessing global settings like redis_url
+        """
+        self.config = config
+        self.parent_config = parent_config
+
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate Django-RQ settings.
+
+        Returns:
+            Dictionary with RQ_QUEUES and related configuration
+        """
+        if not self.config.enabled:
+            return {}
+
+        # Use the model's built-in to_django_settings method
+        settings = self.config.to_django_settings(parent_config=self.parent_config)
+
+        return settings
+
+    def validate(self) -> None:
+        """
+        Validate Django-RQ configuration.
+
+        Ensures:
+        - At least 'default' queue exists (validated by Pydantic)
+        - Queue names are unique (validated by Pydantic)
+        - Queue configurations are valid
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        if not self.config.enabled:
+            return
+
+        # Validation is now handled by Pydantic field validators
+        # This method is kept for potential custom validation logic
+
+
+__all__ = ['DjangoRQSettingsGenerator']