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

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

@@ -1,333 +0,0 @@
-"""
-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

@@ -1,242 +0,0 @@
-"""
-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

@@ -1,66 +0,0 @@
-"""
-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"])