django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

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

@@ -1,366 +0,0 @@
-"""
-Management command to create agent definitions.
-"""
-
-import asyncio
-
-from django.contrib.auth.models import User
-from django.core.management.base import BaseCommand, CommandError
-
-from django_cfg.apps.agents.models.registry import AgentDefinition
-
-
-class Command(BaseCommand):
-    """Create agent definition from command line."""
-
-    help = 'Create a new agent definition'
-
-    def add_arguments(self, parser):
-        """Add command arguments."""
-        parser.add_argument('name', type=str, help='Agent name (unique identifier)')
-        parser.add_argument('instructions', type=str, help='Agent instructions/system prompt')
-
-        parser.add_argument(
-            '--deps-type',
-            type=str,
-            default='DjangoDeps',
-            help='Dependencies type (default: DjangoDeps)'
-        )
-        parser.add_argument(
-            '--output-type',
-            type=str,
-            default='ProcessResult',
-            help='Output type (default: ProcessResult)'
-        )
-        parser.add_argument(
-            '--model',
-            type=str,
-            default='openai:gpt-4o-mini',
-            help='LLM model to use (default: openai:gpt-4o-mini)'
-        )
-        parser.add_argument(
-            '--category',
-            type=str,
-            default='',
-            help='Agent category'
-        )
-        parser.add_argument(
-            '--timeout',
-            type=int,
-            default=300,
-            help='Execution timeout in seconds (default: 300)'
-        )
-        parser.add_argument(
-            '--max-retries',
-            type=int,
-            default=3,
-            help='Maximum retry attempts (default: 3)'
-        )
-        parser.add_argument(
-            '--public',
-            action='store_true',
-            help='Make agent public (accessible to all users)'
-        )
-        parser.add_argument(
-            '--no-cache',
-            action='store_true',
-            help='Disable caching for this agent'
-        )
-        parser.add_argument(
-            '--creator',
-            type=str,
-            help='Username of agent creator (defaults to first superuser)'
-        )
-        parser.add_argument(
-            '--description',
-            type=str,
-            default='',
-            help='Agent description'
-        )
-        parser.add_argument(
-            '--tags',
-            type=str,
-            nargs='*',
-            help='Agent tags (space-separated)'
-        )
-
-    def handle(self, *args, **options):
-        """Handle command execution."""
-        # Run async operations
-        asyncio.run(self._create_agent(options))
-
-    async def _create_agent(self, options):
-        """Create agent definition."""
-        name = options['name']
-        instructions = options['instructions']
-
-        # Validate name
-        if await AgentDefinition.objects.filter(name=name).aexists():
-            raise CommandError(f"Agent '{name}' already exists")
-
-        # Get creator user
-        creator = await self._get_creator_user(options.get('creator'))
-
-        # Prepare agent data
-        agent_data = {
-            'name': name,
-            'instructions': instructions,
-            'deps_type': options['deps_type'],
-            'output_type': options['output_type'],
-            'model': options['model'],
-            'category': options['category'],
-            'timeout': options['timeout'],
-            'max_retries': options['max_retries'],
-            'is_public': options['public'],
-            'enable_caching': not options['no_cache'],
-            'created_by': creator,
-            'description': options['description'],
-        }
-
-        # Add tags if provided
-        if options['tags']:
-            agent_data['tags'] = options['tags']
-
-        # Create agent definition
-        try:
-            agent_def = await AgentDefinition.objects.acreate(**agent_data)
-
-            self.stdout.write(
-                self.style.SUCCESS(f"✅ Created agent definition: {agent_def.name}")
-            )
-
-            # Show agent details
-            self.stdout.write("\nAgent Details:")
-            self.stdout.write(f"  Name: {agent_def.name}")
-            self.stdout.write(f"  Display Name: {agent_def.display_name}")
-            self.stdout.write(f"  Category: {agent_def.category or 'None'}")
-            self.stdout.write(f"  Model: {agent_def.model}")
-            self.stdout.write(f"  Dependencies: {agent_def.deps_type}")
-            self.stdout.write(f"  Output Type: {agent_def.output_type}")
-            self.stdout.write(f"  Timeout: {agent_def.timeout}s")
-            self.stdout.write(f"  Max Retries: {agent_def.max_retries}")
-            self.stdout.write(f"  Public: {agent_def.is_public}")
-            self.stdout.write(f"  Caching: {agent_def.enable_caching}")
-            self.stdout.write(f"  Created by: {agent_def.created_by.username}")
-
-            if agent_def.tags:
-                self.stdout.write(f"  Tags: {', '.join(agent_def.tags)}")
-
-            if agent_def.description:
-                self.stdout.write(f"  Description: {agent_def.description}")
-
-            # Instructions preview
-            instructions_preview = agent_def.instructions[:200]
-            if len(agent_def.instructions) > 200:
-                instructions_preview += "..."
-
-            self.stdout.write(f"  Instructions: {instructions_preview}")
-
-        except Exception as e:
-            raise CommandError(f"Failed to create agent: {e}")
-
-    async def _get_creator_user(self, username):
-        """Get creator user."""
-        if username:
-            try:
-                return await User.objects.aget(username=username)
-            except User.DoesNotExist:
-                raise CommandError(f"User '{username}' not found")
-        else:
-            # Use first superuser
-            try:
-                return await User.objects.filter(is_superuser=True).afirst()
-            except User.DoesNotExist:
-                raise CommandError("No superuser found. Please create a superuser first or specify --creator")
-
-
-class Command(BaseCommand):
-    """Load agent definitions from templates."""
-
-    help = 'Load pre-built agent templates'
-
-    def add_arguments(self, parser):
-        """Add command arguments."""
-        parser.add_argument(
-            '--list',
-            action='store_true',
-            help='List available templates'
-        )
-        parser.add_argument(
-            '--load',
-            type=str,
-            nargs='*',
-            help='Load specific templates (space-separated names)'
-        )
-        parser.add_argument(
-            '--load-all',
-            action='store_true',
-            help='Load all available templates'
-        )
-        parser.add_argument(
-            '--creator',
-            type=str,
-            help='Username of agent creator (defaults to first superuser)'
-        )
-
-    def handle(self, *args, **options):
-        """Handle command execution."""
-        if options['list']:
-            self._list_templates()
-        elif options['load'] or options['load_all']:
-            asyncio.run(self._load_templates(options))
-        else:
-            self.stdout.write(
-                self.style.ERROR('Please specify --list, --load, or --load-all')
-            )
-
-    def _list_templates(self):
-        """List available templates."""
-        templates = self._get_available_templates()
-
-        self.stdout.write(self.style.SUCCESS('📋 Available Agent Templates:'))
-        self.stdout.write('=' * 40)
-
-        for category, agents in templates.items():
-            self.stdout.write(f"\n{category.upper()}:")
-            for agent_name, agent_info in agents.items():
-                self.stdout.write(f"  • {agent_name}: {agent_info['description']}")
-
-    async def _load_templates(self, options):
-        """Load templates."""
-        creator = await self._get_creator_user(options.get('creator'))
-        templates = self._get_available_templates()
-
-        if options['load_all']:
-            # Load all templates
-            to_load = []
-            for category_templates in templates.values():
-                to_load.extend(category_templates.keys())
-        else:
-            to_load = options['load']
-
-        loaded_count = 0
-
-        for template_name in to_load:
-            # Find template
-            template_info = None
-            for category_templates in templates.values():
-                if template_name in category_templates:
-                    template_info = category_templates[template_name]
-                    break
-
-            if not template_info:
-                self.stdout.write(
-                    self.style.WARNING(f"Template '{template_name}' not found")
-                )
-                continue
-
-            # Check if agent already exists
-            if await AgentDefinition.objects.filter(name=template_name).aexists():
-                self.stdout.write(
-                    self.style.WARNING(f"Agent '{template_name}' already exists, skipping")
-                )
-                continue
-
-            # Create agent
-            try:
-                agent_data = template_info.copy()
-                agent_data['name'] = template_name
-                agent_data['created_by'] = creator
-
-                await AgentDefinition.objects.acreate(**agent_data)
-
-                self.stdout.write(
-                    self.style.SUCCESS(f"✅ Loaded template: {template_name}")
-                )
-                loaded_count += 1
-
-            except Exception as e:
-                self.stdout.write(
-                    self.style.ERROR(f"Failed to load template '{template_name}': {e}")
-                )
-
-        self.stdout.write(
-            self.style.SUCCESS(f"\n🎉 Loaded {loaded_count} agent templates")
-        )
-
-    def _get_available_templates(self):
-        """Get available agent templates."""
-        return {
-            'content': {
-                'content_analyzer': {
-                    'description': 'Analyze content sentiment, topics, and quality',
-                    'instructions': 'Analyze content for sentiment, topics, keywords, and quality metrics.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'AnalysisResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'content_generator': {
-                    'description': 'Generate high-quality content based on requirements',
-                    'instructions': 'Generate engaging, well-structured content based on type, audience, and style requirements.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'content_validator': {
-                    'description': 'Validate content quality and compliance',
-                    'instructions': 'Validate content for grammar, style, accuracy, and guideline compliance.',
-                    'deps_type': 'ContentDeps',
-                    'output_type': 'ValidationResult',
-                    'category': 'content',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            },
-            'data': {
-                'data_processor': {
-                    'description': 'Process and transform data',
-                    'instructions': 'Process, clean, and transform data according to specifications.',
-                    'deps_type': 'DataProcessingDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'data',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'data_validator': {
-                    'description': 'Validate data quality and integrity',
-                    'instructions': 'Validate data quality, check for errors, and ensure integrity.',
-                    'deps_type': 'DataProcessingDeps',
-                    'output_type': 'ValidationResult',
-                    'category': 'data',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            },
-            'business': {
-                'business_rules': {
-                    'description': 'Apply business rules and logic',
-                    'instructions': 'Apply business rules, validate decisions, and ensure compliance.',
-                    'deps_type': 'BusinessLogicDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'business',
-                    'model': 'openai:gpt-4o-mini',
-                },
-                'decision_maker': {
-                    'description': 'Make decisions based on criteria',
-                    'instructions': 'Analyze options and make informed decisions based on criteria and context.',
-                    'deps_type': 'BusinessLogicDeps',
-                    'output_type': 'ProcessResult',
-                    'category': 'business',
-                    'model': 'openai:gpt-4o-mini',
-                },
-            }
-        }
-
-    async def _get_creator_user(self, username):
-        """Get creator user."""
-        if username:
-            try:
-                return await User.objects.aget(username=username)
-            except User.DoesNotExist:
-                raise CommandError(f"User '{username}' not found")
-        else:
-            # Use first superuser
-            try:
-                return await User.objects.filter(is_superuser=True).afirst()
-            except User.DoesNotExist:
-                raise CommandError("No superuser found. Please create a superuser first or specify --creator")

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

@@ -1,192 +0,0 @@
-"""
-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 django_cfg.apps.agents.integration.registry import get_registry
-from django_cfg.apps.agents.models.execution import AgentExecution, WorkflowExecution
-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(
-            '--detailed',
-            action='store_true',
-            help='Show detailed statistics'
-        )
-        parser.add_argument(
-            '--agents',
-            action='store_true',
-            help='Show agent-specific statistics'
-        )
-        parser.add_argument(
-            '--recent',
-            type=int,
-            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(
-            created_at__gte=since
-        ).aaggregate(
-            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():
-                metrics = agent.get_metrics()
-                self.stdout.write(
-                    f"    {agent_name}: "
-                    f"{metrics['execution_count']} runs, "
-                    f"{metrics['success_rate']:.1%} success, "
-                    f"{metrics['cache_hit_rate']:.1%} cache hit"
-                )