django-cfg 1.4.120__py3-none-any.whl → 1.5.2__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 feature is available
+        from django_cfg.config import is_feature_available
+        if not is_feature_available("grpc"):
+            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.grpc.interceptors.RequestLoggerInterceptor"
+        )
+
+        # Add logging interceptor in dev mode
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.grpc.interceptors.LoggingInterceptor"
+            )
+
+        # Add auth interceptor if enabled
+        if self.config.grpc.auth.enabled:
+            interceptors.append(
+                "django_cfg.apps.grpc.auth.JWTAuthInterceptor"
+            )
+
+        # Add metrics interceptor in dev mode
+        if is_dev:
+            interceptors.append(
+                "django_cfg.apps.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/startup.py

@@ -416,20 +416,20 @@ class StartupDisplayManager(BaseDisplayManager):
             task_table.add_column("Value", style="white")
 
             # Show real tasks status
-            tasks_enabled = self.config.should_enable_tasks()
+            tasks_enabled = self.config.should_enable_rq()
             if tasks_enabled:
                 task_table.add_row("Tasks Enabled", "[green]True[/green]")
             else:
                 task_table.add_row("Tasks Enabled", "[yellow]False[/yellow]")
 
-            if hasattr(self.config, 'tasks') and self.config.tasks:
-                queue_name = getattr(self.config.tasks, 'queue_name', 'default')
-                task_table.add_row("Queue", f"[yellow]{queue_name}[/yellow]")
+            if hasattr(self.config, 'django_rq') and self.config.django_rq:
+                queue_names = ', '.join(self.config.django_rq.get_queue_names())
+                task_table.add_row("Queues", f"[yellow]{queue_names}[/yellow]")
             else:
-                task_table.add_row("Queue", "[yellow]default[/yellow]")
+                task_table.add_row("Queues", "[yellow]default[/yellow]")
 
             # Add worker command
-            task_table.add_row("Start Workers", "[bright_blue]poetry run python manage.py runrearq[/bright_blue]")
+            task_table.add_row("Start Workers", "[bright_blue]poetry run python manage.py rqworker default[/bright_blue]")
 
             task_panel = self.create_full_width_panel(
                 task_table,
@@ -465,13 +465,6 @@ class StartupDisplayManager(BaseDisplayManager):
             payments_count = 0
 
             config = self.config
-            if config and config.should_enable_tasks():
-                try:
-                    from django_cfg.modules.django_tasks import extend_constance_config_with_tasks
-                    tasks_fields = extend_constance_config_with_tasks()
-                    tasks_count = len(tasks_fields)
-                except:
-                    pass
 
             if config and config.enable_knowbase:
                 try:
@@ -623,13 +616,6 @@ class StartupDisplayManager(BaseDisplayManager):
 
             # Try to get individual app field counts
             config = self.config
-            if config and config.should_enable_tasks():
-                try:
-                    from django_cfg.modules.django_tasks import extend_constance_config_with_tasks
-                    tasks_fields = extend_constance_config_with_tasks()
-                    tasks_count = len(tasks_fields)
-                except:
-                    pass
 
             if config and config.enable_knowbase:
                 try:

django_cfg/mixins/__init__.py

@@ -5,8 +5,10 @@ Shared mixins for DRF views and viewsets.
 """
 from .admin_api import AdminAPIMixin
 from .client_api import ClientAPIMixin
+from .superadmin_api import SuperAdminAPIMixin
 
 __all__ = [
     "AdminAPIMixin",
     "ClientAPIMixin",
+    "SuperAdminAPIMixin",
 ]

django_cfg/mixins/superadmin_api.py

@@ -0,0 +1,59 @@
+"""
+SuperAdmin API Mixin.
+
+Common configuration for superuser-only API endpoints.
+More restrictive than AdminAPIMixin - requires is_superuser flag.
+"""
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+from rest_framework.permissions import BasePermission
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+
+class IsSuperUser(BasePermission):
+    """
+    Permission that allows access only to superusers.
+
+    More restrictive than IsAdminUser - requires is_superuser flag.
+    Use for sensitive operations like command execution.
+    """
+
+    def has_permission(self, request, view):
+        """Check if user is authenticated and is a superuser."""
+        return bool(
+            request.user and
+            request.user.is_authenticated and
+            request.user.is_superuser
+        )
+
+
+class SuperAdminAPIMixin:
+    """
+    Mixin for superuser-only API endpoints.
+
+    Provides:
+    - JWT, Session, and Basic authentication
+    - IsSuperUser permission requirement (is_superuser=True)
+
+    Usage:
+        class MyViewSet(SuperAdminAPIMixin, viewsets.ModelViewSet):
+            queryset = MyModel.objects.all()
+            serializer_class = MySerializer
+
+    Authentication Methods:
+        1. JWT Token (Bearer): For frontend SPA authentication
+        2. Session: For Django admin integration
+        3. Basic Auth: For testing and scripts
+
+    All endpoints require superuser privileges.
+    Only use this for sensitive operations like:
+    - Command execution
+    - System configuration changes
+    - Direct database operations
+    """
+
+    authentication_classes = [
+        JWTAuthentication,      # JWT tokens (Bearer)
+        SessionAuthentication,  # Django session (for admin)
+        BasicAuthentication,    # HTTP Basic (for testing)
+    ]
+    permission_classes = [IsSuperUser]

django_cfg/models/__init__.py

@@ -35,7 +35,7 @@ from .base.module import BaseCfgAutoModule
 from .django.axes import AxesConfig
 from .django.constance import ConstanceConfig, ConstanceField
 from .django.crypto_fields import CryptoFieldsConfig
-from .django.django_q2 import DjangoQ2Config, DjangoQ2ScheduleConfig
+from .django.django_rq import DjangoRQConfig, RQQueueConfig
 from .django.environment import EnvironmentConfig
 from .django.openapi import OpenAPIClientConfig
 from .infrastructure.cache import CacheConfig
@@ -80,8 +80,8 @@ __all__ = [
     "EnvironmentConfig",
     "ConstanceConfig",
     "ConstanceField",
-    "DjangoQ2Config",
-    "DjangoQ2ScheduleConfig",
+    "DjangoRQConfig",
+    "RQQueueConfig",
     "OpenAPIClientConfig",
     "UnfoldConfig",
     "AxesConfig",

django_cfg/models/api/grpc/__init__.py

@@ -0,0 +1,59 @@
+"""
+gRPC configuration models.
+
+Type-safe Pydantic v2 models for gRPC server, authentication, and proto generation.
+
+Requires: pip install django-cfg[grpc]
+
+Example:
+    >>> from django_cfg.models.api.grpc import GRPCConfig, GRPCServerConfig
+    >>> config = GRPCConfig(
+    ...     enabled=True,
+    ...     server=GRPCServerConfig(port=50051)
+    ... )
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .config import (
+        GRPCAuthConfig,
+        GRPCConfig,
+        GRPCProtoConfig,
+        GRPCServerConfig,
+    )
+
+__all__ = [
+    "GRPCConfig",
+    "GRPCServerConfig",
+    "GRPCAuthConfig",
+    "GRPCProtoConfig",
+]
+
+
+def __getattr__(name: str):
+    """Lazy import with helpful error message."""
+    if name in __all__:
+        try:
+            from .config import (
+                GRPCAuthConfig,
+                GRPCConfig,
+                GRPCProtoConfig,
+                GRPCServerConfig,
+            )
+
+            return {
+                "GRPCConfig": GRPCConfig,
+                "GRPCServerConfig": GRPCServerConfig,
+                "GRPCAuthConfig": GRPCAuthConfig,
+                "GRPCProtoConfig": GRPCProtoConfig,
+            }[name]
+
+        except ImportError as e:
+            raise ImportError(
+                f"gRPC support requires additional dependencies. "
+                f"Install with: pip install django-cfg[grpc]\n"
+                f"Missing module: {e.name}"
+            ) from e
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")