django-cfg 1.4.120__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/apps/rq/views/workers.py

@@ -0,0 +1,195 @@
+"""
+Django-RQ Worker Management ViewSet.
+
+Provides REST API endpoints for monitoring RQ workers.
+"""
+
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..serializers import WorkerSerializer, WorkerStatsSerializer
+from ..services import worker_to_model
+
+logger = get_logger("rq.workers")
+
+
+class WorkerViewSet(AdminAPIMixin, viewsets.ViewSet):
+    """
+    ViewSet for RQ worker monitoring.
+
+    Provides endpoints for:
+    - Listing all workers with statistics
+    - Getting worker aggregated stats
+    - Getting individual worker details
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    @extend_schema(
+        tags=["RQ Workers"],
+        summary="List all workers",
+        description="Returns list of all RQ workers with their current state. Supports filtering by state and queue.",
+        parameters=[
+            OpenApiParameter(
+                name="state",
+                type=str,
+                location=OpenApiParameter.QUERY,
+                required=False,
+                description="Filter by worker state (idle, busy, suspended)",
+            ),
+            OpenApiParameter(
+                name="queue",
+                type=str,
+                location=OpenApiParameter.QUERY,
+                required=False,
+                description="Filter by queue name",
+            ),
+        ],
+        responses={
+            200: WorkerSerializer(many=True),
+        },
+    )
+    def list(self, request):
+        """List all workers with optional filtering."""
+        try:
+            import django_rq
+            from rq import Worker
+
+            # Get query params for filtering
+            state_filter = request.query_params.get('state')
+            queue_filter = request.query_params.get('queue')
+
+            # Get all workers using connection from default queue
+            # All queues share the same Redis connection, so we only need one
+            queue = django_rq.get_queue('default')
+            all_workers = Worker.all(connection=queue.connection)
+
+            workers_data = []
+            for worker in all_workers:
+                try:
+                    # Convert RQ Worker to Pydantic model
+                    worker_model = worker_to_model(worker)
+
+                    # Apply filters
+                    if state_filter and worker_model.state != state_filter:
+                        continue
+
+                    if queue_filter and queue_filter not in worker_model.get_queue_list():
+                        continue
+
+                    # Convert Pydantic model to dict for DRF serializer
+                    worker_dict = worker_model.model_dump()
+
+                    # DRF serializer expects 'queues' as list, not comma-separated string
+                    worker_dict['queues'] = worker_model.get_queue_list()
+
+                    # DRF serializer expects 'current_job' not 'current_job_id'
+                    worker_dict['current_job'] = worker_dict.pop('current_job_id')
+
+                    serializer = WorkerSerializer(data=worker_dict)
+                    serializer.is_valid(raise_exception=True)
+                    workers_data.append(serializer.data)
+
+                except Exception as e:
+                    logger.debug(f"Failed to get worker {worker.name}: {e}")
+                    continue
+
+            return Response(workers_data)
+
+        except Exception as e:
+            import traceback
+            logger.error(f"Worker list error: {e}", exc_info=True)
+            return Response(
+                {
+                    "error": str(e),
+                    "traceback": traceback.format_exc(),
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["RQ Workers"],
+        summary="Get worker statistics",
+        description="Returns aggregated statistics for all workers.",
+        responses={
+            200: WorkerStatsSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="stats")
+    def stats(self, request):
+        """Get aggregated worker statistics."""
+        try:
+            import django_rq
+            from rq import Worker
+
+            # Get all workers using connection from default queue
+            # All queues share the same Redis connection, so we only need one
+            queue = django_rq.get_queue('default')
+            all_workers = Worker.all(connection=queue.connection)
+
+            # Count by state
+            busy_workers = 0
+            idle_workers = 0
+            suspended_workers = 0
+            total_successful = 0
+            total_failed = 0
+            total_working_time = 0.0
+
+            workers_list = []
+
+            for worker in all_workers:
+                try:
+                    # Convert RQ Worker to Pydantic model
+                    worker_model = worker_to_model(worker)
+
+                    # Count by state
+                    if worker_model.is_busy:
+                        busy_workers += 1
+                    elif worker_model.is_idle:
+                        idle_workers += 1
+                    elif worker_model.state == 'suspended':
+                        suspended_workers += 1
+
+                    total_successful += worker_model.successful_job_count
+                    total_failed += worker_model.failed_job_count
+                    total_working_time += worker_model.total_working_time
+
+                    # Convert to dict for serializer
+                    worker_dict = worker_model.model_dump()
+                    worker_dict['queues'] = worker_model.get_queue_list()
+                    worker_dict['current_job'] = worker_dict.pop('current_job_id')
+                    workers_list.append(worker_dict)
+
+                except Exception as e:
+                    logger.debug(f"Failed to process worker: {e}")
+                    continue
+
+            stats_data = {
+                "total_workers": len(all_workers),
+                "busy_workers": busy_workers,
+                "idle_workers": idle_workers,
+                "suspended_workers": suspended_workers,
+                "total_successful_jobs": total_successful,
+                "total_failed_jobs": total_failed,
+                "total_working_time": total_working_time,
+                "workers": workers_list,
+            }
+
+            serializer = WorkerStatsSerializer(data=stats_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            import traceback
+            logger.error(f"Worker stats error: {e}", exc_info=True)
+            return Response(
+                {
+                    "error": str(e),
+                    "traceback": traceback.format_exc(),
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

django_cfg/apps/urls.py

@@ -44,15 +44,18 @@ def get_enabled_cfg_apps() -> List[str]:
     if base_module.is_agents_enabled():
         enabled_apps.append("django_cfg.apps.agents")
 
-    if base_module.should_enable_tasks():
-        enabled_apps.append("django_cfg.apps.tasks")
-
     if base_module.is_payments_enabled():
         enabled_apps.append("django_cfg.apps.payments")
 
     if base_module.is_centrifugo_enabled():
         enabled_apps.append("django_cfg.apps.centrifugo")
 
+    if base_module.should_enable_rq():
+        enabled_apps.append("django_cfg.apps.rq")
+
+    if base_module.is_grpc_enabled():
+        enabled_apps.append("django_cfg.apps.grpc")
+
     return enabled_apps
 
 
@@ -84,7 +87,7 @@ def get_default_cfg_group():
         name="cfg",
         apps=get_enabled_cfg_apps(),
         title="Django-CFG API",
-        description="Authentication (OTP), Support, Newsletter, Leads, Knowledge Base, AI Agents, Tasks, Payments, Dashboard",
+        description="Authentication (OTP), Support, Newsletter, Leads, Knowledge Base, AI Agents, Tasks, Payments, Centrifugo, gRPC, Dashboard",
         version="1.0.0",
     )
 
@@ -173,16 +176,18 @@ APP_URL_MAP = {
     "django_cfg.apps.agents": [
         ("cfg/agents/", "django_cfg.apps.agents.urls"),
     ],
-    "django_cfg.apps.tasks": [
-        ("cfg/tasks/", "django_cfg.apps.tasks.urls"),
-    ],
     "django_cfg.apps.payments": [
         ("cfg/payments/", "django_cfg.apps.payments.urls"),
-        # Payments v2.0: No separate urls_admin (uses Django Admin only)
     ],
     "django_cfg.apps.centrifugo": [
         ("cfg/centrifugo/", "django_cfg.apps.centrifugo.urls"),
     ],
+    "django_cfg.apps.rq": [
+        ("cfg/rq/", "django_cfg.apps.rq.urls"),
+    ],
+    "django_cfg.apps.grpc": [
+        ("cfg/grpc/", "django_cfg.apps.grpc.urls"),
+    ],
 }
 
 # Register URLs for enabled apps only

django_cfg/config.py

@@ -45,3 +45,109 @@ def get_default_dropdown_items() -> List[SiteDropdownItem]:
             link=LIB_SITE_URL,
         ),
     ]
+
+
+# ==============================================================================
+# Feature Detection System
+# ==============================================================================
+
+import logging
+from typing import Dict, Callable
+
+logger = logging.getLogger(__name__)
+
+# Feature registry
+FEATURES: Dict[str, Callable[[], bool]] = {}
+
+
+def register_feature(name: str, check_func: Callable[[], bool]) -> None:
+    """
+    Register a feature check function.
+
+    Args:
+        name: Feature name (e.g., 'grpc', 'graphql')
+        check_func: Function that returns True if feature dependencies are installed
+
+    Example:
+        >>> def check_grpc():
+        ...     try:
+        ...         import grpcio
+        ...         return True
+        ...     except ImportError:
+        ...         return False
+        >>> register_feature('grpc', check_grpc)
+    """
+    FEATURES[name] = check_func
+    logger.debug(f"Registered feature: {name}")
+
+
+def is_feature_available(feature: str) -> bool:
+    """
+    Check if optional feature is available.
+
+    Args:
+        feature: Feature name (e.g., 'grpc', 'graphql')
+
+    Returns:
+        True if feature dependencies are installed, False otherwise
+
+    Example:
+        >>> if is_feature_available('grpc'):
+        ...     from django_cfg.models.api.grpc import GRPCConfig
+    """
+    check_func = FEATURES.get(feature)
+    if not check_func:
+        logger.warning(f"Unknown feature: {feature}")
+        return False
+
+    try:
+        result = check_func()
+        logger.debug(f"Feature '{feature}' available: {result}")
+        return result
+    except Exception as e:
+        logger.debug(f"Feature '{feature}' not available: {e}")
+        return False
+
+
+def require_feature(feature: str, error_message: str = None) -> None:
+    """
+    Require a feature or raise ImportError.
+
+    Args:
+        feature: Feature name
+        error_message: Custom error message
+
+    Raises:
+        ImportError: If feature not available
+
+    Example:
+        >>> require_feature('grpc')  # Raises if not installed
+        >>> from django_cfg.models.api.grpc import GRPCConfig  # Safe to import
+    """
+    if not is_feature_available(feature):
+        if error_message is None:
+            error_message = (
+                f"Feature '{feature}' requires additional dependencies. "
+                f"Install with: pip install django-cfg[{feature}]"
+            )
+        raise ImportError(error_message)
+
+
+# ==============================================================================
+# Built-in Feature Checks
+# ==============================================================================
+
+def _check_grpc_available() -> bool:
+    """Check if gRPC dependencies are installed."""
+    try:
+        import grpc as _grpc  # noqa: F401
+        import grpc_tools as _grpc_tools  # noqa: F401
+        import django_grpc_framework as _dgf  # noqa: F401
+        import google.protobuf as _protobuf  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+# Register built-in features
+register_feature('grpc', _check_grpc_available)

django_cfg/core/base/config_model.py

@@ -20,9 +20,9 @@ from ...models import (
     ApiKeys,
     AxesConfig,
     CacheConfig,
-    DjangoQ2Config,
     CryptoFieldsConfig,
     DatabaseConfig,
+    DjangoRQConfig,
     DRFConfig,
     EmailConfig,
     LimitsConfig,
@@ -30,9 +30,9 @@ from ...models import (
     TelegramConfig,
     UnfoldConfig,
 )
+from ...models.api.grpc import GRPCConfig
 from ...models.ngrok import NgrokConfig
 from ...models.payments import PaymentsConfig
-from ...models.tasks import TaskConfig
 from ...modules.nextjs_admin import NextJsAdminConfig
 from ..exceptions import ConfigurationError
 from ..types.enums import EnvironmentMode, StartupInfoMode
@@ -223,7 +223,7 @@ class DjangoConfig(BaseModel):
         description=(
             "Redis connection URL (redis://host:port/db). "
             "If set and cache_default is None, automatically creates RedisCache backend. "
-            "Also used by tasks (ReArq, Django-Q2) if they don't specify broker_url."
+            "Also used by Django-RQ if queues don't specify connection details."
         ),
     )
 
@@ -323,16 +323,10 @@ class DjangoConfig(BaseModel):
         description="Enable modern Tailwind CSS theme for Django REST Framework Browsable API",
     )
 
-    # === Background Task Processing ===
-    tasks: Optional[TaskConfig] = Field(
+    # === Django-RQ Task Queue & Scheduler ===
+    django_rq: Optional[DjangoRQConfig] = Field(
         default=None,
-        description="Background task processing configuration (ReArq)",
-    )
-
-    # === Django-Q2 Task Scheduling ===
-    django_q2: Optional[DjangoQ2Config] = Field(
-        default=None,
-        description="Django-Q2 task scheduling and queue configuration",
+        description="Django-RQ task queue and scheduler configuration (sync tasks, cron scheduling)",
     )
 
     # === Centrifugo Configuration ===
@@ -352,6 +346,11 @@ class DjangoConfig(BaseModel):
         description="Extended DRF Spectacular configuration (supplements OpenAPI Client)",
     )
 
+    grpc: Optional[GRPCConfig] = Field(
+        default=None,
+        description="gRPC framework configuration (server, authentication, proto generation)",
+    )
+
     # === Limits Configuration ===
     limits: Optional[LimitsConfig] = Field(
         default=None,
@@ -635,28 +634,19 @@ class DjangoConfig(BaseModel):
             **kwargs
         )
 
-    def should_enable_tasks(self) -> bool:
+    def should_enable_rq(self) -> bool:
         """
