django-cfg 1.4.21__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/agents/management/commands/orchestrator_status.py

@@ -3,9 +3,10 @@ Management command to show orchestrator status.
 """
 
 import asyncio
+from datetime import timedelta
+
 from django.core.management.base import BaseCommand
 from django.utils import timezone
-from datetime import timedelta
 
 from django_cfg.apps.agents.integration.registry import get_registry
 from django_cfg.apps.agents.models.execution import AgentExecution, WorkflowExecution
@@ -14,9 +15,9 @@ from django_cfg.apps.agents.models.registry import AgentDefinition
 
 class Command(BaseCommand):
     """Show Django Orchestrator status and statistics."""
-    
+
     help = 'Display Django Orchestrator status and statistics'
-    
+
     def add_arguments(self, parser):
         """Add command arguments."""
         parser.add_argument(
@@ -35,98 +36,98 @@ class Command(BaseCommand):
             default=24,
             help='Show statistics for recent hours (default: 24)'
         )
-    
+
     def handle(self, *args, **options):
         """Handle command execution."""
         self.stdout.write(
             self.style.SUCCESS('🤖 Django Orchestrator Status')
         )
         self.stdout.write('=' * 50)
-        
+
         # Run async operations
         asyncio.run(self._show_status(options))
-    
+
     async def _show_status(self, options):
         """Show orchestrator status."""
         # Registry status
         await self._show_registry_status()
-        
+
         # Database statistics
         await self._show_database_stats(options['recent'])
-        
+
         if options['detailed']:
             await self._show_detailed_stats(options['recent'])
-        
+
         if options['agents']:
             await self._show_agent_stats(options['recent'])
-    
+
     async def _show_registry_status(self):
         """Show registry status."""
         self.stdout.write('\n📋 Registry Status:')
-        
+
         registry = get_registry()
         metrics = registry.get_agent_metrics()
-        
+
         self.stdout.write(f"  Runtime Agents: {metrics['runtime_agents_count']}")
         self.stdout.write(f"  Available Patterns: {len(metrics['orchestrator_metrics']['available_patterns'])}")
-        
+
         if metrics['agent_names']:
             self.stdout.write(f"  Loaded Agents: {', '.join(metrics['agent_names'])}")
         else:
             self.stdout.write("  No agents currently loaded")
-    
+
     async def _show_database_stats(self, recent_hours):
         """Show database statistics."""
         self.stdout.write('\n📊 Database Statistics:')
-        
+
         # Total counts
         total_definitions = await AgentDefinition.objects.acount()
         active_definitions = await AgentDefinition.objects.filter(is_active=True).acount()
-        
+
         self.stdout.write(f"  Agent Definitions: {total_definitions} ({active_definitions} active)")
-        
+
         # Recent activity
         since = timezone.now() - timedelta(hours=recent_hours)
-        
+
         recent_executions = await AgentExecution.objects.filter(created_at__gte=since).acount()
         recent_workflows = await WorkflowExecution.objects.filter(created_at__gte=since).acount()
-        
+
         self.stdout.write(f"  Recent Executions ({recent_hours}h): {recent_executions} agents, {recent_workflows} workflows")
-        
+
         # Success rates
         total_executions = await AgentExecution.objects.acount()
         successful_executions = await AgentExecution.objects.filter(status='completed').acount()
-        
+
         if total_executions > 0:
             success_rate = (successful_executions / total_executions) * 100
             self.stdout.write(f"  Overall Success Rate: {success_rate:.1f}%")
-    
+
     async def _show_detailed_stats(self, recent_hours):
         """Show detailed statistics."""
         self.stdout.write('\n📈 Detailed Statistics:')
-        
+
         since = timezone.now() - timedelta(hours=recent_hours)
-        
+
         # Execution status breakdown
         statuses = {}
         async for execution in AgentExecution.objects.filter(created_at__gte=since):
             statuses[execution.status] = statuses.get(execution.status, 0) + 1
-        
+
         if statuses:
             self.stdout.write(f"  Execution Status (last {recent_hours}h):")
             for status, count in statuses.items():
                 self.stdout.write(f"    {status.title()}: {count}")
-        
+
         # Average execution time
         from django.db.models import Avg
         avg_time = await AgentExecution.objects.filter(
             created_at__gte=since,
             execution_time__isnull=False
         ).aaggregate(avg_time=Avg('execution_time'))
-        
+
         if avg_time['avg_time']:
             self.stdout.write(f"  Average Execution Time: {avg_time['avg_time']:.2f}s")
-        
+
         # Token usage
         from django.db.models import Sum
         token_stats = await AgentExecution.objects.filter(
@@ -135,50 +136,50 @@ class Command(BaseCommand):
             total_tokens=Sum('tokens_used'),
             total_cost=Sum('cost')
         )
-        
+
         if token_stats['total_tokens']:
             self.stdout.write(f"  Total Tokens Used: {token_stats['total_tokens']:,}")
-        
+
         if token_stats['total_cost']:
             self.stdout.write(f"  Total Cost: ${token_stats['total_cost']:.4f}")
-    
+
     async def _show_agent_stats(self, recent_hours):
         """Show agent-specific statistics."""
         self.stdout.write('\n🤖 Agent Statistics:')
-        
+
         since = timezone.now() - timedelta(hours=recent_hours)
-        
+
         # Most used agents
         from django.db.models import Count
         agent_usage = []
-        
+
         async for item in AgentExecution.objects.filter(
             created_at__gte=since
         ).values('agent_name').annotate(
             count=Count('id')
         ).order_by('-count')[:10]:
             agent_usage.append((item['agent_name'], item['count']))
-        
+
         if agent_usage:
             self.stdout.write(f"  Most Used Agents (last {recent_hours}h):")
             for agent_name, count in agent_usage:
                 self.stdout.write(f"    {agent_name}: {count} executions")
-        
+
         # Agent definitions by category
         categories = {}
         async for agent_def in AgentDefinition.objects.filter(is_active=True):
             category = agent_def.category or 'uncategorized'
             categories[category] = categories.get(category, 0) + 1
-        
+
         if categories:
             self.stdout.write("  Agents by Category:")
             for category, count in sorted(categories.items()):
                 self.stdout.write(f"    {category.title()}: {count}")
-        
+
         # Registry runtime status
         registry = get_registry()
         runtime_agents = registry.get_runtime_agents()
-        
+
         if runtime_agents:
             self.stdout.write("  Runtime Agent Metrics:")
             for agent_name, agent in runtime_agents.items():

django_cfg/apps/agents/managers/__init__.py

@@ -4,17 +4,22 @@ Django Agents - Custom model managers.
 
 from .execution import AgentExecutionManager, WorkflowExecutionManager
 from .registry import AgentDefinitionManager, AgentTemplateManager
-from .toolsets import ToolExecutionManager, ApprovalLogManager, ToolsetConfigurationManager, ToolPermissionManager
+from .toolsets import (
+    ApprovalLogManager,
+    ToolExecutionManager,
+    ToolPermissionManager,
+    ToolsetConfigurationManager,
+)
 
 __all__ = [
     # Execution managers
     'AgentExecutionManager',
     'WorkflowExecutionManager',
-    
+
     # Registry managers
     'AgentDefinitionManager',
     'AgentTemplateManager',
-    
+
     # Toolsets managers
     'ToolExecutionManager',
     'ApprovalLogManager',

django_cfg/apps/agents/managers/execution.py

@@ -2,44 +2,45 @@
 Custom managers for agent execution models.
 """
 
