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

django_cfg/apps/agents/core/django_agent.py

@@ -6,17 +6,19 @@ with optimal model selection for Python development tasks.
 """
 
 import time
-from typing import TypeVar, Generic, Type, Any, Optional, Dict, Callable, Sequence
+from collections.abc import Sequence
+from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar
 
 from pydantic_ai import Agent
 from pydantic_ai.models import KnownModelName
 from pydantic_ai.models.openai import OpenAIChatModel
-from pydantic_ai.providers.openrouter import OpenRouterProvider
 from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.providers.openrouter import OpenRouterProvider
 
-from django_cfg.modules.django_logging import get_logger
 from django_cfg.modules.base import BaseCfgModule
-from .exceptions import ExecutionError, ConfigurationError
+from django_cfg.modules.django_logging import get_logger
+
+from .exceptions import ExecutionError
 
 # Type variables for generic typing
 DepsT = TypeVar('DepsT')
@@ -36,7 +38,7 @@ class DjangoAgent(Generic[DepsT, OutputT]):
     - Error handling
     - Tool management
     """
-    
+
     def __init__(
         self,
         name: str,
@@ -53,17 +55,17 @@ class DjangoAgent(Generic[DepsT, OutputT]):
         self.deps_type = deps_type
         self.output_type = output_type
         self.instructions = instructions
-        
+
         # Select optimal model for Python development
         if model:
             selected_model = model
             model_kwargs = {}
         else:
             selected_model, model_kwargs = self._get_optimal_model()
-        
+
         # Merge model_kwargs with user kwargs (user kwargs take priority)
         final_kwargs = {**model_kwargs, **kwargs}
-        
+
         # Initialize Pydantic AI Agent directly
         self.agent = Agent(
             model=selected_model,
@@ -74,14 +76,14 @@ class DjangoAgent(Generic[DepsT, OutputT]):
             tools=tools or [],
             **final_kwargs
         )
-        
+
         # Metrics
         self._execution_count = 0
         self._total_execution_time = 0.0
         self._error_count = 0
-        
+
         logger.info(f"Initialized DjangoAgent '{name}' with model '{selected_model}'")
-    
+
     def _get_optimal_model(self) -> tuple[str, dict]:
         """
         Get optimal model for Python development tasks.
@@ -101,101 +103,101 @@ class DjangoAgent(Generic[DepsT, OutputT]):
             # Initialize django-cfg configuration
             cfg = BaseCfgModule()
             django_config = cfg.get_config()
-            
+
             if django_config and hasattr(django_config, 'api_keys') and django_config.api_keys:
                 api_keys = django_config.api_keys
-                
+
                 # Priority 1: OpenRouter + GPT-4o-mini (supports tools) - DEFAULT
                 if api_keys.has_openrouter():
                     openrouter_key = api_keys.get_openrouter_key()
                     logger.info("🚀 Using OpenAI GPT-4o-mini via OpenRouter - reliable tool support (DEFAULT)")
                     logger.debug(f"🔑 OpenRouter API key: {openrouter_key[:10]}...{openrouter_key[-4:] if openrouter_key else 'None'}")
-                    
+
                     provider = OpenRouterProvider(api_key=openrouter_key)
                     # Use GPT-4o-mini through OpenRouter (supports tools)
                     model = OpenAIChatModel('openai/gpt-4o-mini', provider=provider)
                     return model, {}
-                
+
                 # Priority 2: OpenAI GPT-4o-mini (fallback if OpenRouter unavailable)
                 if api_keys.has_openai():
                     openai_key = api_keys.get_openai_key()
                     logger.info("⚠️  Using OpenAI GPT-4o-mini - reliable tool support (FALLBACK - OpenRouter unavailable)")
                     logger.debug(f"🔑 OpenAI API key: {openai_key[:10]}...{openai_key[-4:] if openai_key else 'None'}")
-                    
+
                     provider = OpenAIProvider(api_key=openai_key)
                     model = OpenAIChatModel('gpt-4o-mini', provider=provider)
                     return model, {}
-            
+
             # Test model for development
             logger.warning("⚠️  No API keys found in django-cfg config, using test model")
             return 'test', {}
-            
+
         except Exception as e:
             logger.error(f"❌ Failed to load django-cfg config: {e}")
             logger.warning("⚠️  Using test model due to config error")
             return 'test', {}
-    
+
     async def run(self, prompt: str, deps: DepsT, **kwargs) -> OutputT:
         """Run the agent with given prompt and dependencies."""
         start_time = time.time()
-        
+
         try:
             self._execution_count += 1
-            
+
             # Run Pydantic AI agent
             result = await self.agent.run(prompt, deps=deps, **kwargs)
-            
+
             execution_time = time.time() - start_time
             self._total_execution_time += execution_time
-            
+
             logger.debug(f"✅ Agent '{self.name}' executed in {execution_time:.2f}s")
-            
+
             # Return the result data (Pydantic AI returns RunResult with .data attribute)
             return result.data if hasattr(result, 'data') else result
-            
+
         except Exception as e:
             self._error_count += 1
             execution_time = time.time() - start_time
             self._total_execution_time += execution_time
-            
+
             logger.error(f"❌ Agent '{self.name}' failed after {execution_time:.2f}s: {e}")
             raise ExecutionError(f"Agent execution failed: {e}") from e
-    
+
     def run_sync(self, prompt: str, deps: DepsT, **kwargs) -> OutputT:
         """Run the agent synchronously."""
         start_time = time.time()
-        
+
         try:
             self._execution_count += 1
-            
+
             # Run Pydantic AI agent synchronously
             result = self.agent.run_sync(prompt, deps=deps, **kwargs)
-            
+
             execution_time = time.time() - start_time
             self._total_execution_time += execution_time
-            
+
             logger.debug(f"✅ Agent '{self.name}' executed sync in {execution_time:.2f}s")
-            
+
             # Return the result data (Pydantic AI returns RunResult with .data attribute)
             return result.data if hasattr(result, 'data') else result
-            
+
         except Exception as e:
             self._error_count += 1
             execution_time = time.time() - start_time
             self._total_execution_time += execution_time
-            
+
             logger.error(f"❌ Agent '{self.name}' failed sync after {execution_time:.2f}s: {e}")
             raise ExecutionError(f"Agent execution failed: {e}") from e
-    
+
     def tool(self, func: Callable = None, *, name: str = None):
         """Decorator to add tools to the agent."""
         return self.agent.tool(func, name=name)
-    
+
     def get_metrics(self) -> Dict[str, Any]:
         """Get agent execution metrics."""
         avg_time = self._total_execution_time / max(self._execution_count, 1)
         success_rate = (self._execution_count - self._error_count) / max(self._execution_count, 1)
-        
+
         return {
             "name": self.name,
             "model": str(self.agent.model),
@@ -205,13 +207,13 @@ class DjangoAgent(Generic[DepsT, OutputT]):
             "error_count": self._error_count,
             "success_rate": success_rate
         }
-    
+
     def reset_metrics(self):
         """Reset agent metrics."""
         self._execution_count = 0
         self._total_execution_time = 0.0
         self._error_count = 0
-    
+
     def __repr__(self) -> str:
         """String representation of the agent."""
         return f"DjangoAgent(name='{self.name}', model='{self.agent.model}', deps_type={self.deps_type.__name__}, output_type={self.output_type.__name__})"

django_cfg/apps/agents/core/exceptions.py

@@ -2,12 +2,12 @@
 Exception classes for Django Agents.
 """
 
-from typing import Optional, Any
+from typing import Optional
 
 
 class AgentError(Exception):
     """Base exception for Django Agents."""
-    
+
     def __init__(self, message: str, details: Optional[dict] = None):
         super().__init__(message)
         self.message = message
@@ -16,7 +16,7 @@ class AgentError(Exception):
 
 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)
