django-cfg 1.4.107__py3-none-any.whl → 1.4.109__py3-none-any.whl

django_cfg/apps/tasks/services/sync.py

@@ -0,0 +1,204 @@
+"""
+ReArq to TaskLog sync utilities.
+
+Helpers for syncing data from ReArq (Tortoise ORM) to TaskLog (Django ORM).
+"""
+from typing import Optional
+from django.utils import timezone
+from ..models import TaskLog
+
+
+def create_task_log_from_job(
+    job_id: str,
+    task_name: str,
+    queue_name: str = "default",
+    args: list = None,
+    kwargs: dict = None,
+    job_retry: int = 0,
+    job_retry_after: int = 60,
+    enqueue_time = None,
+    expire_time = None,
+    status: str = "queued",
+    user=None,
+) -> TaskLog:
+    """
+    Create TaskLog entry from ReArq Job data.
+
+    Args:
+        job_id: Unique job identifier from ReArq
+        task_name: Name of the task function
+        queue_name: Queue name (default: "default")
+        args: Positional arguments
+        kwargs: Keyword arguments
+        job_retry: Max retry count from task definition
+        job_retry_after: Seconds to wait before retry
+        enqueue_time: When job was enqueued (Job.enqueue_time)
+        expire_time: When job will expire (Job.expire_time)
+        status: Job status (default: "queued")
+        user: Django User who triggered the task
+
+    Returns:
+        Created TaskLog instance
+    """
+    return TaskLog.objects.create(
+        job_id=job_id,
+        task_name=task_name,
+        queue_name=queue_name,
+        args=args or [],
+        kwargs=kwargs or {},
+        job_retry=job_retry,
+        job_retry_after=job_retry_after,
+        enqueue_time=enqueue_time or timezone.now(),
+        expire_time=expire_time,
+        status=status,
+        user=user,
+    )
+
+
+def update_task_log_from_result(
+    job_id: str,
+    worker: str,
+    success: bool,
+    result: str = None,
+    start_time = None,
+    finish_time = None,
+) -> Optional[TaskLog]:
+    """
+    Update TaskLog with JobResult data.
+
+    Args:
+        job_id: Job identifier
+        worker: Worker that processed the task
+        success: Whether task succeeded
+        result: Task result (JSON string)
+        start_time: When execution started (JobResult.start_time)
+        finish_time: When execution finished (JobResult.finish_time)
+
+    Returns:
+        Updated TaskLog instance or None if not found
+    """
+    try:
+        task_log = TaskLog.objects.get(job_id=job_id)
+    except TaskLog.DoesNotExist:
+        return None
+
+    # Update fields from JobResult
+    task_log.worker_id = worker
+    task_log.success = success
+    task_log.start_time = start_time
+    task_log.finish_time = finish_time
+
+    if result is not None:
+        task_log.result = result
+
+    # Calculate duration
+    if start_time and finish_time:
+        delta = finish_time - start_time
+        task_log.duration_ms = int(delta.total_seconds() * 1000)
+
+    # Update status based on success
+    if success:
+        task_log.status = TaskLog.StatusChoices.SUCCESS
+    else:
+        task_log.status = TaskLog.StatusChoices.FAILED
+
+    task_log.save()
+    return task_log
+
+
+def sync_job_status(job_id: str, status: str, job_retries: int = None) -> Optional[TaskLog]:
+    """
+    Sync Job status to TaskLog.
+
+    Args:
+        job_id: Job identifier
+        status: ReArq JobStatus value
+        job_retries: Current retry count
+
+    Returns:
+        Updated TaskLog instance or None if not found
+    """
+    try:
+        task_log = TaskLog.objects.get(job_id=job_id)
+    except TaskLog.DoesNotExist:
+        return None
+
+    task_log.status = status
+    if job_retries is not None:
+        task_log.job_retries = job_retries
+
+    task_log.save(update_fields=["status", "job_retries", "updated_at"])
+    return task_log
+
+
+async def sync_from_rearq_job(rearq_job):
+    """
+    Sync TaskLog from ReArq Job instance (Tortoise model).
+
+    Usage:
+        from rearq.server.models import Job
+        job = await Job.get(job_id="...")
+        await sync_from_rearq_job(job)
+
+    Args:
+        rearq_job: ReArq Job instance (Tortoise ORM)
+
+    Returns:
+        TaskLog instance
+    """
+    from asgiref.sync import sync_to_async
+
+    # Extract queue name from full queue path
+    queue_name = rearq_job.task.split(':')[-1] if ':' in rearq_job.task else "default"
+
+    # Check if TaskLog exists
+    task_log = await sync_to_async(TaskLog.objects.filter(job_id=rearq_job.job_id).first)()
+
+    if task_log:
+        # Update existing
+        task_log.status = rearq_job.status
+        task_log.job_retries = rearq_job.job_retries
+        await sync_to_async(task_log.save)(update_fields=["status", "job_retries", "updated_at"])
+    else:
+        # Create new
+        task_log = await sync_to_async(create_task_log_from_job)(
+            job_id=rearq_job.job_id,
+            task_name=rearq_job.task,
+            queue_name=queue_name,
+            args=rearq_job.args or [],
+            kwargs=rearq_job.kwargs or {},
+            job_retry=rearq_job.job_retry,
+            job_retry_after=rearq_job.job_retry_after,
+            enqueue_time=rearq_job.enqueue_time,
+            expire_time=rearq_job.expire_time,
+            status=rearq_job.status,
+        )
+
+    return task_log
+
+
+async def sync_from_rearq_result(rearq_result):
+    """
+    Sync TaskLog from ReArq JobResult instance (Tortoise model).
+
+    Usage:
+        from rearq.server.models import JobResult
+        result = await JobResult.get(job_id="...").prefetch_related("job")
+        await sync_from_rearq_result(result)
+
+    Args:
+        rearq_result: ReArq JobResult instance (Tortoise ORM)
+
+    Returns:
+        TaskLog instance or None
+    """
+    from asgiref.sync import sync_to_async
+
+    return await sync_to_async(update_task_log_from_result)(
+        job_id=rearq_result.job_id,
+        worker=rearq_result.worker,
+        success=rearq_result.success,
+        result=rearq_result.result,
+        start_time=rearq_result.start_time,
+        finish_time=rearq_result.finish_time,
+    )

