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

django_cfg/core/generation/integration_generators/grpc_generator.py

@@ -0,0 +1,316 @@
+"""
+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 (async)")
+        logger.info(f"   - Server: {self.config.grpc.server.host}:{self.config.grpc.server.port}")
+        max_streams = self.config.grpc.server.max_concurrent_streams or "unlimited"
+        logger.info(f"   - Max concurrent streams: {max_streams}")
+        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_concurrent_streams": server_config.max_concurrent_streams,
+            "asyncio_debug": server_config.asyncio_debug,
+            "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,
+            "api_key_header": auth_config.api_key_header,
+            "accept_django_secret_key": auth_config.accept_django_secret_key,
+            "public_methods": auth_config.public_methods,
+        }
+
+        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.
+
+        IMPORTANT: Interceptors are executed in reverse order for requests!
+        The first interceptor in the list wraps all others.
+
+        Correct order for our use case:
+        1. Auth interceptor (MUST be first to set context.api_key before logging)
+        2. Request logger interceptor (uses context.api_key from auth)
+        3. Logging interceptor (if dev mode)
+        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")
+
+        # NOTE: Interceptors are applied in REVERSE order (last added = first executed)!
+        # So add them in reverse order of execution:
+
+        # 4. Add metrics interceptor in dev mode (executed LAST)
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.interceptors.MetricsInterceptor"
+            )
+
+        # 3. Add logging interceptor in dev mode (executed 3rd)
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.interceptors.LoggingInterceptor"
+            )
+
+        # 2. Add request logger interceptor (executed 2nd - needs context vars from auth)
+        interceptors.append(
+            "django_cfg.apps.integrations.grpc.interceptors.RequestLoggerInterceptor"
+        )
+
+        # 1. Add auth interceptor LAST in list (executed FIRST - sets contextvars!)
+        if self.config.grpc.auth.enabled:
+            interceptors.append(
+                "django_cfg.apps.integrations.grpc.auth.ApiKeyAuthInterceptor"
+            )
+
+        # 5. 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

django_cfg/core/integration/display/grpc_display.py

@@ -0,0 +1,144 @@
+"""
+gRPC Server Display Manager.
+
+Displays startup information specific to gRPC server.
+"""
+
+from rich.table import Table
+from rich.text import Text
+
+from .base import BaseDisplayManager
+
+
+class GRPCDisplayManager(BaseDisplayManager):
+    """Manager for displaying gRPC server startup information."""
+
+    def display_grpc_startup(
+        self,
+        host: str,
+        port: int,
+        max_workers: int,
+        enable_reflection: bool,
+        enable_health_check: bool,
+        registered_services: int,
+        service_names: list = None,
+    ):
+        """
+        Display gRPC server startup information.
+
+        Args:
+            host: Server host
+            port: Server port
+            max_workers: Maximum worker threads
+            enable_reflection: Whether reflection is enabled
+            enable_health_check: Whether health check is enabled
+            registered_services: Number of registered services
+            service_names: List of registered service names (optional)
+        """
+        # Display header with gRPC indicator
+        header_text = self.create_header_text(show_update_check=True)
+        # Add gRPC server indicator
+        header_text.append(" • ", style="dim")
+        header_text.append("⚡ gRPC Server", style="magenta bold")
+
+        self.console.print(header_text)
+        self.print_spacing()
+
+        # Create server info table
+        server_table = self.create_table()
+        server_table.add_column("Setting", style="cyan", width=25)
+        server_table.add_column("Value", style="white")
+
+        # Server connection info
+        address = f"{host}:{port}"
+        server_table.add_row("⚡ gRPC Server", f"[bold green]{address}[/bold green]")
+        server_table.add_row("👷 Max Workers", str(max_workers))
+
+        # Features
+        reflection_status = "✅ Enabled" if enable_reflection else "❌ Disabled"
+        health_status = "✅ Enabled" if enable_health_check else "❌ Disabled"
+        server_table.add_row("🔍 Reflection", reflection_status)
+        server_table.add_row("❤️ Health Check", health_status)
+
+        # Services
+        services_text = (
+            f"[bold green]{registered_services}[/bold green]"
+            if registered_services > 0
+            else "[yellow]0 (no services registered)[/yellow]"
+        )
+        server_table.add_row("📦 Services", services_text)
+
+        # Create server panel
+        server_panel = self.create_panel(
+            server_table,
+            title="⚡ gRPC Server Configuration",
+            border_style="magenta",
+        )
+        self.console.print(server_panel)
+
+        # Display registered services if available
+        if service_names and len(service_names) > 0:
+            self.print_spacing()
+            self._display_services_list(service_names)
+
+        self.print_spacing()
+
+    def _display_services_list(self, service_names: list):
+        """
+        Display list of registered services.
+
+        Args:
+            service_names: List of service names
+        """
+        services_table = self.create_table()
+        services_table.add_column("Service Name", style="cyan")
+        services_table.add_column("Status", style="green")
+
+        for service_name in service_names:
+            services_table.add_row(
+                f"📡 {service_name}",
+                "✅ Registered"
+            )
+
+        services_panel = self.create_panel(
+            services_table,
+            title="📡 Registered Services",
+            border_style="blue",
+        )
+        self.console.print(services_panel)
+
+    def display_grpc_minimal(
+        self,
+        host: str,
+        port: int,
+        registered_services: int,
+    ):
+        """
+        Display minimal gRPC server startup info.
+
+        Args:
+            host: Server host
+            port: Server port
+            registered_services: Number of registered services
+        """
+        # Display header with gRPC indicator
+        header_text = self.create_header_text(show_update_check=True)
+        # Add gRPC server indicator
+        header_text.append(" • ", style="dim")
+        header_text.append("⚡ gRPC Server", style="magenta bold")
+
+        # Add server address and services count
+        address = f"{host}:{port}"
+        header_text.append(" • ", style="dim")
+        header_text.append(f"⚡ {address}", style="magenta bold")
+        header_text.append(" • ", style="dim")
+
+        if registered_services > 0:
+            header_text.append(f"📦 {registered_services} service(s)", style="green")
+        else:
+            header_text.append("📦 no services", style="yellow")
+
+        self.console.print(header_text)
+
+
+__all__ = ["GRPCDisplayManager"]