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

django_cfg/apps/agents/managers/toolsets.py

@@ -2,48 +2,49 @@
 Custom managers for toolset models.
 """
 
+from typing import Any, Dict, Optional
+
 from django.db import models
 from django.utils import timezone
-from typing import Optional, Dict, Any, List
 
 
 class ToolExecutionQuerySet(models.QuerySet):
     """Custom queryset for ToolExecution."""
-    
+
     def for_user(self, user):
         """Filter tool 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 by_tool(self, tool_name: str):
         """Filter by tool name."""
         return self.filter(tool_name=tool_name)
-    
+
     def by_toolset(self, toolset_name: str):
         """Filter by toolset name."""
         return self.filter(toolset_name=toolset_name)
-    
+
     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 with_retries(self):
         """Get executions that had retries."""
         return self.filter(retry_count__gt=0)
-    
+
     def expensive(self, min_time: float = 1.0):
         """Get time-expensive executions."""
         return self.filter(execution_time__gte=min_time)
@@ -51,46 +52,46 @@ class ToolExecutionQuerySet(models.QuerySet):
 
 class ToolExecutionManager(models.Manager):
     """Custom manager for ToolExecution."""
-    
+
     def get_queryset(self):
         return ToolExecutionQuerySet(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 by_tool(self, tool_name: str):
         """Get executions by tool."""
         return self.get_queryset().by_tool(tool_name)
-    
+
     def by_toolset(self, toolset_name: str):
         """Get executions by toolset."""
         return self.get_queryset().by_toolset(toolset_name)
-    
+
     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 with_retries(self):
         """Get executions with retries."""
         return self.get_queryset().with_retries()
-    
+
     def expensive(self, min_time: float = 1.0):
         """Get expensive executions."""
         return self.get_queryset().expensive(min_time)
-    
+
     def create_execution(
         self,
         tool_name: str,
@@ -109,11 +110,11 @@ class ToolExecutionManager(models.Manager):
             agent_execution=agent_execution,
             **kwargs
         )
-    
+
     def get_stats_for_user(self, user) -> Dict[str, Any]:
         """Get tool execution statistics for user."""
         executions = self.for_user(user)
-        
+
         return {
             'total': executions.count(),
             'successful': executions.successful().count(),
@@ -127,7 +128,7 @@ class ToolExecutionManager(models.Manager):
                 total=models.Sum('retry_count')
             )['total'] or 0,
         }