-        Determine if background tasks should be enabled.
+        Determine if Django-RQ should be enabled.
 
-        Tasks are enabled if:
-        1. Explicitly configured via tasks field
-        2. Knowledge base is enabled (requires background processing)
-        3. Agents are enabled (requires background processing)
+        Django-RQ is enabled if explicitly configured via django_rq field.
 
         Returns:
-            True if tasks should be enabled, False otherwise
+            True if Django-RQ should be enabled, False otherwise
         """
-        # Check if explicitly configured
-        if hasattr(self, 'tasks') and self.tasks and self.tasks.enabled:
-            return True
-
-        # Check if features that require tasks are enabled
-        if self.enable_knowbase or self.enable_agents:
+        if hasattr(self, 'django_rq') and self.django_rq and self.django_rq.enabled:
             return True
 
         return False
 
-
 # Export main class
 __all__ = ["DjangoConfig"]

django_cfg/core/builders/apps_builder.py

@@ -23,7 +23,6 @@ class InstalledAppsBuilder:
     - Combine default Django/third-party apps
     - Add django-cfg apps based on enabled features
     - Handle special ordering (accounts before admin)
-    - Auto-enable tasks if needed
     - Auto-detect dashboard apps from Unfold
     - Add project-specific apps
     - Remove duplicates while preserving order
@@ -140,6 +139,9 @@ class InstalledAppsBuilder:
         if self.config.centrifugo and self.config.centrifugo.enabled:
             apps.append("django_cfg.apps.centrifugo")
 
+        if self.config.grpc and self.config.grpc.enabled:
+            apps.append("django_cfg.apps.grpc")
+
         if self.config.crypto_fields and self.config.crypto_fields.enabled:
             apps.append("django_crypto_fields.apps.AppConfig")
 
@@ -158,16 +160,10 @@ class InstalledAppsBuilder:
         """
         apps = []
 
-        # Auto-enable tasks if needed by other features
-        if self.config.should_enable_tasks():
-            # No external app needed - ReArq is embedded
-            apps.append("django_cfg.apps.tasks")
-
-        # Add django-q2 if enabled
-        if hasattr(self.config, "django_q2") and self.config.django_q2 and self.config.django_q2.enabled:
-            apps.append("django_q")
-            # Auto-add django_q2 module for automatic schedule synchronization
-            apps.append("django_cfg.modules.django_q2")
+        # Add Django-RQ if enabled
+        if hasattr(self.config, "django_rq") and self.config.django_rq and self.config.django_rq.enabled:
+            apps.append("django_rq")  # Core django-rq package
+            apps.append("django_cfg.apps.rq")  # Django-CFG monitoring & API
 
         # Add DRF Tailwind theme module (uses Tailwind via CDN)
         if self.config.enable_drf_tailwind:

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