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

django_cfg/apps/agents/core/agent.py

@@ -0,0 +1,281 @@
+"""
+Django Agent - Wrapper around Pydantic AI Agent with Django integration.
+"""
+
+import time
+import logging
+from typing import TypeVar, Generic, Type, Any, Optional, Dict, Callable
+from dataclasses import dataclass
+
+from pydantic_ai import Agent
+from pydantic_ai.models import Model
+
+from .exceptions import ExecutionError, ConfigurationError
+from .models import ExecutionResult
+
+# Type variables for generic typing
+DepsT = TypeVar('DepsT')
+OutputT = TypeVar('OutputT')
+
+logger = logging.getLogger(__name__)
+
+
+class DjangoAgent(Generic[DepsT, OutputT]):
+    """
+    Django-integrated agent wrapper around Pydantic AI Agent.
+    
+    Provides Django-specific functionality like:
+    - Integration with django_llm module
+    - Caching support
+    - Metrics collection
+    - Error handling
+    - Type safety
+    """
+    
+    def __init__(
+        self,
+        name: str,
+        deps_type: Type[DepsT],
+        output_type: Type[OutputT],
+        instructions: str,
+        model: Optional[str] = None,
+        llm_client: Optional[Any] = None,
+        timeout: int = 300,
+        max_retries: int = 3,
+        enable_caching: bool = True
+    ):
+        """
+        Initialize Django Agent.
+        
+        Args:
+            name: Unique agent identifier
+            deps_type: Type for dependency injection (must be dataclass)
+            output_type: Pydantic model for output validation
+            instructions: System prompt for the agent
+            model: Override model (uses client default if None)
+            llm_client: Optional LLM client (uses default if None)
+            timeout: Execution timeout in seconds
+            max_retries: Maximum retry attempts
+            enable_caching: Whether to enable result caching
+        """
+        self.name = name
+        self.deps_type = deps_type
+        self.output_type = output_type
+        self.instructions = instructions
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.enable_caching = enable_caching
+        
+        # Get LLM client
+        self.llm_client = llm_client or self._get_default_llm_client()
+        
+        # Determine model to use
+        model_name = model or self._get_default_model()
+        
+        # Create Pydantic AI agent
+        self.agent = Agent[DepsT, OutputT](
+            model=model_name,
+            deps_type=deps_type,
+            output_type=output_type,
+            instructions=instructions,
+            retries=max_retries
+        )
+        
+        # Initialize metrics
+        self._execution_count = 0
+        self._total_execution_time = 0.0
+        self._error_count = 0
+        self._cache_hits = 0
+        
+        logger.info(f"Initialized DjangoAgent '{name}' with model '{model_name}'")
+    
+    async def run(self, prompt: str, deps: DepsT, **kwargs) -> ExecutionResult:
+        """
+        Run agent with Django-specific enhancements.
+        
+        Args:
+            prompt: User prompt/instruction
+            deps: Dependencies instance
+            **kwargs: Additional Pydantic AI parameters
+            
+        Returns:
+            ExecutionResult with output, usage, and metadata
+        """
+        start_time = time.time()
+        self._execution_count += 1
+        
+        # Check cache if enabled
+        if self.enable_caching:
+            cached_result = await self._check_cache(prompt, deps)
+            if cached_result:
+                self._cache_hits += 1
+                logger.debug(f"Cache hit for agent '{self.name}'")
+                return ExecutionResult(
+                    agent_name=self.name,
+                    output=cached_result,
+                    execution_time=0.0,
+                    cached=True
+                )
+        
+        try:
+            # Execute agent
+            logger.debug(f"Executing agent '{self.name}' with prompt: {prompt[:100]}...")
+            
+            result = await self.agent.run(prompt, deps=deps, **kwargs)
+            
+            execution_time = time.time() - start_time
+            self._total_execution_time += execution_time
+            
+            # Extract metrics
+            tokens_used = 0
+            cost = 0.0
+            if hasattr(result, 'usage') and result.usage:
+                tokens_used = getattr(result.usage, 'total_tokens', 0)
+                # Calculate cost based on model and tokens (implement based on your pricing)
+                cost = self._calculate_cost(tokens_used)
+            
+            execution_result = ExecutionResult(
+                agent_name=self.name,
+                output=result.output,
+                execution_time=execution_time,
+                tokens_used=tokens_used,
+                cost=cost
+            )
+            
+            # Cache result if enabled
+            if self.enable_caching:
+                await self._cache_result(prompt, deps, result.output)
+            
+            logger.info(
+                f"Agent '{self.name}' executed successfully in {execution_time:.2f}s "
+                f"(tokens: {tokens_used}, cost: ${cost:.4f})"
+            )
+            
+            return execution_result
+            
+        except Exception as e:
+            self._error_count += 1
+            execution_time = time.time() - start_time
+            
+            logger.error(f"Agent '{self.name}' execution failed: {e}")
+            
+            raise ExecutionError(
+                f"Agent '{self.name}' execution failed: {str(e)}",
+                agent_name=self.name,
+                original_error=e
+            )
+    
+    def tool(self, func: Callable) -> Callable:
+        """
+        Register tool with agent.
+        
+        Args:
+            func: Function to register as agent tool
+            
+        Returns:
+            Decorated function
+        """
+        return self.agent.tool(func)
+    
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get agent execution metrics."""
+        return {
+            'name': self.name,
+            'execution_count': self._execution_count,
+            'total_execution_time': self._total_execution_time,
+            'average_execution_time': (
+                self._total_execution_time / self._execution_count 
+                if self._execution_count > 0 else 0
+            ),
+            'error_count': self._error_count,
+            'success_rate': (
+                (self._execution_count - self._error_count) / self._execution_count
+                if self._execution_count > 0 else 0
+            ),
+            'cache_hits': self._cache_hits,
+            'cache_hit_rate': (
+                self._cache_hits / self._execution_count
+                if self._execution_count > 0 else 0
+            )
+        }
+    
+    def reset_metrics(self):
+        """Reset agent metrics."""
+        self._execution_count = 0
+        self._total_execution_time = 0.0
+        self._error_count = 0
+        self._cache_hits = 0
+    
+    def _get_default_llm_client(self):
+        """Get default LLM client from django_llm module."""
+        try:
+            from django_cfg.modules.django_llm import DjangoLLM
+            llm_service = DjangoLLM()
+            if llm_service.is_configured:
+                return llm_service.client
+        except ImportError:
+            logger.warning("django_llm module not available, using default client")
+        
+        return None
+    
+    def _get_default_model(self) -> str:
+        """Get default model name."""
+        if self.llm_client and hasattr(self.llm_client, 'primary_provider'):
+            if self.llm_client.primary_provider == 'openrouter':
+                return 'openai:gpt-4o-mini'
+            elif self.llm_client.primary_provider == 'openai':
+                return 'openai:gpt-4o-mini'
+        
+        return 'openai:gpt-4o-mini'  # Default fallback
+    
+    async def _check_cache(self, prompt: str, deps: DepsT) -> Optional[Any]:
+        """Check cache for existing result."""
+        if not self.llm_client or not hasattr(self.llm_client, 'cache'):
+            return None
+        
+        try:
+            cache_key = self._generate_cache_key(prompt, deps)
+            return self.llm_client.cache.get(cache_key)
+        except Exception as e:
+            logger.warning(f"Cache check failed: {e}")
+            return None
+    
+    async def _cache_result(self, prompt: str, deps: DepsT, result: Any):
+        """Cache execution result."""
+        if not self.llm_client or not hasattr(self.llm_client, 'cache'):
+            return
+        
+        try:
+            cache_key = self._generate_cache_key(prompt, deps)
+            self.llm_client.cache.set(cache_key, result)
+        except Exception as e:
+            logger.warning(f"Cache storage failed: {e}")
+    
+    def _generate_cache_key(self, prompt: str, deps: DepsT) -> str:
+        """Generate cache key for prompt and dependencies."""
+        # Create a simple hash-based key
+        import hashlib
+        
+        # Include agent name, prompt, and relevant deps data
+        key_data = f"{self.name}:{prompt}"
+        
+        # Add user info if available
+        if hasattr(deps, 'user') and deps.user:
+            key_data += f":user_{deps.user.id}"
+        
+        # Add other relevant dependency data
+        if hasattr(deps, 'to_dict'):
+            deps_str = str(sorted(deps.to_dict().items()))
+            key_data += f":deps_{deps_str}"
+        
+        return hashlib.md5(key_data.encode()).hexdigest()
+    
+    def _calculate_cost(self, tokens_used: int) -> float:
+        """Calculate cost based on tokens used."""
+        # Implement based on your pricing model
+        # This is a simple example
+        cost_per_1k_tokens = 0.002  # Example: $0.002 per 1K tokens
+        return (tokens_used / 1000) * cost_per_1k_tokens
+    
+    def __repr__(self) -> str:
+        return f"DjangoAgent(name='{self.name}', deps_type={self.deps_type.__name__}, output_type={self.output_type.__name__})"

django_cfg/apps/agents/core/dependencies.py

@@ -0,0 +1,154 @@
+"""
+Dependency injection classes for Django Orchestrator.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional, TYPE_CHECKING
+from django.http import HttpRequest
+
+# Re-export RunContext from pydantic_ai for convenience
+from pydantic_ai import RunContext
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser
+
+__all__ = ["DjangoDeps", "ContentDeps", "RunContext"]
+
+
+@dataclass
+class DjangoDeps:
+    """Standard Django dependencies for agent execution."""
+    
+    user: "AbstractUser"
+    request: Optional[HttpRequest] = None
+    session_data: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    async def from_request(cls, request: HttpRequest) -> 'DjangoDeps':
+        """Create dependencies from Django request."""
+        return cls(
+            user=request.user,
+            request=request,
+            session_data=dict(request.session) if request.session else {}
+        )
+    
+    @classmethod
+    async def from_user_id(cls, user_id: int) -> 'DjangoDeps':
+        """Create dependencies from user ID."""
+        from django.contrib.auth import get_user_model
+        User = get_user_model()
+        user = await User.objects.aget(id=user_id)
+        return cls(user=user)
+    
+    @classmethod
+    async def from_user(cls, user: "AbstractUser") -> 'DjangoDeps':
+        """Create dependencies from user instance."""
+        return cls(user=user)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'user_id': self.user.id,
+            'username': self.user.username,
+            'session_data': self.session_data,
+            'has_request': self.request is not None
+        }
+
+
+@dataclass
+class ContentDeps(DjangoDeps):
+    """Content-specific dependencies."""
+    
+    content_id: Optional[int] = None
+    content_type: str = "article"
+    target_audience: str = "general"
+    
+    async def get_content(self):
+        """Get content object if content_id is provided."""
+        if not self.content_id:
+            return None
+        
+        # Import here to avoid circular imports
+        from django.apps import apps
+        
+        try:
+            Content = apps.get_model('your_app', 'Content')  # Adjust app name
+            return await Content.objects.aget(id=self.content_id)
+        except Exception:
+            return None
+
+
+@dataclass
+class DataProcessingDeps(DjangoDeps):
+    """Dependencies for data processing agents."""
+    
+    dataset_id: Optional[int] = None
+    processing_options: Dict[str, Any] = field(default_factory=dict)
+    batch_size: int = 100
+    
+    async def get_dataset(self):
+        """Get dataset object if dataset_id is provided."""
+        if not self.dataset_id:
+            return None
+        
+        # Import here to avoid circular imports
+        from django.apps import apps
+        
+        try:
+            Dataset = apps.get_model('your_app', 'Dataset')  # Adjust app name
+            return await Dataset.objects.aget(id=self.dataset_id)
+        except Exception:
+            return None
+
+
+@dataclass
+class BusinessLogicDeps(DjangoDeps):
+    """Dependencies for business logic agents."""
+    
+    business_context: Dict[str, Any] = field(default_factory=dict)
+    rules_version: str = "latest"
+    organization_id: Optional[int] = None
+    
+    async def get_organization(self):
+        """Get organization object if organization_id is provided."""
+        if not self.organization_id:
+            return None
+        
+        # Import here to avoid circular imports
+        from django.apps import apps
+        
+        try:
+            Organization = apps.get_model('your_app', 'Organization')  # Adjust app name
+            return await Organization.objects.aget(id=self.organization_id)
+        except Exception:
+            return None
+
+
+@dataclass
+class IntegrationDeps(DjangoDeps):
+    """Dependencies for external integration agents."""
+    
+    api_credentials: Dict[str, str] = field(default_factory=dict)
+    service_config: Dict[str, Any] = field(default_factory=dict)
+    rate_limit_key: Optional[str] = None
+    
+    def get_api_key(self, service_name: str) -> Optional[str]:
+        """Get API key for specific service."""
+        return self.api_credentials.get(f"{service_name}_api_key")
+    
+    def get_service_config(self, service_name: str) -> Dict[str, Any]:
+        """Get configuration for specific service."""
+        return self.service_config.get(service_name, {})
+
+
+@dataclass
+class TestDeps:
+    """Simple dependencies for testing."""
+    
+    user_id: int
+    test_data: Dict[str, Any] = field(default_factory=dict)
+    mock_responses: Dict[str, Any] = field(default_factory=dict)
+    
+    def get_mock_response(self, key: str) -> Any:
+        """Get mock response for testing."""
+        return self.mock_responses.get(key)