+from typing import Any, Dict, Optional
+
 from django.db import models
 from django.utils import timezone
-from typing import Optional, Dict, Any
 
 
 class AgentExecutionQuerySet(models.QuerySet):
     """Custom queryset for AgentExecution."""
-    
+
     def for_user(self, user):
         """Filter executions for specific user."""
         return self.filter(user=user)
-    
+
     def by_status(self, status: str):
         """Filter by execution status."""
         return self.filter(status=status)
-    
+
     def successful(self):
         """Get successful executions."""
         return self.filter(status='completed')
-    
+
     def failed(self):
         """Get failed executions."""
         return self.filter(status='failed')
-    
+
     def recent(self, days: int = 7):
         """Get recent executions."""
         from datetime import timedelta
         cutoff = timezone.now() - timedelta(days=days)
         return self.filter(created_at__gte=cutoff)
-    
+
     def by_agent(self, agent_name: str):
         """Filter by agent name."""
         return self.filter(agent_name=agent_name)
-    
+
     def with_metrics(self):
         """Include execution metrics in query."""
         return self.select_related('user', 'workflow_execution', 'agent_definition')
-    
+
     def expensive(self, min_cost: float = 0.01):
         """Get expensive executions."""
         return self.filter(cost__gte=min_cost)
@@ -47,42 +48,42 @@ class AgentExecutionQuerySet(models.QuerySet):
 
 class AgentExecutionManager(models.Manager):
     """Custom manager for AgentExecution."""
