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

django_cfg/apps/agents/models/execution.py

@@ -3,21 +3,22 @@ Django models for tracking agent and workflow executions.
 """
 
 import uuid
-from django.db import models
+
 from django.conf import settings
+from django.db import models
 from django.utils import timezone
 
 
 class AgentExecution(models.Model):
     """Track individual agent executions."""
-    
+
     class Status(models.TextChoices):
         PENDING = 'pending', 'Pending'
         RUNNING = 'running', 'Running'
         COMPLETED = 'completed', 'Completed'
         FAILED = 'failed', 'Failed'
         CANCELLED = 'cancelled', 'Cancelled'
-    
+
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     agent_name = models.CharField(max_length=100, db_index=True)
     agent_definition = models.ForeignKey(
@@ -29,43 +30,43 @@ class AgentExecution(models.Model):
         help_text="Agent definition used for this execution"
     )
     user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, null=True, blank=True)
-    
+
     # Execution data
     status = models.CharField(
-        max_length=20, 
-        choices=Status.choices, 
+        max_length=20,
+        choices=Status.choices,
         default=Status.PENDING,
         db_index=True
     )
     input_prompt = models.TextField()
     output_data = models.JSONField(null=True, blank=True)
     error_message = models.TextField(blank=True)
-    
+
     # Metrics
     execution_time = models.FloatField(null=True, blank=True, help_text="Execution time in seconds")
     tokens_used = models.IntegerField(default=0)
     cost = models.DecimalField(max_digits=10, decimal_places=6, default=0)
     cached = models.BooleanField(default=False)
-    
+
     # Workflow context
     workflow_execution = models.ForeignKey(
-        'WorkflowExecution', 
-        on_delete=models.CASCADE, 
-        null=True, 
+        'WorkflowExecution',
+        on_delete=models.CASCADE,
+        null=True,
         blank=True,
         related_name='agent_executions'
     )
     execution_order = models.PositiveIntegerField(default=0)
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True, db_index=True)
     started_at = models.DateTimeField(null=True, blank=True)
     completed_at = models.DateTimeField(null=True, blank=True)
-    
+
     # Custom managers
     from ..managers.execution import AgentExecutionManager
     objects = AgentExecutionManager()
-    
+
     class Meta:
         db_table = 'orchestrator_agent_executions'
         indexes = [
@@ -75,26 +76,26 @@ class AgentExecution(models.Model):
             models.Index(fields=['workflow_execution', 'execution_order']),
         ]
         ordering = ['-created_at']
-    
+
     def __str__(self):
         return f"AgentExecution({self.agent_name}, {self.status})"
-    
+
     def save(self, *args, **kwargs):
         # Auto-set timestamps based on status
         if self.status == self.Status.RUNNING and not self.started_at:
             self.started_at = timezone.now()
         elif self.status in [self.Status.COMPLETED, self.Status.FAILED] and not self.completed_at:
             self.completed_at = timezone.now()
-        
+
         super().save(*args, **kwargs)
-    
+
     @property
     def duration(self):
         """Calculate execution duration."""
         if self.started_at and self.completed_at:
             return (self.completed_at - self.started_at).total_seconds()
         return None
-    
+
     @property
     def is_successful(self):
         """Check if execution was successful."""
@@ -103,7 +104,7 @@ class AgentExecution(models.Model):
 
 class WorkflowExecution(models.Model):
     """Track multi-agent workflow executions."""
-    
+
     class Status(models.TextChoices):
         PENDING = 'pending', 'Pending'
         RUNNING = 'running', 'Running'
@@ -111,53 +112,53 @@ class WorkflowExecution(models.Model):
         FAILED = 'failed', 'Failed'
         CANCELLED = 'cancelled', 'Cancelled'
         PAUSED = 'paused', 'Paused'
-    
+
     class Pattern(models.TextChoices):
         SEQUENTIAL = 'sequential', 'Sequential'
         PARALLEL = 'parallel', 'Parallel'
         CONDITIONAL = 'conditional', 'Conditional'
         CUSTOM = 'custom', 'Custom'
-    
+
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     name = models.CharField(max_length=200, blank=True)
     user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, null=True, blank=True)
-    
+
     # Workflow configuration
     pattern = models.CharField(max_length=20, choices=Pattern.choices, default=Pattern.SEQUENTIAL)
     agent_names = models.JSONField(help_text="List of agent names in execution order")
     input_prompt = models.TextField()
-    
+
     # Execution state
     status = models.CharField(
-        max_length=20, 
-        choices=Status.choices, 
+        max_length=20,
+        choices=Status.choices,
         default=Status.PENDING,
         db_index=True
     )
     current_step = models.PositiveIntegerField(default=0)
     total_steps = models.PositiveIntegerField(default=0)
-    
+
     # Configuration
     config = models.JSONField(default=dict, blank=True, help_text="Workflow configuration")
-    
+
     # Results
     final_output = models.JSONField(null=True, blank=True)
     error_message = models.TextField(blank=True)
-    
+
     # Metrics
     total_execution_time = models.FloatField(null=True, blank=True)
     total_tokens_used = models.IntegerField(default=0)
     total_cost = models.DecimalField(max_digits=10, decimal_places=6, default=0)
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True, db_index=True)
     started_at = models.DateTimeField(null=True, blank=True)
     completed_at = models.DateTimeField(null=True, blank=True)
-    
+
     # Custom managers
     from ..managers.execution import WorkflowExecutionManager
     objects = WorkflowExecutionManager()
-    
+
     class Meta:
         db_table = 'orchestrator_workflow_executions'
         indexes = [
@@ -166,50 +167,50 @@ class WorkflowExecution(models.Model):
             models.Index(fields=['pattern', 'status']),
         ]
         ordering = ['-created_at']
-    
+
     def __str__(self):
         return f"WorkflowExecution({self.name or self.id}, {self.status})"
-    
+
     def save(self, *args, **kwargs):
         # Auto-set total_steps from agent_names
         if self.agent_names:
             self.total_steps = len(self.agent_names)
-        
+
         # Auto-set timestamps based on status
         if self.status == self.Status.RUNNING and not self.started_at:
             self.started_at = timezone.now()
         elif self.status in [self.Status.COMPLETED, self.Status.FAILED] and not self.completed_at:
             self.completed_at = timezone.now()
-        
+
         super().save(*args, **kwargs)
-    
+
     @property
     def duration(self):
         """Calculate workflow duration."""
         if self.started_at and self.completed_at:
             return (self.completed_at - self.started_at).total_seconds()
         return None
-    
+
     @property
     def progress_percentage(self):
         """Calculate progress percentage."""
         if self.total_steps == 0:
             return 0
         return (self.current_step / self.total_steps) * 100
-    
+
     @property
     def is_successful(self):
         """Check if workflow was successful."""
         return self.status == self.Status.COMPLETED and not self.error_message
-    
+
     def get_agent_executions(self):
         """Get related agent executions in order."""
         return self.agent_executions.order_by('execution_order')
-    
+
     def get_successful_executions(self):
         """Get successful agent executions."""
         return self.agent_executions.filter(status=AgentExecution.Status.COMPLETED)
-    
+
     def get_failed_executions(self):
         """Get failed agent executions."""
         return self.agent_executions.filter(status=AgentExecution.Status.FAILED)

django_cfg/apps/agents/models/registry.py

@@ -2,43 +2,44 @@
 Django models for agent registry and configuration.
 """
 
