django-cfg 1.4.106__py3-none-any.whl → 1.4.108__py3-none-any.whl

django_cfg/apps/tasks/templates/tasks/widgets/task_footer.html

@@ -1,86 +0,0 @@
-<!-- Task Footer Widget -->
-<div class="px-6 py-4 border-t border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-900 rounded-b-xl">
-    <!-- Pagination (top section) -->
-    <div class="flex items-center justify-between mb-4 pb-4 border-b border-gray-200 dark:border-gray-700" x-show="pagination.total_pages > 1">
-        <div class="text-sm text-gray-600 dark:text-gray-400">
-            Showing <span class="font-semibold" x-text="((pagination.page - 1) * pagination.page_size) + 1"></span>
-            to <span class="font-semibold" x-text="Math.min(pagination.page * pagination.page_size, pagination.total_count)"></span>
-            of <span class="font-semibold" x-text="pagination.total_count"></span> tasks
-        </div>
-
-        <div class="flex items-center space-x-2">
-            <!-- Previous Button -->
-            <button @click="previousPage()"
-                    :disabled="!pagination.has_previous"
-                    class="inline-flex items-center px-3 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed">
-                <span class="material-icons text-sm">chevron_left</span>
-                Previous
-            </button>
-
-            <!-- Page Numbers -->
-            <div class="flex items-center space-x-1">
-                <template x-for="pageNum in Array.from({length: pagination.total_pages}, (_, i) => i + 1)" :key="pageNum">
-                    <button @click="goToPage(pageNum)"
-                            x-show="pageNum === 1 || pageNum === pagination.total_pages || Math.abs(pageNum - pagination.page) <= 2"
-                            :class="pageNum === pagination.page ? 'bg-blue-600 text-white' : 'bg-white dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700'"
-                            class="px-3 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg transition-colors">
-                        <span x-text="pageNum"></span>
-                    </button>
-                </template>
-            </div>
-
-            <!-- Next Button -->
-            <button @click="nextPage()"
-                    :disabled="!pagination.has_next"
-                    class="inline-flex items-center px-3 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed">
-                Next
-                <span class="material-icons text-sm">chevron_right</span>
-            </button>
-        </div>
-    </div>
-
-    <div class="flex items-center justify-between flex-wrap gap-4">
-        <!-- Status Summary -->
-        <div class="flex items-center space-x-6 text-sm">
-            <div class="flex items-center">
-                <div class="w-3 h-3 bg-green-500 rounded-full mr-2"></div>
-                <span class="text-gray-600 dark:text-gray-400">Completed</span>
-                <span class="ml-1 font-semibold text-gray-900 dark:text-white"
-                      x-text="tasks.filter(t => t.status === 'completed').length"></span>
-            </div>
-            <div class="flex items-center">
-                <div class="w-3 h-3 bg-blue-500 rounded-full mr-2"></div>
-                <span class="text-gray-600 dark:text-gray-400">Running</span>
-                <span class="ml-1 font-semibold text-gray-900 dark:text-white"
-                      x-text="tasks.filter(t => t.status === 'running').length"></span>
-            </div>
-            <div class="flex items-center">
-                <div class="w-3 h-3 bg-yellow-500 rounded-full mr-2"></div>
-                <span class="text-gray-600 dark:text-gray-400">Pending</span>
-                <span class="ml-1 font-semibold text-gray-900 dark:text-white"
-                      x-text="tasks.filter(t => t.status === 'pending').length"></span>
-            </div>
-            <div class="flex items-center">
-                <div class="w-3 h-3 bg-red-500 rounded-full mr-2"></div>
-                <span class="text-gray-600 dark:text-gray-400">Failed</span>
-                <span class="ml-1 font-semibold text-gray-900 dark:text-white"
-                      x-text="tasks.filter(t => t.status === 'failed').length"></span>
-            </div>
-        </div>
-
-        <!-- Actions -->
-        <div class="flex items-center space-x-2">
-            <button @click="clearCompletedTasks()"
-                    :disabled="loading || tasks.filter(t => t.status === 'completed').length === 0"
-                    class="px-3 py-2 text-sm text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-white transition-colors disabled:opacity-50 disabled:cursor-not-allowed">
-                Clear Completed
-            </button>
-            <button @click="exportTasksCSV()"
-                    :disabled="loading || tasks.length === 0"
-                    class="inline-flex items-center px-3 py-2 text-sm bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed">
-                <span class="material-icons text-sm mr-1">download</span>
-                Export CSV
-            </button>
-        </div>
-    </div>
-</div>