-    
+
     def get_queryset(self):
         return AgentExecutionQuerySet(self.model, using=self._db)
-    
+
     def for_user(self, user):
         """Get executions for specific user."""
         return self.get_queryset().for_user(user)
-    
+
     def by_status(self, status: str):
         """Get executions by status."""
         return self.get_queryset().by_status(status)
-    
+
     def successful(self):
         """Get successful executions."""
         return self.get_queryset().successful()
-    
+
     def failed(self):
         """Get failed executions."""
         return self.get_queryset().failed()
-    
+
     def recent(self, days: int = 7):
         """Get recent executions."""
         return self.get_queryset().recent(days)
-    
+
     def by_agent(self, agent_name: str):
         """Get executions by agent name."""
         return self.get_queryset().by_agent(agent_name)
-    
+
     def with_metrics(self):
         """Get executions with metrics."""
         return self.get_queryset().with_metrics()
-    
+
     def expensive(self, min_cost: float = 0.01):
         """Get expensive executions."""
         return self.get_queryset().expensive(min_cost)
-    
+
     def create_execution(
         self,
         agent_name: str,
@@ -101,11 +102,11 @@ class AgentExecutionManager(models.Manager):
             workflow_execution=workflow_execution,
             **kwargs
         )
-    
+
     def get_stats_for_user(self, user) -> Dict[str, Any]:
         """Get execution statistics for user."""
         executions = self.for_user(user)
-        
+
         return {
             'total': executions.count(),
             'successful': executions.successful().count(),
@@ -122,37 +123,37 @@ class AgentExecutionManager(models.Manager):
 
 class WorkflowExecutionQuerySet(models.QuerySet):
     """Custom queryset for WorkflowExecution."""
-    
+
     def for_user(self, user):
         """Filter workflows for specific user."""
         return self.filter(user=user)
-    
+
     def by_status(self, status: str):
         """Filter by workflow status."""
         return self.filter(status=status)
-    
+
     def by_pattern(self, pattern: str):
         """Filter by workflow pattern."""
         return self.filter(pattern=pattern)
-    
+
     def successful(self):
         """Get successful workflows."""
         return self.filter(status='completed')
-    
+
     def failed(self):
         """Get failed workflows."""
         return self.filter(status='failed')
-    
+
     def running(self):
         """Get currently running workflows."""
         return self.filter(status='running')
-    
+
     def recent(self, days: int = 7):
         """Get recent workflows."""
         from datetime import timedelta
         cutoff = timezone.now() - timedelta(days=days)
         return self.filter(created_at__gte=cutoff)
-    
+
     def with_executions(self):
         """Include related agent executions."""
         return self.prefetch_related('agent_executions')
@@ -160,42 +161,42 @@ class WorkflowExecutionQuerySet(models.QuerySet):
 
 class WorkflowExecutionManager(models.Manager):
     """Custom manager for WorkflowExecution."""
-    
+
     def get_queryset(self):
         return WorkflowExecutionQuerySet(self.model, using=self._db)
-    
+
     def for_user(self, user):
         """Get workflows for specific user."""
         return self.get_queryset().for_user(user)
-    
+
     def by_status(self, status: str):
         """Get workflows by status."""
         return self.get_queryset().by_status(status)
-    
+
     def by_pattern(self, pattern: str):
         """Get workflows by pattern."""
         return self.get_queryset().by_pattern(pattern)
-    
+
     def successful(self):
         """Get successful workflows."""
         return self.get_queryset().successful()
-    
+
     def failed(self):
         """Get failed workflows."""
         return self.get_queryset().failed()
-    
+
     def running(self):
         """Get running workflows."""
         return self.get_queryset().running()
-    
+
     def recent(self, days: int = 7):
         """Get recent workflows."""
         return self.get_queryset().recent(days)
-    
+
     def with_executions(self):
         """Get workflows with executions."""
         return self.get_queryset().with_executions()
-    
+
     def create_workflow(
         self,
         name: str,
@@ -216,11 +217,11 @@ class WorkflowExecutionManager(models.Manager):
             config=config or {},
             **kwargs
         )
-    
+
     def get_stats_for_user(self, user) -> Dict[str, Any]:
         """Get workflow statistics for user."""
         workflows = self.for_user(user)
-        
+
         return {
             'total': workflows.count(),
             'successful': workflows.successful().count(),