django_cfg/apps/tasks/urls.py

@@ -1,22 +1,16 @@
 """
-URLs for Django CFG Tasks app.
+ReArq Tasks API URLs.
 
-Provides RESTful endpoints for task queue management and monitoring using ViewSets and routers.
+REST API endpoints for task monitoring and management.
 """
-
-from django.urls import include, path
+from django.urls import path
 from rest_framework.routers import DefaultRouter
 
-from .views import TaskManagementViewSet
+from .views import TaskLogViewSet
 
-app_name = 'tasks'
+app_name = 'django_cfg_tasks'
 
-# Main router for ViewSets
 router = DefaultRouter()
-router.register(r'', TaskManagementViewSet, basename='task-management')
-
-urlpatterns = [
-    # RESTful API endpoints using ViewSets
-    path('api/', include(router.urls)),
+router.register(r'logs', TaskLogViewSet, basename='tasklog')
 
-]
+urlpatterns = router.urls

django_cfg/apps/tasks/views/__init__.py

@@ -1,16 +1,10 @@
 """
-Views package for Django CFG Tasks app.
+ReArq Tasks API Views.
 
-Provides organized views structure:
-- api: DRF ViewSets for API endpoints
-- dashboard: Dashboard template views
-- base: Shared functionality and mixins
+ViewSets for task monitoring and management.
 """
-
-from .api import TaskManagementViewSet
-from .dashboard import dashboard_view
+from .task_log import TaskLogViewSet
 
 __all__ = [
-    'TaskManagementViewSet',
-    'dashboard_view'
+    "TaskLogViewSet",
 ]

django_cfg/apps/tasks/views/task_log.py

@@ -0,0 +1,41 @@
+"""
+TaskLog ViewSet - Main Entry Point.
+
+Combines all task log functionality through mixins.
+"""
+from .task_log_base import TaskLogBaseViewSet
+from .task_log_stats import TaskLogStatsMixin
+from .task_log_timeline import TaskLogTimelineMixin
+from .task_log_overview import TaskLogOverviewMixin
+from .task_log_related import TaskLogRelatedMixin
+
+
+class TaskLogViewSet(
+    TaskLogStatsMixin,
+    TaskLogTimelineMixin,
+    TaskLogOverviewMixin,
+    TaskLogRelatedMixin,
+    TaskLogBaseViewSet,
+):
+    """
+    Complete ViewSet for TaskLog monitoring.
+
+    Provides read-only access to task execution logs with filtering,
+    searching, and statistics.
+
+    Endpoints:
+        GET /api/tasks/logs/ - List all task logs
+        GET /api/tasks/logs/{id}/ - Get task log details
+        GET /api/tasks/logs/{id}/related/ - Get related task logs
+        GET /api/tasks/logs/stats/ - Get aggregated statistics
+        GET /api/tasks/logs/timeline/ - Get task execution timeline
+        GET /api/tasks/logs/overview/ - Get summary overview
+
+    Mixins:
+        - TaskLogStatsMixin: Aggregated statistics
+        - TaskLogTimelineMixin: Time-series data
+        - TaskLogOverviewMixin: High-level summary
+        - TaskLogRelatedMixin: Related task lookup
+        - TaskLogBaseViewSet: Base CRUD operations
+    """
+    pass

