django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/tasks/admin/task_log.py

@@ -1,265 +0,0 @@
-"""
-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,15 +0,0 @@
-"""Django AppConfig for tasks app."""
-from django.apps import AppConfig
-
-
-class TasksConfig(AppConfig):
-    """Django app configuration for ReArq 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."""
-        # Import services to ensure client is available
-        from . import services  # noqa: F401

django_cfg/apps/tasks/filters/__init__.py

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

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

django_cfg/apps/tasks/migrations/0001_initial.py

@@ -1,196 +0,0 @@
-# Generated by Django 5.2.7 on 2025-10-30 11:15
-
-import django.db.models.deletion
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    initial = True
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="TaskLog",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
-                    ),
-                ),
-                (
-                    "job_id",
-                    models.CharField(
-                        db_index=True,
-                        help_text="Unique job identifier from ReArq",
-                        max_length=100,
-                        unique=True,
-                    ),
-                ),
-                (
-                    "task_name",
-                    models.CharField(
-                        db_index=True, help_text="Name of the task function", max_length=200
-                    ),
-                ),
-                (
-                    "queue_name",
-                    models.CharField(
-                        db_index=True, help_text="Queue where task was executed", max_length=100
-                    ),
-                ),
-                (
-                    "args",
-                    models.JSONField(default=list, help_text="Positional arguments passed to task"),
-                ),
-                (
-                    "kwargs",
-                    models.JSONField(default=dict, help_text="Keyword arguments passed to task"),
-                ),
-                (
-                    "status",
-                    models.CharField(
-                        choices=[
-                            ("deferred", "Deferred"),
-                            ("queued", "Queued"),
-                            ("in_progress", "In Progress"),
-                            ("success", "Success"),
-                            ("failed", "Failed"),
-                            ("expired", "Expired"),
-                            ("canceled", "Canceled"),
-                        ],
-                        db_index=True,
-                        default="queued",
-                        help_text="Current task status",
-                        max_length=20,
-                    ),
-                ),
-                (
-                    "duration_ms",
-                    models.IntegerField(
-                        blank=True, help_text="Task execution duration in milliseconds", null=True
-                    ),
-                ),
-                (
-                    "job_retry",
-                    models.IntegerField(
-                        default=0,
-                        help_text="Maximum number of retries allowed (from task definition)",
-                    ),
-                ),
-                (
-                    "job_retries",
-                    models.IntegerField(default=0, help_text="Number of retries performed so far"),
-                ),
-                (
-                    "job_retry_after",
-                    models.IntegerField(default=60, help_text="Seconds to wait before retry"),
-                ),
-                (
-                    "success",
-                    models.BooleanField(
-                        blank=True,
-                        help_text="Whether task completed successfully (null = not finished)",
-                        null=True,
-                    ),
-                ),
-                (
-                    "result",
-                    models.TextField(blank=True, help_text="Task result (JSON string)", null=True),
-                ),
-                (
-                    "error_message",
-                    models.TextField(
-                        blank=True, help_text="Error message if task failed", null=True
-                    ),
-                ),
-                (
-                    "worker_id",
-                    models.CharField(
-                        blank=True,
-                        help_text="ID of worker that processed the task",
-                        max_length=100,
-                        null=True,
-                    ),
-                ),
-                (
-                    "enqueue_time",
-                    models.DateTimeField(
-                        db_index=True,
-                        help_text="When job was enqueued to ReArq (from Job.enqueue_time)",
-                    ),
-                ),
-                (
-                    "expire_time",
-                    models.DateTimeField(
-                        blank=True,
-                        help_text="When job will expire (from Job.expire_time)",
-                        null=True,
-                    ),
-                ),
-                (
-                    "start_time",
-                    models.DateTimeField(
-                        blank=True,
-                        help_text="When task execution started (from JobResult.start_time)",
-                        null=True,
-                    ),
-                ),
-                (
-                    "finish_time",
-                    models.DateTimeField(
-                        blank=True,
-                        help_text="When task execution finished (from JobResult.finish_time)",
-                        null=True,
-                    ),
-                ),
-                (
-                    "created_at",
-                    models.DateTimeField(
-                        auto_now_add=True, help_text="When TaskLog record was created in Django DB"
-                    ),
-                ),
-                (
-                    "updated_at",
-                    models.DateTimeField(
-                        auto_now=True, help_text="When TaskLog record was last updated"
-                    ),
-                ),
-                (
-                    "user",
-                    models.ForeignKey(
-                        blank=True,
-                        help_text="User who triggered the task (if applicable)",
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        to=settings.AUTH_USER_MODEL,
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "Task Log",
-                "verbose_name_plural": "Task Logs",
-                "db_table": "django_cfg_task_log",
-                "ordering": ["-enqueue_time"],
-                "indexes": [
-                    models.Index(
-                        fields=["task_name", "-enqueue_time"], name="django_cfg__task_na_e84031_idx"
-                    ),
-                    models.Index(
-                        fields=["status", "-enqueue_time"], name="django_cfg__status_a59726_idx"
-                    ),
-                    models.Index(
-                        fields=["queue_name", "status"], name="django_cfg__queue_n_b8a67b_idx"
-                    ),
-                    models.Index(
-                        fields=["success", "-enqueue_time"], name="django_cfg__success_85e48e_idx"
-                    ),
-                    models.Index(fields=["-created_at"], name="django_cfg__created_4eea05_idx"),
-                ],
-            },
-        ),
-    ]

django_cfg/apps/tasks/migrations/0002_delete_tasklog.py

@@ -1,16 +0,0 @@
-# Generated by Django 5.2.7 on 2025-10-31 05:54
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("tasks", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.DeleteModel(
-            name="TaskLog",
-        ),
-    ]

django_cfg/apps/tasks/models/__init__.py

@@ -1,4 +0,0 @@
-"""Task models."""
-from .task_log import TaskLog
-
-__all__ = ["TaskLog"]