-from django.db import models
+import json
+
 from django.conf import settings
 from django.core.exceptions import ValidationError
-import json
+from django.db import models
 
 
 class AgentDefinition(models.Model):
     """Registry of available agents with their configurations."""
-    
+
     name = models.CharField(max_length=100, unique=True, db_index=True)
     display_name = models.CharField(max_length=200, blank=True)
     description = models.TextField()
     instructions = models.TextField(help_text="System prompt for the agent")
-    
+
     # Type information
     deps_type = models.CharField(max_length=100, help_text="Python class name for dependencies")
     output_type = models.CharField(max_length=100, help_text="Python class name for output")
-    
+
     # Model configuration
     model = models.CharField(max_length=100, default='openai:gpt-4o-mini')
     timeout = models.PositiveIntegerField(default=300, help_text="Timeout in seconds")
     max_retries = models.PositiveIntegerField(default=3)
     enable_caching = models.BooleanField(default=True)
-    
+
     # Tools configuration
     tools_config = models.JSONField(
-        default=dict, 
+        default=dict,
         blank=True,
         help_text="Configuration for agent tools"
     )
-    
+
     # Permissions and access control
     is_active = models.BooleanField(default=True, db_index=True)
     is_public = models.BooleanField(default=False, help_text="Available to all users")
     allowed_users = models.ManyToManyField(
-        settings.AUTH_USER_MODEL, 
-        blank=True, 
+        settings.AUTH_USER_MODEL,
+        blank=True,
         related_name='allowed_agents',
         help_text="Users allowed to use this agent"
     )
