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

django_cfg/apps/agents/integration/registry.py

@@ -3,12 +3,13 @@ Agent registry for Django integration.
 """
 
 import logging
-from typing import Dict, List, Optional, Type, Any
+from typing import Any, Dict, List, Optional, Type
+
 from django.contrib.auth.models import User
 
 from ..core.agent import DjangoAgent
-from ..core.orchestrator import SimpleOrchestrator
 from ..core.dependencies import DjangoDeps
+from ..core.orchestrator import SimpleOrchestrator
 from ..models.registry import AgentDefinition
 
 logger = logging.getLogger(__name__)
@@ -24,19 +25,19 @@ class AgentRegistry:
     - Runtime agent creation
     - Permission checking
     """
-    
+
     def __init__(self):
         """Initialize agent registry."""
         self._runtime_agents: Dict[str, DjangoAgent] = {}
         self._orchestrator = SimpleOrchestrator()
-        
+
         logger.info("Initialized AgentRegistry")
-    
+
     @property
     def orchestrator(self) -> SimpleOrchestrator:
         """Get orchestrator instance."""
         return self._orchestrator
-    
+
     async def register_agent_definition(
         self,
         name: str,
@@ -63,7 +64,7 @@ class AgentRegistry:
         # Check if agent already exists
         if await AgentDefinition.objects.filter(name=name).aexists():
             raise ValueError(f"Agent '{name}' already exists")
-        
+
         # Create agent definition
         agent_def = await AgentDefinition.objects.acreate(
             name=name,
@@ -73,35 +74,35 @@ class AgentRegistry:
             created_by=user,
             **kwargs
         )
-        
+
         logger.info(f"Registered agent definition: {name}")
         return agent_def
-    
+
     async def get_agent_definition(self, name: str) -> Optional[AgentDefinition]:
         """Get agent definition by name."""
         try:
             return await AgentDefinition.objects.aget(name=name, is_active=True)
         except AgentDefinition.DoesNotExist:
             return None
-    
+
     async def list_agent_definitions(
-        self, 
+        self,
         user: Optional[User] = None,
         category: Optional[str] = None
     ) -> List[AgentDefinition]:
         """List available agent definitions."""
         queryset = AgentDefinition.objects.filter(is_active=True)
-        
+
         if user:
             queryset = AgentDefinition.get_available_for_user(user)
-        
+
         if category:
             queryset = queryset.filter(category=category)
-        
+
         return [agent_def async for agent_def in queryset.order_by('name')]
-    
+
     async def create_runtime_agent(
-        self, 
+        self,
         agent_def: AgentDefinition,
         llm_client: Optional[Any] = None
     ) -> DjangoAgent:
@@ -118,7 +119,7 @@ class AgentRegistry:
         # Import dependency and output types
         deps_type = self._import_type(agent_def.deps_type)
         output_type = self._import_type(agent_def.output_type)
-        
+
         # Create agent
         agent = DjangoAgent(
             name=agent_def.name,
@@ -131,22 +132,22 @@ class AgentRegistry:
             max_retries=agent_def.max_retries,
             enable_caching=agent_def.enable_caching
         )
-        
+
         # Apply tools configuration if available
         if agent_def.tools_config:
             await self._apply_tools_config(agent, agent_def.tools_config)
-        
+
         # Cache runtime agent
         self._runtime_agents[agent_def.name] = agent
-        
+
         # Register with orchestrator
         self._orchestrator.register_agent(agent)
-        
+
         logger.info(f"Created runtime agent: {agent_def.name}")
         return agent
-    
+
     async def get_or_create_agent(
-        self, 
+        self,
         name: str,
         user: Optional[User] = None,
         llm_client: Optional[Any] = None
@@ -165,7 +166,7 @@ class AgentRegistry:
         # Check if already in runtime cache
         if name in self._runtime_agents:
             agent = self._runtime_agents[name]
-            
+
             # Verify agent is still valid
             agent_def = await self.get_agent_definition(name)
             if agent_def and (not user or agent_def.can_be_used_by(user)):
@@ -174,20 +175,20 @@ class AgentRegistry:
                 # Remove invalid agent
                 del self._runtime_agents[name]
                 self._orchestrator.unregister_agent(name)
-        
+
         # Get agent definition
         agent_def = await self.get_agent_definition(name)
         if not agent_def:
             return None
-        
+
         # Check permissions
         if user and not agent_def.can_be_used_by(user):
             logger.warning(f"User {user.username} denied access to agent '{name}'")
             return None
-        
+
         # Create runtime agent
         return await self.create_runtime_agent(agent_def, llm_client)
-    
+
     async def execute_agent(
         self,
         agent_name: str,
@@ -213,15 +214,15 @@ class AgentRegistry:
         agent = await self.get_or_create_agent(agent_name, user)
         if not agent:
             raise ValueError(f"Agent '{agent_name}' not found or not accessible")
-        
+
         # Update usage statistics
         agent_def = await self.get_agent_definition(agent_name)
         if agent_def:
             agent_def.increment_usage()
-        
+
         # Execute agent
         return await agent.run(prompt, deps, **kwargs)
-    
+
     async def reload_agent(self, name: str) -> bool:
         """
         Reload agent from database definition.
@@ -236,15 +237,15 @@ class AgentRegistry:
         if name in self._runtime_agents:
             del self._runtime_agents[name]
             self._orchestrator.unregister_agent(name)
-        
+
         # Recreate from definition
         agent_def = await self.get_agent_definition(name)
         if agent_def:
             await self.create_runtime_agent(agent_def)
             return True
-        
+
         return False
-    
+
     async def reload_all_agents(self) -> int:
         """
         Reload all agents from database.
@@ -254,36 +255,38 @@ class AgentRegistry:
         """
         # Clear runtime cache
         self._runtime_agents.clear()
-        
+
         # Clear orchestrator
         for agent_name in list(self._orchestrator.agents.keys()):
             self._orchestrator.unregister_agent(agent_name)
-        
+
         # Reload all active agents
         agent_defs = await self.list_agent_definitions()
         count = 0
-        
+
         for agent_def in agent_defs:
             try:
                 await self.create_runtime_agent(agent_def)
                 count += 1
             except Exception as e:
                 logger.error(f"Failed to reload agent '{agent_def.name}': {e}")
-        
+
         logger.info(f"Reloaded {count} agents")
         return count
-    
+
     def _import_type(self, type_name: str) -> Type:
         """Import type by name."""
         # Handle built-in types
         if type_name in ['DjangoDeps', 'ContentDeps', 'DataProcessingDeps', 'BusinessLogicDeps']:
-            from ..core.dependencies import DjangoDeps, ContentDeps, DataProcessingDeps, BusinessLogicDeps
+            from ..core.dependencies import (
+                DjangoDeps,
+            )
             return locals()[type_name]
-        
+
         if type_name in ['ProcessResult', 'AnalysisResult', 'ValidationResult']:
-            from ..core.models import ProcessResult, AnalysisResult, ValidationResult
+            from ..core.models import ProcessResult
             return locals()[type_name]
-        
+
         # Handle custom types
         try:
             module_name, class_name = type_name.rsplit('.', 1)
@@ -294,22 +297,22 @@ class AgentRegistry:
             # Fallback to basic types
             from ..core.dependencies import DjangoDeps
             from ..core.models import ProcessResult
-            
+
             if 'Deps' in type_name:
                 return DjangoDeps
             else:
                 return ProcessResult
-    
+
     async def _apply_tools_config(self, agent: DjangoAgent, tools_config: Dict[str, Any]):
         """Apply tools configuration to agent."""
         # This would be extended to support dynamic tool loading
         # For now, just log the configuration
         logger.debug(f"Tools config for agent '{agent.name}': {tools_config}")
-    
+
     def get_runtime_agents(self) -> Dict[str, DjangoAgent]:
         """Get all runtime agents."""
         return self._runtime_agents.copy()
-    
+
     def get_agent_metrics(self) -> Dict[str, Any]:
         """Get registry metrics."""
         return {
@@ -334,12 +337,12 @@ def get_registry() -> AgentRegistry:
 async def initialize_registry() -> AgentRegistry:
     """Initialize registry and load agents from database."""
     registry = get_registry()
-    
+
     try:
         # Load all active agents
         count = await registry.reload_all_agents()
         logger.info(f"Initialized registry with {count} agents")
     except Exception as e:
         logger.error(f"Failed to initialize registry: {e}")
-    
+
     return registry

django_cfg/apps/agents/integration/signals.py

@@ -3,9 +3,9 @@ Django signals for orchestrator integration.
 """
 
 import logging
-from django.db.models.signals import post_save, post_delete
+
+from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
-from django.contrib.auth.models import User
 
 from ..models.registry import AgentDefinition
 from .registry import get_registry
@@ -17,12 +17,12 @@ logger = logging.getLogger(__name__)
 async def agent_definition_saved(sender, instance: AgentDefinition, created, **kwargs):
     """Handle agent definition save."""
     registry = get_registry()
-    
+
     if created:
         logger.info(f"New agent definition created: {instance.name}")
     else:
         logger.info(f"Agent definition updated: {instance.name}")
-        
+
         # Reload agent if it exists in runtime
         if instance.name in registry.get_runtime_agents():
             try:
@@ -36,7 +36,7 @@ async def agent_definition_saved(sender, instance: AgentDefinition, created, **k
 def agent_definition_deleted(sender, instance: AgentDefinition, **kwargs):
     """Handle agent definition deletion."""
     registry = get_registry()
-    
+
     # Remove from runtime if exists
     if instance.name in registry.get_runtime_agents():
         del registry._runtime_agents[instance.name]

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

@@ -3,22 +3,23 @@ Management command to create agent definitions.
 """
 
 import asyncio
-from django.core.management.base import BaseCommand, CommandError
+
 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,
@@ -82,24 +83,24 @@ class Command(BaseCommand):
             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,
@@ -115,19 +116,19 @@ class Command(BaseCommand):
             '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}")
@@ -141,23 +142,23 @@ class Command(BaseCommand):
             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:
@@ -175,9 +176,9 @@ class Command(BaseCommand):
 
 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(
@@ -201,7 +202,7 @@ class Command(BaseCommand):
             type=str,
             help='Username of agent creator (defaults to first superuser)'
         )
-    
+
     def handle(self, *args, **options):
         """Handle command execution."""
         if options['list']:
@@ -212,24 +213,24 @@ class Command(BaseCommand):
             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 = []
@@ -237,9 +238,9 @@ class Command(BaseCommand):
                 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
@@ -247,42 +248,42 @@ class Command(BaseCommand):
                 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 {
@@ -349,7 +350,7 @@ class Command(BaseCommand):
                 },
             }
         }
-    
+
     async def _get_creator_user(self, username):
         """Get creator user."""
         if username: