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

django_cfg/apps/agents/core/orchestrator.py

@@ -3,14 +3,14 @@ Simple Orchestrator - Main coordination class for multi-agent workflows.
 """
 
 import asyncio
-import time
 import logging
-from typing import Dict, List, Any, Optional, Callable
+import time
 from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
 
 from .django_agent import DjangoAgent
+from .exceptions import AgentNotFoundError, ConfigurationError, ExecutionError
 from .models import ExecutionResult, WorkflowConfig
-from .exceptions import AgentNotFoundError, ExecutionError, ConfigurationError
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +18,10 @@ logger = logging.getLogger(__name__)
 @dataclass
 class ExecutionPattern:
     """Base class for execution patterns."""
-    
+
     name: str
     description: str
-    
+
     async def execute(
         self,
         agents: List[DjangoAgent],
@@ -35,13 +35,13 @@ class ExecutionPattern:
 
 class SequentialPattern(ExecutionPattern):
     """Sequential execution pattern - agents run one after another."""
-    
+
     def __init__(self):
         super().__init__(
             name="sequential",
             description="Execute agents one after another, passing results forward"
         )
-    
+
     async def execute(
         self,
         agents: List[DjangoAgent],
@@ -52,18 +52,18 @@ class SequentialPattern(ExecutionPattern):
         """Execute agents sequentially."""
         results = []
         current_prompt = prompt
-        
+
         for i, agent in enumerate(agents):
             logger.debug(f"Executing agent {i+1}/{len(agents)}: {agent.name}")
-            
+
             try:
                 result = await agent.run(current_prompt, deps)
                 results.append(result)
-                
+
                 # Pass result to next agent (if not the last one)
                 if i < len(agents) - 1:
                     current_prompt = f"Previous result: {result.output}\nNew task: {prompt}"
-                
+
             except Exception as e:
                 logger.error(f"Sequential execution failed at agent '{agent.name}': {e}")
                 # Add failed result
@@ -74,19 +74,19 @@ class SequentialPattern(ExecutionPattern):
                     error=str(e)
                 ))
                 break  # Stop execution on error
-        
+
         return results
 
 
 class ParallelPattern(ExecutionPattern):
     """Parallel execution pattern - agents run concurrently."""
-    
+
     def __init__(self):
         super().__init__(
             name="parallel",
             description="Execute agents concurrently with optional concurrency limits"
         )
-    
+
     async def execute(
         self,
         agents: List[DjangoAgent],
@@ -97,7 +97,7 @@ class ParallelPattern(ExecutionPattern):
         """Execute agents in parallel."""
         max_concurrent = kwargs.get('max_concurrent', 5)
         semaphore = asyncio.Semaphore(max_concurrent)
-        
+
         async def run_agent_with_semaphore(agent: DjangoAgent) -> ExecutionResult:
             async with semaphore:
                 start_time = time.time()
@@ -106,10 +106,10 @@ class ParallelPattern(ExecutionPattern):
                     agent_deps = deps
                     if isinstance(deps, dict):
                         agent_deps = deps.get(agent.name, deps)
-                    
+
                     result = await agent.run(prompt, agent_deps)
                     execution_time = time.time() - start_time
-                    
+
                     return ExecutionResult(
                         agent_name=agent.name,
                         output=result,
@@ -125,13 +125,13 @@ class ParallelPattern(ExecutionPattern):
                         execution_time=execution_time,
                         error=str(e)
                     )
-        
+
         logger.debug(f"Executing {len(agents)} agents in parallel (max_concurrent={max_concurrent})")
-        
+
         # Execute all agents concurrently
         tasks = [run_agent_with_semaphore(agent) for agent in agents]
         results = await asyncio.gather(*tasks, return_exceptions=True)
-        
+
         # Handle any exceptions that weren't caught
         final_results = []
         for i, result in enumerate(results):
@@ -144,19 +144,19 @@ class ParallelPattern(ExecutionPattern):
                 ))
             else:
                 final_results.append(result)
-        
+
         return final_results
 
 
 class ConditionalPattern(ExecutionPattern):
     """Conditional execution pattern - execute agents based on conditions."""
-    
+
     def __init__(self):
         super().__init__(
             name="conditional",
             description="Execute agents based on condition evaluation"
         )
-    
+
     async def execute(
         self,
         agents: List[DjangoAgent],
@@ -167,32 +167,32 @@ class ConditionalPattern(ExecutionPattern):
         """Execute agents conditionally."""
         if len(agents) < 2:
             raise ConfigurationError("Conditional pattern requires at least 2 agents")
-        
+
         # First agent determines condition
         condition_agent = agents[0]
         execution_agents = agents[1:]
-        
+
         logger.debug(f"Using '{condition_agent.name}' as condition agent")
-        
+
         # Get condition
         condition_result = await condition_agent.run(prompt, deps)
         results = [condition_result]
-        
+
         # Check if we should proceed
         should_proceed = self._evaluate_condition(condition_result.output)
-        
+
         if should_proceed:
             logger.debug(f"Condition met, executing {len(execution_agents)} agents")
-            
+
             # Execute remaining agents sequentially
             sequential = SequentialPattern()
             execution_results = await sequential.execute(execution_agents, prompt, deps, **kwargs)
             results.extend(execution_results)
         else:
             logger.debug("Condition not met, skipping execution agents")
-        
+
         return results
-    
+
     def _evaluate_condition(self, output: Any) -> bool:
         """Evaluate condition from agent output."""
         # Simple condition evaluation
@@ -214,7 +214,7 @@ class SimpleOrchestrator:
     Provides simple, clean interface for multi-agent workflows
     following KISS principles.
     """
-    
+
     def __init__(self):
         """Initialize orchestrator."""
         self.agents: Dict[str, DjangoAgent] = {}
@@ -223,14 +223,14 @@ class SimpleOrchestrator:
             'parallel': ParallelPattern(),
             'conditional': ConditionalPattern()
         }
-        
+
         # Metrics
         self._total_executions = 0
         self._total_execution_time = 0.0
         self._pattern_usage = {}
-        
+
         logger.info("Initialized SimpleOrchestrator")
-    
+
     def register_agent(self, agent: DjangoAgent):
         """
         Register agent with orchestrator.
@@ -243,10 +243,10 @@ class SimpleOrchestrator:
         """
         if agent.name in self.agents:
             raise ConfigurationError(f"Agent '{agent.name}' already registered")
-        
+
         self.agents[agent.name] = agent
         logger.info(f"Registered agent '{agent.name}'")
-    
+
     def unregister_agent(self, agent_name: str):
         """
         Unregister agent from orchestrator.
@@ -257,7 +257,7 @@ class SimpleOrchestrator:
         if agent_name in self.agents:
             del self.agents[agent_name]
             logger.info(f"Unregistered agent '{agent_name}'")
-    
+
     def get_agent(self, name: str) -> DjangoAgent:
         """
         Get registered agent by name.
@@ -273,13 +273,13 @@ class SimpleOrchestrator:
         """
         if name not in self.agents:
             raise AgentNotFoundError(name)
-        
+
         return self.agents[name]
-    
+
     def list_agents(self) -> List[str]:
         """Get list of registered agent names."""
         return list(self.agents.keys())
-    
+
     def add_pattern(self, pattern: ExecutionPattern):
         """
         Add custom execution pattern.
@@ -289,7 +289,7 @@ class SimpleOrchestrator:
         """
         self.patterns[pattern.name] = pattern
         logger.info(f"Added execution pattern '{pattern.name}'")
-    
+
     async def execute(
         self,
         pattern: str,
@@ -324,59 +324,59 @@ class SimpleOrchestrator:
             raise ConfigurationError(
                 f"Unknown pattern '{pattern}'. Available patterns: {available_patterns}"
             )
-        
+
         # Validate agents
         agent_instances = []
         for agent_name in agents:
             if agent_name not in self.agents:
                 raise AgentNotFoundError(agent_name)
             agent_instances.append(self.agents[agent_name])
-        
+
         # Apply configuration
         if config:
             kwargs.setdefault('max_concurrent', config.max_concurrent)
             kwargs.setdefault('timeout', config.timeout)
-        
+
         # Execute pattern
         start_time = time.time()
         execution_id = f"exec_{int(time.time() * 1000)}"
-        
+
         logger.info(
             f"Starting execution {execution_id}: pattern='{pattern}', "
             f"agents={agents}, prompt='{prompt[:50]}...'"
         )
-        
+
         try:
             pattern_executor = self.patterns[pattern]
             results = await pattern_executor.execute(agent_instances, prompt, deps, **kwargs)
-            
+
             execution_time = time.time() - start_time
-            
+
             # Update metrics
             self._total_executions += 1
             self._total_execution_time += execution_time
             self._pattern_usage[pattern] = self._pattern_usage.get(pattern, 0) + 1
-            
+
             # Log results
             successful_agents = sum(1 for r in results if r.success)
             failed_agents = len(results) - successful_agents
-            
+
             logger.info(
                 f"Completed execution {execution_id} in {execution_time:.2f}s: "
                 f"{successful_agents} successful, {failed_agents} failed"
             )
-            
+
             return results
-            
+
         except Exception as e:
             execution_time = time.time() - start_time
             logger.error(f"Execution {execution_id} failed after {execution_time:.2f}s: {e}")
-            
+
             raise ExecutionError(
                 f"Execution failed: {str(e)}",
                 original_error=e
             )
-    
+
     def get_metrics(self) -> Dict[str, Any]:
         """Get orchestrator metrics."""
         return {
@@ -390,17 +390,17 @@ class SimpleOrchestrator:
             'registered_agents': len(self.agents),
             'available_patterns': list(self.patterns.keys())
         }
-    
+
     def reset_metrics(self):
         """Reset orchestrator metrics."""
         self._total_executions = 0
         self._total_execution_time = 0.0
         self._pattern_usage = {}
-    
+
     @property
     def registered_agents(self) -> Dict[str, DjangoAgent]:
         """Get copy of registered agents."""
         return self.agents.copy()
-    
+
     def __repr__(self) -> str:
         return f"SimpleOrchestrator(agents={len(self.agents)}, patterns={len(self.patterns)})"

django_cfg/apps/agents/examples/simple_example.py

@@ -3,11 +3,16 @@ Simple example demonstrating Django Orchestrator usage.
 """
 
 import asyncio
-from dataclasses import dataclass
-from pydantic import BaseModel
+
 from django.contrib.auth.models import User
+from pydantic import BaseModel
 
-from django_cfg.modules.django_orchestrator import DjangoAgent, SimpleOrchestrator, DjangoDeps, RunContext
+from django_cfg.modules.django_orchestrator import (
+    DjangoAgent,
+    DjangoDeps,
+    RunContext,
+    SimpleOrchestrator,
+)
 
 
 # Define output model
@@ -40,7 +45,7 @@ async def get_time_of_day(ctx: RunContext[DjangoDeps]) -> str:
     """Get current time of day for greeting."""
     from datetime import datetime
     hour = datetime.now().hour
-    
+
     if hour < 12:
         return "morning"
     elif hour < 17:
@@ -53,7 +58,7 @@ async def simple_example():
     """Run simple orchestrator example."""
     print("🤖 Django Orchestrator Simple Example")
     print("=" * 50)
-    
+
     # Create test user (in real app, get from request)
     try:
         user = await User.objects.aget(username='testuser')
@@ -64,14 +69,14 @@ async def simple_example():
             first_name='Test',
             last_name='User'
         )
-    
+
     # Create dependencies
     deps = DjangoDeps(user=user)
-    
+
     # Create orchestrator
     orchestrator = SimpleOrchestrator()
     orchestrator.register_agent(greeting_agent)
-    
+
     # Execute single agent
     print("\n1. Single Agent Execution:")
     results = await orchestrator.execute(
@@ -80,19 +85,19 @@ async def simple_example():
         prompt="Create a personalized greeting",
         deps=deps
     )
-    
+
     result = results[0]
     print(f"✅ Agent: {result.agent_name}")
     print(f"✅ Output: {result.output}")
     print(f"✅ Execution Time: {result.execution_time:.2f}s")
     print(f"✅ Tokens Used: {result.tokens_used}")
-    
+
     # Get metrics
     print("\n2. Agent Metrics:")
     metrics = greeting_agent.get_metrics()
     for key, value in metrics.items():
         print(f"📊 {key}: {value}")
-    
+
     # Get orchestrator metrics
     print("\n3. Orchestrator Metrics:")
     orch_metrics = orchestrator.get_metrics()