django_cfg/apps/tasks/templates/tasks/widgets/task_table.html

@@ -1,90 +0,0 @@
-<!-- Task Table Widget -->
-<div class="task-table-widget overflow-x-auto custom-scrollbar">
-    <table class="min-w-full bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700">
-        <thead class="bg-gray-50 dark:bg-gray-700">
-            <tr>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider w-32">
-                    <div class="flex items-center space-x-1">
-                        <span>Status</span>
-                    </div>
-                </th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">
-                    <div class="flex items-center space-x-1">
-                        <span>Task</span>
-                    </div>
-                </th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider w-24">
-                    <div class="flex items-center space-x-1">
-                        <span>Queue</span>
-                    </div>
-                </th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider w-20">
-                    Duration
-                </th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider w-24">
-                    <div class="flex items-center space-x-1">
-                        <span>Updated</span>
-                    </div>
-                </th>
-                <th class="px-4 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider w-32">
-                    Actions
-                </th>
-            </tr>
-        </thead>
-        <tbody class="divide-y divide-gray-200 dark:divide-gray-600">
-            <template x-for="task in filteredTasks" :key="task.id || task.task_id || task.message_id">
-                <tr class="task-row hover:bg-gray-50 dark:hover:bg-gray-700/50 transition-colors">
-                    <!-- Status -->
-                    <td class="px-4 py-3">
-                        <span class="status-badge"
-                              :class="'status-badge ' + (task.status || 'pending')"
-                              x-text="task.status || 'pending'"></span>
-                    </td>
-
-                    <!-- Task Name -->
-                    <td class="px-4 py-3">
-                        <div class="text-sm font-medium text-gray-900 dark:text-white" x-text="task.name || task.actor_name || task.task_id"></div>
-                        <div class="text-xs text-gray-500 dark:text-gray-400" x-text="task.task_id || task.message_id"></div>
-                    </td>
-
-                    <!-- Queue -->
-                    <td class="px-4 py-3">
-                        <span class="text-sm text-gray-700 dark:text-gray-300" x-text="task.queue || task.queue_name || 'default'"></span>
-                    </td>
-
-                    <!-- Duration -->
-                    <td class="px-4 py-3">
-                        <span class="text-sm text-gray-700 dark:text-gray-300" x-text="formatDuration(task.duration)"></span>
-                    </td>
-
-                    <!-- Updated -->
-                    <td class="px-4 py-3">
-                        <span class="text-xs text-gray-500 dark:text-gray-400" x-text="formatDate(task.updated_at || task.created_at)"></span>
-                    </td>
-
-                    <!-- Actions -->
-                    <td class="px-4 py-3 text-right">
-                        <div class="flex items-center justify-end space-x-2">
-                            <button @click="viewTaskDetails(task)"
-                                    class="text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300"
-                                    title="View details">
-                                <span class="material-icons text-sm">visibility</span>
-                            </button>
-                            <button @click="retryTask(task)"
-                                    x-show="task.status === 'failed'"
-                                    class="text-green-600 hover:text-green-800 dark:text-green-400 dark:hover:text-green-300"
-                                    title="Retry task">
-                                <span class="material-icons text-sm">refresh</span>
-                            </button>
-                            <button @click="deleteTask(task)"
-                                    class="text-red-600 hover:text-red-800 dark:text-red-400 dark:hover:text-red-300"
-                                    title="Delete task">
-                                <span class="material-icons text-sm">delete</span>
-                            </button>
-                        </div>
-                    </td>
-                </tr>
-            </template>
-        </tbody>
-    </table>
-</div>

