django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/agents/core/orchestrator.py

@@ -0,0 +1,391 @@
+"""
+Simple Orchestrator - Main coordination class for multi-agent workflows.
+"""
+
+import asyncio
+import time
+import logging
+from typing import Dict, List, Any, Optional, Callable
+from dataclasses import dataclass
+
+from .agent import DjangoAgent
+from .models import ExecutionResult, WorkflowConfig
+from .exceptions import AgentNotFoundError, ExecutionError, ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ExecutionPattern:
+    """Base class for execution patterns."""
+    
+    name: str
+    description: str
+    
+    async def execute(
+        self,
+        agents: List[DjangoAgent],
+        prompt: str,
+        deps: Any,
+        **kwargs
+    ) -> List[ExecutionResult]:
+        """Execute agents according to pattern."""
+        raise NotImplementedError
+
+
+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],
+        prompt: str,
+        deps: Any,
+        **kwargs
+    ) -> List[ExecutionResult]:
+        """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
+                results.append(ExecutionResult(
+                    agent_name=agent.name,
+                    output=None,
+                    execution_time=0.0,
+                    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],
+        prompt: str,
+        deps: Any,
+        **kwargs
+    ) -> List[ExecutionResult]:
+        """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:
+                try:
+                    return await agent.run(prompt, deps)
+                except Exception as e:
+                    logger.error(f"Parallel execution failed for agent '{agent.name}': {e}")
+                    return ExecutionResult(
+                        agent_name=agent.name,
+                        output=None,
+                        execution_time=0.0,
+                        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):
+            if isinstance(result, Exception):
+                final_results.append(ExecutionResult(
+                    agent_name=agents[i].name,
+                    output=None,
+                    execution_time=0.0,
+                    error=str(result)
+                ))
+            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],
+        prompt: str,
+        deps: Any,
+        **kwargs
+    ) -> List[ExecutionResult]:
+        """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
+        if isinstance(output, dict):
+            return output.get('proceed', False) or output.get('success', False)
+        elif isinstance(output, bool):
+            return output
+        elif hasattr(output, 'success'):
+            return output.success
+        else:
+            # Default to True if we can't determine condition
+            return True
+
+
+class SimpleOrchestrator:
+    """
+    Main orchestrator for agent coordination.
+    
+    Provides simple, clean interface for multi-agent workflows
+    following KISS principles.
+    """
+    
+    def __init__(self):
+        """Initialize orchestrator."""
+        self.agents: Dict[str, DjangoAgent] = {}
+        self.patterns: Dict[str, ExecutionPattern] = {
+            'sequential': SequentialPattern(),
+            '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.
+        
+        Args:
+            agent: DjangoAgent instance to register
+            
+        Raises:
+            ConfigurationError: If agent name already exists
+        """
+        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.
+        
+        Args:
+            agent_name: Name of agent to unregister
+        """
+        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.
+        
+        Args:
+            name: Agent name
+            
+        Returns:
+            DjangoAgent instance
+            
+        Raises:
+            AgentNotFoundError: If agent not found
+        """
+        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.
+        
+        Args:
+            pattern: ExecutionPattern instance
+        """
+        self.patterns[pattern.name] = pattern
+        logger.info(f"Added execution pattern '{pattern.name}'")
+    
+    async def execute(
+        self,
+        pattern: str,
+        agents: List[str],
+        prompt: str,
+        deps: Any,
+        config: Optional[WorkflowConfig] = None,
+        **kwargs
+    ) -> List[ExecutionResult]:
+        """
+        Execute agents using specified pattern.
+        
+        Args:
+            pattern: Execution pattern name
+            agents: List of agent names to execute
+            prompt: Input prompt for agents
+            deps: Dependencies for execution
+            config: Optional workflow configuration
+            **kwargs: Pattern-specific options
+            
+        Returns:
+            List of execution results
+            
+        Raises:
+            AgentNotFoundError: If any agent not found
+            ConfigurationError: If pattern not found
+            ExecutionError: If execution fails
+        """
+        # Validate pattern
+        if pattern not in self.patterns:
+            available_patterns = list(self.patterns.keys())
+            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 {
+            'total_executions': self._total_executions,
+            'total_execution_time': self._total_execution_time,
+            'average_execution_time': (
+                self._total_execution_time / self._total_executions
+                if self._total_executions > 0 else 0
+            ),
+            'pattern_usage': self._pattern_usage.copy(),
+            '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/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for Django Orchestrator.
+"""

