django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/modules/django_app_agent/core/config.py

@@ -0,0 +1,300 @@
+"""
+Configuration management for Django App Agent Module.
+
+This module provides type-safe configuration management with:
+- Integration with django-cfg BaseCfgModule
+- Pydantic 2 models for all configuration
+- Environment variable support
+- Validation and default values
+- AI model configuration
+"""
+
+from typing import Optional, Dict, Any, List, Literal
+from pathlib import Path
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from enum import Enum
+
+from django_cfg.modules.base import BaseCfgModule
+from .exceptions import ConfigurationError
+
+
+class LogLevel(str, Enum):
+    """Logging levels."""
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class AIProvider(str, Enum):
+    """AI service providers."""
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    OPENROUTER = "openrouter"
+
+
+class ModelTier(str, Enum):
+    """AI model performance tiers."""
+    FAST = "fast"        # Fast, cheaper models for simple tasks
+    BALANCED = "balanced"  # Balanced performance and cost
+    PREMIUM = "premium"   # Best quality, higher cost
+
+
+class ModelConfig(BaseModel):
+    """Configuration for AI models."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True,
+        str_strip_whitespace=True
+    )
+    
+    provider: AIProvider = Field(description="AI service provider")
+    model_id: str = Field(description="Model identifier")
+    tier: ModelTier = Field(description="Model performance tier")
+    max_tokens: int = Field(gt=0, le=200000, description="Maximum tokens per request")
+    temperature: float = Field(ge=0.0, le=2.0, default=0.1, description="Model temperature")
+    timeout_seconds: float = Field(gt=0, default=300.0, description="Request timeout")
+    
+    @field_validator('model_id')
+    @classmethod
+    def validate_model_id(cls, v: str) -> str:
+        """Validate model ID format."""
+        if not v or len(v.strip()) == 0:
+            raise ValueError("Model ID cannot be empty")
+        return v.strip()
+
+
+class APIKeyConfig(BaseModel):
+    """API key configuration."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True,
+        str_strip_whitespace=True
+    )
+    
+    openai: Optional[str] = Field(default=None, description="OpenAI API key")
+    anthropic: Optional[str] = Field(default=None, description="Anthropic API key")
+    openrouter: Optional[str] = Field(default=None, description="OpenRouter API key")
+    
+    def get_key(self, provider: AIProvider) -> Optional[str]:
+        """Get API key for provider."""
+        return getattr(self, provider.value, None)
+    
+    def has_key(self, provider: AIProvider) -> bool:
+        """Check if API key exists for provider."""
+        key = self.get_key(provider)
+        return key is not None and len(key.strip()) > 0
+
+
+class UIConfig(BaseModel):
+    """User interface configuration."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True
+    )
+    
+    enable_rich_interface: bool = Field(default=True, description="Enable Rich CLI interface")
+    show_progress_bars: bool = Field(default=True, description="Show progress bars")
+    enable_colors: bool = Field(default=True, description="Enable colored output")
+    verbose_output: bool = Field(default=False, description="Enable verbose output")
+    max_console_width: int = Field(gt=40, le=200, default=120, description="Maximum console width")
+
+
+class GenerationConfig(BaseModel):
+    """Code generation configuration."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True
+    )
+    
+    max_questions: int = Field(gt=0, le=50, default=20, description="Maximum questions to ask")
+    questioning_timeout_minutes: int = Field(gt=0, le=60, default=15, description="Questioning timeout")
+    quality_threshold: float = Field(ge=0.0, le=10.0, default=8.0, description="Minimum quality score")
+    enable_caching: bool = Field(default=True, description="Enable response caching")
+    cache_ttl_seconds: int = Field(gt=0, default=3600, description="Cache TTL in seconds")
+    max_concurrent_generations: int = Field(gt=0, le=10, default=3, description="Max concurrent generations")
+    
+    @field_validator('quality_threshold')
+    @classmethod
+    def validate_quality_threshold(cls, v: float) -> float:
+        """Validate quality threshold is reasonable."""
+        if v < 5.0:
+            raise ValueError("Quality threshold should be at least 5.0 for production use")
+        return v
+
+
+class AgentConfig(BaseModel):
+    """Django App Agent Module configuration."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True,
+        str_strip_whitespace=True
+    )
+    
+    # Core settings
+    module_name: str = Field(default="django_app_agent", description="Module name")
+    version: str = Field(default="0.1.0", description="Module version")
+    debug_mode: bool = Field(default=False, description="Enable debug mode")
+    log_level: LogLevel = Field(default=LogLevel.INFO, description="Logging level")
+    
+    # API configuration
+    api_keys: APIKeyConfig = Field(default_factory=APIKeyConfig, description="API keys")
+    preferred_models: Dict[str, ModelConfig] = Field(
+        default_factory=dict,
+        description="Preferred models for different tasks"
+    )
+    
+    # UI configuration
+    ui: UIConfig = Field(default_factory=UIConfig, description="UI settings")
+    
+    # Generation configuration
+    generation: GenerationConfig = Field(default_factory=GenerationConfig, description="Generation settings")
+    
+    # File paths
+    output_directory: Optional[Path] = Field(default=None, description="Default output directory")
+    template_directory: Optional[Path] = Field(default=None, description="Template directory")
+    cache_directory: Optional[Path] = Field(default=None, description="Cache directory")
+    
+    @classmethod
+    def from_django_cfg(cls) -> "AgentConfig":
+        """Load configuration from django-cfg."""
+        try:
+            cfg_module = BaseCfgModule()
+            django_cfg_config = cfg_module.get_config()
+            
+            # Extract relevant configuration
+            config_data: Dict[str, Any] = {}
+            
+            # API keys - extract string values from SecretStr
+            if hasattr(django_cfg_config, 'api_keys'):
+                api_keys_data = {}
+                if hasattr(django_cfg_config.api_keys, 'openai') and django_cfg_config.api_keys.openai:
+                    # Extract string value from SecretStr if needed
+                    openai_key = django_cfg_config.api_keys.openai
+                    api_keys_data['openai'] = str(openai_key) if hasattr(openai_key, 'get_secret_value') else openai_key
+                if hasattr(django_cfg_config.api_keys, 'anthropic') and django_cfg_config.api_keys.anthropic:
+                    # Extract string value from SecretStr if needed
+                    anthropic_key = django_cfg_config.api_keys.anthropic
+                    api_keys_data['anthropic'] = str(anthropic_key) if hasattr(anthropic_key, 'get_secret_value') else anthropic_key
+                if hasattr(django_cfg_config.api_keys, 'openrouter') and django_cfg_config.api_keys.openrouter:
+                    # Extract string value from SecretStr if needed
+                    openrouter_key = django_cfg_config.api_keys.openrouter
+                    api_keys_data['openrouter'] = str(openrouter_key) if hasattr(openrouter_key, 'get_secret_value') else openrouter_key
+                
+                config_data['api_keys'] = api_keys_data
+            
+            # Agent-specific settings
+            if hasattr(django_cfg_config, 'agents') and django_cfg_config.agents:
+                agent_config = django_cfg_config.agents
+                
+                if hasattr(agent_config, 'debug_mode'):
+                    config_data['debug_mode'] = agent_config.debug_mode
+                
+                if hasattr(agent_config, 'max_questions'):
+                    config_data['generation'] = config_data.get('generation', {})
+                    config_data['generation']['max_questions'] = agent_config.max_questions
+                
+                if hasattr(agent_config, 'quality_threshold'):
+                    config_data['generation'] = config_data.get('generation', {})
+                    config_data['generation']['quality_threshold'] = agent_config.quality_threshold
+            
+            return cls(**config_data)
+            
+        except Exception as e:
+            raise ConfigurationError(
+                f"Failed to load configuration from django-cfg: {e}",
+                cause=e
+            )
+    
+    def get_api_key(self, provider: AIProvider) -> Optional[str]:
+        """Get API key for provider."""
+        return self.api_keys.get_key(provider)
+    
+    def has_api_key(self, provider: AIProvider) -> bool:
+        """Check if API key exists for provider."""
+        return self.api_keys.has_key(provider)
+    
+    def get_model_config(self, task_type: str) -> Optional[ModelConfig]:
+        """Get model configuration for task type."""
+        return self.preferred_models.get(task_type)
+    
+    def validate_configuration(self) -> List[str]:
+        """Validate configuration and return list of issues."""
+        issues: List[str] = []
+        
+        # Check API keys
+        if not any(self.api_keys.has_key(provider) for provider in AIProvider):
+            issues.append("No API keys configured for any AI provider")
+        
+        # Check directories
+        if self.output_directory and not self.output_directory.exists():
+            issues.append(f"Output directory does not exist: {self.output_directory}")
+        
+        if self.template_directory and not self.template_directory.exists():
+            issues.append(f"Template directory does not exist: {self.template_directory}")
+        
+        # Check model configurations
+        for task_type, model_config in self.preferred_models.items():
+            if not self.has_api_key(model_config.provider):
+                issues.append(f"No API key for {model_config.provider} (required for {task_type})")
+        
+        return issues
+
+
+# Default model configurations
+DEFAULT_MODELS: Dict[str, ModelConfig] = {
+    "generation": ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="anthropic/claude-3-haiku",
+        tier=ModelTier.BALANCED,
+        max_tokens=100000,
+        temperature=0.1,
+        timeout_seconds=300.0
+    ),
+    "analysis": ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="openai/gpt-4o-mini",
+        tier=ModelTier.FAST,
+        max_tokens=50000,
+        temperature=0.0,
+        timeout_seconds=180.0
+    ),
+    "validation": ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="anthropic/claude-3-haiku",
+        tier=ModelTier.FAST,
+        max_tokens=30000,
+        temperature=0.0,
+        timeout_seconds=120.0
+    ),
+    "dialogue": ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="openai/gpt-4o-mini",
+        tier=ModelTier.FAST,
+        max_tokens=20000,
+        temperature=0.2,
+        timeout_seconds=60.0
+    )
+}
+
+
+def get_default_config() -> AgentConfig:
+    """Get default configuration with sensible defaults."""
+    return AgentConfig(
+        preferred_models=DEFAULT_MODELS.copy()
+    )
+
+
+def load_config() -> AgentConfig:
+    """Load configuration from django-cfg or use defaults."""
+    try:
+        return AgentConfig.from_django_cfg()
+    except ConfigurationError:
+        # Fall back to default configuration
+        return get_default_config()

django_cfg/modules/django_app_agent/core/exceptions.py

@@ -0,0 +1,359 @@
+"""
+Exception hierarchy for Django App Agent Module.
+
+This module defines a comprehensive exception hierarchy following best practices:
+- Clear inheritance structure
+- Contextual error information
+- Structured error data with Pydantic models
+- Support for error recovery and retry logic
+"""
+
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class ErrorContext(BaseModel):
+    """Context information for errors."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True,
+        str_strip_whitespace=True
+    )
+    
+    operation: str = Field(description="Operation that caused the error")
+    component: str = Field(description="Component where error occurred")
+    timestamp: str = Field(description="Error timestamp")
+    correlation_id: Optional[str] = Field(default=None, description="Correlation ID for tracing")
+    additional_data: Dict[str, Any] = Field(default_factory=dict, description="Additional error context")
+
+
+class DjangoAppAgentError(Exception):
+    """Base exception for all Django App Agent Module errors."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        error_code: Optional[str] = None,
+        context: Optional[ErrorContext] = None,
+        cause: Optional[Exception] = None,
+        recoverable: bool = False
+    ) -> None:
+        """Initialize Django App Agent error.
+        
+        Args:
+            message: Human-readable error message
+            error_code: Machine-readable error code
+            context: Error context information
+            cause: Original exception that caused this error
+            recoverable: Whether this error can be recovered from
+        """
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code or self.__class__.__name__
+        self.context = context
+        self.cause = cause
+        self.recoverable = recoverable
+    
+    def __str__(self) -> str:
+        """String representation of the error."""
+        parts = [self.message]
+        
+        if self.error_code:
+            parts.append(f"[{self.error_code}]")
+        
+        if self.context:
+            parts.append(f"Operation: {self.context.operation}")
+            parts.append(f"Component: {self.context.component}")
+        
+        return " | ".join(parts)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert error to dictionary representation."""
+        return {
+            "error_type": self.__class__.__name__,
+            "message": self.message,
+            "error_code": self.error_code,
+            "context": self.context.model_dump() if self.context else None,
+            "recoverable": self.recoverable,
+            "cause": str(self.cause) if self.cause else None,
+        }
+
+
+class ConfigurationError(DjangoAppAgentError):
+    """Error in module configuration or setup."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        config_key: Optional[str] = None,
+        config_file: Optional[Path] = None,
+        **kwargs
+    ) -> None:
+        """Initialize configuration error.
+        
+        Args:
+            message: Error message
+            config_key: Configuration key that caused the error
+            config_file: Configuration file path
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, **kwargs)
+        self.config_key = config_key
+        self.config_file = config_file
+
+
+class GenerationError(DjangoAppAgentError):
+    """Error during application generation process."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        app_name: Optional[str] = None,
+        generation_stage: Optional[str] = None,
+        partial_results: Optional[List[str]] = None,
+        **kwargs
+    ) -> None:
+        """Initialize generation error.
+        
+        Args:
+            message: Error message
+            app_name: Name of app being generated
+            generation_stage: Stage where error occurred
+            partial_results: Partial results before error
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, recoverable=True, **kwargs)
+        self.app_name = app_name
+        self.generation_stage = generation_stage
+        self.partial_results = partial_results or []
+
+
+class ValidationError(DjangoAppAgentError):
+    """Error during validation of generated code or user input."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        validation_type: Optional[str] = None,
+        field_name: Optional[str] = None,
+        field_value: Optional[Any] = None,
+        **kwargs
+    ) -> None:
+        """Initialize validation error.
+        
+        Args:
+            message: Error message
+            validation_type: Type of validation that failed
+            field_name: Field that failed validation
+            field_value: Value that failed validation
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, **kwargs)
+        self.validation_type = validation_type
+        self.field_name = field_name
+        self.field_value = field_value
+
+
+class QualityValidationError(ValidationError):
+    """Error when generated code doesn't meet quality standards."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        quality_score: Optional[float] = None,
+        minimum_score: Optional[float] = None,
+        quality_issues: Optional[List[str]] = None,
+        **kwargs
+    ) -> None:
+        """Initialize quality validation error.
+        
+        Args:
+            message: Error message
+            quality_score: Actual quality score achieved
+            minimum_score: Minimum required quality score
+            quality_issues: List of specific quality issues
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, validation_type="quality", **kwargs)
+        self.quality_score = quality_score
+        self.minimum_score = minimum_score
+        self.quality_issues = quality_issues or []
+
+
+class AgentExecutionError(DjangoAppAgentError):
+    """Error during AI agent execution."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        agent_name: Optional[str] = None,
+        agent_operation: Optional[str] = None,
+        retry_count: int = 0,
+        max_retries: int = 3,
+        **kwargs
+    ) -> None:
+        """Initialize agent execution error.
+        
+        Args:
+            message: Error message
+            agent_name: Name of the agent that failed
+            agent_operation: Operation the agent was performing
+            retry_count: Number of retries attempted
+            max_retries: Maximum number of retries allowed
+            **kwargs: Additional arguments for base class
+        """
+        recoverable = retry_count < max_retries
+        super().__init__(message, recoverable=recoverable, **kwargs)
+        self.agent_name = agent_name
+        self.agent_operation = agent_operation
+        self.retry_count = retry_count
+        self.max_retries = max_retries
+
+
+class AuthenticationError(DjangoAppAgentError):
+    """Error with AI service authentication."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        provider: Optional[str] = None,
+        api_key_hint: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        """Initialize authentication error.
+        
+        Args:
+            message: Error message
+            provider: AI service provider (openai, anthropic, etc.)
+            api_key_hint: Hint about API key (first/last chars)
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, **kwargs)
+        self.provider = provider
+        self.api_key_hint = api_key_hint
+
+
+class RateLimitError(DjangoAppAgentError):
+    """Error when AI service rate limits are exceeded."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        provider: Optional[str] = None,
+        retry_after: Optional[int] = None,
+        requests_remaining: Optional[int] = None,
+        **kwargs
+    ) -> None:
+        """Initialize rate limit error.
+        
+        Args:
+            message: Error message
+            provider: AI service provider
+            retry_after: Seconds to wait before retry
+            requests_remaining: Number of requests remaining
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, recoverable=True, **kwargs)
+        self.provider = provider
+        self.retry_after = retry_after
+        self.requests_remaining = requests_remaining
+
+
+class TimeoutError(DjangoAppAgentError):
+    """Error when operations exceed time limits."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        operation: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        elapsed_seconds: Optional[float] = None,
+        **kwargs
+    ) -> None:
+        """Initialize timeout error.
+        
+        Args:
+            message: Error message
+            operation: Operation that timed out
+            timeout_seconds: Configured timeout
+            elapsed_seconds: Actual elapsed time
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, recoverable=True, **kwargs)
+        self.operation = operation
+        self.timeout_seconds = timeout_seconds
+        self.elapsed_seconds = elapsed_seconds
+
+
+class FileSystemError(DjangoAppAgentError):
+    """Error when file system operations fail."""
+    
+    def __init__(
+        self,
+        message: str,
+        *,
+        file_path: Optional[str] = None,
+        operation: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        """Initialize file system error.
+        
+        Args:
+            message: Error message
+            file_path: Path to the file that caused the error
+            operation: File system operation that failed
+            **kwargs: Additional arguments for base class
+        """
+        super().__init__(message, recoverable=True, **kwargs)
+        self.file_path = file_path
+        self.operation = operation
+
+
+# Exception mapping for easy lookup
+EXCEPTION_MAP: Dict[str, type[DjangoAppAgentError]] = {
+    "configuration": ConfigurationError,
+    "generation": GenerationError,
+    "validation": ValidationError,
+    "quality": QualityValidationError,
+    "agent": AgentExecutionError,
+    "auth": AuthenticationError,
+    "rate_limit": RateLimitError,
+    "timeout": TimeoutError,
+    "filesystem": FileSystemError,
+}
+
+
+def create_error(
+    error_type: str,
+    message: str,
+    **kwargs
+) -> DjangoAppAgentError:
+    """Create an error of the specified type.
+    
+    Args:
+        error_type: Type of error to create
+        message: Error message
+        **kwargs: Additional arguments for the error
+        
+    Returns:
+        Appropriate error instance
+        
+    Raises:
+        ValueError: If error_type is not recognized
+    """
+    if error_type not in EXCEPTION_MAP:
+        raise ValueError(f"Unknown error type: {error_type}")
+    
+    error_class = EXCEPTION_MAP[error_type]
+    return error_class(message, **kwargs)