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

django_cfg/apps/tasks/services/sync.py

@@ -1,204 +0,0 @@
-"""
-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,16 +0,0 @@
-"""
-ReArq Tasks API URLs.
-
-REST API endpoints for task monitoring and management.
-"""
-from django.urls import path
-from rest_framework.routers import DefaultRouter
-
-from .views import TaskLogViewSet
-
-app_name = 'django_cfg_tasks'
-
-router = DefaultRouter()
-router.register(r'logs', TaskLogViewSet, basename='tasklog')
-
-urlpatterns = router.urls

django_cfg/apps/tasks/views/__init__.py

@@ -1,10 +0,0 @@
-"""
-ReArq Tasks API Views.
-
-ViewSets for task monitoring and management.
-"""
-from .task_log import TaskLogViewSet
-
-__all__ = [
-    "TaskLogViewSet",
-]

django_cfg/apps/tasks/views/task_log.py

@@ -1,41 +0,0 @@
-"""
-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

@@ -1,41 +0,0 @@
-"""
-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

@@ -1,100 +0,0 @@
-"""
-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

@@ -1,41 +0,0 @@
-"""
-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

@@ -1,91 +0,0 @@
-"""
-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

@@ -1,81 +0,0 @@
-"""
-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)