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

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)

django_cfg/core/generation/integration_generators/django_q2.py

@@ -1,133 +0,0 @@
-"""
-Django-Q2 settings generator for django-cfg.
-
-Generates django-q2 settings and handles INSTALLED_APPS integration.
-"""
-
-from typing import TYPE_CHECKING, Any, Dict, Optional
-
-from django_cfg.modules.django_logging import logger
-
-if TYPE_CHECKING:
-    from django_cfg.models.django.django_q import DjangoQ2Config
-
-
-class DjangoQ2SettingsGenerator:
-    """
-    Generates task scheduling settings for django-q2.
-
-    Automatically:
-    - Generates Q_CLUSTER configuration
-    - Adds django_q to INSTALLED_APPS if enabled
-    - Configures broker, workers, and task settings
-    - Provides schedule management via Django ORM
-
-    Django-Q2 vs django-crontab:
-    - No need to run 'crontab add' - schedules in database
-    - Built-in admin interface for monitoring
-    - Support for both cron and interval scheduling
-    - Task retries and hooks
-    - Async task support
-    """
-
-    def __init__(self, config: "DjangoQ2Config", parent_config: Optional[Any] = None):
-        """
-        Initialize with Django-Q2 configuration.
-
-        Args:
-            config: DjangoQ2Config instance
-            parent_config: Optional parent DjangoConfig for accessing redis_url
-        """
-        self.config = config
-        self.parent_config = parent_config
-
-    def generate(self) -> Dict[str, Any]:
-        """
-        Generate Django-Q2 settings.
-
-        Returns:
-            Dictionary with Q_CLUSTER configuration
-        """
-        if not self.config or not self.config.enabled:
-            return {}
-
-        settings = self.config.to_django_settings(parent_config=self.parent_config)
-
-        # Log configuration
-        logger.info(
-            f"✓ Configured Django-Q2 task queue "
-            f"[broker: {self.config.broker_class}, workers: {self.config.workers}]"
-        )
-
-        enabled_schedules = self.config.get_enabled_schedules()
-        if enabled_schedules:
-            logger.info(
-                f"✓ Found {len(enabled_schedules)} scheduled task(s) "
-                f"[use admin or management commands to create schedules]"
-            )
-
-            # Log individual schedules in debug mode
-            for schedule in enabled_schedules:
-                logger.debug(
-                    f"  - {schedule.name}: {schedule.schedule_type} → "
-                    f"{schedule.command if schedule.command else schedule.func}"
-                )
-
-            logger.info(
-                "📝 To create schedules: python manage.py qcluster "
-                "or use Django admin at /admin/django_q/schedule/"
-            )
-
-        return settings
-
-    def generate_schedule_creation_code(self) -> str:
-        """
-        Generate Python code to create schedules programmatically.
-
-        Returns:
-            Python code string for creating schedules
-
-        Example:
-            ```python
-            code = generator.generate_schedule_creation_code()
-            # Use in management command or startup script
-            ```
-        """
-        if not self.config or not self.config.enabled:
-            return ""
-
-        enabled_schedules = self.config.get_enabled_schedules()
-        if not enabled_schedules:
-            return ""
-
-        lines = [
-            "# Auto-generated Django-Q2 schedule creation",
-            "from django_q.models import Schedule",
-            "",
-            "# Create or update schedules",
-        ]
-
-        for schedule in enabled_schedules:
-            schedule_dict = schedule.to_django_q_format()
-
-            lines.append("")
-            lines.append(f"# {schedule.name}")
-            lines.append("Schedule.objects.update_or_create(")
-            lines.append(f"    name='{schedule.name}',")
-            lines.append("    defaults={")
-
-            for key, value in schedule_dict.items():
-                if key == "name":
-                    continue
-                if isinstance(value, str):
-                    lines.append(f"        '{key}': '{value}',")
-                else:
-                    lines.append(f"        '{key}': {value},")
-
-            lines.append("    }")
-            lines.append(")")
-
-        return "\n".join(lines)
-
-
-__all__ = ["DjangoQ2SettingsGenerator"]

django_cfg/core/generation/integration_generators/tasks.py

@@ -1,88 +0,0 @@
-"""
-Background tasks generator.
-
-Handles ReArq task queue configuration.
-Size: ~100 lines (focused on task processing)
-"""
-
-import logging
-from typing import TYPE_CHECKING, Any, Dict
-
-if TYPE_CHECKING:
-    from ...base.config_model import DjangoConfig
-
-logger = logging.getLogger(__name__)
-
-
-class TasksSettingsGenerator:
-    """
-    Generates background task processing settings.
-
-    Responsibilities:
-    - Configure ReArq task queue
-    - Auto-detect if tasks should be enabled
-    - Set up task configuration
-
-    Example:
-        ```python
-        generator = TasksSettingsGenerator(config)
-        settings = generator.generate()
-        ```
-    """
-
-    def __init__(self, config: "DjangoConfig"):
-        """
-        Initialize generator with configuration.
-
-        Args:
-            config: DjangoConfig instance
-        """
-        self.config = config
-
-    def generate(self) -> Dict[str, Any]:
-        """
-        Generate task processing settings.
-
-        Returns:
-            Dictionary with ReArq configuration
-
-        Example:
-            >>> generator = TasksSettingsGenerator(config)
-            >>> settings = generator.generate()
-        """
-        # Check if tasks should be enabled
-        if not self.config.should_enable_tasks():
-            logger.debug("⏭️  Tasks disabled")
-            return {}
-
-        try:
-            return self._generate_rearq_settings()
-        except ImportError as e:
-            logger.warning(f"Failed to import ReArq: {e}")
-            return {}
-        except Exception as e:
-            logger.error(f"Failed to generate ReArq settings: {e}")
-            return {}
-
-    def _generate_rearq_settings(self) -> Dict[str, Any]:
-        """
-        Generate ReArq-specific settings.
-
-        Returns:
-            Dictionary with ReArq configuration
-        """
-        from django_cfg.models.tasks import TaskConfig
-
-        # Auto-initialize TaskConfig if needed
-        task_config = TaskConfig.auto_initialize_if_needed()
-        if task_config is None:
-            return {}
-
-        # Generate settings via standard method
-        settings = task_config.to_django_settings()
-
-        logger.info("✅ ReArq tasks enabled")
-        return settings
-
-
-__all__ = ["TasksSettingsGenerator"]