django-cfg 1.4.113__py3-none-any.whl → 1.4.114__py3-none-any.whl

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.113"
+__version__ = "1.4.114"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/dashboard/serializers/__init__.py

@@ -22,10 +22,11 @@ from .commands import (
     CommandHelpResponseSerializer,
 )
 from .apizones import APIZoneSerializer, APIZonesSummarySerializer
-from .crontab import (
-    CrontabJobSerializer,
-    CrontabJobsSerializer,
-    CrontabStatusSerializer,
+from .django_q2 import (
+    DjangoQ2ScheduleSerializer,
+    DjangoQ2TaskSerializer,
+    DjangoQ2StatusSerializer,
+    DjangoQ2SummarySerializer,
 )
 
 __all__ = [
@@ -65,8 +66,9 @@ __all__ = [
     'APIZoneSerializer',
     'APIZonesSummarySerializer',
 
-    # Crontab
-    'CrontabJobSerializer',
-    'CrontabJobsSerializer',
-    'CrontabStatusSerializer',
+    # Django-Q2
+    'DjangoQ2ScheduleSerializer',
+    'DjangoQ2TaskSerializer',
+    'DjangoQ2StatusSerializer',
+    'DjangoQ2SummarySerializer',
 ]

django_cfg/apps/dashboard/serializers/django_q2.py

@@ -0,0 +1,50 @@
+"""
+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/__init__.py

@@ -11,7 +11,7 @@ from .charts_service import ChartsService
 from .commands_service import CommandsService
 from .apizones_service import APIZonesService
 from .overview_service import OverviewService
-from .crontab_service import CrontabService
+from .django_q2_service import DjangoQ2Service
 
 __all__ = [
     'StatisticsService',
@@ -20,5 +20,5 @@ __all__ = [
     'CommandsService',
     'APIZonesService',
     'OverviewService',
-    'CrontabService',
+    'DjangoQ2Service',
 ]

django_cfg/apps/dashboard/services/django_q2_service.py

@@ -0,0 +1,159 @@
+"""
+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/services/system_health_service.py

@@ -191,73 +191,86 @@ class SystemHealthService:
                 'health_percentage': 0,
             }
 
-    def check_crontab_health(self) -> Dict[str, Any]:
+    def check_django_q2_health(self) -> Dict[str, Any]:
         """
-        Check crontab/scheduled jobs configuration and status.
+        Check Django-Q2 task scheduling configuration and status.
 
         Returns:
-            Health status dictionary with job count and configuration details
+            Health status dictionary with schedule count and cluster status
         """
         try:
             from django_cfg.core.config import get_current_config
 
             config = get_current_config()
 
-            # Check if crontab is configured
-            if not hasattr(config, 'crontab') or not config.crontab:
+            # Check if django_q2 is configured
+            if not hasattr(config, 'django_q2') or not config.django_q2:
                 return {
-                    'component': 'crontab',
+                    'component': 'django_q2',
                     'status': 'info',
-                    'description': 'Crontab scheduling not configured',
+                    'description': 'Django-Q2 scheduling not configured',
                     'last_check': datetime.now().isoformat(),
                     'health_percentage': 100,
                     'details': {
                         'enabled': False,
-                        'jobs_count': 0,
+                        'schedules_count': 0,
                     }
                 }
 
-            crontab_config = config.crontab
+            django_q2_config = config.django_q2
 
             # Check if enabled
-            if not crontab_config.enabled:
+            if not django_q2_config.enabled:
                 return {
-                    'component': 'crontab',
+                    'component': 'django_q2',
                     'status': 'warning',
-                    'description': 'Crontab scheduling is disabled',
+                    'description': 'Django-Q2 scheduling is disabled',
                     'last_check': datetime.now().isoformat(),
                     'health_percentage': 50,
                     'details': {
                         'enabled': False,
-                        'jobs_count': len(crontab_config.jobs),
+                        'schedules_count': len(django_q2_config.schedules) if django_q2_config.schedules else 0,
                     }
                 }
 
-            # Count enabled jobs
-            enabled_jobs = [job for job in crontab_config.jobs if job.enabled]
-            jobs_count = len(enabled_jobs)
+            # Count schedules
+            schedules_count = len(django_q2_config.schedules) if django_q2_config.schedules else 0
+
+            # Try to check cluster status from database
+            cluster_running = False
+            try:
+                from django_q.models import Schedule, Task
+                from django.utils import timezone
+                from datetime import timedelta
+
+                # Check for recent task activity
+                recent_task = Task.objects.filter(
+                    started__gte=timezone.now() - timedelta(minutes=5)
+                ).exists()
+                cluster_running = recent_task
+            except Exception:
+                pass
 
             return {
-                'component': 'crontab',
+                'component': 'django_q2',
                 'status': 'healthy',
-                'description': f'{jobs_count} scheduled job(s) configured',
+                'description': f'{schedules_count} schedule(s) configured, cluster {"running" if cluster_running else "idle"}',
                 'last_check': datetime.now().isoformat(),
                 'health_percentage': 100,
                 'details': {
                     'enabled': True,
-                    'jobs_count': jobs_count,
-                    'total_jobs': len(crontab_config.jobs),
-                    'lock_jobs': crontab_config.lock_jobs,
-                    'comment': crontab_config.comment,
+                    'schedules_count': schedules_count,
+                    'cluster_running': cluster_running,
+                    'workers': django_q2_config.workers,
                 }
             }
 
         except Exception as e:
-            self.logger.error(f"Crontab health check failed: {e}")
+            self.logger.error(f"Django-Q2 health check failed: {e}")
             return {
-                'component': 'crontab',
+                'component': 'django_q2',
                 'status': 'error',
-                'description': f'Crontab check error: {str(e)}',
+                'description': f'Django-Q2 check error: {str(e)}',
                 'last_check': datetime.now().isoformat(),
                 'health_percentage': 0,
             }
@@ -276,7 +289,7 @@ class SystemHealthService:
             self.check_cache_health(),
             self.check_queue_health(),
             self.check_storage_health(),
-            self.check_crontab_health(),
+            self.check_django_q2_health(),
         ]
 
         return checks