-    
+
     def get_tool_stats(self) -> Dict[str, Any]:
         """Get overall tool statistics."""
         return {
@@ -143,47 +144,47 @@ class ToolExecutionManager(models.Manager):
 
 class ApprovalLogQuerySet(models.QuerySet):
     """Custom queryset for ApprovalLog."""
-    
+
     def for_user(self, user):
         """Filter approvals for specific user."""
         return self.filter(user=user)
-    
+
     def by_status(self, status: str):
         """Filter by approval status."""
         return self.filter(status=status)
-    
+
     def by_tool(self, tool_name: str):
         """Filter by tool name."""
         return self.filter(tool_name=tool_name)
-    
+
     def pending(self):
         """Get pending approvals."""
         return self.filter(status='pending')
-    
+
     def approved(self):
         """Get approved requests."""
         return self.filter(status='approved')
-    
+
     def rejected(self):
         """Get rejected requests."""
         return self.filter(status='rejected')
-    
+
     def expired(self):
         """Get expired requests."""
         return self.filter(status='expired')
-    
+
     def recent(self, days: int = 7):
         """Get recent requests."""
         from datetime import timedelta
         cutoff = timezone.now() - timedelta(days=days)
         return self.filter(requested_at__gte=cutoff)
-    
+
     def decided_by(self, user):
         """Get requests decided by specific user."""
         return self.filter(
             models.Q(approved_by=user) | models.Q(rejected_by=user)
         )
-    
+
     def fast_decisions(self, max_seconds: int = 60):
         """Get quickly decided requests."""
         return self.filter(time_to_decision__lte=max_seconds)
@@ -191,50 +192,50 @@ class ApprovalLogQuerySet(models.QuerySet):
 
 class ApprovalLogManager(models.Manager):
     """Custom manager for ApprovalLog."""
-    
+
     def get_queryset(self):
         return ApprovalLogQuerySet(self.model, using=self._db)
-    
+
     def for_user(self, user):
         """Get approvals for specific user."""
         return self.get_queryset().for_user(user)
-    
+
     def by_status(self, status: str):
         """Get approvals by status."""
         return self.get_queryset().by_status(status)
-    
+
     def by_tool(self, tool_name: str):
         """Get approvals by tool."""
         return self.get_queryset().by_tool(tool_name)
-    
+
     def pending(self):
         """Get pending approvals."""
         return self.get_queryset().pending()
-    
+
     def approved(self):
         """Get approved requests."""
         return self.get_queryset().approved()
-    
+
     def rejected(self):
         """Get rejected requests."""
         return self.get_queryset().rejected()
-    
+
     def expired(self):
         """Get expired requests."""
         return self.get_queryset().expired()
-    
+
     def recent(self, days: int = 7):
         """Get recent requests."""
         return self.get_queryset().recent(days)
-    
+
     def decided_by(self, user):
         """Get requests decided by user."""
         return self.get_queryset().decided_by(user)
-    
+
     def fast_decisions(self, max_seconds: int = 60):
         """Get fast decisions."""
         return self.get_queryset().fast_decisions(max_seconds)
-    
+
     def create_approval_request(
         self,
         approval_id: str,
@@ -249,7 +250,7 @@ class ApprovalLogManager(models.Manager):
         if expires_at is None:
             from datetime import timedelta
             expires_at = timezone.now() + timedelta(hours=24)
-        
+
         return self.create(
             approval_id=approval_id,
             tool_name=tool_name,
@@ -259,11 +260,11 @@ class ApprovalLogManager(models.Manager):
             expires_at=expires_at,
             **kwargs
         )
-    
+
     def get_stats_for_user(self, user) -> Dict[str, Any]:
         """Get approval statistics for user."""
         requests = self.for_user(user)
-        
+
         return {
             'total': requests.count(),
             'pending': requests.pending().count(),
@@ -282,11 +283,11 @@ class ApprovalLogManager(models.Manager):
 
 class ToolsetConfigurationQuerySet(models.QuerySet):
     """Custom queryset for ToolsetConfiguration."""
-    
+
     def active(self):
         """Get active toolset configurations."""
         return self.filter(is_active=True)
-    
+
     def for_user(self, user):
         """Get toolsets available for specific user."""
         return self.filter(
@@ -294,21 +295,21 @@ class ToolsetConfigurationQuerySet(models.QuerySet):
             models.Q(allowed_groups__in=user.groups.all()) |
             models.Q(created_by=user)
         ).distinct()
-    
+
     def by_creator(self, user):
         """Get toolsets created by specific user."""
         return self.filter(created_by=user)
-    
+
     def by_class(self, toolset_class: str):
         """Filter by toolset class."""
         return self.filter(toolset_class=toolset_class)
-    
+
     def recent(self, days: int = 7):
         """Get recently created toolsets."""
         from datetime import timedelta
         cutoff = timezone.now() - timedelta(days=days)
         return self.filter(created_at__gte=cutoff)
-    
+
     def search(self, query: str):
         """Search toolsets by name or description."""
         return self.filter(
@@ -320,34 +321,34 @@ class ToolsetConfigurationQuerySet(models.QuerySet):
 
 class ToolsetConfigurationManager(models.Manager):
     """Custom manager for ToolsetConfiguration."""
-    
+
     def get_queryset(self):
         return ToolsetConfigurationQuerySet(self.model, using=self._db)
-    
+
     def active(self):
         """Get active toolsets."""
         return self.get_queryset().active()
-    
+
     def for_user(self, user):
         """Get toolsets for user."""
         return self.get_queryset().for_user(user)
-    
+
     def by_creator(self, user):
         """Get toolsets by creator."""
         return self.get_queryset().by_creator(user)
-    
+
     def by_class(self, toolset_class: str):
         """Get toolsets by class."""
         return self.get_queryset().by_class(toolset_class)
-    
+
     def recent(self, days: int = 7):
         """Get recent toolsets."""
         return self.get_queryset().recent(days)
-    
+
     def search(self, query: str):
         """Search toolsets."""
         return self.get_queryset().search(query)
-    
+
     def create_toolset(
         self,
         name: str,
@@ -366,11 +367,11 @@ class ToolsetConfigurationManager(models.Manager):
             created_by=created_by,
             **kwargs
         )
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get toolset statistics."""
         queryset = self.get_queryset()
-        
+
         return {
             'total': queryset.count(),
             'active': queryset.active().count(),
@@ -381,35 +382,35 @@ class ToolsetConfigurationManager(models.Manager):
 
 class ToolPermissionQuerySet(models.QuerySet):
     """Custom queryset for ToolPermission."""
-    
+
     def for_user(self, user):
         """Filter permissions for specific user."""
         return self.filter(user=user)
-    
+
     def by_tool(self, tool_name: str):
         """Filter by tool name."""
         return self.filter(tool_name=tool_name)
-    
+
     def by_permission(self, permission: str):
         """Filter by permission type."""
         return self.filter(permission=permission)
-    
+
     def allowed(self):
         """Get allowed permissions."""
         return self.filter(permission='allow')
-    
+
     def denied(self):
         """Get denied permissions."""
         return self.filter(permission='deny')
-    
+
     def requiring_approval(self):
         """Get permissions requiring approval."""
         return self.filter(permission='require_approval')
-    
+
     def by_creator(self, user):
         """Get permissions created by specific user."""
         return self.filter(created_by=user)
-    
+
     def recent(self, days: int = 7):
         """Get recently created permissions."""
         from datetime import timedelta
@@ -419,42 +420,42 @@ class ToolPermissionQuerySet(models.QuerySet):
 
 class ToolPermissionManager(models.Manager):
     """Custom manager for ToolPermission."""
-    
+
     def get_queryset(self):
         return ToolPermissionQuerySet(self.model, using=self._db)
-    
+
     def for_user(self, user):
         """Get permissions for specific user."""
         return self.get_queryset().for_user(user)
-    
+
     def by_tool(self, tool_name: str):
         """Get permissions by tool."""
         return self.get_queryset().by_tool(tool_name)
-    
+
     def by_permission(self, permission: str):
         """Get permissions by type."""
         return self.get_queryset().by_permission(permission)
-    
+
     def allowed(self):
         """Get allowed permissions."""
         return self.get_queryset().allowed()
-    
+
     def denied(self):
         """Get denied permissions."""
         return self.get_queryset().denied()
-    
+
     def requiring_approval(self):
         """Get permissions requiring approval."""
         return self.get_queryset().requiring_approval()
-    
+
     def by_creator(self, user):
         """Get permissions by creator."""
         return self.get_queryset().by_creator(user)
-    
+
     def recent(self, days: int = 7):
         """Get recent permissions."""
         return self.get_queryset().recent(days)
-    
+
     def create_permission(
         self,
         user,
@@ -473,18 +474,18 @@ class ToolPermissionManager(models.Manager):
             created_by=created_by,
             **kwargs
         )
-    
+
     def get_user_permission(self, user, tool_name: str):
         """Get user's permission for specific tool."""
         try:
             return self.get(user=user, tool_name=tool_name)
         except self.model.DoesNotExist:
             return None
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get permission statistics."""
         queryset = self.get_queryset()
-        
+
         return {
             'total': queryset.count(),
             'allowed': queryset.allowed().count(),

django_cfg/apps/agents/migrations/0001_initial.py

@@ -1,7 +1,8 @@
 # Generated by Django 5.2.6 on 2025-09-20 16:57
 
-import django.db.models.deletion
 import uuid
+
+import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
 

django_cfg/apps/agents/models/__init__.py

@@ -4,11 +4,11 @@ Django models for Django Orchestrator persistence.
 
 from .execution import AgentExecution, WorkflowExecution
 from .registry import AgentDefinition
-from .toolsets import ToolExecution, ApprovalLog
+from .toolsets import ApprovalLog, ToolExecution
 
 __all__ = [
     "AgentExecution",
-    "WorkflowExecution", 
+    "WorkflowExecution",
     "AgentDefinition",
     "ToolExecution",
     "ApprovalLog",