django_cfg/apps/agents/examples/simple_example.py

@@ -0,0 +1,161 @@
+"""
+Simple example demonstrating Django Orchestrator usage.
+"""
+
+import asyncio
+from dataclasses import dataclass
+from pydantic import BaseModel
+from django.contrib.auth.models import User
+
+from django_cfg.modules.django_orchestrator import DjangoAgent, SimpleOrchestrator, DjangoDeps, RunContext
+
+
+# Define output model
+class GreetingResult(BaseModel):
+    """Result from greeting agent."""
+    greeting: str
+    personalized: bool
+    user_info: str
+
+
+# Create agent
+greeting_agent = DjangoAgent[DjangoDeps, GreetingResult](
+    name="greeting_agent",
+    deps_type=DjangoDeps,
+    output_type=GreetingResult,
+    instructions="Generate personalized greetings for users"
+)
+
+
+# Add tools to agent
+@greeting_agent.tool
+async def get_user_info(ctx: RunContext[DjangoDeps]) -> str:
+    """Get user information for personalization."""
+    user = ctx.deps.user
+    return f"User: {user.username}, Email: {user.email}, Joined: {user.date_joined}"
+
+
+@greeting_agent.tool
+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:
+        return "afternoon"
+    else:
+        return "evening"
+
+
+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')
+    except User.DoesNotExist:
+        user = await User.objects.acreate_user(
+            username='testuser',
+            email='test@example.com',
+            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(
+        pattern="sequential",
+        agents=["greeting_agent"],
+        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()
+    for key, value in orch_metrics.items():
+        print(f"📈 {key}: {value}")
+
+
+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",
+        deps_type=DjangoDeps,
+        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(
+        pattern="sequential",
+        agents=["content_analyzer", "content_formatter"],
+        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(
+        pattern="parallel",
+        agents=["content_analyzer", "content_formatter"],
+        prompt="Process content in parallel",
+        deps=deps,
+        max_concurrent=2
+    )
+    
+    successful = sum(1 for r in results if r.success)
+    print(f"✅ {successful}/{len(results)} agents completed successfully")
+
+
+if __name__ == "__main__":
+    # Run examples
+    asyncio.run(simple_example())
+    asyncio.run(multi_agent_example())

django_cfg/apps/agents/integration/__init__.py

@@ -0,0 +1,14 @@
+"""
+Django integration components for orchestrator.
+"""
+
+from .registry import AgentRegistry, initialize_registry
+from .signals import setup_signals
+from .middleware import OrchestratorMiddleware
+
+__all__ = [
+    "AgentRegistry",
+    "initialize_registry",
+    "setup_signals",
+    "OrchestratorMiddleware",
+]

django_cfg/apps/agents/integration/middleware.py

@@ -0,0 +1,80 @@
+"""
+Django middleware for orchestrator integration.
+"""
+
+import time
+import logging
+from typing import Callable
+from django.http import HttpRequest, HttpResponse
+from django.utils.deprecation import MiddlewareMixin
+
+logger = logging.getLogger(__name__)
+
+
+class OrchestratorMiddleware(MiddlewareMixin):
+    """
+    Middleware for Django Orchestrator integration.
+    
+    Provides:
+    - Request context for agents
+    - Performance monitoring
+    - 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
+        request.orchestrator_start_time = time.time()
+        request.orchestrator_context = {
+            'user_agent': request.META.get('HTTP_USER_AGENT', ''),
+            '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'):
+            logger.error(
+                f"Exception in orchestrator context: {exception}",
+                extra={
+                    'request_path': request.path,
+                    'user_id': request.user.id if hasattr(request, 'user') and request.user.is_authenticated else None,
+                    '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')
+        if x_forwarded_for:
+            ip = x_forwarded_for.split(',')[0]
+        else:
+            ip = request.META.get('REMOTE_ADDR')
+        return ip or 'unknown'