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

django_cfg/apps/agents/toolsets/orm_toolset.py

@@ -3,11 +3,12 @@ Django ORM toolset for database operations.
 """
 
 import logging
-from typing import Dict, Any, List, Optional, Union
-from pydantic_ai.toolsets import AbstractToolset
-from pydantic_ai import RunContext
-from django.db import models
+from typing import Any, Dict, List, Optional, Union
+
 from django.apps import apps
+from django.db import models
+from pydantic_ai import RunContext
+from pydantic_ai.toolsets import AbstractToolset
 
 from ..core.dependencies import DjangoDeps
 
@@ -24,7 +25,7 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
     - Relationship traversal
     - Safe filtering
     """
-    
+
     def __init__(self, read_only: bool = True, allowed_models: Optional[List[str]] = None):
         """
         Initialize ORM toolset.
@@ -35,68 +36,68 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
         """
         self.read_only = read_only
         self.allowed_models = set(allowed_models) if allowed_models else None
-    
+
     @property
     def id(self) -> str:
         return "django_orm"
-    
+
     def _check_model_access(self, app_label: str, model_name: str) -> bool:
         """Check if model access is allowed."""
         if self.allowed_models is None:
             return True
-        
+
         model_key = f"{app_label}.{model_name}"
         return model_key in self.allowed_models
-    
+
     def _get_model(self, app_label: str, model_name: str) -> models.Model:
         """Get Django model class with access check."""
         if not self._check_model_access(app_label, model_name):
             raise PermissionError(f"Access to model '{app_label}.{model_name}' not allowed")
-        
+
         try:
             return apps.get_model(app_label, model_name)
         except LookupError:
             raise ValueError(f"Model '{app_label}.{model_name}' not found")
-    
+
     async def count_objects(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         filters: Optional[Dict[str, Any]] = None
     ) -> int:
         """Count objects in model with optional filters."""
         model = self._get_model(app_label, model_name)
-        
+
         queryset = model.objects.all()
-        
+
         if filters:
             # Apply safe filters
             safe_filters = self._sanitize_filters(filters)
             queryset = queryset.filter(**safe_filters)
-        
+
         return await queryset.acount()
-    
+
     async def get_object(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         object_id: Union[int, str]
     ) -> Optional[Dict[str, Any]]:
         """Get single object by ID."""
         model = self._get_model(app_label, model_name)
-        
+
         try:
             obj = await model.objects.aget(pk=object_id)
             return self._serialize_object(obj)
         except model.DoesNotExist:
             return None
-    
+
     async def list_objects(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         filters: Optional[Dict[str, Any]] = None,
         limit: int = 10,
@@ -105,32 +106,32 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
     ) -> Dict[str, Any]:
         """List objects with pagination and filtering."""
         model = self._get_model(app_label, model_name)
-        
+
         queryset = model.objects.all()
-        
+
         # Apply filters
         if filters:
             safe_filters = self._sanitize_filters(filters)
             queryset = queryset.filter(**safe_filters)
-        
+
         # Apply ordering
         if order_by:
             # Sanitize order_by field
             order_field = order_by.lstrip('-')
             if hasattr(model, order_field):
                 queryset = queryset.order_by(order_by)
-        
+
         # Get total count
         total_count = await queryset.acount()
-        
+
         # Apply pagination
         queryset = queryset[offset:offset + limit]
-        
+
         # Serialize objects
         objects = []
         async for obj in queryset:
             objects.append(self._serialize_object(obj))
-        
+
         return {
             'objects': objects,
             'total_count': total_count,
@@ -139,28 +140,28 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
             'has_next': offset + limit < total_count,
             'has_previous': offset > 0,
         }
-    
+
     async def aggregate_data(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         aggregations: Dict[str, str],
         filters: Optional[Dict[str, Any]] = None,
         group_by: Optional[str] = None
     ) -> Dict[str, Any]:
         """Perform aggregations on model data."""
-        from django.db.models import Count, Sum, Avg, Max, Min
-        
+        from django.db.models import Avg, Count, Max, Min, Sum
+
         model = self._get_model(app_label, model_name)
-        
+
         queryset = model.objects.all()
-        
+
         # Apply filters
         if filters:
             safe_filters = self._sanitize_filters(filters)
             queryset = queryset.filter(**safe_filters)