django_cfg/apps/dashboard/urls.py

@@ -21,7 +21,7 @@ from .views import (
     ChartsViewSet,
     CommandsViewSet,
     APIZonesViewSet,
-    CrontabViewSet,
+    DjangoQ2ViewSet,
 )
 
 app_name = 'django_cfg_dashboard'
@@ -35,7 +35,7 @@ router.register(r'activity', ActivityViewSet, basename='activity')
 router.register(r'charts', ChartsViewSet, basename='charts')
 router.register(r'commands', CommandsViewSet, basename='commands')
 router.register(r'zones', APIZonesViewSet, basename='zones')
-router.register(r'crontab', CrontabViewSet, basename='crontab')
+router.register(r'django_q2', DjangoQ2ViewSet, basename='django_q2')
 
 urlpatterns = [
     # RESTful API endpoints using ViewSets

django_cfg/apps/dashboard/views/__init__.py

@@ -11,7 +11,7 @@ from .activity_views import ActivityViewSet
 from .charts_views import ChartsViewSet
 from .commands_views import CommandsViewSet
 from .apizones_views import APIZonesViewSet
-from .crontab_views import CrontabViewSet
+from .django_q2_views import DjangoQ2ViewSet
 
 __all__ = [
     'OverviewViewSet',
@@ -21,5 +21,5 @@ __all__ = [
     'ChartsViewSet',
     'CommandsViewSet',
     'APIZonesViewSet',
-    'CrontabViewSet',
+    'DjangoQ2ViewSet',
 ]

django_cfg/apps/dashboard/views/django_q2_views.py

@@ -0,0 +1,79 @@
+"""
+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/migrations/0002_delete_tasklog.py

@@ -0,0 +1,16 @@
+# 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/core/base/config_model.py

@@ -20,7 +20,7 @@ from ...models import (
     ApiKeys,
     AxesConfig,
     CacheConfig,
-    CrontabConfig,
+    DjangoQ2Config,
     CryptoFieldsConfig,
     DatabaseConfig,
     DRFConfig,
@@ -217,9 +217,19 @@ class DjangoConfig(BaseModel):
     )
 
     # === Cache Configuration ===
+    # Redis URL - used for automatic cache configuration if cache_default is not set
+    redis_url: Optional[str] = Field(
+        default=None,
+        description=(
+            "Redis connection URL (redis://host:port/db). "
+            "If set and cache_default is None, automatically creates RedisCache backend. "
+            "Also used by tasks (ReArq, Django-Q2) if they don't specify broker_url."
+        ),
+    )
+
     cache_default: Optional[CacheConfig] = Field(
         default=None,
-        description="Default cache backend",
+        description="Default cache backend (auto-created from redis_url if not set)",
     )
 
     cache_sessions: Optional[CacheConfig] = Field(
@@ -319,10 +329,10 @@ class DjangoConfig(BaseModel):
         description="Background task processing configuration (ReArq)",
     )
 
-    # === Crontab Scheduling ===
-    crontab: Optional[CrontabConfig] = Field(
+    # === Django-Q2 Task Scheduling ===
+    django_q2: Optional[DjangoQ2Config] = Field(
         default=None,
-        description="Crontab scheduling configuration (django-crontab integration)",
+        description="Django-Q2 task scheduling and queue configuration",
     )
 
     # === Centrifugo Configuration ===

django_cfg/core/builders/apps_builder.py

@@ -163,9 +163,9 @@ class InstalledAppsBuilder:
             # No external app needed - ReArq is embedded
             apps.append("django_cfg.apps.tasks")
 
-        # Add django-crontab if enabled
-        if hasattr(self.config, "crontab") and self.config.crontab and self.config.crontab.enabled:
-            apps.append("django_crontab")
+        # Add django-q2 if enabled
+        if hasattr(self.config, "django_q2") and self.config.django_q2 and self.config.django_q2.enabled:
+            apps.append("django_q")
 
         # Add DRF Tailwind theme module (uses Tailwind via CDN)
         if self.config.enable_drf_tailwind:

django_cfg/core/generation/data_generators/cache.py

@@ -58,13 +58,18 @@ class CacheSettingsGenerator:
 
         # Default cache - always provide one
         if self.config.cache_default:
+            # User explicitly configured cache_default
             caches["default"] = self.config.cache_default.to_django_config(
                 self.config.env_mode,
                 self.config.debug,
                 "default"
             )
+        elif self.config.redis_url:
+            # Auto-create Redis cache from redis_url
+            logger.info(f"Auto-creating Redis cache from redis_url: {self.config.redis_url}")
+            caches["default"] = self._get_redis_cache_config()
         else:
-            # Create default cache backend
+            # Fallback to default cache backend (LocMem/FileBased depending on env)
             caches["default"] = self._get_default_cache_config()
 
         # Sessions cache
@@ -88,9 +93,30 @@ class CacheSettingsGenerator:
 
         return settings
 
+    def _get_redis_cache_config(self) -> Dict[str, Any]:
+        """
+        Auto-create Redis cache from config.redis_url.
+
+        Returns:
+            Dictionary with Redis cache backend configuration
+        """
+        from ....models.infrastructure.cache import CacheConfig
+
+        redis_cache = CacheConfig(
+            redis_url=self.config.redis_url,
+            timeout=300,  # 5 minutes default
+            max_connections=50,
+            key_prefix=self.config.project_name.lower().replace(" ", "_") if self.config.project_name else "django",
+        )
+        return redis_cache.to_django_config(
+            self.config.env_mode,
+            self.config.debug,
+            "default"
+        )
+
     def _get_default_cache_config(self) -> Dict[str, Any]:
         """
-        Get default cache configuration.
+        Get default cache configuration (fallback when no redis_url).
 
         Returns:
             Dictionary with default cache backend configuration

django_cfg/core/generation/integration_generators/__init__.py

@@ -6,11 +6,12 @@ Contains generators for third-party integrations and frameworks:
 - External services (Telegram, Unfold, Constance)
 - API frameworks (JWT, DRF, Spectacular, OpenAPI Client)
 - Background tasks (ReArq)
-- Crontab scheduling (django-crontab)
+- Task scheduling (django-q2)
+- Tailwind CSS configuration
 """
 
 from .api import APIFrameworksGenerator
-from .crontab import CrontabSettingsGenerator
+from .django_q2 import DjangoQ2SettingsGenerator
 from .sessions import SessionSettingsGenerator
 from .tasks import TasksSettingsGenerator
 from .third_party import ThirdPartyIntegrationsGenerator
@@ -20,5 +21,5 @@ __all__ = [
     "ThirdPartyIntegrationsGenerator",
     "APIFrameworksGenerator",
     "TasksSettingsGenerator",
-    "CrontabSettingsGenerator",
+    "DjangoQ2SettingsGenerator",
 ]