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

django_cfg/apps/agents/models/toolsets.py

@@ -3,34 +3,35 @@ Django models for toolset management and tool execution tracking.
 """
 
 import uuid
-from django.db import models
+
 from django.conf import settings
+from django.db import models
 from django.utils import timezone
 
 
 class ToolExecution(models.Model):
     """Track tool executions within agent runs."""
-    
+
     class Status(models.TextChoices):
         PENDING = 'pending', 'Pending'
         RUNNING = 'running', 'Running'
         COMPLETED = 'completed', 'Completed'
         FAILED = 'failed', 'Failed'
-    
+
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    
+
     # Context
     user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
     agent_execution = models.ForeignKey(
-        'AgentExecution', 
+        'AgentExecution',
         on_delete=models.CASCADE,
         related_name='tool_executions'
     )
-    
+
     # Tool information
     tool_name = models.CharField(max_length=100, db_index=True)
     toolset_name = models.CharField(max_length=100, blank=True)
-    
+
     # Execution data
     status = models.CharField(
         max_length=20,
@@ -41,20 +42,20 @@ class ToolExecution(models.Model):
     arguments = models.JSONField(help_text="Tool arguments")
     result = models.JSONField(null=True, blank=True, help_text="Tool execution result")
     error_message = models.TextField(blank=True)
-    
+
     # Metrics
     execution_time = models.FloatField(null=True, blank=True)
     retry_count = models.PositiveIntegerField(default=0)
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True)
     started_at = models.DateTimeField(null=True, blank=True)
     completed_at = models.DateTimeField(null=True, blank=True)
-    
+
     # Custom managers
     from ..managers.toolsets import ToolExecutionManager
     objects = ToolExecutionManager()
-    
+
     class Meta:
         db_table = 'orchestrator_tool_executions'
         indexes = [
@@ -63,26 +64,26 @@ class ToolExecution(models.Model):
             models.Index(fields=['agent_execution', 'created_at']),
         ]
         ordering = ['-created_at']
-    
+
     def __str__(self):
         return f"ToolExecution({self.tool_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."""
@@ -91,22 +92,22 @@ class ToolExecution(models.Model):
 
 class ApprovalLog(models.Model):
     """Log approval decisions for tool executions."""
-    
+
     class Status(models.TextChoices):
         PENDING = 'pending', 'Pending'
         APPROVED = 'approved', 'Approved'
         REJECTED = 'rejected', 'Rejected'
         EXPIRED = 'expired', 'Expired'
-    
+
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     approval_id = models.CharField(max_length=100, unique=True, db_index=True)
-    
+
     # Request context
     user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='approval_requests')
     tool_name = models.CharField(max_length=100)
     tool_args = models.JSONField()
     justification = models.TextField(blank=True)
-    
+
     # Approval decision
     status = models.CharField(
         max_length=20,
@@ -115,30 +116,30 @@ class ApprovalLog(models.Model):
         db_index=True
     )
     approved_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL, 
-        on_delete=models.SET_NULL, 
-        null=True, 
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
         blank=True,
         related_name='approvals_given'
     )
     rejected_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL, 
-        on_delete=models.SET_NULL, 
-        null=True, 
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
         blank=True,
         related_name='rejections_given'
     )
     rejection_reason = models.TextField(blank=True)
-    
+
     # Timestamps
     requested_at = models.DateTimeField(auto_now_add=True)
     decided_at = models.DateTimeField(null=True, blank=True)
     expires_at = models.DateTimeField(null=True, blank=True)
-    
+
     # Custom managers
     from ..managers.toolsets import ApprovalLogManager
     objects = ApprovalLogManager()
-    
+
     class Meta:
         db_table = 'orchestrator_approval_logs'
         indexes = [
@@ -147,38 +148,38 @@ class ApprovalLog(models.Model):
             models.Index(fields=['approved_by', '-decided_at']),
         ]
         ordering = ['-requested_at']
-    
+
     def __str__(self):
         return f"ApprovalLog({self.approval_id}, {self.status})"
-    
+
     def save(self, *args, **kwargs):
         # Auto-set decided_at timestamp
         if self.status in [self.Status.APPROVED, self.Status.REJECTED] and not self.decided_at:
             self.decided_at = timezone.now()
-        
+
         super().save(*args, **kwargs)
-    
+
     @property
     def is_expired(self):
         """Check if approval request has expired."""
         if self.expires_at:
             return timezone.now() > self.expires_at
         return False
-    
+
     @property
     def time_to_decision(self):
         """Calculate time from request to decision."""
         if self.decided_at:
             return (self.decided_at - self.requested_at).total_seconds()
         return None