-        
+
         # Prepare aggregation functions
         agg_functions = {
             'count': Count,
@@ -169,7 +170,7 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
             'max': Max,
             'min': Min,
         }
-        
+
         agg_kwargs = {}
         for alias, agg_spec in aggregations.items():
             if ':' in agg_spec:
@@ -177,14 +178,14 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
             else:
                 func_name = agg_spec
                 field_name = 'id'  # Default field
-            
+
             if func_name.lower() in agg_functions:
                 agg_func = agg_functions[func_name.lower()]
                 if func_name.lower() == 'count':
                     agg_kwargs[alias] = agg_func(field_name)
                 else:
                     agg_kwargs[alias] = agg_func(field_name)
-        
+
         # Perform aggregation
         if group_by and hasattr(model, group_by):
             # Group by field
@@ -196,11 +197,11 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
             # Simple aggregation
             result = await queryset.aaggregate(**agg_kwargs)
             return result
-    
+
     async def search_objects(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         search_fields: List[str],
         query: str,
@@ -208,31 +209,31 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
     ) -> List[Dict[str, Any]]:
         """Search objects using icontains on specified fields."""
         from django.db.models import Q
-        
+
         model = self._get_model(app_label, model_name)
-        
+
         # Build search query
         search_q = Q()
         for field in search_fields:
             if hasattr(model, field):
                 search_q |= Q(**{f"{field}__icontains": query})
-        
+
         if not search_q:
             return []
-        
+
         # Execute search
         queryset = model.objects.filter(search_q)[:limit]
-        
+
         results = []
         async for obj in queryset:
             results.append(self._serialize_object(obj))
-        
+
         return results
-    
+
     async def get_related_objects(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        app_label: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        app_label: str,
         model_name: str,
         object_id: Union[int, str],
         relation_name: str,
@@ -240,18 +241,18 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
     ) -> List[Dict[str, Any]]:
         """Get related objects through foreign key or many-to-many."""
         model = self._get_model(app_label, model_name)
-        
+
         try:
             obj = await model.objects.aget(pk=object_id)
         except model.DoesNotExist:
             return []
-        
+
         # Check if relation exists
         if not hasattr(obj, relation_name):
             return []
-        
+
         relation = getattr(obj, relation_name)
-        
+
         # Handle different relation types
         if hasattr(relation, 'all'):
             # Many-to-many or reverse foreign key
@@ -262,24 +263,24 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
                 return [self._serialize_object(relation)]
             else:
                 return []
-        
+
         results = []
         async for related_obj in related_objects:
             results.append(self._serialize_object(related_obj))
-        
+
         return results
-    
+
     def _sanitize_filters(self, filters: Dict[str, Any]) -> Dict[str, Any]:
         """Sanitize filters to prevent dangerous operations."""
         safe_filters = {}
-        
+
         # Allowed lookup types
         allowed_lookups = {
             'exact', 'iexact', 'contains', 'icontains', 'startswith', 'istartswith',
             'endswith', 'iendswith', 'gt', 'gte', 'lt', 'lte', 'in', 'isnull',
             'date', 'year', 'month', 'day', 'week_day', 'hour', 'minute', 'second'
         }
-        
+
         for key, value in filters.items():
             # Check for dangerous operations
             if '__' in key:
@@ -289,16 +290,16 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
             else:
                 # Direct field lookup (exact)
                 safe_filters[key] = value
-        
+
         return safe_filters
-    
+
     def _serialize_object(self, obj: models.Model) -> Dict[str, Any]:
         """Serialize Django model object to dictionary."""
         data = {}
-        
+
         for field in obj._meta.fields:
             value = getattr(obj, field.name)
-            
+
             # Handle special field types
             if hasattr(value, 'isoformat'):
                 # DateTime fields
@@ -311,9 +312,9 @@ class ORMToolset(AbstractToolset[DjangoDeps]):
                 }
             else:
                 data[field.name] = value
-        
+
         # Add primary key and string representation
         data['pk'] = obj.pk
         data['str'] = str(obj)
-        
+
         return data

django_cfg/apps/agents/urls.py