@@ -25,10 +25,10 @@ class AgentNotFoundError(AgentError):
 
 class ExecutionError(AgentError):
     """Raised when agent execution fails."""
-    
+
     def __init__(
-        self, 
-        message: str, 
+        self,
+        message: str,
         agent_name: Optional[str] = None,
         original_error: Optional[Exception] = None
     ):
@@ -39,7 +39,7 @@ class ExecutionError(AgentError):
 
 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 []
@@ -52,7 +52,7 @@ class ConfigurationError(AgentError):
 
 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
@@ -60,7 +60,7 @@ class PermissionError(AgentError):
 
 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
@@ -68,10 +68,10 @@ class TimeoutError(AgentError):
 
 class OrchestratorError(AgentError):
     """Raised when orchestrator execution fails."""
-    
+
     def __init__(
-        self, 
-        message: str, 
+        self,
+        message: str,
         orchestrator_name: Optional[str] = None,
         original_error: Optional[Exception] = None
     ):

django_cfg/apps/agents/core/models.py

@@ -4,14 +4,15 @@ 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
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
 
 
 @dataclass
 class ExecutionResult:
     """Result from agent execution with metadata."""
-    
+
     agent_name: str
     output: Any
     execution_time: float
@@ -20,7 +21,7 @@ class ExecutionResult:
     cached: bool = False
     error: Optional[str] = None
     timestamp: datetime = field(default_factory=datetime.now)
-    
+
     @property
     def success(self) -> bool:
         """Check if execution was successful."""
@@ -29,9 +30,9 @@ class ExecutionResult:
 
 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")
@@ -44,9 +45,9 @@ class WorkflowConfig(BaseModel):
 
 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")
@@ -61,9 +62,9 @@ class AgentDefinition(BaseModel):
 
 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")
@@ -72,9 +73,9 @@ class ProcessResult(BaseModel):
 
 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")
@@ -84,9 +85,9 @@ class AnalysisResult(BaseModel):
 
 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")
@@ -96,7 +97,7 @@ class ValidationResult(BaseModel):
 @dataclass
 class ErrorContext:
     """Error context information."""
-    
+
     agent_name: str
     prompt: str
     error_type: str