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

django_cfg/apps/tasks/admin/config.py

@@ -0,0 +1,98 @@
+"""
+Admin configuration for Task models.
+
+Declarative AdminConfig using PydanticAdmin patterns.
+"""
+
+from django_cfg.modules.django_admin import (
+    AdminConfig,
+    BadgeField,
+    DateTimeField,
+    Icons,
+    UserField,
+)
+
+from ..models import TaskLog
+
+
+# Declarative configuration for TaskLog
+tasklog_config = AdminConfig(
+    model=TaskLog,
+
+    # Performance optimization
+    select_related=["user"],
+
+    # List display
+    list_display=[
+        "task_name",
+        "queue_badge",
+        "status_badge",
+        "user",
+        "duration_display",
+        "retry_count",
+        "created_at",
+        "completed_at",
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(
+            name="queue_name",
+            title="Queue",
+            variant="info",
+            icon=Icons.LAYERS,
+        ),
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "queued": "secondary",
+                "in_progress": "info",
+                "completed": "success",
+                "failed": "danger",
+                "canceled": "warning",
+            },
+        ),
+        UserField(name="user", title="User", header=True),
+        DateTimeField(name="created_at", title="Created", ordering="created_at"),
+        DateTimeField(name="started_at", title="Started", ordering="started_at"),
+        DateTimeField(name="completed_at", title="Completed", ordering="completed_at"),
+    ],
+
+    # Filters
+    list_filter=["status", "task_name", "queue_name", "created_at"],
+    search_fields=[
+        "job_id",
+        "task_name",
+        "worker_id",
+        "error_message",
+        "user__username",
+        "user__email",
+    ],
+
+    # Autocomplete for user field
+    autocomplete_fields=["user"],
+
+    # Readonly fields
+    readonly_fields=[
+        "id",
+        "job_id",
+        "created_at",
+        "started_at",
+        "completed_at",
+        "duration_ms",
+        "worker_id",
+    ],
+
+    # Date hierarchy
+    date_hierarchy="created_at",
+
+    # Per page
+    list_per_page=50,
+
+    # Ordering
+    ordering=["-created_at"],
+)
+
+
+__all__ = ["tasklog_config"]

django_cfg/apps/tasks/admin/task_log.py

