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

django_cfg/apps/dashboard/serializers/django_q2.py

@@ -1,50 +0,0 @@
-"""
-Django-Q2 Task Serializers
-
-Serializers for displaying Django-Q2 scheduled tasks and task history.
-"""
-
-from rest_framework import serializers
-
-
-class DjangoQ2ScheduleSerializer(serializers.Serializer):
-    """Serializer for Django-Q2 scheduled tasks."""
-
-    id = serializers.IntegerField(read_only=True)
-    name = serializers.CharField(max_length=255)
-    func = serializers.CharField(max_length=512)
-    schedule_type = serializers.CharField(max_length=24)
-    repeats = serializers.IntegerField()
-    next_run = serializers.DateTimeField(allow_null=True)
-    last_run = serializers.DateTimeField(allow_null=True)
-
-
-class DjangoQ2TaskSerializer(serializers.Serializer):
-    """Serializer for Django-Q2 task execution history."""
-
-    id = serializers.CharField(max_length=32)
-    name = serializers.CharField(max_length=255)
-    func = serializers.CharField(max_length=512)
-    started = serializers.DateTimeField()
-    stopped = serializers.DateTimeField(allow_null=True)
-    success = serializers.BooleanField()
-    result = serializers.CharField(allow_null=True)
-
-
-class DjangoQ2StatusSerializer(serializers.Serializer):
-    """Serializer for Django-Q2 cluster status."""
-
-    cluster_running = serializers.BooleanField()
-    total_schedules = serializers.IntegerField()
-    active_schedules = serializers.IntegerField()
-    recent_tasks = serializers.IntegerField()
-    successful_tasks = serializers.IntegerField()
-    failed_tasks = serializers.IntegerField()
-
-
-class DjangoQ2SummarySerializer(serializers.Serializer):
-    """Summary serializer for Django-Q2 dashboard."""
-
-    status = DjangoQ2StatusSerializer()
-    schedules = DjangoQ2ScheduleSerializer(many=True)
-    recent_tasks = DjangoQ2TaskSerializer(many=True)

django_cfg/apps/dashboard/services/django_q2_service.py

@@ -1,159 +0,0 @@
-"""
-Django-Q2 Service
-
-Business logic for collecting Django-Q2 task data.
-"""
-
-from typing import Dict, List, Any
-
-
-class DjangoQ2Service:
-    """Service for aggregating Django-Q2 task information."""
-
-    @staticmethod
-    def get_schedules() -> List[Dict[str, Any]]:
-        """
-        Get all scheduled tasks from Django-Q2.
-
-        Returns:
-            List of scheduled tasks with their configurations
-        """
-        try:
-            from django_q.models import Schedule
-
-            schedules = Schedule.objects.all().order_by('-next_run')
-            return [
-                {
-                    'id': schedule.id,
-                    'name': schedule.name,
-                    'func': schedule.func,
-                    'schedule_type': schedule.schedule_type,
-                    'repeats': schedule.repeats,
-                    'next_run': schedule.next_run,
-                    'last_run': getattr(schedule, 'last_run', None),
-                }
-                for schedule in schedules
-            ]
-        except ImportError:
-            # django-q2 not installed
-            return []
-        except Exception:
-            # Database error or table doesn't exist yet
-            return []
-
-    @staticmethod
-    def get_recent_tasks(limit: int = 20) -> List[Dict[str, Any]]:
-        """
-        Get recent task executions from Django-Q2.
-
-        Args:
-            limit: Maximum number of tasks to return
-
-        Returns:
-            List of recent task executions with their results
-        """
-        try:
-            from django_q.models import Task
-
-            tasks = Task.objects.all().order_by('-started')[:limit]
-            return [
-                {
-                    'id': task.id,
-                    'name': task.name,
-                    'func': task.func,
-                    'started': task.started,
-                    'stopped': task.stopped,
-                    'success': task.success,
-                    'result': str(task.result) if task.result else None,
-                }
-                for task in tasks
-            ]
-        except ImportError:
-            # django-q2 not installed
-            return []
-        except Exception:
-            # Database error or table doesn't exist yet
-            return []
-
-    @staticmethod
-    def get_cluster_status() -> Dict[str, Any]:
-        """
-        Get Django-Q2 cluster status.
-
-        Returns:
-            Dictionary with cluster status information
-        """
-        try:
-            from django_q.models import Schedule, Task
-            from django_q.cluster import Cluster
-
-            # Count schedules
-            total_schedules = Schedule.objects.count()
-            active_schedules = Schedule.objects.filter(repeats__gt=0).count()
-
-            # Count recent tasks (last 24 hours)
-            from django.utils import timezone
-            from datetime import timedelta
-
-            last_24h = timezone.now() - timedelta(hours=24)
-            recent_tasks = Task.objects.filter(started__gte=last_24h).count()
-            successful_tasks = Task.objects.filter(
-                started__gte=last_24h, success=True
-            ).count()
-            failed_tasks = Task.objects.filter(
-                started__gte=last_24h, success=False
-            ).count()
-
-            # Check if cluster is running
-            cluster_running = False
-            try:
-                # Check for recent task activity as proxy for cluster status
-                recent_task = Task.objects.filter(
-                    started__gte=timezone.now() - timedelta(minutes=5)
-                ).exists()
-                cluster_running = recent_task
-            except Exception:
-                pass
-
-            return {
-                'cluster_running': cluster_running,
-                'total_schedules': total_schedules,
-                'active_schedules': active_schedules,
-                'recent_tasks': recent_tasks,
-                'successful_tasks': successful_tasks,
-                'failed_tasks': failed_tasks,
-            }
-        except ImportError:
-            # django-q2 not installed
-            return {
-                'cluster_running': False,
-                'total_schedules': 0,
-                'active_schedules': 0,
-                'recent_tasks': 0,
-                'successful_tasks': 0,
-                'failed_tasks': 0,
-            }
-        except Exception:
-            # Database error or table doesn't exist yet
-            return {
-                'cluster_running': False,
-                'total_schedules': 0,
-                'active_schedules': 0,
-                'recent_tasks': 0,
-                'successful_tasks': 0,
-                'failed_tasks': 0,
-            }
-
-    @classmethod
-    def get_summary(cls) -> Dict[str, Any]:
-        """
-        Get complete Django-Q2 summary for dashboard.
-
-        Returns:
-            Dictionary with status, schedules, and recent tasks
-        """
-        return {
-            'status': cls.get_cluster_status(),
-            'schedules': cls.get_schedules(),
-            'recent_tasks': cls.get_recent_tasks(limit=10),
-        }

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/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",
-]