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

django_cfg/modules/django_app_agent/models/requests.py

@@ -0,0 +1,500 @@
+"""
+Request models for Django App Agent Module.
+
+This module defines all request models with:
+- Complete Pydantic 2 validation
+- Type-safe field definitions
+- Business logic validation
+- Clear documentation
+"""
+
+from typing import List, Optional, Dict, Any, Set
+from pathlib import Path
+from pydantic import Field, field_validator, model_validator
+
+from .base import BaseAgentModel, ValidationMixin
+from .enums import AppFeature, AppComplexity, AppType, QuestionType, ImpactLevel
+from ..utils.validation import validate_app_name, validate_description
+
+
+class AppGenerationRequest(BaseAgentModel, ValidationMixin):
+    """Request for generating a Django application."""
+    
+    # Core application details
+    app_name: str = Field(
+        description="Name of the Django application to generate",
+        min_length=2,
+        max_length=50,
+        pattern=r'^[a-z][a-z0-9_]*$'
+    )
+    
+    description: str = Field(
+        description="Detailed description of the application purpose and functionality",
+        min_length=10,
+        max_length=500
+    )
+    
+    # Application configuration
+    app_type: AppType = Field(
+        default=AppType.DJANGO_CFG,
+        description="Type of Django application to generate"
+    )
+    
+    features: List[AppFeature] = Field(
+        default_factory=list,
+        description="List of features to include in the generated application"
+    )
+    
+    complexity: AppComplexity = Field(
+        default=AppComplexity.MODERATE,
+        description="Complexity level of the application"
+    )
+    
+    # Generation options
+    enable_questioning: bool = Field(
+        default=True,
+        description="Whether to enable intelligent questioning system"
+    )
+    
+    max_questions: int = Field(
+        default=20,
+        ge=0,
+        le=50,
+        description="Maximum number of questions to ask during generation"
+    )
+    
+    questioning_timeout_minutes: int = Field(
+        default=15,
+        ge=1,
+        le=60,
+        description="Timeout for questioning session in minutes"
+    )
+    
+    # Quality requirements
+    quality_threshold: float = Field(
+        default=8.0,
+        ge=0.0,
+        le=10.0,
+        description="Minimum quality score required for generated code"
+    )
+    
+    # Integration options
+    target_apps: List[str] = Field(
+        default_factory=list,
+        description="Existing apps to analyze for integration patterns"
+    )
+    
+    exclude_patterns: List[str] = Field(
+        default_factory=list,
+        description="Patterns to exclude from generation"
+    )
+    
+    # Output configuration
+    output_directory: Optional[Path] = Field(
+        default=None,
+        description="Custom output directory for generated files"
+    )
+    
+    # Advanced options
+    custom_requirements: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Custom requirements and constraints"
+    )
+    
+    # UI options
+    rich_interface: bool = Field(
+        default=True,
+        description="Enable Rich CLI interface with progress bars"
+    )
+    
+    verbose_output: bool = Field(
+        default=False,
+        description="Enable verbose output during generation"
+    )
+    
+    @field_validator('app_name')
+    @classmethod
+    def validate_app_name_field(cls, v: str) -> str:
+        """Validate application name using utility function."""
+        return validate_app_name(v, check_reserved=True)
+    
+    @field_validator('description')
+    @classmethod
+    def validate_description_field(cls, v: str) -> str:
+        """Validate application description."""
+        return validate_description(v, min_length=10, max_length=500)
+    
+    @field_validator('features')
+    @classmethod
+    def validate_features_list(cls, v: List[AppFeature]) -> List[AppFeature]:
+        """Validate and deduplicate features list."""
+        if not v:
+            return []
+        
+        # Convert strings to enums if needed
+        enum_features = []
+        for feature in v:
+            if isinstance(feature, str):
+                enum_features.append(AppFeature(feature))
+            else:
+                enum_features.append(feature)
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_features = []
+        for feature in enum_features:
+            if feature not in seen:
+                seen.add(feature)
+                unique_features.append(feature)
+        
+        return unique_features
+    
+    @field_validator('complexity')
+    @classmethod
+    def validate_complexity_enum(cls, v) -> AppComplexity:
+        """Ensure complexity is proper enum."""
+        if isinstance(v, str):
+            return AppComplexity(v)
+        return v
+    
+    @field_validator('app_type')
+    @classmethod
+    def validate_app_type_enum(cls, v) -> AppType:
+        """Ensure app_type is proper enum."""
+        if isinstance(v, str):
+            return AppType(v)
+        return v
+    
+    @field_validator('target_apps')
+    @classmethod
+    def validate_target_apps(cls, v: List[str]) -> List[str]:
+        """Validate target apps list."""
+        if not v:
+            return []
+        
+        validated_apps = []
+        for app_name in v:
+            try:
+                validated_name = validate_app_name(app_name, check_reserved=False)
+                validated_apps.append(validated_name)
+            except Exception:
+                # Skip invalid app names
+                continue
+        
+        return validated_apps
+    
+    @model_validator(mode='after')
+    def validate_consistency(self) -> 'AppGenerationRequest':
+        """Validate consistency between fields."""
+        # Note: Pydantic 2 handles enum conversion automatically, 
+        # so we don't need to manually convert them here
+        
+        # Auto-populate features based on complexity if not specified
+        if not self.features:
+            self.features = list(self.complexity.get_recommended_features())
+        
+        # Validate feature dependencies
+        all_features = set(self.features)
+        for feature in self.features:
+            dependencies = feature.get_dependencies()
+            missing_deps = dependencies - all_features
+            if missing_deps:
+                # Add missing dependencies
+                self.features.extend(list(missing_deps))
+        
+        # Adjust max_questions based on complexity
+        if self.max_questions > self.complexity.get_max_questions():
+            self.max_questions = self.complexity.get_max_questions()
+        
+        # Validate app type supports all requested features
+        unsupported_features = []
+        for feature in self.features:
+            if not self.app_type.supports_feature(feature):
+                unsupported_features.append(feature)
+        
+        if unsupported_features:
+            raise ValueError(
+                f"App type {self.app_type} does not support features: {unsupported_features}"
+            )
+        
+        return self
+    
+    def get_estimated_time_minutes(self) -> int:
+        """Get estimated generation time in minutes."""
+        base_time = self.complexity.get_estimated_time_minutes()
+        
+        # Add time for additional features
+        feature_multiplier = len(self.features) / len(self.complexity.get_recommended_features())
+        adjusted_time = int(base_time * max(1.0, feature_multiplier))
+        
+        # Add questioning time if enabled
+        if self.enable_questioning:
+            adjusted_time += min(self.questioning_timeout_minutes, 10)
+        
+        return adjusted_time
+    
+    def get_feature_set(self) -> Set[AppFeature]:
+        """Get set of features for easy lookup."""
+        return set(self.features)
+    
+    def has_feature(self, feature: AppFeature) -> bool:
+        """Check if a specific feature is requested."""
+        return feature in self.get_feature_set()
+
+
+class QuestioningRequest(BaseAgentModel):
+    """Request for conducting an intelligent questioning session."""
+    
+    user_intent: str = Field(
+        description="User's stated intent or goal for the application",
+        min_length=5,
+        max_length=200
+    )
+    
+    project_path: Path = Field(
+        description="Path to the Django project for context analysis"
+    )
+    
+    app_generation_request: AppGenerationRequest = Field(
+        description="Associated app generation request"
+    )
+    
+    max_questions: int = Field(
+        default=20,
+        ge=1,
+        le=50,
+        description="Maximum number of questions to ask"
+    )
+    
+    timeout_minutes: int = Field(
+        default=15,
+        ge=1,
+        le=60,
+        description="Maximum time for questioning session"
+    )
+    
+    focus_areas: List[str] = Field(
+        default_factory=list,
+        description="Specific areas to focus questions on"
+    )
+    
+    skip_basic_questions: bool = Field(
+        default=False,
+        description="Skip basic questions and focus on advanced topics"
+    )
+    
+    @field_validator('project_path')
+    @classmethod
+    def validate_project_path(cls, v: Path) -> Path:
+        """Validate that project path exists and is a directory."""
+        from ..utils.validation import validate_file_path
+        
+        return validate_file_path(
+            v,
+            must_exist=True,
+            must_be_dir=True
+        )
+
+
+class DiagnosticRequest(BaseAgentModel):
+    """Request for diagnosing problems in Django applications."""
+    
+    project_path: Path = Field(
+        description="Path to the Django project to diagnose"
+    )
+    
+    app_name: Optional[str] = Field(
+        default=None,
+        description="Specific app to focus diagnosis on"
+    )
+    
+    problem_description: str = Field(
+        description="Description of the problem or issue",
+        min_length=10,
+        max_length=1000
+    )
+    
+    error_messages: List[str] = Field(
+        default_factory=list,
+        description="Any error messages encountered"
+    )
+    
+    symptoms: List[str] = Field(
+        default_factory=list,
+        description="Observed symptoms of the problem"
+    )
+    
+    recent_changes: List[str] = Field(
+        default_factory=list,
+        description="Recent changes that might be related"
+    )
+    
+    urgency_level: ImpactLevel = Field(
+        default=ImpactLevel.MEDIUM,
+        description="Urgency level of the problem"
+    )
+    
+    include_suggestions: bool = Field(
+        default=True,
+        description="Whether to include solution suggestions"
+    )
+    
+    max_suggestions: int = Field(
+        default=5,
+        ge=1,
+        le=20,
+        description="Maximum number of solution suggestions"
+    )
+    
+    @field_validator('project_path')
+    @classmethod
+    def validate_project_path(cls, v: Path) -> Path:
+        """Validate that project path exists."""
+        from ..utils.validation import validate_file_path
+        
+        return validate_file_path(
+            v,
+            must_exist=True,
+            must_be_dir=True
+        )
+    
+    @field_validator('app_name')
+    @classmethod
+    def validate_app_name_field(cls, v: Optional[str]) -> Optional[str]:
+        """Validate app name if provided."""
+        if v is None:
+            return v
+        
+        return validate_app_name(v, check_reserved=False)
+    
+    @field_validator('problem_description')
+    @classmethod
+    def validate_problem_description(cls, v: str) -> str:
+        """Validate problem description."""
+        return validate_description(v, min_length=10, max_length=1000)
+
+
+class ContextualQuestion(BaseAgentModel):
+    """A contextual question generated by the intelligent questioning system."""
+    
+    id: str = Field(description="Unique question identifier")
+    
+    text: str = Field(
+        description="The question text to display to the user",
+        min_length=10,
+        max_length=500
+    )
+    
+    question_type: QuestionType = Field(
+        description="Type of question (yes/no, multiple choice, etc.)"
+    )
+    
+    impact_level: ImpactLevel = Field(
+        description="Impact level of this question on the final result"
+    )
+    
+    context_evidence: List[str] = Field(
+        default_factory=list,
+        description="Evidence from codebase that prompted this question"
+    )
+    
+    options: Optional[List[str]] = Field(
+        default=None,
+        description="Available options for multiple choice questions"
+    )
+    
+    default_answer: Optional[str] = Field(
+        default=None,
+        description="Default answer if user skips"
+    )
+    
+    architectural_implications: List[str] = Field(
+        default_factory=list,
+        description="How the answer affects architectural decisions"
+    )
+    
+    @field_validator('question_type')
+    @classmethod
+    def validate_question_type_enum(cls, v) -> QuestionType:
+        """Ensure question_type is proper enum."""
+        if isinstance(v, str):
+            return QuestionType(v)
+        return v
+    
+    @field_validator('impact_level')
+    @classmethod
+    def validate_impact_level_enum(cls, v) -> ImpactLevel:
+        """Ensure impact_level is proper enum."""
+        if isinstance(v, str):
+            return ImpactLevel(v)
+        return v
+    
+    @model_validator(mode='after')
+    def validate_question_consistency(self) -> 'ContextualQuestion':
+        """Validate question consistency."""
+        # Note: Pydantic 2 handles enum conversion automatically
+        
+        # Questions requiring options must have them
+        if self.question_type.requires_options() and not self.options:
+            raise ValueError(f"Question type {self.question_type} requires options")
+        
+        # Validate default answer is in options if provided
+        if self.default_answer and self.options:
+            if self.default_answer not in self.options:
+                raise ValueError("Default answer must be one of the provided options")
+        
+        return self
+
+
+class QuestionResponse(BaseAgentModel):
+    """Response to a contextual question."""
+    
+    question_id: str = Field(description="ID of the question being answered")
+    
+    answer: str = Field(
+        description="User's answer to the question",
+        min_length=1,
+        max_length=1000
+    )
+    
+    confidence: float = Field(
+        default=1.0,
+        ge=0.0,
+        le=1.0,
+        description="User's confidence in their answer (0-1)"
+    )
+    
+    notes: Optional[str] = Field(
+        default=None,
+        max_length=500,
+        description="Additional notes or context from user"
+    )
+
+
+class TemplateRequest(BaseAgentModel):
+    """Request for template rendering."""
+    
+    template_name: str = Field(
+        description="Name of the template to render",
+        min_length=1,
+        max_length=100
+    )
+    
+    app_type: AppType = Field(
+        description="Type of Django application"
+    )
+    
+    features: List[AppFeature] = Field(
+        default_factory=list,
+        description="List of features to include in template"
+    )
+    
+    variables: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Template variables for rendering"
+    )
+    
+    custom_templates: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Custom template overrides"
+    )