django-cfg 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/tasks/admin/tasks_admin.py

@@ -0,0 +1,430 @@
+"""
+Tasks admin interfaces using Django Admin Utilities.
+
+Enhanced Dramatiq task management with Material Icons and optimized queries.
+Only available if django-dramatiq is installed.
+"""
+
+import logging
+import subprocess
+import sys
+from typing import Dict, Any, Optional
+from django.db.models import Count
+from django.contrib import admin, messages
+from django.contrib.admin.views.main import ChangeList
+from django.http import JsonResponse
+from django.urls import path
+from django.views.decorators.csrf import csrf_exempt
+from django.db import models
+from django.db.models import Q
+from unfold.admin import ModelAdmin
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+    ActionVariant,
+    display,
+    action,
+    StandaloneActionsMixin,
+    standalone_action
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+from django_cfg.modules.django_tasks import DjangoTasks
+
+# Try to import django-dramatiq components
+try:
+    from django_dramatiq.models import Task
+    from django_dramatiq.admin import TaskAdmin as BaseDramatiqTaskAdmin
+    DRAMATIQ_AVAILABLE = True
+except ImportError:
+    Task = None
+    BaseDramatiqTaskAdmin = None
+    DRAMATIQ_AVAILABLE = False
+
+
+if DRAMATIQ_AVAILABLE:
+    
+    class TaskQueueChangeList(ChangeList):
+        """Custom changelist for task queue management."""
+        
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.tasks_service = DjangoTasks()
+
+
+    class TaskQueueAdminMixin(OptimizedModelAdmin, DisplayMixin, StandaloneActionsMixin):
+        """Mixin for task queue management functionality."""
+        
+        change_list_template = 'admin/tasks/taskqueue/change_list.html'
+        actions_list = ['start_workers', 'clear_queues', 'refresh_status']
+        
+        def has_add_permission(self, request):
+            return False
+        
+        def has_change_permission(self, request, obj=None):
+            return True
+        
+        def has_delete_permission(self, request, obj=None):
+            return False
+        
+        def get_changelist(self, request, **kwargs):
+            return TaskQueueChangeList
+        
+        def changelist_view(self, request, extra_context=None):
+            """Enhanced changelist with queue statistics."""
+            extra_context = extra_context or {}
+            
+            try:
+                tasks_service = DjangoTasks()
+                
+                # Queue statistics
+                total_tasks = Task.objects.count()
+                pending_tasks = Task.objects.filter(status='pending').count()
+                running_tasks = Task.objects.filter(status='running').count()
+                failed_tasks = Task.objects.filter(status='failed').count()
+                completed_tasks = Task.objects.filter(status='done').count()
+                
+                # Queue status
+                queue_stats = tasks_service.get_queue_stats()
+                
+                extra_context.update({
+                    'queue_statistics': {
+                        'total_tasks': total_tasks,
+                        'pending_tasks': pending_tasks,
+                        'running_tasks': running_tasks,
+                        'failed_tasks': failed_tasks,
+                        'completed_tasks': completed_tasks,
+                    },
+                    'queue_status': queue_stats,
+                    'workers_running': tasks_service.are_workers_running(),
+                })
+                
+            except Exception as e:
+                extra_context['queue_error'] = str(e)
+            
+            return super().changelist_view(request, extra_context)
+        
+        @display(description="Queue Status")
+        def queue_status_display(self, obj):
+            """Display queue status with badge."""
+            return StatusBadge.create(
+                text="Active",
+                variant="success",
+                icon=Icons.PLAY_ARROW
+            )
+        
+        @display(description="Worker Status")
+        def worker_status_display(self, obj):
+            """Display worker status."""
+            return StatusBadge.create(
+                text="Running",
+                variant="info",
+                icon=Icons.SETTINGS
+            )
+        
+        @display(description="Task Statistics")
+        def task_stats_display(self, obj):
+            """Display task statistics."""
+            total = Task.objects.count()
+            pending = Task.objects.filter(status='pending').count()
+            return f"Total: {total}, Pending: {pending}"
+        
+        @standalone_action(
+            description="Start Workers",
+            icon=Icons.PLAY_ARROW,
+            variant=ActionVariant.SUCCESS,
+            background=True,
+            success_message="Workers started successfully!",
+            error_message="Failed to start workers."
+        )
+        def start_workers(self, request):
+            """Start Dramatiq workers."""
+            try:
+                tasks_service = DjangoTasks()
+                tasks_service.start_workers()
+                return True
+            except Exception as e:
+                logging.error(f"Failed to start workers: {e}")
+                return False
+        
+        @standalone_action(
+            description="Clear Queues",
+            icon=Icons.CLEAR_ALL,
+            variant=ActionVariant.WARNING,
+            background=True,
+            success_message="Queues cleared successfully!",
+            error_message="Failed to clear queues."
+        )
+        def clear_queues(self, request):
+            """Clear all task queues."""
+            try:
+                tasks_service = DjangoTasks()
+                tasks_service.clear_queues()
+                return True
+            except Exception as e:
+                logging.error(f"Failed to clear queues: {e}")
+                return False
+        
+        @standalone_action(
+            description="Refresh Status",
+            icon=Icons.REFRESH,
+            variant=ActionVariant.INFO,
+            success_message="Status refreshed!",
+            error_message="Failed to refresh status."
+        )
+        def refresh_status(self, request):
+            """Refresh queue status."""
+            return True
+
+
+    # Unregister the default TaskAdmin and register our enhanced version
+    try:
+        admin.site.unregister(Task)
+    except admin.sites.NotRegistered:
+        pass
+
+    @admin.register(Task)
+    class TaskAdmin(TaskQueueAdminMixin, ModelAdmin):
+        """Enhanced admin for Dramatiq Task model with queue management functionality."""
+        
+        list_display = [
+            'id_display', 'actor_name_display', 'status_display', 
+            'queue_name_display', 'created_at_display'
+        ]
+        
+        list_filter = [
+            'status', 'queue_name', 'actor_name', 
+            'created_at', 'updated_at'
+        ]
+        
+        search_fields = ['actor_name', 'queue_name', 'message_id']
+        
+        readonly_fields = [
+            'id_display', 'actor_name', 'queue_name',
+            'args_preview', 'kwargs_preview', 'result_preview',
+            'created_at_display', 'started_at_display', 'finished_at_display',
+            'duration_display', 'retries_display', 'error_message_display'
+        ]
+        
+        fieldsets = (
+            ('Task Information', {
+                'fields': ('id_display', 'status', 'actor_name', 'queue_name')
+            }),
+            ('Execution Details', {
+                'fields': ('args_preview', 'kwargs_preview', 'result_preview', 'error_message_display')
+            }),
+            ('Timing', {
+                'fields': ('created_at_display', 'started_at_display', 'finished_at_display', 'duration_display')
+            }),
+            ('Retry Information', {
+                'fields': ('retries_display',)
+            }),
+        )
+        
+        actions = ['retry_failed_tasks', 'cancel_pending_tasks']
+        
+        def changelist_view(self, request, extra_context=None):
+            """Enhanced changelist with task statistics."""
+            extra_context = extra_context or {}
+            
+            try:
+                # Task statistics
+                total_tasks = self.get_queryset(request).count()
+                status_stats = self.get_queryset(request).values('status').annotate(
+                    count=Count('id')
+                ).order_by('status')
+                
+                # Actor statistics
+                actor_stats = self.get_queryset(request).values('actor_name').annotate(
+                    count=Count('id')
+                ).order_by('-count')[:10]
+                
+                # Queue statistics
+                queue_stats = self.get_queryset(request).values('queue_name').annotate(
+                    count=Count('id')
+                ).order_by('-count')
+                
+                extra_context.update({
+                    'task_statistics': {
+                        'total_tasks': total_tasks,
+                        'status_distribution': list(status_stats),
+                        'top_actors': list(actor_stats),
+                        'queue_distribution': list(queue_stats),
+                    }
+                })
+                
+            except Exception as e:
+                extra_context['task_error'] = str(e)
+            
+            return super().changelist_view(request, extra_context)
+        
+        @display(description="Task ID")
+        def id_display(self, obj):
+            """Display task ID with icon."""
+            return StatusBadge.create(
+                text=str(obj.id),
+                variant="info",
+                icon=Icons.TAG
+            )
+        
+        @display(description="Actor")
+        def actor_name_display(self, obj):
+            """Display actor name with icon."""
+            return StatusBadge.create(
+                text=obj.actor_name or "Unknown",
+                variant="default",
+                icon=Icons.FUNCTIONS
+            )
+        
+        @display(description="Status")
+        def status_display(self, obj):
+            """Display task status with appropriate badge."""
+            status_variants = {
+                'pending': 'warning',
+                'running': 'info', 
+                'done': 'success',
+                'failed': 'danger',
+                'cancelled': 'secondary'
+            }
+            
+            status_icons = {
+                'pending': Icons.SCHEDULE,
+                'running': Icons.PLAY_ARROW,
+                'done': Icons.CHECK_CIRCLE,
+                'failed': Icons.ERROR,
+                'cancelled': Icons.CANCEL
+            }
+            
+            return StatusBadge.create(
+                text=obj.status.title(),
+                variant=status_variants.get(obj.status, 'default'),
+                icon=status_icons.get(obj.status, Icons.HELP)
+            )
+        
+        @display(description="Queue")
+        def queue_name_display(self, obj):
+            """Display queue name."""
+            return StatusBadge.create(
+                text=obj.queue_name or "default",
+                variant="info",
+                icon=Icons.QUEUE
+            )
+        
+        @display(description="Created")
+        def created_at_display(self, obj):
+            """Display creation time."""
+            return self.display_datetime_relative(obj.created_at)
+        
+        @display(description="Started")
+        def started_at_display(self, obj):
+            """Display start time."""
+            if obj.started_at:
+                return self.display_datetime_relative(obj.started_at)
+            return "Not started"
+        
+        @display(description="Finished")
+        def finished_at_display(self, obj):
+            """Display finish time."""
+            if obj.finished_at:
+                return self.display_datetime_relative(obj.finished_at)
+            return "Not finished"
+        
+        @display(description="Duration")
+        def duration_display(self, obj):
+            """Display task duration."""
+            if obj.started_at and obj.finished_at:
+                duration = obj.finished_at - obj.started_at
+                return f"{duration.total_seconds():.2f}s"
+            return "N/A"
+        
+        @display(description="Retries")
+        def retries_display(self, obj):
+            """Display retry count."""
+            retries = getattr(obj, 'retries', 0)
+            if retries > 0:
+                return StatusBadge.create(
+                    text=str(retries),
+                    variant="warning",
+                    icon=Icons.REFRESH
+                )
+            return "0"
+        
+        @display(description="Error")
+        def error_message_display(self, obj):
+            """Display error message preview."""
+            if hasattr(obj, 'error') and obj.error:
+                error_text = str(obj.error)
+                if len(error_text) > 100:
+                    error_text = error_text[:100] + "..."
+                return error_text
+            return "No error"
+        
+        @display(description="Arguments")
+        def args_preview(self, obj):
+            """Display task arguments preview."""
+            if hasattr(obj, 'args') and obj.args:
+                args_text = str(obj.args)
+                if len(args_text) > 100:
+                    args_text = args_text[:100] + "..."
+                return args_text
+            return "No arguments"
+        
+        @display(description="Keyword Arguments")
+        def kwargs_preview(self, obj):
+            """Display task keyword arguments preview."""
+            if hasattr(obj, 'kwargs') and obj.kwargs:
+                kwargs_text = str(obj.kwargs)
+                if len(kwargs_text) > 100:
+                    kwargs_text = kwargs_text[:100] + "..."
+                return kwargs_text
+            return "No kwargs"
+        
+        @display(description="Result")
+        def result_preview(self, obj):
+            """Display task result preview."""
+            if hasattr(obj, 'result') and obj.result:
+                result_text = str(obj.result)
+                if len(result_text) > 100:
+                    result_text = result_text[:100] + "..."
+                return result_text
+            return "No result"
+        
+        @action(description="Retry Failed Tasks", variant=ActionVariant.WARNING)
+        def retry_failed_tasks(self, request, queryset):
+            """Retry selected failed tasks."""
+            failed_tasks = queryset.filter(status='failed')
+            count = failed_tasks.count()
+            
+            if count > 0:
+                # Here you would implement the retry logic
+                messages.success(request, f"Queued {count} tasks for retry.")
+            else:
+                messages.warning(request, "No failed tasks selected.")
+        
+        @action(description="Cancel Pending Tasks", variant=ActionVariant.DANGER)
+        def cancel_pending_tasks(self, request, queryset):
+            """Cancel selected pending tasks."""
+            pending_tasks = queryset.filter(status='pending')
+            count = pending_tasks.count()
+            
+            if count > 0:
+                pending_tasks.update(status='cancelled')
+                messages.success(request, f"Cancelled {count} pending tasks.")
+            else:
+                messages.warning(request, "No pending tasks selected.")
+
+
+    # TaskQueueAdminMixin provides queue management functionality to TaskAdmin
+
+else:
+    # If django-dramatiq is not available, create empty admin classes
+    class TaskQueueAdmin:
+        """Placeholder when django-dramatiq is not available."""
+        pass
+    
+    class TaskAdmin:
+        """Placeholder when django-dramatiq is not available."""
+        pass