-    
+
     def approve(self, approver):
         """Approve the request."""
         self.status = self.Status.APPROVED
         self.approved_by = approver
         self.decided_at = timezone.now()
         self.save()
-    
+
     def reject(self, rejector, reason: str = ""):
         """Reject the request."""
         self.status = self.Status.REJECTED
@@ -190,60 +191,60 @@ class ApprovalLog(models.Model):
 
 class ToolsetConfiguration(models.Model):
     """Configuration for toolsets."""
-    
+
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField()
-    
+
     # Configuration
     toolset_class = models.CharField(max_length=200, help_text="Python class path")
     config = models.JSONField(default=dict, help_text="Toolset configuration")
-    
+
     # Access control
     is_active = models.BooleanField(default=True)
     allowed_users = models.ManyToManyField(settings.AUTH_USER_MODEL, blank=True, related_name='allowed_toolsets')
     allowed_groups = models.ManyToManyField('auth.Group', blank=True, related_name='allowed_toolsets')
-    
+
     # 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)
-    
+
     # Custom managers
     from ..managers.toolsets import ToolsetConfigurationManager
     objects = ToolsetConfigurationManager()
-    
+
     class Meta:
         db_table = 'orchestrator_toolset_configurations'
         ordering = ['name']
-    
+
     def __str__(self):
         return f"ToolsetConfiguration({self.name})"
-    
+
     def can_be_used_by(self, user) -> bool:
         """Check if user can use this toolset."""
         if not self.is_active:
             return False
-        
+
         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
 
 
 class ToolPermission(models.Model):
     """Permissions for specific tools."""
-    
+
     class Permission(models.TextChoices):
         ALLOW = 'allow', 'Allow'
         DENY = 'deny', 'Deny'
         REQUIRE_APPROVAL = 'require_approval', 'Require Approval'
-    
+
     user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
     tool_name = models.CharField(max_length=100, db_index=True)
     permission = models.CharField(
@@ -251,26 +252,26 @@ class ToolPermission(models.Model):
         choices=Permission.choices,
         default=Permission.ALLOW
     )
-    
+
     # Optional conditions
     conditions = models.JSONField(
-        default=dict, 
+        default=dict,
         blank=True,
         help_text="Conditions for permission (e.g., argument limits)"
     )
-    
+
     # Metadata
     created_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL, 
-        on_delete=models.CASCADE, 
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
         related_name='tool_permissions_created'
     )
     created_at = models.DateTimeField(auto_now_add=True)
-    
+
     # Custom managers
     from ..managers.toolsets import ToolPermissionManager
     objects = ToolPermissionManager()
-    
+
     class Meta:
         db_table = 'orchestrator_tool_permissions'
         unique_together = ['user', 'tool_name']
@@ -278,21 +279,21 @@ class ToolPermission(models.Model):
             models.Index(fields=['user', 'tool_name']),
             models.Index(fields=['tool_name', 'permission']),
         ]
-    
+
     def __str__(self):
         return f"ToolPermission({self.user.username}, {self.tool_name}, {self.permission})"
-    
+
     def check_conditions(self, tool_args: dict) -> bool:
         """Check if tool arguments meet permission conditions."""
         if not self.conditions:
             return True
-        
+
         # Implement condition checking logic
         # This is a simple example - extend as needed
         for condition_key, condition_value in self.conditions.items():
             if condition_key in tool_args:
                 arg_value = tool_args[condition_key]
-                
+
                 # Simple equality check
                 if isinstance(condition_value, dict):
                     if 'max' in condition_value and arg_value > condition_value['max']:
@@ -301,5 +302,5 @@ class ToolPermission(models.Model):
                         return False
                 elif arg_value != condition_value:
                     return False
-        
+
         return True

django_cfg/apps/agents/patterns/__init__.py

@@ -2,21 +2,21 @@
 Pre-built agent patterns for common use cases.
 """
 
+from .business_agents import BusinessRuleAgent, DecisionAgent, WorkflowAgent
 from .content_agents import ContentAnalyzerAgent, ContentGeneratorAgent, ContentValidatorAgent
-from .data_agents import DataProcessorAgent, DataValidatorAgent, DataTransformerAgent
-from .business_agents import BusinessRuleAgent, WorkflowAgent, DecisionAgent
+from .data_agents import DataProcessorAgent, DataTransformerAgent, DataValidatorAgent
 
 __all__ = [
     # Content patterns
     "ContentAnalyzerAgent",
-    "ContentGeneratorAgent", 
+    "ContentGeneratorAgent",
     "ContentValidatorAgent",
-    
+
     # Data patterns
     "DataProcessorAgent",
     "DataValidatorAgent",
     "DataTransformerAgent",
-    
+
     # Business patterns
     "BusinessRuleAgent",
     "WorkflowAgent",

django_cfg/apps/agents/patterns/content_agents.py

@@ -2,12 +2,13 @@
 Pre-built content processing agents.
 """
 