django_cfg/apps/tasks/views/task_log_base.py

@@ -0,0 +1,41 @@
+"""
+TaskLog Base ViewSet.
+
+Base viewset with common configuration for task log endpoints.
+"""
+from rest_framework import viewsets
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters.rest_framework import DjangoFilterBackend
+
+from django_cfg.mixins import AdminAPIMixin
+from ..models import TaskLog
+from ..serializers import (
+    TaskLogSerializer,
+    TaskLogListSerializer,
+    TaskLogDetailSerializer,
+)
+from ..filters import TaskLogFilter
+
+
+class TaskLogBaseViewSet(AdminAPIMixin, viewsets.ReadOnlyModelViewSet):
+    """
+    Base ViewSet for TaskLog monitoring.
+
+    Provides read-only access to task execution logs with filtering and searching.
+    Extended by mixins for additional functionality (stats, timeline, overview).
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    queryset = TaskLog.objects.all().order_by('-enqueue_time')
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = TaskLogFilter
+    search_fields = ['task_name', 'job_id', 'queue_name', 'error_message', 'worker_id']
+    ordering_fields = ['enqueue_time', 'start_time', 'finish_time', 'duration_ms', 'job_retries', 'created_at']
+
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'list':
+            return TaskLogListSerializer
+        elif self.action == 'retrieve':
+            return TaskLogDetailSerializer
+        return TaskLogSerializer

django_cfg/apps/tasks/views/task_log_overview.py

@@ -0,0 +1,100 @@
+"""
+TaskLog Overview Actions.
+
+Provides high-level summary statistics for the entire task system.
+"""
+from django.db.models import Q, Count
+from django.utils import timezone
+from datetime import timedelta
+from drf_spectacular.utils import extend_schema
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import TaskLog
+from ..serializers import TaskLogOverviewSerializer
+
+
+class TaskLogOverviewMixin:
+    """
+    Mixin for task system overview endpoints.
+
+    Provides high-level statistics:
+    - Total task counts
+    - Active queues
+    - Recent failures
+    - Distribution by queue and status
+    """
+
+    @extend_schema(
+        responses={200: TaskLogOverviewSerializer},
+        summary="Task System Overview",
+        description="Get high-level summary statistics for the entire task system"
+    )
+    @action(detail=False, methods=['get'])
+    def overview(self, request):
+        """
+        Get summary overview of task system.
+
+        Returns properly structured data validated by TaskLogOverviewSerializer.
+
+        Returns:
+            {
+                "total_tasks": 1500,
+                "active_queues": ["default", "high", "knowledge"],
+                "recent_failures": 5,
+                "tasks_by_queue": [
+                    {"queue_name": "default", "count": 800},
+                    {"queue_name": "high", "count": 500},
+                    {"queue_name": "knowledge", "count": 200}
+                ],
+                "tasks_by_status": [
+                    {"status": "success", "count": 1450},
+                    {"status": "failed", "count": 45},
+                    {"status": "in_progress", "count": 5}
+                ]
+            }
+        """
+        # Get all-time statistics
+        total_tasks = TaskLog.objects.count()
+
+        # Get active queues
+        active_queues = list(
+            TaskLog.objects.values_list('queue_name', flat=True)
+            .distinct()
+            .order_by('queue_name')
+        )
+
+        # Recent failures (last 24 hours)
+        time_threshold = timezone.now() - timedelta(hours=24)
+        recent_failures = TaskLog.objects.filter(
+            Q(success=False) | Q(status__in=['failed', 'expired']),
+            created_at__gte=time_threshold
+        ).count()
+
+        # Tasks by queue - convert to array of objects
+        tasks_by_queue = [
+            {'queue_name': item['queue_name'], 'count': item['count']}
+            for item in TaskLog.objects.values('queue_name')
+            .annotate(count=Count('id'))
+            .order_by('queue_name')
+        ]
+
+        # Tasks by status - convert to array of objects
+        tasks_by_status = [
+            {'status': item['status'], 'count': item['count']}
+            for item in TaskLog.objects.values('status')
+            .annotate(count=Count('id'))
+            .order_by('status')
+        ]
+
+        overview_data = {
+            'total_tasks': total_tasks,
+            'active_queues': active_queues,
+            'recent_failures': recent_failures,
+            'tasks_by_queue': tasks_by_queue,
+            'tasks_by_status': tasks_by_status,
+        }
+
+        # Validate and serialize data
+        serializer = TaskLogOverviewSerializer(overview_data)
+        return Response(serializer.data)

django_cfg/apps/tasks/views/task_log_related.py

@@ -0,0 +1,41 @@
+"""
+TaskLog Related Tasks Actions.
+
+Provides endpoints for finding related task executions.
+"""
+from django.db.models import Q
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import TaskLog
+from ..serializers import TaskLogListSerializer
+
+
+class TaskLogRelatedMixin:
+    """
+    Mixin for related tasks endpoints.
+
+    Provides functionality to find related task executions:
+    - Same job_id (retries)
+    - Same task_name (similar executions)
+    """
+
+    @action(detail=True, methods=['get'])
+    def related(self, request, pk=None):
+        """
+        Get related task logs (same job_id or task_name).
+
+        Returns tasks that share the same job_id or are retries of the same task.
+
+        Returns:
+            Array of related TaskLog objects (up to 10 most recent)
+        """
+        task_log = self.get_object()
+
+        # Find related tasks
+        related = TaskLog.objects.filter(
+            Q(job_id=task_log.job_id) | Q(task_name=task_log.task_name)
+        ).exclude(id=task_log.id).order_by('-created_at')[:10]
+
+        serializer = TaskLogListSerializer(related, many=True)
+        return Response(serializer.data)

django_cfg/apps/tasks/views/task_log_stats.py

@@ -0,0 +1,91 @@
+"""
+TaskLog Statistics Actions.
+
+Provides aggregated statistics and metrics for task execution monitoring.
+"""
+from django.db.models import Q, Avg
+from django.utils import timezone
+from datetime import timedelta
+from drf_spectacular.utils import extend_schema
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import TaskLog
+from ..serializers import TaskLogStatsSerializer
+
+
+class TaskLogStatsMixin:
+    """
+    Mixin for task statistics endpoints.
+
+    Provides aggregated statistics about task execution:
+    - Success/failure rates
+    - Average durations
+    - Task counts by status
+    """
+
+    @extend_schema(
+        responses={200: TaskLogStatsSerializer},
+        summary="Task Execution Statistics",
+        description="Get aggregated statistics about task execution (success/failure rates, duration)"
+    )
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """
+        Get aggregated task statistics.
+
+        Query Parameters:
+            period_hours (int): Statistics period in hours (default: 24)
+            task_name (str): Filter by specific task name
+
+        Returns:
+            {
+                "total": 150,
+                "successful": 145,
+                "failed": 5,
+                "in_progress": 2,
+                "success_rate": 96.67,
+                "avg_duration_ms": 1250,
+                "avg_duration_seconds": 1.25,
+                "period_hours": 24
+            }
+        """
+        period_hours = int(request.query_params.get('period_hours', 24))
+        task_name = request.query_params.get('task_name')
+
+        # Calculate time threshold
+        time_threshold = timezone.now() - timedelta(hours=period_hours)
+
+        # Base queryset
+        queryset = TaskLog.objects.filter(created_at__gte=time_threshold)
+        if task_name:
+            queryset = queryset.filter(task_name=task_name)
+
+        # Calculate statistics
+        total = queryset.count()
+        successful = queryset.filter(success=True).count()
+        failed = queryset.filter(success=False, status='failed').count()
+        in_progress = queryset.filter(Q(status='in_progress') | Q(status='queued')).count()
+
+        # Calculate success rate
+        completed = successful + failed
+        success_rate = (successful / completed * 100) if completed > 0 else 0.0
+
+        # Calculate average duration (only for completed tasks)
+        avg_duration = queryset.filter(
+            duration_ms__isnull=False
+        ).aggregate(avg=Avg('duration_ms'))['avg'] or 0
+
+        stats_data = {
+            'total': total,
+            'successful': successful,
+            'failed': failed,
+            'in_progress': in_progress,
+            'success_rate': round(success_rate, 2),
+            'avg_duration_ms': int(avg_duration),
+            'avg_duration_seconds': round(avg_duration / 1000, 2),
+            'period_hours': period_hours,
+        }
+
+        serializer = TaskLogStatsSerializer(stats_data)
+        return Response(serializer.data)

django_cfg/apps/tasks/views/task_log_timeline.py

@@ -0,0 +1,81 @@
+"""
+TaskLog Timeline Actions.
+
+Provides time-series data for task execution visualization.
+"""
+from django.utils import timezone
+from datetime import timedelta
+from drf_spectacular.utils import extend_schema
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import TaskLog
+from ..serializers import TaskLogTimelineSerializer
+
+
+class TaskLogTimelineMixin:
+    """
+    Mixin for task timeline endpoints.
+
+    Provides time-bucketed statistics for visualization:
+    - Hourly/daily task counts
+    - Success/failure trends
+    - Performance metrics over time
+    """
+
+    @extend_schema(
+        responses={200: TaskLogTimelineSerializer},
+        summary="Task Execution Timeline",
+        description="Get time-series data of task executions grouped by time intervals"
+    )
+    @action(detail=False, methods=['get'])
+    def timeline(self, request):
+        """
+        Get task execution timeline grouped by time intervals.
+
+        Returns timeline data wrapped in object with period/interval metadata.
+
+        Query Parameters:
+            period_hours (int): Timeline period in hours (default: 24)
+            interval (str): Grouping interval - 'hour', 'day' (default: 'hour')
+            task_name (str): Filter by specific task name
+
+        Returns:
+            {
+                "period_hours": 24,
+                "interval": "hour",
+                "data": [
+                    {
+                        "timestamp": "2025-10-30T10:00:00Z",
+                        "total": 15,
+                        "successful": 14,
+                        "failed": 1,
+                        "avg_duration_ms": 1200
+                    },
+                    ...
+                ]
+            }
+        """
+        period_hours = int(request.query_params.get('period_hours', 24))
+        interval = request.query_params.get('interval', 'hour')
+        task_name = request.query_params.get('task_name')
+
+        # Calculate time threshold
+        time_threshold = timezone.now() - timedelta(hours=period_hours)
+
+        # Base queryset
+        queryset = TaskLog.objects.filter(created_at__gte=time_threshold)
+        if task_name:
+            queryset = queryset.filter(task_name=task_name)
+
+        # TODO: Implement proper time-series grouping with SQL time bucketing
+        # For now, return empty data array with correct structure
+        timeline_data = {
+            'period_hours': period_hours,
+            'interval': interval,
+            'data': []  # Empty for now - will be implemented later
+        }
+
+        # Validate and serialize
+        serializer = TaskLogTimelineSerializer(timeline_data)
+        return Response(serializer.data)

django_cfg/apps/urls.py

@@ -175,7 +175,6 @@ APP_URL_MAP = {
     ],
     "django_cfg.apps.tasks": [
         ("cfg/tasks/", "django_cfg.apps.tasks.urls"),
-        ("cfg/tasks/admin/", "django_cfg.apps.tasks.urls_admin"),
     ],
     "django_cfg.apps.payments": [
         ("cfg/payments/", "django_cfg.apps.payments.urls"),

django_cfg/cli/commands/info.py

@@ -74,7 +74,7 @@ def info(verbose: bool):
         "🌐 Service Integrations": ["twilio", "sendgrid", "openai", "telegram-bot-api"],
         "🎨 Admin & UI": ["django-unfold", "django-constance"],
         "📊 API & Documentation": ["djangorestframework", "drf-spectacular"],
-        "⚡ Background Processing": ["dramatiq", "redis"],
+        "⚡ Background Processing": ["rearq", "redis"],
         "🛠️  Development Tools": ["ngrok"],
     }
 

django_cfg/cli/utils.py

@@ -166,7 +166,7 @@ def get_standard_dependencies() -> Dict[str, str]:
         "drf-spectacular": "drf_spectacular",
 
         # Tasks & Background Processing
-        "dramatiq": "dramatiq",
+        "rearq": "rearq",
         "redis": "redis",
 
         # Development