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

django_cfg/apps/dashboard/views/django_q2_views.py

@@ -1,79 +0,0 @@
-"""
-Django-Q2 ViewSet
-
-API endpoints for Django-Q2 task monitoring.
-"""
-
-from rest_framework import viewsets, status
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
-
-from ..services.django_q2_service import DjangoQ2Service
-from ..serializers.django_q2 import (
-    DjangoQ2ScheduleSerializer,
-    DjangoQ2TaskSerializer,
-    DjangoQ2StatusSerializer,
-    DjangoQ2SummarySerializer,
-)
-
-
-class DjangoQ2ViewSet(viewsets.ViewSet):
-    """
-    ViewSet for Django-Q2 task monitoring.
-
-    Provides endpoints for:
-    - Scheduled tasks list
-    - Recent task executions
-    - Cluster status
-    - Complete summary
-    """
-
-    permission_classes = [IsAuthenticated]
-
-    @action(detail=False, methods=['get'])
-    def schedules(self, request):
-        """
-        Get all scheduled tasks.
-
-        GET /api/django_q2/schedules/
-        """
-        schedules = DjangoQ2Service.get_schedules()
-        serializer = DjangoQ2ScheduleSerializer(schedules, many=True)
-        return Response(serializer.data)
-
-    @action(detail=False, methods=['get'])
-    def tasks(self, request):
-        """
-        Get recent task executions.
-
-        GET /api/django_q2/tasks/
-        Query params:
-            - limit: Number of tasks to return (default: 20)
-        """
-        limit = int(request.query_params.get('limit', 20))
-        tasks = DjangoQ2Service.get_recent_tasks(limit=limit)
-        serializer = DjangoQ2TaskSerializer(tasks, many=True)
-        return Response(serializer.data)
-
-    @action(detail=False, methods=['get'])
-    def status(self, request):
-        """
-        Get Django-Q2 cluster status.
-
-        GET /api/django_q2/status/
-        """
-        status_data = DjangoQ2Service.get_cluster_status()
-        serializer = DjangoQ2StatusSerializer(status_data)
-        return Response(serializer.data)
-
-    def list(self, request):
-        """
-        Get complete Django-Q2 summary.
-
-        GET /api/django_q2/
-        Returns status, schedules, and recent tasks.
-        """
-        summary = DjangoQ2Service.get_summary()
-        serializer = DjangoQ2SummarySerializer(summary)
-        return Response(serializer.data)

django_cfg/apps/tasks/__init__.py

@@ -1,64 +0,0 @@
-"""
-ReArq tasks app for Django-CFG.
-
-Provides async background task processing with Redis queue.
-"""
-
-__all__ = [
-    "ReArqClient",
-    "get_rearq_client",
-    "get_tasks_config",
-    "get_tasks_config_or_default",
-    "task",
-    "cron_task",
-]
-
-
-def __getattr__(name):
-    """Lazy imports to avoid loading ReArq at Django startup."""
-    if name in ("ReArqClient", "get_rearq_client"):
-        from .services.client import ReArqClient, get_rearq_client
-        return ReArqClient if name == "ReArqClient" else get_rearq_client
-    elif name in ("get_tasks_config", "get_tasks_config_or_default"):
-        from .services.config_helper import get_tasks_config, get_tasks_config_or_default
-        return get_tasks_config if name == "get_tasks_config" else get_tasks_config_or_default
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
-
-def task(queue: str = "default", **kwargs):
-    """
-    Task decorator shortcut.
-
-    Example:
-        >>> from django_cfg.apps.tasks import task
-        >>>
-        >>> @task(queue="default")
-        >>> async def my_task(data: str):
-        ...     return f"Processed {data}"
-        >>>
-        >>> # Execute task
-        >>> job = await my_task.delay(data="test")
-        >>> result = await job.result(timeout=30)
-    """
-    from .services.client import get_rearq_client
-    client = get_rearq_client()
-    return client.task(queue=queue, **kwargs)
-
-
-def cron_task(cron: str, **kwargs):
-    """
-    Cron task decorator shortcut.
-
-    Args:
-        cron: Cron expression (e.g., "0 * * * *" for hourly)
-
-    Example:
-        >>> from django_cfg.apps.tasks import cron_task
-        >>>
-        >>> @cron_task(cron="0 0 * * *")  # Daily at midnight
-        >>> async def daily_cleanup():
-        ...     return "Cleanup complete"
-    """
-    from .services.client import get_rearq_client
-    client = get_rearq_client()
-    return client.cron_task(cron=cron, **kwargs)

django_cfg/apps/tasks/admin/__init__.py

@@ -1,4 +0,0 @@
-"""Admin configuration for tasks app."""
-from .config import tasklog_config
-
-__all__ = ["tasklog_config"]

django_cfg/apps/tasks/admin/config.py

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

@@ -1,238 +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 self.html.code_block(formatted, language="json", max_height="400px")
-        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.text("No errors", variant="success"),
-                separator=" "
-            )
-
-        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.code(obj.error_message, css_class="text-font-danger-light dark:text-font-danger-dark text-sm"),
-            separator=" "
-        )
-
-    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.text("No retries", muted=True),
-                separator=" "
-            )
-
-        # 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.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."""
-        # Duration
-        duration_line = None
-        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"
-            duration_line = self.html.key_value("Duration", duration_str)
-
-        # Retry count
-        retry_line = None
-        if obj.retry_count > 0:
-            retry_line = self.html.key_value(
-                "Retries",
-                self.html.badge(str(obj.retry_count), variant="warning")
-            )
-
-        # Worker ID
-        worker_line = None
-        if obj.worker_id:
-            worker_line = self.html.key_value("Worker", self.html.code(obj.worker_id, css_class="text-xs"))
-
-        return self.html.breakdown(duration_line, retry_line, worker_line) if (duration_line or retry_line or worker_line) 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))