django-cfg 1.5.1__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,15 @@ 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")
 
@@ -176,16 +176,15 @@ 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"),
     ],

django_cfg/core/base/config_model.py

@@ -20,9 +20,9 @@ from ...models import (
     ApiKeys,
     AxesConfig,
     CacheConfig,
-    DjangoQ2Config,
     CryptoFieldsConfig,
     DatabaseConfig,
+    DjangoRQConfig,
     DRFConfig,
     EmailConfig,
     LimitsConfig,
@@ -33,7 +33,6 @@ from ...models import (
 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
@@ -224,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."
         ),
     )
 
@@ -324,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 ===
@@ -641,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
@@ -161,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']

django_cfg/core/generation/orchestrator.py

@@ -77,9 +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_django_q2_settings())
             settings.update(self._generate_tailwind_settings())
 
             # Apply additional settings (user overrides)
@@ -216,14 +215,17 @@ 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
+            raise ConfigurationError(f"Failed to generate Django-RQ settings: {e}") from e
 
     def _generate_grpc_settings(self) -> Dict[str, Any]:
         """Generate gRPC framework settings."""
@@ -234,18 +236,6 @@ class SettingsOrchestrator:
         except Exception as e:
             raise ConfigurationError(f"Failed to generate gRPC 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 {}
-
-        try:
-            from .integration_generators.django_q2 import DjangoQ2SettingsGenerator
-            generator = DjangoQ2SettingsGenerator(self.config.django_q2, parent_config=self.config)
-            return generator.generate()
-        except Exception as e:
-            raise ConfigurationError(f"Failed to generate Django-Q2 settings: {e}") from e
-
     def _generate_tailwind_settings(self) -> Dict[str, Any]:
         """Generate Tailwind CSS settings."""
         try:

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

@@ -6,7 +6,7 @@ Django integrations and extensions.
 
 from .axes import AxesConfig
 from .constance import ConstanceConfig, ConstanceField
-from .django_q2 import DjangoQ2Config, DjangoQ2ScheduleConfig
+from .django_rq import DjangoRQConfig, RQQueueConfig
 from .environment import EnvironmentConfig
 from .openapi import OpenAPIClientConfig
 
@@ -14,8 +14,8 @@ __all__ = [
     "EnvironmentConfig",
     "ConstanceConfig",
     "ConstanceField",
-    "DjangoQ2Config",
-    "DjangoQ2ScheduleConfig",
+    "DjangoRQConfig",
+    "RQQueueConfig",
     "OpenAPIClientConfig",
     "AxesConfig",
 ]