django-cfg 1.4.116__py3-none-any.whl → 1.5.8__py3-none-any.whl

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/integration_generators/__init__.py

@@ -5,21 +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 (ReArq)
-- Task scheduling (django-q2)
+- Task scheduling (django-rq)
 - Tailwind CSS configuration
 """
 
 from .api import APIFrameworksGenerator
-from .django_q2 import DjangoQ2SettingsGenerator
+from .django_rq import DjangoRQSettingsGenerator
 from .sessions import SessionSettingsGenerator
-from .tasks import TasksSettingsGenerator
 from .third_party import ThirdPartyIntegrationsGenerator
 
 __all__ = [
     "SessionSettingsGenerator",
     "ThirdPartyIntegrationsGenerator",
     "APIFrameworksGenerator",
-    "TasksSettingsGenerator",
-    "DjangoQ2SettingsGenerator",
+    "DjangoRQSettingsGenerator",
 ]

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']

django_cfg/core/generation/integration_generators/grpc_generator.py

@@ -0,0 +1,318 @@
+"""
+gRPC framework generator.
+
+Handles gRPC server, authentication, and proto configuration.
+Size: ~250 lines (focused on gRPC framework)
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class GRPCSettingsGenerator:
+    """
+    Generates gRPC framework settings.
+
+    Responsibilities:
+    - Configure gRPC server settings
+    - Setup authentication and interceptors
+    - Configure proto generation
+    - Auto-detect if gRPC should be enabled
+    - Resolve handlers hook from ROOT_URLCONF
+
+    Example:
+        ```python
+        generator = GRPCSettingsGenerator(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 gRPC framework settings.
+
+        Returns:
+            Dictionary with gRPC configuration
+
+        Example:
+            >>> generator = GRPCSettingsGenerator(config)
+            >>> settings = generator.generate()
+        """
+        # Check if gRPC should be enabled
+        if not self._should_enable_grpc():
+            logger.debug("⏭️  gRPC disabled")
+            return {}
+
+        try:
+            return self._generate_grpc_settings()
+        except ImportError as e:
+            logger.warning(f"Failed to import gRPC dependencies: {e}")
+            logger.info("💡 Install with: pip install django-cfg[grpc]")
+            return {}
+        except Exception as e:
+            logger.error(f"Failed to generate gRPC settings: {e}")
+            return {}
+
+    def _should_enable_grpc(self) -> bool:
+        """
+        Check if gRPC should be enabled.
+
+        Returns:
+            True if gRPC should be enabled
+        """
+        # Check if grpc config exists and is enabled
+        if not hasattr(self.config, "grpc") or not self.config.grpc:
+            return False
+
+        if not self.config.grpc.enabled:
+            return False
+
+        # Check if gRPC dependencies are available
+        from django_cfg.apps.integrations.grpc._cfg import check_grpc_available
+        if not check_grpc_available():
+            logger.warning("gRPC enabled but dependencies not installed")
+            logger.info("💡 Install with: pip install django-cfg[grpc]")
+            return False
+
+        return True
+
+    def _generate_grpc_settings(self) -> Dict[str, Any]:
+        """
+        Generate gRPC-specific settings.
+
+        Returns:
+            Dictionary with gRPC configuration
+        """
+        settings = {}
+
+        # Generate GRPC_FRAMEWORK settings
+        grpc_framework = self._build_grpc_framework_settings()
+        if grpc_framework:
+            settings["GRPC_FRAMEWORK"] = grpc_framework
+
+        # Generate server-specific settings
+        grpc_server = self._build_grpc_server_settings()
+        if grpc_server:
+            settings["GRPC_SERVER"] = grpc_server
+
+        # Generate auth-specific settings
+        grpc_auth = self._build_grpc_auth_settings()
+        if grpc_auth:
+            settings["GRPC_AUTH"] = grpc_auth
+
+        # Generate proto-specific settings
+        grpc_proto = self._build_grpc_proto_settings()
+        if grpc_proto:
+            settings["GRPC_PROTO"] = grpc_proto
+
+        logger.info("✅ gRPC framework enabled")
+        logger.info(f"   - Server: {self.config.grpc.server.host}:{self.config.grpc.server.port}")
+        logger.info(f"   - Workers: {self.config.grpc.server.max_workers}")
+        logger.info(f"   - Auth: {'enabled' if self.config.grpc.auth.enabled else 'disabled'}")
+        logger.info(f"   - Reflection: {'enabled' if self.config.grpc.server.enable_reflection else 'disabled'}")
+
+        return settings
+
+    def _build_grpc_framework_settings(self) -> Dict[str, Any]:
+        """
+        Build GRPC_FRAMEWORK settings dictionary.
+
+        Returns:
+            Dictionary with framework-level gRPC settings
+        """
+        grpc_config = self.config.grpc
+
+        # Resolve handlers hook (replace {ROOT_URLCONF} placeholder)
+        handlers_hook = self._resolve_handlers_hook(grpc_config.handlers_hook)
+
+        # Build interceptors list
+        interceptors = self._build_interceptors()
+
+        framework_settings = {
+            "ROOT_HANDLERS_HOOK": handlers_hook,
+            "SERVER_INTERCEPTORS": interceptors,
+        }
+
+        # Add auto-registration settings
+        if grpc_config.auto_register_apps:
+            framework_settings["AUTO_REGISTER_APPS"] = grpc_config.enabled_apps
+
+        # Add custom services
+        if grpc_config.custom_services:
+            framework_settings["CUSTOM_SERVICES"] = grpc_config.custom_services
+
+        return framework_settings
+
+    def _build_grpc_server_settings(self) -> Dict[str, Any]:
+        """
+        Build GRPC_SERVER settings dictionary.
+
+        Returns:
+            Dictionary with server configuration
+        """
+        server_config = self.config.grpc.server
+
+        server_settings = {
+            "host": server_config.host,
+            "port": server_config.port,
+            "max_workers": server_config.max_workers,
+            "enable_reflection": server_config.enable_reflection,
+            "enable_health_check": server_config.enable_health_check,
+            "max_send_message_length": server_config.max_send_message_length,
+            "max_receive_message_length": server_config.max_receive_message_length,
+            "keepalive_time_ms": server_config.keepalive_time_ms,
+            "keepalive_timeout_ms": server_config.keepalive_timeout_ms,
+        }
+
+        # Add optional compression
+        if server_config.compression:
+            server_settings["compression"] = server_config.compression
+
+        # Add custom interceptors from config
+        if server_config.interceptors:
+            server_settings["custom_interceptors"] = server_config.interceptors
+
+        return server_settings
+
+    def _build_grpc_auth_settings(self) -> Dict[str, Any]:
+        """
+        Build GRPC_AUTH settings dictionary.
+
+        Returns:
+            Dictionary with authentication configuration
+        """
+        auth_config = self.config.grpc.auth
+
+        auth_settings = {
+            "enabled": auth_config.enabled,
+            "require_auth": auth_config.require_auth,
+            "token_header": auth_config.token_header,
+            "token_prefix": auth_config.token_prefix,
+            "jwt_algorithm": auth_config.jwt_algorithm,
+            "jwt_verify_exp": auth_config.jwt_verify_exp,
+            "jwt_leeway": auth_config.jwt_leeway,
+            "public_methods": auth_config.public_methods,
+        }
+
+        # Use JWT secret from auth config or fall back to Django SECRET_KEY
+        if auth_config.jwt_secret_key:
+            auth_settings["jwt_secret_key"] = auth_config.jwt_secret_key
+        else:
+            # Will be resolved from Django settings at runtime
+            auth_settings["jwt_secret_key"] = None  # Signal to use Django SECRET_KEY
+
+        return auth_settings
+
+    def _build_grpc_proto_settings(self) -> Dict[str, Any]:
+        """
+        Build GRPC_PROTO settings dictionary.
+
+        Returns:
+            Dictionary with proto generation configuration
+        """
+        proto_config = self.config.grpc.proto
+
+        proto_settings = {
+            "auto_generate": proto_config.auto_generate,
+            "output_dir": proto_config.output_dir,
+            "package_prefix": proto_config.package_prefix,
+            "include_services": proto_config.include_services,
+            "field_naming": proto_config.field_naming,
+        }
+
+        return proto_settings
+
+    def _build_interceptors(self) -> List[str]:
+        """
+        Build list of server interceptors.
+
+        Interceptors are added in order:
+        1. Request logger interceptor (always enabled for monitoring)
+        2. Logging interceptor (if dev mode)
+        3. Auth interceptor (if auth enabled)
+        4. Metrics interceptor (if dev mode)
+        5. Custom interceptors (from config)
+
+        Returns:
+            List of interceptor class paths
+        """
+        interceptors = []
+
+        # Check if we're in dev mode
+        is_dev = self.config.env_mode in ("local", "development", "dev")
+
+        # Add request logger interceptor (always enabled for DB logging)
+        interceptors.append(
+            "django_cfg.apps.integrations.grpc.interceptors.RequestLoggerInterceptor"
+        )
+
+        # Add logging interceptor in dev mode
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.interceptors.LoggingInterceptor"
+            )
+
+        # Add auth interceptor if enabled
+        if self.config.grpc.auth.enabled:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.auth.JWTAuthInterceptor"
+            )
+
+        # Add metrics interceptor in dev mode
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.interceptors.MetricsInterceptor"
+            )
+
+        # Add custom interceptors from server config
+        if self.config.grpc.server.interceptors:
+            interceptors.extend(self.config.grpc.server.interceptors)
+
+        return interceptors
+
+    def _resolve_handlers_hook(self, handlers_hook: str) -> str:
+        """
+        Resolve handlers hook path.
+
+        Replaces {ROOT_URLCONF} placeholder with actual ROOT_URLCONF value.
+
+        Args:
+            handlers_hook: Handler hook path (may contain {ROOT_URLCONF})
+
+        Returns:
+            Resolved handler hook path
+
+        Example:
+            >>> self._resolve_handlers_hook("{ROOT_URLCONF}.grpc_handlers")
+            'myproject.urls.grpc_handlers'
+        """
+        if "{ROOT_URLCONF}" in handlers_hook:
+            # Get ROOT_URLCONF from config
+            root_urlconf = getattr(self.config, "root_urlconf", None)
+            if not root_urlconf:
+                # Fall back to default Django pattern
+                root_urlconf = f"{self.config.project_name}.urls"
+                logger.debug(
+                    f"ROOT_URLCONF not set, using default: {root_urlconf}"
+                )
+
+            handlers_hook = handlers_hook.replace("{ROOT_URLCONF}", root_urlconf)
+
+        return handlers_hook
+
+
+__all__ = ["GRPCSettingsGenerator"]