@@ -0,0 +1,265 @@
+"""
+Task Log Admin.
+
+PydanticAdmin for TaskLog model with custom computed fields.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import TaskLog
+from .config import tasklog_config
+
+
+@admin.register(TaskLog)
+class TaskLogAdmin(PydanticAdmin):
+    """
+    Task log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - Duration display with performance indicators
+    - Retry count tracking
+    - Formatted JSON for arguments
+    - Error details with highlighted display
+    """
+
+    config = tasklog_config
+
+    @computed_field("Queue", ordering="queue_name")
+    def queue_badge(self, obj):
+        """Display queue name as badge."""
+        variant_map = {
+            "critical": "danger",
+            "high": "warning",
+            "default": "primary",
+            "low": "secondary",
+            "background": "secondary",
+        }
+        variant = variant_map.get(obj.queue_name, "info")
+        return self.html.badge(obj.queue_name, variant=variant, icon=Icons.LAYERS)
+
+    @computed_field("Status", ordering="status")
+    def status_badge(self, obj):
+        """Display status with appropriate badge."""
+        variant_map = {
+            "queued": "secondary",
+            "in_progress": "info",
+            "completed": "success",
+            "failed": "danger",
+            "canceled": "warning",
+        }
+        icon_map = {
+            "queued": Icons.TIMER,
+            "in_progress": Icons.SPEED,
+            "completed": Icons.CHECK_CIRCLE,
+            "failed": Icons.ERROR,
+            "canceled": Icons.WARNING,
+        }
+        variant = variant_map.get(obj.status, "secondary")
+        icon = icon_map.get(obj.status, Icons.NOTIFICATIONS)
+        return self.html.badge(obj.get_status_display(), variant=variant, icon=icon)
+
+    @computed_field("Duration", ordering="duration_ms")
+    def duration_display(self, obj):
+        """Display duration with color coding based on speed."""
+        if obj.duration_ms is None:
+            return self.html.empty()
+
+        # Color code based on duration
+        if obj.duration_ms < 1000:  # < 1s
+            variant = "success"  # Fast
+            icon = Icons.SPEED
+        elif obj.duration_ms < 5000:  # < 5s
+            variant = "info"  # Normal
+            icon = Icons.TIMER
+        elif obj.duration_ms < 30000:  # < 30s
+            variant = "warning"  # Slow
+            icon = Icons.TIMER
+        else:
+            variant = "danger"  # Very slow
+            icon = Icons.ERROR
+
+        # Format duration
+        if obj.duration_ms < 1000:
+            duration_str = f"{obj.duration_ms}ms"
+        else:
+            duration_str = f"{obj.duration_ms / 1000:.2f}s"
+
+        return self.html.badge(duration_str, variant=variant, icon=icon)
+
+    def args_display(self, obj):
+        """Display formatted JSON arguments."""
+        if not obj.args and not obj.kwargs:
+            return self.html.empty("No arguments")
+
+        try:
+            data = {}
+            if obj.args:
+                data["args"] = obj.args
+            if obj.kwargs:
+                data["kwargs"] = obj.kwargs
+
+            formatted = json.dumps(data, indent=2)
+            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
+        except Exception:
+            return str(data)
+
+    args_display.short_description = "Task Arguments"
+
+    def error_details_display(self, obj):
+        """Display error information if task failed."""
+        if obj.is_successful or obj.status in ["queued", "in_progress"]:
+            return self.html.inline(
+                [
+                    self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                    self.html.span("No errors", "text-green-600"),
+                ]
+            )
+
+        if not obj.error_message:
+            return self.html.empty("No error message")
+
+        return self.html.inline(
+            [
+                self.html.icon(Icons.ERROR, size="sm"),
+                self.html.span(obj.error_message, "text-red-600 font-mono text-sm"),
+            ]
+        )
+
+    error_details_display.short_description = "Error Details"
+
+    def retry_info_display(self, obj):
+        """Display retry information."""
+        if obj.retry_count == 0:
+            return self.html.inline(
+                [
+                    self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                    self.html.span("No retries", "text-gray-600"),
+                ]
+            )
+
+        # Show retry count with warning if high
+        if obj.retry_count >= 3:
+            variant = "danger"
+            icon = Icons.ERROR
+        elif obj.retry_count >= 2:
+            variant = "warning"
+            icon = Icons.WARNING
+        else:
+            variant = "info"
+            icon = Icons.TIMER
+
+        return self.html.inline(
+            [
+                self.html.badge(f"{obj.retry_count} retries", variant=variant, icon=icon),
+            ]
+        )
+
+    retry_info_display.short_description = "Retry Info"
+
+    def performance_summary(self, obj):
+        """Display performance summary."""
+        stats = []
+
+        # Duration
+        if obj.duration_ms is not None:
+            if obj.duration_ms < 1000:
+                duration_str = f"{obj.duration_ms}ms"
+            else:
+                duration_str = f"{obj.duration_ms / 1000:.2f}s"
+            stats.append(
+                self.html.inline(
+                    [
+                        self.html.span("Duration:", "font-semibold"),
+                        self.html.span(duration_str, "text-gray-600"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        # Retry count
+        if obj.retry_count > 0:
+            stats.append(
+                self.html.inline(
+                    [
+                        self.html.span("Retries:", "font-semibold"),
+                        self.html.badge(str(obj.retry_count), variant="warning"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        # Worker ID
+        if obj.worker_id:
+            stats.append(
+                self.html.inline(
+                    [
+                        self.html.span("Worker:", "font-semibold"),
+                        self.html.span(obj.worker_id, "text-gray-600 font-mono text-xs"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        return "<br>".join(stats) if stats else self.html.empty()
+
+    performance_summary.short_description = "Performance"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Task Information",
+                {
+                    "fields": (
+                        "id",
+                        "job_id",
+                        "task_name",
+                        "queue_name",
+                        "status",
+                        "user",
+                    )
+                },
+            ),
+            (
+                "Arguments",
+                {"fields": ("args_display",), "classes": ("collapse",)},
+            ),
+            (
+                "Performance",
+                {
+                    "fields": (
+                        "performance_summary",
+                        "created_at",
+                        "started_at",
+                        "completed_at",
+                    )
+                },
+            ),
+        ]
+
+        # Add error section only if failed
+        if obj and obj.is_failed:
+            fieldsets.insert(
+                2,
+                (
+                    "Error Details",
+                    {
+                        "fields": (
+                            "error_details_display",
+                            "error_message",
+                            "retry_info_display",
+                        )
+                    },
+                ),
+            )
+
+        return fieldsets
+
+
+__all__ = ["TaskLogAdmin"]

django_cfg/apps/tasks/apps.py

@@ -1,17 +1,15 @@
-"""
-Django CFG Tasks App Configuration
-"""
-
+"""Django AppConfig for tasks app."""
 from django.apps import AppConfig
 
 
 class TasksConfig(AppConfig):
-    """Configuration for Django CFG Tasks app."""
+    """Django app configuration for ReArq tasks."""
 
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.apps.tasks'
-    verbose_name = 'Background Tasks'
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_cfg.apps.tasks"
+    verbose_name = "Background Tasks"
 
     def ready(self):
         """Initialize app when Django starts."""
-        pass
+        # Import services to ensure client is available
+        from . import services  # noqa: F401

django_cfg/apps/tasks/filters/__init__.py

@@ -0,0 +1,10 @@
+"""
+ReArq Tasks Filters.
+
+Django-filter FilterSets for task log filtering.
+"""
+from .task_log import TaskLogFilter
+
+__all__ = [
+    "TaskLogFilter",
+]

django_cfg/apps/tasks/filters/task_log.py

@@ -0,0 +1,121 @@
+"""
+TaskLog FilterSet for advanced filtering.
+
+Provides comprehensive filtering capabilities for task logs.
+"""
+import django_filters
+from django.db.models import Q
+
+from ..models import TaskLog
+
+
+class TaskLogFilter(django_filters.FilterSet):
+    """
+    Advanced FilterSet for TaskLog.
+
+    Matches ReArq API query parameters where possible.
+
+    Provides filters for:
+    - Task name (exact, contains)
+    - Queue name (exact, in)
+    - Status (exact, in) - matching ReArq JobStatus
+    - Date ranges (enqueue, start, finish)
+    - Duration ranges
+    - Retry count ranges
+    - Success/failure flags
+    """
+
+    # Task name filters (matching ReArq "task" param)
+    task = django_filters.CharFilter(field_name='task_name', lookup_expr='exact')
+    task_name = django_filters.CharFilter(lookup_expr='icontains')
+    task_name_exact = django_filters.CharFilter(field_name='task_name', lookup_expr='exact')
+
+    # Queue filters
+    queue_name = django_filters.CharFilter(lookup_expr='exact')
+    queue_name_in = django_filters.BaseInFilter(field_name='queue_name')
+
+    # Status filters (matching ReArq "status" param)
+    status = django_filters.CharFilter(lookup_expr='exact')
+    status_in = django_filters.BaseInFilter(field_name='status')
+
+    # Success filter (matching ReArq JobResult)
+    success = django_filters.BooleanFilter()
+
+    # Boolean flags (computed properties)
+    is_completed = django_filters.BooleanFilter(method='filter_is_completed')
+    is_successful = django_filters.BooleanFilter(method='filter_is_successful')
+    is_failed = django_filters.BooleanFilter(method='filter_is_failed')
+
+    # Date range filters (matching ReArq "start_time" / "end_time")
+    start_time = django_filters.DateTimeFilter(field_name='enqueue_time', lookup_expr='gte')
+    end_time = django_filters.DateTimeFilter(field_name='enqueue_time', lookup_expr='lte')
+
+    # Additional date filters
+    enqueue_after = django_filters.DateTimeFilter(field_name='enqueue_time', lookup_expr='gte')
+    enqueue_before = django_filters.DateTimeFilter(field_name='enqueue_time', lookup_expr='lte')
+
+    start_after = django_filters.DateTimeFilter(field_name='start_time', lookup_expr='gte')
+    start_before = django_filters.DateTimeFilter(field_name='start_time', lookup_expr='lte')
+
+    finish_after = django_filters.DateTimeFilter(field_name='finish_time', lookup_expr='gte')
+    finish_before = django_filters.DateTimeFilter(field_name='finish_time', lookup_expr='lte')
+
+    # Django-specific filters
+    created_after = django_filters.DateTimeFilter(field_name='created_at', lookup_expr='gte')
+    created_before = django_filters.DateTimeFilter(field_name='created_at', lookup_expr='lte')
+
+    # Duration filters (milliseconds)
+    duration_min = django_filters.NumberFilter(field_name='duration_ms', lookup_expr='gte')
+    duration_max = django_filters.NumberFilter(field_name='duration_ms', lookup_expr='lte')
+
+    # Retry filters (matching ReArq Job fields)
+    job_retries_min = django_filters.NumberFilter(field_name='job_retries', lookup_expr='gte')
+    job_retries_max = django_filters.NumberFilter(field_name='job_retries', lookup_expr='lte')
+
+    # Job ID filter (matching ReArq "job_id" param)
+    job_id = django_filters.CharFilter(lookup_expr='exact')
+
+    # Worker filter (matching ReArq JobResult "worker" param)
+    worker = django_filters.CharFilter(field_name='worker_id', lookup_expr='exact')
+
+    # Error message search
+    has_error = django_filters.BooleanFilter(method='filter_has_error')
+
+    class Meta:
+        model = TaskLog
+        fields = [
+            'task_name',
+            'queue_name',
+            'status',
+            'success',
+            'job_id',
+            'worker_id',
+        ]
+
+    def filter_has_error(self, queryset, name, value):
+        """Filter tasks with/without errors."""
+        if value:
+            return queryset.filter(error_message__isnull=False).exclude(error_message='')
+        else:
+            return queryset.filter(Q(error_message__isnull=True) | Q(error_message=''))
+
+    def filter_is_completed(self, queryset, name, value):
+        """Filter by completed status."""
+        if value:
+            return queryset.filter(status__in=['success', 'failed', 'expired', 'canceled'])
+        else:
+            return queryset.filter(status__in=['deferred', 'queued', 'in_progress'])
+
+    def filter_is_successful(self, queryset, name, value):
+        """Filter by successful completion."""
+        if value:
+            return queryset.filter(status='success', success=True)
+        else:
+            return queryset.exclude(status='success', success=True)
+
+    def filter_is_failed(self, queryset, name, value):
+        """Filter by failed status."""
+        if value:
+            return queryset.filter(Q(status__in=['failed', 'expired']) | Q(success=False))
+        else:
+            return queryset.exclude(Q(status__in=['failed', 'expired']) | Q(success=False))