django_cfg/apps/tasks/urls_admin.py

@@ -1,15 +0,0 @@
-"""
-URLs for Django CFG Tasks app.
-
-Provides RESTful endpoints for task queue management and monitoring using ViewSets and routers.
-"""
-
-from django.urls import path
-
-from .views import dashboard_view
-
-urlpatterns = [
-
-    # Dashboard view
-    path('dashboard/', dashboard_view, name='dashboard'),
-]

django_cfg/apps/tasks/utils/__init__.py

@@ -1 +0,0 @@
-# Tasks utilities

django_cfg/apps/tasks/utils/simulator.py

@@ -1,353 +0,0 @@
-"""
-Real Dramatiq data provider for Tasks Dashboard.
-
-This module provides real-time access to Dramatiq queue data from Redis,
-with optional test task generation for demonstration purposes.
-"""
-
-import logging
-import random
-from datetime import datetime
-from typing import Any, Dict, Optional
-from urllib.parse import urlparse
-
-import redis
-from django.conf import settings
-
-logger = logging.getLogger(__name__)
-
-
-class TaskSimulator:
-    """Real Dramatiq data provider with test task generation capabilities."""
-
-    def __init__(self):
-        """Initialize with Redis connection for real Dramatiq data."""
-        self.queues = ['critical', 'high', 'default', 'low', 'background', 'payments', 'agents', 'knowbase']
-        self._redis_client = None
-        self._setup_redis_connection()
-
-    def _setup_redis_connection(self):
-        """Setup Redis connection for real Dramatiq data."""
-        try:
-            # Get Redis URL from Django settings (DRAMATIQ_BROKER)
-            dramatiq_config = getattr(settings, 'DRAMATIQ_BROKER', {})
-            redis_url = dramatiq_config.get('OPTIONS', {}).get('url')
-
-            if redis_url:
-                parsed = urlparse(redis_url)
-                self._redis_client = redis.Redis(
-                    host=parsed.hostname or 'localhost',
-                    port=parsed.port or 6379,
-                    db=int(parsed.path.lstrip('/')) if parsed.path else 1,
-                    decode_responses=True
-                )
-                # Test connection
-                self._redis_client.ping()
-                logger.info(f"Connected to Redis: {redis_url}")
-            else:
-                logger.warning("No Redis URL found in DRAMATIQ_BROKER settings")
-
-        except Exception as e:
-            logger.error(f"Failed to connect to Redis: {e}")
-            self._redis_client = None
-
-    def get_current_queue_status(self) -> Dict[str, Any]:
-        """
-        Get current queue status from real Dramatiq Redis data.
-        
-        Returns:
-            Dict with queue status data
-        """
-        if not self._redis_client:
-            return self._get_no_connection_response()
-
-        try:
-            queues_data = {}
-            total_pending = 0
-            total_failed = 0
-            active_queues = 0
-
-            # Get real queue data from Redis
-            for queue_name in self.queues:
-                # Get queue length (pending tasks) - Dramatiq uses dramatiq:{queue_name}.msgs format
-                try:
-                    pending = self._redis_client.hlen(f'dramatiq:{queue_name}.msgs')
-                except:
-                    pending = 0
-
-                # Get failed queue length - Dramatiq uses dramatiq:{queue_name}.DQ format
-                try:
-                    failed = self._redis_client.llen(f'dramatiq:{queue_name}.DQ')
-                except:
-                    failed = 0
-
-                if pending > 0 or failed > 0:
-                    active_queues += 1
-                    queues_data[queue_name] = {
-                        'pending': pending,
-                        'failed': failed,
-                        'processed': 0,  # Can't easily get this from Redis
-                        'last_activity': datetime.now().isoformat()
-                    }
-
-                total_pending += pending
-                total_failed += failed
-
-            # Get worker count from heartbeats - Dramatiq uses dramatiq:__heartbeats__ sorted set
-            try:
-                active_workers = self._redis_client.zcard('dramatiq:__heartbeats__')
-            except:
-                active_workers = 0
-
-            return {
-                'queues': queues_data,
-                'workers': active_workers,
-                'redis_connected': True,
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False,
-                'total_pending': total_pending,
-                'total_failed': total_failed,
-                'active_queues': active_queues
-            }
-
-        except Exception as e:
-            logger.error(f"Error getting queue status: {e}")
-            return self._get_error_response(str(e))
-
-    def get_current_workers_list(self) -> Dict[str, Any]:
-        """
-        Get current workers list from real Dramatiq Redis data.
-        
-        Returns:
-            Dict with workers data
-        """
-        if not self._redis_client:
-            return {
-                'error': 'Redis connection not available',
-                'workers': [],
-                'active_count': 0,
-                'total_processed': 0,
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-        try:
-            workers = []
-            # Get worker IDs from heartbeats - Dramatiq uses dramatiq:__heartbeats__ sorted set
-            try:
-                worker_ids = self._redis_client.zrange('dramatiq:__heartbeats__', 0, -1)
-            except:
-                worker_ids = []
-
-            for worker_id in worker_ids:
-                # Create worker info from heartbeat data
-                workers.append({
-                    'id': worker_id,
-                    'name': f'worker-{worker_id[:8]}',  # Short name
-                    'pid': 'unknown',  # Dramatiq doesn't store PID in heartbeats
-                    'threads': 2,  # Default threads
-                    'tasks_processed': 0,  # Can't get this from heartbeats
-                    'started_at': datetime.now().isoformat(),  # Approximate
-                    'last_heartbeat': datetime.now().isoformat(),
-                    'uptime': 'Active'  # Since it's in heartbeats, it's active
-                })
-
-            return {
-                'workers': workers,
-                'active_count': len(workers),
-                'total_processed': sum(w['tasks_processed'] for w in workers),
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-        except Exception as e:
-            logger.error(f"Error getting workers list: {e}")
-            return {
-                'error': f'Error getting workers list: {str(e)}',
-                'workers': [],
-                'active_count': 0,
-                'total_processed': 0,
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-    def get_current_task_statistics(self) -> Dict[str, Any]:
-        """
-        Get current task statistics from real Dramatiq Redis data.
-        
-        Returns:
-            Dict with task statistics data
-        """
-        if not self._redis_client:
-            return {
-                'error': 'Redis connection not available',
-                'statistics': {'total': 0},
-                'recent_tasks': [],
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-        try:
-            # Calculate statistics from queue data
-            queue_status = self.get_current_queue_status()
-
-            total_pending = queue_status.get('total_pending', 0)
-            total_failed = queue_status.get('total_failed', 0)
-
-            # Estimate completed tasks (this is approximate)
-            estimated_completed = random.randint(100, 1000)  # Would need persistent storage for real data
-
-            total_tasks = total_pending + total_failed + estimated_completed
-
-            statistics = {
-                'total': total_tasks,
-                'completed': estimated_completed,
-                'failed': total_failed,
-                'pending': total_pending,
-                'average_duration': round(random.uniform(1.0, 5.0), 2),  # Would need real tracking
-                'tasks_per_minute': round(random.uniform(5, 50), 1),  # Would need real tracking
-                'success_rate': round((estimated_completed / max(total_tasks, 1)) * 100, 1) if total_tasks > 0 else 100
-            }
-
-            return {
-                'statistics': statistics,
-                'recent_tasks': [],  # Would need task history storage for real data
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-        except Exception as e:
-            logger.error(f"Error getting task statistics: {e}")
-            return {
-                'error': f'Error getting task statistics: {str(e)}',
-                'statistics': {'total': 0},
-                'recent_tasks': [],
-                'timestamp': datetime.now().isoformat(),
-                'simulated': False
-            }
-
-    def run_simulation(self, workers: int = 3, clear_first: bool = True) -> Dict[str, Any]:
-        """
-        Generate test tasks for demonstration purposes.
-        
-        Args:
-            workers: Number of test tasks to generate (ignored, kept for compatibility)
-            clear_first: Whether to clear existing tasks first (ignored)
-            
-        Returns:
-            Dict with simulation results
-        """
-        try:
-            # Generate realistic test tasks using Dramatiq
-            tasks_created = self._generate_test_tasks()
-
-            return {
-                'success': True,
-                'message': f'Generated {tasks_created} test tasks for demonstration',
-                'details': {
-                    'tasks_created': tasks_created,
-                    'queues_used': self.queues,
-                    'timestamp': datetime.now().isoformat()
-                }
-            }
-
-        except Exception as e:
-            logger.error(f"Test task generation failed: {e}")
-            return {
-                'success': False,
-                'error': f'Test task generation failed: {str(e)}'
-            }
-
-    def clear_all_data(self) -> Dict[str, Any]:
-        """
-        Clear all tasks from Dramatiq queues.
-        
-        Returns:
-            Dict with clear operation results
-        """
-        if not self._redis_client:
-            return {
-                'success': False,
-                'error': 'Redis connection not available'
-            }
-
-        try:
-            cleared_count = 0
-
-            # Clear all queue data
-            for queue_name in self.queues:
-                # Clear main queue - Dramatiq uses dramatiq:{queue_name} format
-                main_queue_len = self._redis_client.llen(f'dramatiq:{queue_name}')
-                if main_queue_len > 0:
-                    self._redis_client.delete(f'dramatiq:{queue_name}')
-                    cleared_count += main_queue_len
-
-                # Clear failed queue - Dramatiq uses dramatiq:{queue_name}.DQ format
-                failed_queue_len = self._redis_client.llen(f'dramatiq:{queue_name}.DQ')
-                if failed_queue_len > 0:
-                    self._redis_client.delete(f'dramatiq:{queue_name}.DQ')
-                    cleared_count += failed_queue_len
-
-            return {
-                'success': True,
-                'message': f'Cleared {cleared_count} tasks from all queues',
-                'cleared_tasks': cleared_count
-            }
-
-        except Exception as e:
-            logger.error(f"Clear operation failed: {e}")
-            return {
-                'success': False,
-                'error': f'Clear operation failed: {str(e)}'
-            }
-
-    def _generate_test_tasks(self) -> int:
-        """Generate realistic test tasks for demonstration."""
-        try:
-            # Import and use the demo tasks module
-            from ..tasks.demo_tasks import generate_demo_tasks
-            return generate_demo_tasks()
-        except ImportError as e:
-            logger.error(f"Failed to import demo tasks: {e}")
-            return 0
-
-    def _calculate_uptime(self, started_at: Optional[str]) -> str:
-        """Calculate uptime from start time."""
-        if not started_at:
-            return 'Unknown'
-
-        try:
-            start_time = datetime.fromisoformat(started_at.replace('Z', '+00:00'))
-            uptime = datetime.now() - start_time.replace(tzinfo=None)
-
-            hours = int(uptime.total_seconds() // 3600)
-            minutes = int((uptime.total_seconds() % 3600) // 60)
-
-            if hours > 0:
-                return f'{hours}h {minutes}m'
-            else:
-                return f'{minutes}m'
-        except:
-            return 'Unknown'
-
-    def _get_no_connection_response(self) -> Dict[str, Any]:
-        """Return response when Redis connection is not available."""
-        return {
-            'error': 'Redis connection not available - check DRAMATIQ_BROKER settings',
-            'queues': {},
-            'workers': 0,
-            'redis_connected': False,
-            'timestamp': datetime.now().isoformat(),
-            'simulated': False
-        }
-
-    def _get_error_response(self, error_message: str) -> Dict[str, Any]:
-        """Return error response."""
-        return {
-            'error': f'Error getting queue status: {error_message}',
-            'queues': {},
-            'workers': 0,
-            'redis_connected': False,
-            'timestamp': datetime.now().isoformat(),
-            'simulated': False
-        }