@@ -104,7 +109,7 @@ async def multi_agent_example():
     """Run multi-agent orchestrator example."""
     print("\n🤖 Multi-Agent Example")
     print("=" * 30)
-    
+
     # Create additional agents
     analyzer_agent = DjangoAgent[DjangoDeps, BaseModel](
         name="content_analyzer",
@@ -112,23 +117,23 @@ async def multi_agent_example():
         output_type=BaseModel,
         instructions="Analyze content sentiment and topics"
     )
-    
+
     formatter_agent = DjangoAgent[DjangoDeps, BaseModel](
         name="content_formatter",
         deps_type=DjangoDeps,
         output_type=BaseModel,
         instructions="Format content for display"
     )
-    
+
     # Create orchestrator
     orchestrator = SimpleOrchestrator()
     orchestrator.register_agent(analyzer_agent)
     orchestrator.register_agent(formatter_agent)
-    
+
     # Get user
     user = await User.objects.aget(username='testuser')
     deps = DjangoDeps(user=user)
-    
+
     # Execute sequential workflow
     print("\n1. Sequential Workflow:")
     results = await orchestrator.execute(
@@ -137,10 +142,10 @@ async def multi_agent_example():
         prompt="Analyze and format this content: Hello world!",
         deps=deps
     )
-    
+
     for i, result in enumerate(results, 1):
         print(f"Step {i} - {result.agent_name}: {result.success}")
-    
+
     # Execute parallel workflow
     print("\n2. Parallel Workflow:")
     results = await orchestrator.execute(
@@ -150,7 +155,7 @@ async def multi_agent_example():
         deps=deps,
         max_concurrent=2
     )
-    
+
     successful = sum(1 for r in results if r.success)
     print(f"✅ {successful}/{len(results)} agents completed successfully")
 

django_cfg/apps/agents/integration/__init__.py

@@ -2,9 +2,9 @@
 Django integration components for orchestrator.
 """
 
+from .middleware import OrchestratorMiddleware
 from .registry import AgentRegistry, initialize_registry
 from .signals import setup_signals
-from .middleware import OrchestratorMiddleware
 
 __all__ = [
     "AgentRegistry",

django_cfg/apps/agents/integration/middleware.py

@@ -2,9 +2,10 @@
 Django middleware for orchestrator integration.
 """
 
-import time
 import logging
+import time
 from typing import Callable
+
 from django.http import HttpRequest, HttpResponse
 from django.utils.deprecation import MiddlewareMixin
 
@@ -21,12 +22,12 @@ class OrchestratorMiddleware(MiddlewareMixin):
     - Error tracking
     - User session integration
     """
-    
+
     def __init__(self, get_response: Callable):
         """Initialize middleware."""
         self.get_response = get_response
         super().__init__(get_response)
-    
+
     def process_request(self, request: HttpRequest):
         """Process incoming request."""
         # Add orchestrator context to request
@@ -36,25 +37,25 @@ class OrchestratorMiddleware(MiddlewareMixin):
             'ip_address': self._get_client_ip(request),
             'session_key': request.session.session_key if hasattr(request, 'session') else None,
         }
-        
+
         logger.debug(f"Orchestrator middleware: Processing request {request.path}")
-    
+
     def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
         """Process outgoing response."""
         if hasattr(request, 'orchestrator_start_time'):
             duration = time.time() - request.orchestrator_start_time
-            
+
             # Add performance header
             response['X-Orchestrator-Duration'] = f"{duration:.3f}s"
-            
+
             # Log slow requests
             if duration > 5.0:  # 5 seconds threshold
                 logger.warning(
                     f"Slow request detected: {request.path} took {duration:.3f}s"
                 )
-        
+
         return response
-    
+
     def process_exception(self, request: HttpRequest, exception: Exception):
         """Process exceptions."""
         if hasattr(request, 'orchestrator_context'):
@@ -66,10 +67,10 @@ class OrchestratorMiddleware(MiddlewareMixin):
                     'orchestrator_context': request.orchestrator_context,
                 }
             )
-        
+
         # Don't handle the exception, just log it
         return None
-    
+
     def _get_client_ip(self, request: HttpRequest) -> str:
         """Get client IP address."""
         x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')