django_cfg/config.py

@@ -5,7 +5,7 @@ Configuration settings for the django-cfg library itself.
 """
 
 from typing import List
-from .modules.django_unfold.icons import Icons
+from .modules.django_admin.icons import Icons
 from .modules.django_unfold.models.dropdown import SiteDropdownItem
 
 

django_cfg/core/config.py

@@ -19,13 +19,15 @@ from urllib.parse import urlparse
 from django_cfg import (
     ConfigurationError, ValidationError, EnvironmentError,
     DatabaseConfig, CacheConfig, EmailConfig, TelegramConfig,
-    UnfoldConfig, DRFConfig, SpectacularConfig, LimitsConfig
+    UnfoldConfig, DRFConfig, SpectacularConfig, LimitsConfig, ApiKeys
 )
 from django_cfg.models.tasks import TaskConfig
 from django_cfg.models.payments import PaymentsConfig
 
 # Default apps
 DEFAULT_APPS = [
+    # WhiteNoise for static files (must be before django.contrib.staticfiles)
+    "whitenoise.runserver_nostatic",
     # Unfold
     "unfold",
     "unfold.contrib.filters",  # optional, if special filters are needed
@@ -329,6 +331,12 @@ class DjangoConfig(BaseModel):
         description="Application limits configuration (file uploads, requests, etc.)",
     )
 
+    # === API Keys Configuration ===
+    api_keys: Optional[ApiKeys] = Field(
+        default=None,
+        description="API keys for external services (OpenAI, OpenRouter, etc.)",
+    )
+
     # === Middleware Configuration ===
     custom_middleware: List[str] = Field(
         default_factory=list,
@@ -776,15 +784,12 @@ class DjangoConfig(BaseModel):
 
         # Add CORS middleware if security domains are configured
         if self.security_domains:
-            middleware.insert(1, "corsheaders.middleware.CorsMiddleware")
+            middleware.insert(2, "corsheaders.middleware.CorsMiddleware")  # Insert after WhiteNoise
 
         # Add Django CFG middleware based on enabled features
         if self.enable_accounts:
             middleware.append("django_cfg.middleware.UserActivityMiddleware")
 
-        # Add static no-cache middleware (auto-detects development mode)
-        middleware.append("django_cfg.middleware.StaticNoCacheMiddleware")
-
         # Add payments middleware if enabled
         if self.payments and self.payments.enabled:
             middleware.extend(self.payments.get_middleware_classes())

django_cfg/core/generation.py

@@ -332,7 +332,7 @@ class SettingsGenerator:
                 "STATICFILES_STORAGE": "whitenoise.storage.CompressedManifestStaticFilesStorage",
                 "WHITENOISE_USE_FINDERS": True,
                 "WHITENOISE_AUTOREFRESH": config.debug,
-                "WHITENOISE_MAX_AGE": 31536000,  # 1 year
+                "WHITENOISE_MAX_AGE": 0 if config.debug else 3600,  # No cache in debug, 1 hour
             }
 
             # Set paths relative to base directory

django_cfg/management/commands/__init__.py

@@ -1 +1,13 @@
-# Django management commands
+"""
+Django management commands for django-cfg.
+
+This package contains all Django management commands including:
+
+Django App Agent Commands:
+- app_agent_generate: Generate Django applications with AI assistance
+- app_agent_diagnose: Diagnose problems in Django/Django-cfg projects  
+- app_agent_info: Show information about Django App Agent capabilities
+
+Other Commands:
+- Various utility and maintenance commands
+"""