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

django_cfg/modules/django_app_agent/services/validation_service/django_validator.py

@@ -0,0 +1,333 @@
+"""
+Django Best Practices Validator.
+
+This module validates Django-specific patterns, conventions,
+and best practices in generated code.
+"""
+
+from typing import List, Dict, Any, Optional
+import ast
+import re
+
+from pydantic import BaseModel, Field
+
+from ...models.responses import GeneratedFile
+from ..base import ServiceDependencies
+from .models import ValidationIssue
+
+
+class DjangoValidator(BaseModel):
+    """Validates Django best practices and conventions."""
+    
+    django_rules: Dict[str, Dict[str, Any]] = Field(
+        default_factory=lambda: {
+            "model_meta_class": {
+                "description": "Models should have proper Meta class",
+                "severity": "warning"
+            },
+            "model_string_representation": {
+                "description": "Models should have __str__ method",
+                "severity": "warning"
+            },
+            "admin_registration": {
+                "description": "Admin classes should be properly registered",
+                "severity": "info"
+            },
+            "url_naming": {
+                "description": "URL patterns should have names",
+                "severity": "warning"
+            },
+            "view_docstrings": {
+                "description": "Views should have docstrings",
+                "severity": "info"
+            },
+            "form_validation": {
+                "description": "Forms should have proper validation",
+                "severity": "warning"
+            }
+        },
+        description="Django validation rules"
+    )
+
+    async def validate_django_practices(
+        self,
+        file: GeneratedFile,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django best practices for a single file."""
+        issues = []
+        
+        if file.file_type != "python":
+            return issues
+        
+        try:
+            tree = ast.parse(file.content)
+            
+            # Determine file type and apply appropriate validations
+            if "models.py" in file.path:
+                issues.extend(self._validate_models(file, tree, dependencies))
+            elif "admin.py" in file.path:
+                issues.extend(self._validate_admin(file, tree, dependencies))
+            elif "views.py" in file.path:
+                issues.extend(self._validate_views(file, tree, dependencies))
+            elif "urls.py" in file.path:
+                issues.extend(self._validate_urls(file, tree, dependencies))
+            elif "forms.py" in file.path:
+                issues.extend(self._validate_forms(file, tree, dependencies))
+            elif "serializers.py" in file.path:
+                issues.extend(self._validate_serializers(file, tree, dependencies))
+            
+        except SyntaxError:
+            # Skip Django validation if syntax is invalid
+            pass
+        except Exception as e:
+            dependencies.log_error(f"Django validation failed for {file.path}", e)
+        
+        return issues
+    
+    def _validate_models(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django model best practices."""
+        issues = []
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                # Check if it's a model class
+                is_model = any(
+                    isinstance(base, ast.Attribute) and 
+                    isinstance(base.value, ast.Name) and
+                    base.value.id == "models" and
+                    base.attr == "Model"
+                    for base in node.bases
+                ) or any(
+                    isinstance(base, ast.Name) and
+                    "Model" in base.id
+                    for base in node.bases
+                )
+                
+                if is_model:
+                    issues.extend(self._check_model_class(file, node))
+        
+        return issues
+    
+    def _check_model_class(
+        self,
+        file: GeneratedFile,
+        node: ast.ClassDef
+    ) -> List[ValidationIssue]:
+        """Check individual model class for best practices."""
+        issues = []
+        
+        # Check for __str__ method
+        has_str_method = any(
+            isinstance(item, ast.FunctionDef) and item.name == "__str__"
+            for item in node.body
+        )
+        
+        if not has_str_method:
+            issues.append(ValidationIssue(
+                severity="warning",
+                category="django",
+                message=f"Model '{node.name}' should have a __str__ method",
+                file_path=file.path,
+                line_number=node.lineno,
+                rule_id="model_str_method",
+                suggestion=f"Add a __str__ method to {node.name} that returns a meaningful string representation"
+            ))
+        
+        # Check for Meta class
+        has_meta_class = any(
+            isinstance(item, ast.ClassDef) and item.name == "Meta"
+            for item in node.body
+        )
+        
+        if not has_meta_class:
+            issues.append(ValidationIssue(
+                severity="info",
+                category="django",
+                message=f"Model '{node.name}' could benefit from a Meta class",
+                file_path=file.path,
+                line_number=node.lineno,
+                rule_id="model_meta_class",
+                suggestion=f"Consider adding a Meta class to {node.name} for verbose_name, ordering, etc."
+            ))
+        
+        return issues
+    
+    def _validate_admin(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django admin best practices."""
+        issues = []
+        
+        # Check for admin registrations
+        has_registrations = False
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                # Check for admin.site.register() calls
+                if (isinstance(node.func, ast.Attribute) and
+                    isinstance(node.func.value, ast.Attribute) and
+                    isinstance(node.func.value.value, ast.Name) and
+                    node.func.value.value.id == "admin" and
+                    node.func.value.attr == "site" and
+                    node.func.attr == "register"):
+                    has_registrations = True
+            elif isinstance(node, ast.FunctionDef):
+                # Check for @admin.register decorator
+                for decorator in node.decorator_list:
+                    if (isinstance(decorator, ast.Call) and
+                        isinstance(decorator.func, ast.Attribute) and
+                        isinstance(decorator.func.value, ast.Name) and
+                        decorator.func.value.id == "admin" and
+                        decorator.func.attr == "register"):
+                        has_registrations = True
+        
+        if not has_registrations:
+            issues.append(ValidationIssue(
+                severity="info",
+                category="django",
+                message="No admin registrations found",
+                file_path=file.path,
+                line_number=1,
+                rule_id="admin_registration",
+                suggestion="Register models with admin.site.register() or @admin.register decorator"
+            ))
+        
+        return issues
+    
+    def _validate_views(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django view best practices."""
+        issues = []
+        
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+                # Check for docstrings
+                if not ast.get_docstring(node):
+                    issues.append(ValidationIssue(
+                        severity="info",
+                        category="django",
+                        message=f"View '{node.name}' should have a docstring",
+                        file_path=file.path,
+                        line_number=node.lineno,
+                        rule_id="view_docstring",
+                        suggestion=f"Add a docstring to {node.name} explaining its purpose"
+                    ))
+        
+        return issues
+    
+    def _validate_urls(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django URL patterns best practices."""
+        issues = []
+        
+        # Check for named URL patterns
+        content = file.content
+        path_patterns = re.findall(r'path\([^)]+\)', content)
+        
+        for pattern in path_patterns:
+            if 'name=' not in pattern:
+                issues.append(ValidationIssue(
+                    severity="warning",
+                    category="django",
+                    message="URL pattern should have a name",
+                    file_path=file.path,
+                    line_number=1,  # Would need more sophisticated line tracking
+                    rule_id="url_naming",
+                    suggestion="Add name='...' parameter to path() for reverse URL lookup"
+                ))
+        
+        return issues
+    
+    def _validate_forms(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Django form best practices."""
+        issues = []
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                # Check if it's a form class
+                is_form = any(
+                    isinstance(base, ast.Attribute) and
+                    base.attr in ["Form", "ModelForm"]
+                    for base in node.bases
+                )
+                
+                if is_form:
+                    # Check for clean methods
+                    has_clean_methods = any(
+                        isinstance(item, ast.FunctionDef) and 
+                        (item.name.startswith("clean_") or item.name == "clean")
+                        for item in node.body
+                    )
+                    
+                    if not has_clean_methods:
+                        issues.append(ValidationIssue(
+                            severity="info",
+                            category="django",
+                            message=f"Form '{node.name}' could benefit from validation methods",
+                            file_path=file.path,
+                            line_number=node.lineno,
+                            rule_id="form_validation",
+                            suggestion=f"Consider adding clean_* methods to {node.name} for field validation"
+                        ))
+        
+        return issues
+    
+    def _validate_serializers(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate DRF serializer best practices."""
+        issues = []
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                # Check if it's a serializer class
+                is_serializer = any(
+                    isinstance(base, ast.Attribute) and
+                    "Serializer" in base.attr
+                    for base in node.bases
+                )
+                
+                if is_serializer:
+                    # Check for Meta class in ModelSerializer
+                    has_meta = any(
+                        isinstance(item, ast.ClassDef) and item.name == "Meta"
+                        for item in node.body
+                    )
+                    
+                    if "ModelSerializer" in str(node.bases) and not has_meta:
+                        issues.append(ValidationIssue(
+                            severity="warning",
+                            category="django",
+                            message=f"ModelSerializer '{node.name}' should have a Meta class",
+                            file_path=file.path,
+                            line_number=node.lineno,
+                            rule_id="serializer_meta",
+                            suggestion=f"Add Meta class to {node.name} with model and fields"
+                        ))
+        
+        return issues

django_cfg/modules/django_app_agent/services/validation_service/main.py

@@ -0,0 +1,242 @@
+"""
+Main Validation Service for Django App Agent Module.
+
+This service orchestrates comprehensive code validation including
+syntax, Django best practices, security, and quality analysis.
+"""
+
+from typing import List, Dict, Any, Optional
+import asyncio
+
+from pydantic import BaseModel, Field
+
+from ...core.config import AgentConfig
+from ...models.responses import GeneratedFile, QualityMetrics
+from ..base import BaseService, ServiceDependencies
+from .models import ValidationRequest, ValidationResult, ValidationIssue
+from .syntax_validator import SyntaxValidator
+from .django_validator import DjangoValidator
+from .security_validator import SecurityValidator
+from .quality_validator import QualityValidator
+
+
+class ValidationService(BaseService[ValidationRequest, ValidationResult]):
+    """
+    Comprehensive code validation and quality analysis service.
+    
+    Provides validation for:
+    - Python syntax and AST analysis
+    - Django best practices and conventions
+    - Security vulnerabilities and patterns
+    - Code quality metrics and standards
+    - Performance considerations
+    - Type hint completeness
+    """
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize validation service."""
+        super().__init__("validation", config)
+        self.config = config
+        
+        # Initialize validators
+        self.syntax_validator = SyntaxValidator()
+        self.django_validator = DjangoValidator()
+        self.security_validator = SecurityValidator()
+        self.quality_validator = QualityValidator()
+    
+    async def process(
+        self,
+        request: ValidationRequest,
+        dependencies: ServiceDependencies
+    ) -> ValidationResult:
+        """
+        Process comprehensive code validation.
+        
+        Args:
+            request: Validation request with files and rules
+            dependencies: Service dependencies
+            
+        Returns:
+            ValidationResult with issues and quality metrics
+        """
+        dependencies.log_operation(
+            "Starting code validation",
+            files_count=len(request.files),
+            validation_rules=request.validation_rules,
+            strict_mode=request.strict_mode
+        )
+        
+        all_issues = []
+        
+        try:
+            # Validate each file
+            for file in request.files:
+                file_issues = await self._validate_file(file, request, dependencies)
+                all_issues.extend(file_issues)
+            
+            # Calculate quality metrics
+            quality_metrics = await self.quality_validator.calculate_quality_metrics(
+                request.files, dependencies
+            )
+            
+            # Determine if validation passed
+            error_count = len([issue for issue in all_issues if issue.severity == "error"])
+            is_valid = error_count == 0 or not request.strict_mode
+            
+            # Create summary
+            summary = self._create_validation_summary(all_issues, quality_metrics)
+            
+            result = ValidationResult(
+                is_valid=is_valid,
+                quality_metrics=quality_metrics,
+                issues=all_issues,
+                summary=summary
+            )
+            
+            dependencies.log_operation(
+                "Validation completed",
+                is_valid=is_valid,
+                total_issues=len(all_issues),
+                error_count=error_count,
+                warning_count=result.warning_count,
+                info_count=result.info_count,
+                overall_quality_score=quality_metrics.overall_score
+            )
+            
+            return result
+            
+        except Exception as e:
+            dependencies.log_error("Validation process failed", e)
+            raise
+    
+    async def _validate_file(
+        self,
+        file: GeneratedFile,
+        request: ValidationRequest,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate a single file with all applicable validators."""
+        issues = []
+        
+        dependencies.log_operation(f"Validating file: {file.path}")
+        
+        # Run validators based on requested rules
+        validation_tasks = []
+        
+        if "syntax" in request.validation_rules:
+            validation_tasks.append(
+                self.syntax_validator.validate_syntax(file, dependencies)
+            )
+        
+        if "django_best_practices" in request.validation_rules:
+            validation_tasks.append(
+                self.django_validator.validate_django_practices(file, dependencies)
+            )
+        
+        if "security" in request.validation_rules:
+            validation_tasks.append(
+                self.security_validator.validate_security(file, dependencies)
+            )
+        
+        if "quality" in request.validation_rules:
+            validation_tasks.append(
+                self.quality_validator.validate_quality(file, dependencies)
+            )
+        
+        # Run all validations concurrently
+        if validation_tasks:
+            validation_results = await asyncio.gather(*validation_tasks, return_exceptions=True)
+            
+            for result in validation_results:
+                if isinstance(result, Exception):
+                    dependencies.log_error(f"Validator failed for {file.path}", result)
+                    issues.append(ValidationIssue(
+                        severity="error",
+                        category="validation",
+                        message=f"Validation failed: {result}",
+                        file_path=file.path,
+                        line_number=1,
+                        rule_id="validation_error"
+                    ))
+                else:
+                    issues.extend(result)
+        
+        return issues
+    
+    def _create_validation_summary(
+        self,
+        issues: List[ValidationIssue],
+        quality_metrics: QualityMetrics
+    ) -> Dict[str, Any]:
+        """Create validation summary statistics."""
+        # Group issues by category and severity
+        by_category = {}
+        by_severity = {"error": 0, "warning": 0, "info": 0}
+        
+        for issue in issues:
+            # Count by category
+            if issue.category not in by_category:
+                by_category[issue.category] = 0
+            by_category[issue.category] += 1
+            
+            # Count by severity
+            if issue.severity in by_severity:
+                by_severity[issue.severity] += 1
+        
+        # Calculate pass rates
+        total_checks = len(issues) if issues else 1
+        error_rate = by_severity["error"] / total_checks * 100
+        warning_rate = by_severity["warning"] / total_checks * 100
+        
+        return {
+            "total_issues": len(issues),
+            "issues_by_severity": by_severity,
+            "issues_by_category": by_category,
+            "error_rate_percentage": error_rate,
+            "warning_rate_percentage": warning_rate,
+            "quality_score": quality_metrics.overall_score,
+            "type_safety_score": quality_metrics.type_safety_score,
+            "documentation_coverage": quality_metrics.documentation_coverage,
+            "maintainability_score": quality_metrics.maintainability_score,
+            "recommendations": self._generate_recommendations(issues, quality_metrics)
+        }
+    
+    def _generate_recommendations(
+        self,
+        issues: List[ValidationIssue],
+        quality_metrics: QualityMetrics
+    ) -> List[str]:
+        """Generate actionable recommendations based on validation results."""
+        recommendations = []
+        
+        # Analyze issue patterns
+        error_count = len([i for i in issues if i.severity == "error"])
+        warning_count = len([i for i in issues if i.severity == "warning"])
+        
+        if error_count > 0:
+            recommendations.append(f"Fix {error_count} critical error(s) before deployment")
+        
+        if warning_count > 5:
+            recommendations.append(f"Address {warning_count} warning(s) to improve code quality")
+        
+        # Quality-based recommendations
+        if quality_metrics.type_safety_score < 7.0:
+            recommendations.append("Add type hints to improve type safety")
+        
+        if quality_metrics.documentation_coverage < 6.0:
+            recommendations.append("Add docstrings to classes and functions")
+        
+        if quality_metrics.code_complexity > 7.0:
+            recommendations.append("Reduce code complexity by breaking down large functions")
+        
+        # Security recommendations
+        security_issues = [i for i in issues if i.category == "security"]
+        if security_issues:
+            recommendations.append("Review and address security-related issues")
+        
+        # Django-specific recommendations
+        django_issues = [i for i in issues if i.category == "django"]
+        if len(django_issues) > 3:
+            recommendations.append("Follow Django best practices more consistently")
+        
+        return recommendations[:5]  # Limit to top 5 recommendations

django_cfg/modules/django_app_agent/services/validation_service/models.py

@@ -0,0 +1,66 @@
+"""
+Data Models for Validation Service.
+
+This module defines the data structures used by the validation service
+for requests, responses, and validation issues.
+"""
+
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...models.responses import QualityMetrics, GeneratedFile
+
+
+class ValidationRequest(BaseModel):
+    """Request for code validation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    files: List[GeneratedFile] = Field(description="Files to validate")
+    validation_rules: List[str] = Field(
+        default_factory=lambda: ["syntax", "django_best_practices", "security", "quality"],
+        description="Validation rules to apply"
+    )
+    strict_mode: bool = Field(default=False, description="Whether to use strict validation")
+    custom_rules: Dict[str, Any] = Field(default_factory=dict, description="Custom validation rules")
+
+
+class ValidationIssue(BaseModel):
+    """Represents a validation issue."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    severity: str = Field(description="Issue severity: error, warning, info")
+    category: str = Field(description="Issue category: syntax, security, quality, etc.")
+    message: str = Field(description="Issue description message")
+    file_path: str = Field(description="Path to the file with the issue")
+    line_number: Optional[int] = Field(default=None, description="Line number of the issue")
+    column: Optional[int] = Field(default=None, description="Column number of the issue")
+    rule_id: str = Field(default="", description="Validation rule identifier")
+    suggestion: Optional[str] = Field(default=None, description="Suggested fix for the issue")
+
+
+class ValidationResult(BaseModel):
+    """Result of code validation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    is_valid: bool = Field(description="Whether the code passed validation")
+    quality_metrics: QualityMetrics = Field(description="Calculated quality metrics")
+    issues: List[ValidationIssue] = Field(default_factory=list, description="List of validation issues")
+    summary: Dict[str, Any] = Field(default_factory=dict, description="Validation summary")
+    
+    @property
+    def error_count(self) -> int:
+        """Count of error-level issues."""
+        return len([i for i in self.issues if i.severity == "error"])
+    
+    @property
+    def warning_count(self) -> int:
+        """Count of warning-level issues."""
+        return len([i for i in self.issues if i.severity == "warning"])
+    
+    @property
+    def info_count(self) -> int:
+        """Count of info-level issues."""
+        return len([i for i in self.issues if i.severity == "info"])