django_cfg/apps/agents/core/exceptions.py

@@ -0,0 +1,66 @@
+"""
+Exception classes for Django Agents.
+"""
+
+from typing import Optional, Any
+
+
+class AgentError(Exception):
+    """Base exception for Django Agents."""
+    
+    def __init__(self, message: str, details: Optional[dict] = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class AgentNotFoundError(AgentError):
+    """Raised when requested agent is not found in registry."""
+    
+    def __init__(self, agent_name: str):
+        message = f"Agent '{agent_name}' not found in registry"
+        super().__init__(message)
+        self.agent_name = agent_name
+
+
+class ExecutionError(AgentError):
+    """Raised when agent execution fails."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        agent_name: Optional[str] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(message)
+        self.agent_name = agent_name
+        self.original_error = original_error
+
+
+class ValidationError(AgentError):
+    """Raised when input/output validation fails."""
+    
+    def __init__(self, message: str, validation_errors: Optional[list] = None):
+        super().__init__(message)
+        self.validation_errors = validation_errors or []
+
+
+class ConfigurationError(AgentError):
+    """Raised when agent configuration is invalid."""
+    pass
+
+
+class PermissionError(AgentError):
+    """Raised when user lacks required permissions."""
+    
+    def __init__(self, message: str, required_permission: Optional[str] = None):
+        super().__init__(message)
+        self.required_permission = required_permission
+
+
+class TimeoutError(AgentError):
+    """Raised when agent execution times out."""
+    
+    def __init__(self, message: str, timeout_seconds: Optional[float] = None):
+        super().__init__(message)
+        self.timeout_seconds = timeout_seconds

django_cfg/apps/agents/core/models.py

@@ -0,0 +1,106 @@
+"""
+Data models for Django Orchestrator.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Literal
+from pydantic import BaseModel, Field, ConfigDict
+
+
+@dataclass
+class ExecutionResult:
+    """Result from agent execution with metadata."""
+    
+    agent_name: str
+    output: Any
+    execution_time: float
+    tokens_used: int = 0
+    cost: float = 0.0
+    cached: bool = False
+    error: Optional[str] = None
+    timestamp: datetime = field(default_factory=datetime.now)
+    
+    @property
+    def success(self) -> bool:
+        """Check if execution was successful."""
+        return self.error is None
+
+
+class WorkflowConfig(BaseModel):
+    """Configuration for workflow execution."""
+    
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    name: str = Field(..., description="Workflow identifier")
+    timeout: int = Field(default=300, ge=1, le=3600, description="Timeout in seconds")
+    max_retries: int = Field(default=3, ge=0, le=10, description="Maximum retry attempts")
+    execution_strategy: Literal["sequential", "parallel", "conditional"] = Field(
+        default="sequential", description="Execution strategy"
+    )
+    priority: int = Field(default=1, ge=1, le=10, description="Execution priority")
+    max_concurrent: int = Field(default=5, ge=1, le=20, description="Max concurrent executions")
+
+
+class AgentDefinition(BaseModel):
+    """Agent definition for registry storage."""
+    
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    name: str = Field(..., description="Agent identifier")
+    instructions: str = Field(..., description="Agent instructions")
+    deps_type: str = Field(..., description="Dependencies type name")
+    output_type: str = Field(..., description="Output type name")
+    model: str = Field(default="openai:gpt-4o-mini", description="LLM model to use")
+    timeout: int = Field(default=300, ge=1, le=3600, description="Execution timeout")
+    max_retries: int = Field(default=3, ge=0, le=10, description="Maximum retries")
+    is_active: bool = Field(default=True, description="Whether agent is active")
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+
+
+class ProcessResult(BaseModel):
+    """Standard processing result model."""
+    
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool = Field(..., description="Whether processing was successful")
+    message: str = Field(..., description="Result message")
+    data: Dict[str, Any] = Field(default_factory=dict, description="Additional data")
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class AnalysisResult(BaseModel):
+    """Standard analysis result model."""
+    
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    sentiment: str = Field(..., description="Sentiment analysis result")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    topics: List[str] = Field(default_factory=list, description="Extracted topics")
+    keywords: List[str] = Field(default_factory=list, description="Key terms")
+    summary: str = Field(default="", description="Content summary")
+
+
+class ValidationResult(BaseModel):
+    """Standard validation result model."""
+    
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    is_valid: bool = Field(..., description="Whether input is valid")
+    errors: List[str] = Field(default_factory=list, description="Validation errors")
+    warnings: List[str] = Field(default_factory=list, description="Validation warnings")
+    suggestions: List[str] = Field(default_factory=list, description="Improvement suggestions")
+
+
+@dataclass
+class ErrorContext:
+    """Error context information."""
+    
+    agent_name: str
+    prompt: str
+    error_type: str
+    error_message: str
+    timestamp: datetime
+    retry_count: int = 0
+    stack_trace: Optional[str] = None