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

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

@@ -60,7 +60,7 @@ class ThirdPartyIntegrationsGenerator:
         settings.update(self._generate_telegram_settings())
         settings.update(self._generate_unfold_settings())
         settings.update(self._generate_constance_settings())
-        settings.update(self._generate_rpc_settings())
+        settings.update(self._generate_centrifugo_settings())
 
         # Track enabled integrations
         if self.integrations:
@@ -116,20 +116,20 @@ class ThirdPartyIntegrationsGenerator:
 
         return constance_settings
 
-    def _generate_rpc_settings(self) -> Dict[str, Any]:
+    def _generate_centrifugo_settings(self) -> Dict[str, Any]:
         """
-        Generate RPC Client settings.
+        Generate Centrifugo settings.
 
         Returns:
-            Dictionary with RPC configuration
+            Dictionary with Centrifugo configuration
         """
-        if not hasattr(self.config, "django_ipc") or not self.config.django_ipc:
+        if not hasattr(self.config, "centrifugo") or not self.config.centrifugo:
             return {}
 
-        rpc_settings = self.config.django_ipc.to_django_settings()
-        self.integrations.append("django_ipc")
+        centrifugo_settings = self.config.centrifugo.to_django_settings()
+        self.integrations.append("centrifugo")
 
-        return rpc_settings
+        return centrifugo_settings
 
     def get_enabled_integrations(self) -> List[str]:
         """

django_cfg/core/generation/orchestrator.py

@@ -69,6 +69,7 @@ class SettingsOrchestrator:
             settings.update(self._generate_database_settings())
             settings.update(self._generate_cache_settings())
             settings.update(self._generate_security_settings())
+            settings.update(self._generate_crypto_fields_settings())
             settings.update(self._generate_email_settings())
             settings.update(self._generate_logging_settings())
             settings.update(self._generate_i18n_settings())
@@ -76,7 +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_rq_settings())
+            settings.update(self._generate_grpc_settings())
             settings.update(self._generate_tailwind_settings())
 
             # Apply additional settings (user overrides)
@@ -141,6 +143,15 @@ class SettingsOrchestrator:
         except Exception as e:
             raise ConfigurationError(f"Failed to generate security settings: {e}") from e
 
+    def _generate_crypto_fields_settings(self) -> Dict[str, Any]:
+        """Generate django-crypto-fields encryption settings."""
+        try:
+            from .security_generators.crypto_fields import CryptoFieldsSettingsGenerator
+            generator = CryptoFieldsSettingsGenerator(self.config)
+            return generator.generate()
+        except Exception as e:
+            raise ConfigurationError(f"Failed to generate crypto-fields settings: {e}") from e
+
     def _generate_email_settings(self) -> Dict[str, Any]:
         """Generate email settings."""
         try:
@@ -204,14 +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.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 Django-RQ settings: {e}") from e
+
+    def _generate_grpc_settings(self) -> Dict[str, Any]:
+        """Generate gRPC framework settings."""
         try:
-            from .integration_generators.tasks import TasksSettingsGenerator
-            generator = TasksSettingsGenerator(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 tasks 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/generation/security_generators/crypto_fields.py

@@ -0,0 +1,72 @@
+"""
+Django Crypto Fields settings generator.
+
+Generates encryption settings for django-crypto-fields with smart defaults.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict
+
+if TYPE_CHECKING:
+    from ...base.config_model import DjangoConfig
+
+
+class CryptoFieldsSettingsGenerator:
+    """
+    Generates django-crypto-fields encryption settings.
+
+    Responsibilities:
+    - DJANGO_CRYPTO_FIELDS_KEY_PATH
+    - KEY_PREFIX
+    - AUTO_CREATE_KEYS
+    - Environment-aware defaults
+
+    Example:
+        ```python
+        generator = CryptoFieldsSettingsGenerator(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 django-crypto-fields settings.
+
+        Returns:
+            Dictionary with encryption settings (empty if disabled)
+
+        Example:
+            >>> config = DjangoConfig(project_name="Test", secret_key="x"*50)
+            >>> generator = CryptoFieldsSettingsGenerator(config)
+            >>> settings = generator.generate()
+            >>> isinstance(settings, dict)
+            True
+        """
+        # Only generate settings if crypto_fields is configured
+        if not hasattr(self.config, 'crypto_fields') or not self.config.crypto_fields:
+            return {}
+
+        crypto_config = self.config.crypto_fields
+
+        # Skip if disabled
+        if not crypto_config.enabled:
+            return {}
+
+        # Generate settings using config's to_django_settings method
+        return crypto_config.to_django_settings(
+            base_dir=self.config.base_dir,
+            is_production=self.config.is_production,
+            debug=self.config.debug,
+            project_version=self.config.project_version
+        )
+
+
+__all__ = ["CryptoFieldsSettingsGenerator"]

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