@@ -48,25 +49,25 @@ class AgentDefinition(models.Model):
         related_name='allowed_agents',
         help_text="Groups allowed to use this agent"
     )
-    
+
     # Metadata
     category = models.CharField(max_length=50, blank=True, db_index=True)
     tags = models.JSONField(default=list, blank=True, help_text="List of tags")
     version = models.CharField(max_length=20, default='1.0.0')
-    
+
     # Audit fields
     created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='created_agents')
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
-    
+
     # Usage statistics
     usage_count = models.PositiveIntegerField(default=0)
     last_used_at = models.DateTimeField(null=True, blank=True)
-    
+
     # Custom managers
     from ..managers.registry import AgentDefinitionManager
     objects = AgentDefinitionManager()
-    
+
     class Meta:
         db_table = 'orchestrator_agent_definitions'
         indexes = [
@@ -75,14 +76,14 @@ class AgentDefinition(models.Model):
             models.Index(fields=['-usage_count']),
         ]
         ordering = ['name']
-    
+
     def __str__(self):
         return f"AgentDefinition({self.name})"
-    
+
     def clean(self):
         """Validate agent definition."""
         super().clean()
-        
+
         # Validate tools_config is valid JSON
         if self.tools_config:
             try:
@@ -90,55 +91,55 @@ class AgentDefinition(models.Model):
                     json.loads(self.tools_config)
             except json.JSONDecodeError:
                 raise ValidationError({'tools_config': 'Invalid JSON format'})
-        
+
         # Validate tags is a list
         if self.tags and not isinstance(self.tags, list):
             raise ValidationError({'tags': 'Tags must be a list'})
-        
+
         # Validate timeout range
         if self.timeout < 1 or self.timeout > 3600:
             raise ValidationError({'timeout': 'Timeout must be between 1 and 3600 seconds'})
-        
+
         # Validate max_retries range
         if self.max_retries < 0 or self.max_retries > 10:
             raise ValidationError({'max_retries': 'Max retries must be between 0 and 10'})
-    
+
     def save(self, *args, **kwargs):
         # Set display_name if not provided
         if not self.display_name:
             self.display_name = self.name.replace('_', ' ').title()
-        
+
         # Clean and validate
         self.full_clean()
-        
+
         super().save(*args, **kwargs)
-    
+
     def can_be_used_by(self, user) -> bool:
         """Check if user can use this agent."""
         if not self.is_active:
             return False
-        
+
         if self.is_public:
             return True
-        
+
         if user == self.created_by:
             return True
-        
+
         if self.allowed_users.filter(id=user.id).exists():
             return True
-        
+
         if self.allowed_groups.filter(user__id=user.id).exists():
             return True
-        
+
         return False
-    
+
     def increment_usage(self):
         """Increment usage count and update last used timestamp."""
         from django.utils import timezone
         self.usage_count += 1
         self.last_used_at = timezone.now()
         self.save(update_fields=['usage_count', 'last_used_at'])
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary for serialization."""
         return {
@@ -161,50 +162,50 @@ class AgentDefinition(models.Model):
             'created_at': self.created_at.isoformat() if self.created_at else None,
             'updated_at': self.updated_at.isoformat() if self.updated_at else None,
         }
-    
+
 
 
 class AgentTemplate(models.Model):
     """Templates for creating new agents."""
-    
+
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField()
-    
+
     # Template configuration
     template_config = models.JSONField(help_text="Template configuration")
     default_instructions = models.TextField()
     recommended_model = models.CharField(max_length=100, default='openai:gpt-4o-mini')
-    
+
     # Categorization
     category = models.CharField(max_length=50, db_index=True)
     use_cases = models.JSONField(default=list, help_text="List of use cases")
-    
+
     # Metadata
     created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
     is_active = models.BooleanField(default=True)
-    
+
     # Custom managers
     from ..managers.registry import AgentTemplateManager
     objects = AgentTemplateManager()
-    
+
     class Meta:
         db_table = 'orchestrator_agent_templates'
         ordering = ['category', 'name']
-    
+
     def __str__(self):
         return f"AgentTemplate({self.name})"
-    
+
     def create_agent_definition(
-        self, 
-        name: str, 
-        user, 
+        self,
+        name: str,
+        user,
         custom_instructions: str = None
     ) -> AgentDefinition:
         """Create agent definition from template."""
         config = self.template_config.copy()
-        
+
         return AgentDefinition.objects.create(
             name=name,
             description=self.description,