django_cfg/core/generation/orchestrator.py

@@ -77,8 +77,8 @@ class SettingsOrchestrator:
             settings.update(self._generate_session_settings())
             settings.update(self._generate_third_party_settings())
             settings.update(self._generate_api_settings())
-            settings.update(self._generate_tasks_settings())
-            settings.update(self._generate_django_q2_settings())
+            settings.update(self._generate_django_rq_settings())
+            settings.update(self._generate_grpc_settings())
             settings.update(self._generate_tailwind_settings())
 
             # Apply additional settings (user overrides)
@@ -215,26 +215,26 @@ class SettingsOrchestrator:
         except Exception as e:
             raise ConfigurationError(f"Failed to generate API settings: {e}") from e
 
-    def _generate_tasks_settings(self) -> Dict[str, Any]:
-        """Generate background tasks settings."""
+    def _generate_django_rq_settings(self) -> Dict[str, Any]:
+        """Generate Django-RQ task queue and scheduler settings."""
+        if not hasattr(self.config, "django_rq") or not self.config.django_rq:
+            return {}
+
         try:
-            from .integration_generators.tasks import TasksSettingsGenerator
-            generator = TasksSettingsGenerator(self.config)
+            from .integration_generators.django_rq import DjangoRQSettingsGenerator
+            generator = DjangoRQSettingsGenerator(self.config.django_rq, parent_config=self.config)
             return generator.generate()
         except Exception as e:
-            raise ConfigurationError(f"Failed to generate tasks settings: {e}") from e
-
-    def _generate_django_q2_settings(self) -> Dict[str, Any]:
-        """Generate Django-Q2 task scheduling settings."""
-        if not hasattr(self.config, "django_q2") or not self.config.django_q2:
-            return {}
+            raise ConfigurationError(f"Failed to generate Django-RQ settings: {e}") from e
 
+    def _generate_grpc_settings(self) -> Dict[str, Any]:
+        """Generate gRPC framework settings."""
         try:
-            from .integration_generators.django_q2 import DjangoQ2SettingsGenerator
-            generator = DjangoQ2SettingsGenerator(self.config.django_q2, parent_config=self.config)
+            from .integration_generators.grpc_generator import GRPCSettingsGenerator
+            generator = GRPCSettingsGenerator(self.config)
             return generator.generate()
         except Exception as e:
-            raise ConfigurationError(f"Failed to generate Django-Q2 settings: {e}") from e
+            raise ConfigurationError(f"Failed to generate gRPC settings: {e}") from e
 
     def _generate_tailwind_settings(self) -> Dict[str, Any]:
         """Generate Tailwind CSS settings."""

django_cfg/core/integration/display/__init__.py

@@ -5,6 +5,7 @@ Modular, class-based display system for startup information.
 """
 
 from .base import BaseDisplayManager
+from .grpc_display import GRPCDisplayManager
 from .ngrok import NgrokDisplayManager
 from .startup import StartupDisplayManager
 
@@ -12,4 +13,5 @@ __all__ = [
     "BaseDisplayManager",
     "StartupDisplayManager",
     "NgrokDisplayManager",
+    "GRPCDisplayManager",
 ]

django_cfg/core/integration/display/base.py

@@ -9,6 +9,7 @@ from rich.columns import Columns
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
+from rich.text import Text
 
 # Panel width configuration - use fixed widths for consistent layout
 CONSOLE_WIDTH = 120  # Console width that fits most terminals
@@ -155,3 +156,53 @@ class BaseDisplayManager:
         """Print empty lines for spacing."""
         for _ in range(lines):
             self.console.print()
+
+    def create_header_text(self, show_update_check: bool = True) -> Text:
+        """
+        Create reusable header text for startup display.
+
+        Args:
+            show_update_check: Whether to check and display update availability
+
+        Returns:
+            Rich Text object with formatted header
+
+        Example:
+            >>> header = self.create_header_text()
+            >>> self.console.print(header)
+            # Output: 🚧 Django CFG v1.5.5 • development • Project Name
+        """
+        version = self.get_version()
+        panel_style, env_emoji, env_color = self.get_environment_style()
+
+        header_text = Text()
+        header_text.append(f"{env_emoji} Django CFG ", style="bold")
+        header_text.append(f"v{version}", style="cyan")
+        header_text.append(" • ", style="dim")
+        header_text.append(f"{self.config.env_mode}", style=env_color)
+
+        # Show debug_warnings if enabled
+        if self.config and self.config.debug_warnings:
+            header_text.append(" • ", style="dim")
+            header_text.append("🔍 warnings debug", style="yellow")
+
+        # Add project name
+        if self.config and self.config.project_name:
+            header_text.append(" • ", style="dim")
+            header_text.append(f"{self.config.project_name}", style="white")
+
+        # Check for critical updates
+        if show_update_check:
+            try:
+                from ..version_checker import get_version_info
+                version_info = get_version_info()
+                if version_info.get('update_available'):
+                    header_text.append(" • ", style="dim")
+                    header_text.append("🚨 UPDATE AVAILABLE", style="bold yellow")
+                    header_text.append(" (", style="dim")
+                    header_text.append("poetry add django-cfg@latest", style="bright_blue")
+                    header_text.append(")", style="dim")
+            except Exception:
+                pass
+
+        return header_text