@@ -4,7 +4,7 @@ Django Orchestrator URLs.
 Provides API endpoints for agent management and execution.
 """
 
-from django.urls import path, include
+from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
 # Import views when they're created
@@ -23,7 +23,7 @@ router = DefaultRouter()
 urlpatterns = [
     # API endpoints
     path('api/', include(router.urls)),
-    
+
     # Health check endpoint
     path('health/', lambda request: JsonResponse({'status': 'ok', 'service': 'django-orchestrator'}), name='health'),
 ]
@@ -31,6 +31,7 @@ urlpatterns = [
 # For now, create a simple health endpoint
 from django.http import JsonResponse
 
+
 def health_check(request):
     """Health check endpoint for Django Orchestrator."""
     return JsonResponse({

django_cfg/apps/api/commands/urls.py

@@ -3,6 +3,7 @@ Django CFG Commands API URLs.
 """
 
 from django.urls import path
+
 from . import views
 
 urlpatterns = [

django_cfg/apps/api/commands/views.py

@@ -5,18 +5,15 @@ Web interface for executing Django management commands.
 """
 
 import json
-import subprocess
-import threading
-import time
 import logging
-from typing import Dict, Any, List
+import time
+
+from django.contrib.auth.decorators import user_passes_test
+from django.core.management import call_command, get_commands
 from django.http import JsonResponse, StreamingHttpResponse
+from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_http_methods
-from django.contrib.auth.decorators import user_passes_test
-from django.core.management import get_commands, call_command
-from django.conf import settings
-from django.utils import timezone
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +35,7 @@ def list_commands_view(request):
     try:
         # Get all available commands
         commands_dict = get_commands()
-        
+
         # Categorize commands
         categorized_commands = {
             "django_cfg": [],
@@ -46,14 +43,14 @@ def list_commands_view(request):
             "third_party": [],
             "project": [],
         }
-        
+
         for command_name, app_name in commands_dict.items():
             command_info = {
                 "name": command_name,
                 "app": app_name,
                 "description": _get_command_description(command_name),
             }
-            
+
             if app_name == "django_cfg":
                 categorized_commands["django_cfg"].append(command_info)
             elif app_name.startswith("django."):
@@ -62,14 +59,14 @@ def list_commands_view(request):
                 categorized_commands["project"].append(command_info)
             else:
                 categorized_commands["third_party"].append(command_info)
-        
+
         return JsonResponse({
             "status": "success",
             "commands": categorized_commands,
             "total_commands": len(commands_dict),
             "timestamp": timezone.now().isoformat(),
         })
-        
+
     except Exception as e:
         logger.error(f"Error listing commands: {e}")
         return JsonResponse({
@@ -102,13 +99,13 @@ def execute_command_view(request):
         command_name = data.get("command")
         args = data.get("args", [])
         options = data.get("options", {})
-        
+
         if not command_name:
             return JsonResponse({
                 "status": "error",
                 "error": "Command name is required",
             }, status=400)
-        
+
         # Validate command exists
         available_commands = get_commands()
         if command_name not in available_commands:
@@ -128,7 +125,7 @@ def execute_command_view(request):
                 "error": f"Command '{command_name}' is not allowed via web interface for security reasons",
                 "suggestion": "Only safe django_cfg commands and whitelisted utilities can be executed via web.",
             }, status=403)
-        
+
         # Create streaming response generator
         def stream_command_execution():
             """Generator that yields command output in SSE format."""
@@ -139,8 +136,8 @@ def execute_command_view(request):
 
             try:
                 # Capture command output using StringIO
-                from io import StringIO
                 import sys
+                from io import StringIO
 
                 # Create output buffer
                 output_buffer = StringIO()
@@ -200,7 +197,7 @@ def execute_command_view(request):
 
                 # Send error event
                 yield f"data: {json.dumps({'type': 'error', 'message': str(cmd_error), 'execution_time': round(execution_time, 2)})}\n\n"
-        
+
         # Return streaming response
         response = StreamingHttpResponse(
             stream_command_execution(),
@@ -208,9 +205,9 @@ def execute_command_view(request):
         )
         response['Cache-Control'] = 'no-cache'
         response['X-Accel-Buffering'] = 'no'  # Disable nginx buffering
-        
+
         return response
-        
+
     except json.JSONDecodeError:
         return JsonResponse({
             "status": "error",
@@ -236,16 +233,16 @@ def command_help_view(request, command_name):
     """
     try:
         available_commands = get_commands()
-        
+
         if command_name not in available_commands:
             return JsonResponse({
                 "status": "error",
                 "error": f"Command '{command_name}' not found",
             }, status=404)
-        
+
         # Get command help
         help_text = _get_command_help(command_name)
-        
+
         return JsonResponse({
             "status": "success",
             "command": command_name,
@@ -253,7 +250,7 @@ def command_help_view(request, command_name):
             "help": help_text,
             "timestamp": timezone.now().isoformat(),
         })
-        
+
     except Exception as e:
         logger.error(f"Error getting help for command {command_name}: {e}")
         return JsonResponse({
@@ -278,11 +275,11 @@ def _get_command_help(command_name: str) -> str:
     try:
         from django.core.management import load_command_class
         command_class = load_command_class(get_commands()[command_name], command_name)
-        
+
         # Create command instance to get help
         command_instance = command_class()
         parser = command_instance.create_parser('manage.py', command_name)
-        
+
         return parser.format_help()
     except Exception as e:
         return f"Could not retrieve help for command '{command_name}': {str(e)}"

django_cfg/apps/api/endpoints/checker.py

@@ -4,14 +4,15 @@ Endpoints Status Checker
 Utility for checking all registered Django URL endpoints.
 """
 
-import time
 import re
+import time
 import uuid
-from typing import List, Dict, Any, Optional, Tuple
-from django.urls import get_resolver, URLPattern, URLResolver
+from typing import Any, Dict, List, Optional
+
+from django.contrib.auth import get_user_model
 from django.test import Client
+from django.urls import URLPattern, URLResolver, get_resolver
 from django.utils import timezone
-from django.contrib.auth import get_user_model
 
 
 def get_url_group(url_pattern: str, depth: int = 3) -> str:

django_cfg/apps/api/endpoints/drf_views.py

@@ -4,10 +4,10 @@ Django CFG Endpoints Status DRF Views
 DRF browsable API views with Tailwind theme support.
 """
 
-from rest_framework.views import APIView
-from rest_framework.response import Response
 from rest_framework import status
 from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.views import APIView
 
 from .checker import check_all_endpoints
 from .serializers import EndpointsStatusSerializer

django_cfg/apps/api/endpoints/tests.py

@@ -2,16 +2,17 @@
 Tests for Django CFG Endpoints Status API
 """
 
-from django.test import TestCase, Client
-from django.urls import reverse, path
 from django.http import JsonResponse
+from django.test import Client, TestCase
+from django.urls import path, reverse
 from django.views import View
+
 from .checker import (
+    check_all_endpoints,
+    check_endpoint,
+    collect_endpoints,
     get_url_group,
     should_check_endpoint,
-    collect_endpoints,
-    check_endpoint,
-    check_all_endpoints,
 )
 
 

django_cfg/apps/api/endpoints/urls.py

@@ -3,7 +3,8 @@ Django CFG Endpoints Status URLs.
 """
 
 from django.urls import path
-from . import views, drf_views
+
+from . import drf_views, views
 
 urlpatterns = [
     # Original JSON endpoint

django_cfg/apps/api/endpoints/views.py

@@ -6,6 +6,7 @@ Plain Django views for endpoints status checking.
 
 from django.http import JsonResponse
 from django.views import View
+
 from .checker import check_all_endpoints
 
 

django_cfg/apps/api/health/drf_views.py

@@ -6,21 +6,21 @@ DRF browsable API views with Tailwind theme support.
 
 import os
 import time
-import psutil
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any, Dict
 
+import psutil
 from django.conf import settings
-from django.db import connections
 from django.core.cache import cache
+from django.db import connections
 from django.utils import timezone
-
-from rest_framework.views import APIView
-from rest_framework.response import Response
 from rest_framework import status
 from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.views import APIView
 
 from django_cfg.core.integration import get_current_version
+
 from .serializers import HealthCheckSerializer, QuickHealthSerializer
 
 

django_cfg/apps/api/health/urls.py

@@ -3,7 +3,8 @@ Django CFG Health Check URLs.
 """
 
 from django.urls import path
-from . import views, drf_views
+
+from . import drf_views, views
 
 urlpatterns = [
     # Original JSON endpoints