+from typing import Any, Dict, List
+
 from pydantic import BaseModel, Field
-from typing import List, Dict, Any
 
 from ..core.agent import DjangoAgent
 from ..core.dependencies import ContentDeps, RunContext
-from ..core.models import AnalysisResult, ProcessResult, ValidationResult
+from ..core.models import ValidationResult
 
 
 class ContentAnalysisResult(BaseModel):
@@ -59,7 +60,7 @@ def ContentAnalyzerAgent() -> DjangoAgent[ContentDeps, ContentAnalysisResult]:
         Be thorough but concise in your analysis.
         """
     )
-    
+
     @agent.tool
     async def analyze_text_structure(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
         """Analyze text structure and formatting."""
@@ -70,7 +71,7 @@ def ContentAnalyzerAgent() -> DjangoAgent[ContentDeps, ContentAnalysisResult]:
             "avg_sentence_length": 0.0,
             "complexity_score": 0.0
         }
-    
+
     @agent.tool
     async def extract_entities(ctx: RunContext[ContentDeps]) -> List[Dict[str, str]]:
         """Extract named entities from content."""
@@ -78,7 +79,7 @@ def ContentAnalyzerAgent() -> DjangoAgent[ContentDeps, ContentAnalysisResult]:
         return [
             {"text": "example", "label": "PERSON", "confidence": 0.95}
         ]
-    
+
     @agent.tool
     async def get_content_metadata(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
         """Get content metadata from dependencies."""
@@ -88,7 +89,7 @@ def ContentAnalyzerAgent() -> DjangoAgent[ContentDeps, ContentAnalysisResult]:
             "target_audience": ctx.deps.target_audience,
             "user_id": ctx.deps.user.id
         }
-    
+
     return agent
 
 
@@ -123,7 +124,7 @@ def ContentGeneratorAgent() -> DjangoAgent[ContentDeps, ContentGenerationResult]
         - Optimized for readability
         """
     )
-    
+
     @agent.tool
     async def get_style_guidelines(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
         """Get style guidelines for content generation."""
@@ -134,7 +135,7 @@ def ContentGeneratorAgent() -> DjangoAgent[ContentDeps, ContentGenerationResult]
             "include_headers": True,
             "target_audience": ctx.deps.target_audience
         }
-    
+
     @agent.tool
     async def check_content_requirements(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
         """Check content requirements and constraints."""
@@ -145,19 +146,19 @@ def ContentGeneratorAgent() -> DjangoAgent[ContentDeps, ContentGenerationResult]
             "required_keywords": [],
             "forbidden_topics": []
         }
-    
+
     @agent.tool
     async def validate_generated_content(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
         """Validate generated content quality."""
         word_count = len(content.split())
-        
+
         return {
             "word_count": word_count,
             "quality_score": 0.85,  # This would be calculated by quality metrics
             "passes_validation": word_count >= 100,
             "suggestions": []
         }
-    
+
     return agent
 
 
@@ -189,7 +190,7 @@ def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
         Mark content as valid only if it meets all quality standards.
         """
     )
-    
+
     @agent.tool
     async def check_grammar_spelling(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
         """Check grammar and spelling."""
@@ -200,7 +201,7 @@ def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
             "grammar_score": 0.95,
             "suggestions": []
         }
-    
+
     @agent.tool
     async def check_style_consistency(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
         """Check style consistency."""
@@ -210,7 +211,7 @@ def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
             "tone_analysis": "consistent",
             "readability_grade": 8.5
         }
-    
+
     @agent.tool
     async def check_content_guidelines(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
         """Check compliance with content guidelines."""
@@ -220,7 +221,7 @@ def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
             "compliance_score": 0.98,
             "recommendations": []
         }
-    
+
     @agent.tool
     async def check_factual_accuracy(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
         """Check factual accuracy of content."""
@@ -230,5 +231,5 @@ def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
             "fact_check_results": [],
             "verification_needed": []
         }
-    
+
     return agent

django_cfg/apps/agents/toolsets/__init__.py

@@ -2,14 +2,14 @@
 Django-specific toolsets for agent orchestration.
 """
 
-from .django_toolset import DjangoToolset
-from .orm_toolset import ORMToolset
 from .cache_toolset import CacheToolset
+from .django_toolset import DjangoToolset
 from .file_toolset import FileToolset
+from .orm_toolset import ORMToolset
 
 __all__ = [
     "DjangoToolset",
-    "ORMToolset", 
+    "ORMToolset",
     "CacheToolset",
     "FileToolset",
 ]