django-cfg 1.4.10__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/modules/django_client/core/validation/rules/type_hints.py

@@ -0,0 +1,288 @@
+"""Type hint validation rule for SerializerMethodField."""
+
+import ast
+from pathlib import Path
+from typing import List
+
+from .base import Issue, Severity, ValidationRule
+
+
+class TypeHintRule(ValidationRule):
+    """
+    Add type hints to SerializerMethodField methods.
+
+    Checks: get_* methods without return type annotations
+    Fixes: Adds inferred type hints based on method name patterns
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "type-hint-001"
+
+    @property
+    def name(self) -> str:
+        return "SerializerMethodField Type Hints"
+
+    @property
+    def description(self) -> str:
+        return "Ensures all get_* methods have return type hints"
+
+    def check(self, file_path: Path) -> List[Issue]:
+        """Find methods missing type hints."""
+        issues = []
+
+        try:
+            content = file_path.read_text(encoding='utf-8')
+            tree = ast.parse(content)
+        except (SyntaxError, UnicodeDecodeError):
+            # Skip files with syntax errors or encoding issues
+            return []
+
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.FunctionDef):
+                continue
+
+            # Only process get_* methods
+            if not node.name.startswith('get_'):
+                continue
+
+            # Skip if already has type hint
+            if node.returns is not None:
+                continue
+
+            # Skip private methods
+            if node.name.startswith('_get_'):
+                continue
+
+            # Infer type hint
+            inferred_type = self._infer_type(node)
+
+            issues.append(Issue(
+                rule_id=self.rule_id,
+                severity=Severity.WARNING,
+                file=file_path,
+                line=node.lineno,
+                column=node.col_offset,
+                message=f"Method {node.name}() missing return type hint",
+                suggestion=f"Add: -> {inferred_type}",
+                auto_fixable=True,
+                context={
+                    'method_name': node.name,
+                    'inferred_type': inferred_type,
+                    'line_number': node.lineno,
+                }
+            ))
+
+        return issues
+
+    def can_fix(self, issue: Issue) -> bool:
+        """All type hint issues are auto-fixable."""
+        return issue.auto_fixable and issue.rule_id == self.rule_id
+
+    def fix(self, issue: Issue, skip_imports: bool = False) -> bool:
+        """
+        Add type hint to method.
+
+        Args:
+            issue: Issue to fix
+            skip_imports: If True, skip adding imports (for batch processing)
+        """
+        file_path = issue.file
+        inferred_type = issue.context['inferred_type']
+        line_number = issue.context['line_number']
+
+        try:
+            # Read file
+            content = file_path.read_text(encoding='utf-8')
+            lines = content.splitlines(keepends=True)
+
+            # Ensure line exists
+            if line_number > len(lines):
+                return False
+
+            # Find method definition line
+            target_line = lines[line_number - 1]
+
+            # Add type hint (preserve indentation and formatting)
+            if ')' in target_line and ':' in target_line:
+                # def method(self, obj): → def method(self, obj) -> Type:
+                modified_line = target_line.replace('):', f") -> {inferred_type}:", 1)
+                lines[line_number - 1] = modified_line
+
+                # Add imports if needed (unless skipping for batch mode)
+                if not skip_imports:
+                    imports_needed = self._get_required_imports(inferred_type)
+                    if imports_needed:
+                        lines = self._add_imports(lines, imports_needed)
+
+                # Write back
+                file_path.write_text(''.join(lines), encoding='utf-8')
+                return True
+
+        except Exception as e:
+            print(f"Error fixing {issue.context['method_name']}: {e}")
+            return False
+
+        return False
+
+    def fix_batch(self, issues: list[Issue]) -> bool:
+        """
+        Fix multiple issues in same file at once.
+        This prevents line number shifting from import additions.
+        """
+        if not issues:
+            return True
+
+        file_path = issues[0].file
+
+        try:
+            # Read file once
+            content = file_path.read_text(encoding='utf-8')
+            lines = content.splitlines(keepends=True)
+
+            # Sort issues by line number in reverse order
+            sorted_issues = sorted(issues, key=lambda i: i.context['line_number'], reverse=True)
+
+            # Collect all required imports
+            all_imports = set()
+
+            # Fix all methods (from bottom to top)
+            for issue in sorted_issues:
+                inferred_type = issue.context['inferred_type']
+                line_number = issue.context['line_number']
+
+                if line_number > len(lines):
+                    continue
+
+                target_line = lines[line_number - 1]
+
+                if ')' in target_line and ':' in target_line:
+                    # Add type hint
+                    modified_line = target_line.replace('):', f") -> {inferred_type}:", 1)
+                    lines[line_number - 1] = modified_line
+
+                    # Collect imports
+                    imports_needed = self._get_required_imports(inferred_type)
+                    for imp in imports_needed:
+                        all_imports.add(imp)
+
+            # Add all imports at once
+            if all_imports:
+                lines = self._add_imports(lines, list(all_imports))
+
+            # Write back once
+            file_path.write_text(''.join(lines), encoding='utf-8')
+            return True
+
+        except Exception as e:
+            print(f"Error in batch fix: {e}")
+            return False
+
+    def _infer_type(self, node: ast.FunctionDef) -> str:
+        """Infer return type from method name and body."""
+        name = node.name
+
+        # Pattern matching for common cases
+        if any(pattern in name for pattern in ['can_', 'is_', 'has_']):
+            return 'bool'
+
+        if name.endswith('_count') or name.endswith('_total'):
+            return 'int'
+
+        if any(pattern in name for pattern in ['get_children', 'get_items', 'get_replies', 'get_list']):
+            return 'List[Dict[str, Any]]'
+
+        if name.endswith('_display') or name.endswith('_text'):
+            return 'str'
+
+        # Analyze return statements
+        for child in ast.walk(node):
+            if isinstance(child, ast.Return) and child.value:
+                # Constant values
+                if isinstance(child.value, ast.Constant):
+                    if isinstance(child.value.value, bool):
+                        return 'bool'
+                    elif isinstance(child.value.value, int):
+                        return 'int'
+                    elif isinstance(child.value.value, str):
+                        return 'str'
+                    elif child.value.value is None:
+                        return 'Optional[Any]'
+
+                # List/Dict literals
+                elif isinstance(child.value, ast.List):
+                    return 'List[Any]'
+                elif isinstance(child.value, ast.Dict):
+                    return 'Dict[str, Any]'
+
+                # Method calls that suggest serializer
+                elif isinstance(child.value, ast.Call):
+                    # SomeSerializer(...).data pattern
+                    if hasattr(child.value.func, 'attr') and child.value.func.attr == 'data':
+                        # Check if many=True in call
+                        for keyword in getattr(child.value, 'keywords', []):
+                            if keyword.arg == 'many' and isinstance(keyword.value, ast.Constant):
+                                if keyword.value.value is True:
+                                    return 'List[Dict[str, Any]]'
+                        return 'Dict[str, Any]'
+
+        # Default fallback
+        return 'Any'
+
+    def _get_required_imports(self, type_hint: str) -> List[str]:
+        """Get required imports for type hint."""
+        imports = set()
+
+        if 'List' in type_hint:
+            imports.add('List')
+        if 'Dict' in type_hint:
+            imports.add('Dict')
+        if 'Optional' in type_hint:
+            imports.add('Optional')
+        if 'Any' in type_hint or not imports:
+            imports.add('Any')
+
+        if imports:
+            return [f"from typing import {', '.join(sorted(imports))}"]
+        return []
+
+    def _add_imports(self, lines: List[str], imports: List[str]) -> List[str]:
+        """Add imports to file if not already present."""
+        content = ''.join(lines)
+
+        for import_line in imports:
+            # Skip if import already exists
+            if import_line in content:
+                continue
+
+            # Check if similar import exists
+            import_parts = set(import_line.split('import ')[1].replace(' ', '').split(','))
+
+            # Try to merge with existing typing imports
+            merged = False
+            for i, line in enumerate(lines):
+                if line.strip().startswith('from typing import'):
+                    existing_parts = set(line.split('import ')[1].replace(' ', '').replace('\n', '').split(','))
+                    combined = sorted(existing_parts | import_parts)
+                    lines[i] = f"from typing import {', '.join(combined)}\n"
+                    merged = True
+                    break
+
+            if merged:
+                continue
+
+            # Find where to insert (after other imports)
+            insert_idx = 0
+            found_import = False
+            for i, line in enumerate(lines):
+                stripped = line.strip()
+                if stripped.startswith('import ') or stripped.startswith('from '):
+                    found_import = True
+                    insert_idx = i + 1
+                elif found_import and stripped and not stripped.startswith('#'):
+                    # Found first non-import, non-comment line
+                    break
+
+            lines.insert(insert_idx, import_line + '\n')
+
+        return lines

django_cfg/modules/django_client/core/validation/safety.py

@@ -0,0 +1,266 @@
+"""
+Safety Manager for Code Modifications.
+
+Ensures all code modifications are:
+- Backed up before changes
+- Syntax-validated after changes
+- Revertible via rollback
+- Logged for audit trail
+"""
+
+import ast
+import shutil
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SafetyManager:
+    """
+    Manages backups and rollbacks for safe code modification.
+
+    Example:
+        >>> safety = SafetyManager(workspace=Path('.'))
+        >>> transaction_id = safety.start_transaction()
+        >>> safety.backup_file(Path('serializers.py'))
+        >>> # ... modify file ...
+        >>> if safety.validate_syntax(Path('serializers.py')):
+        ...     safety.commit_transaction()
+        ... else:
+        ...     safety.rollback_transaction()
+    """
+
+    def __init__(self, workspace: Path):
+        """
+        Initialize safety manager.
+
+        Args:
+            workspace: Root directory for project (usually project root)
+        """
+        self.workspace = workspace
+        self.backup_dir = workspace / '.validation_backups'
+        self.transaction_id: Optional[str] = None
+        self.backed_up_files: Dict[Path, Path] = {}
+
+        # Ensure backup directory exists
+        self.backup_dir.mkdir(exist_ok=True)
+
+    def start_transaction(self) -> str:
+        """
+        Start a new modification transaction.
+
+        Returns:
+            Transaction ID (timestamp-based)
+        """
+        self.transaction_id = f"fix_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
+        self.backed_up_files = {}
+
+        logger.info(f"Started transaction: {self.transaction_id}")
+        return self.transaction_id
+
+    def backup_file(self, file_path: Path) -> Path:
+        """
+        Create backup of file before modification.
+
+        Args:
+            file_path: Path to file to backup
+
+        Returns:
+            Path to backup file
+
+        Raises:
+            RuntimeError: If no active transaction
+            FileNotFoundError: If file doesn't exist
+        """
+        if not self.transaction_id:
+            raise RuntimeError("No active transaction. Call start_transaction() first.")
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Create transaction backup directory
+        transaction_dir = self.backup_dir / self.transaction_id
+        transaction_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create backup with relative path structure
+        relative_path = file_path.relative_to(self.workspace)
+        backup_path = transaction_dir / relative_path
+        backup_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Copy file
+        shutil.copy2(file_path, backup_path)
+        self.backed_up_files[file_path] = backup_path
+
+        logger.debug(f"Backed up: {file_path} → {backup_path}")
+        return backup_path
+
+    def validate_syntax(self, file_path: Path) -> bool:
+        """
+        Validate Python syntax after modification.
+
+        Args:
+            file_path: Path to Python file to validate
+
+        Returns:
+            True if syntax is valid, False otherwise
+        """
+        try:
+            content = file_path.read_text(encoding='utf-8')
+            ast.parse(content)
+            logger.debug(f"Syntax valid: {file_path}")
+            return True
+        except SyntaxError as e:
+            logger.error(f"Syntax error in {file_path}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error validating {file_path}: {e}")
+            return False
+
+    def rollback_file(self, file_path: Path) -> bool:
+        """
+        Rollback a single file to its backup.
+
+        Args:
+            file_path: Path to file to rollback
+
+        Returns:
+            True if rollback successful, False otherwise
+        """
+        backup_path = self.backed_up_files.get(file_path)
+        if not backup_path or not backup_path.exists():
+            logger.warning(f"No backup found for: {file_path}")
+            return False
+
+        try:
+            shutil.copy2(backup_path, file_path)
+            logger.info(f"Rolled back: {file_path}")
+            return True
+        except Exception as e:
+            logger.error(f"Error rolling back {file_path}: {e}")
+            return False
+
+    def commit_transaction(self) -> bool:
+        """
+        Finalize successful transaction.
+
+        Keeps backups for 7 days then schedules cleanup.
+
+        Returns:
+            True if commit successful
+        """
+        if not self.transaction_id:
+            logger.warning("No active transaction to commit")
+            return False
+
+        logger.info(f"Committed transaction: {self.transaction_id}")
+
+        # Schedule cleanup (delete backups after 7 days)
+        self._schedule_cleanup(days=7)
+
+        # Clear transaction state
+        transaction_id = self.transaction_id
+        self.transaction_id = None
+        self.backed_up_files = {}
+
+        return True
+
+    def rollback_transaction(self) -> bool:
+        """
+        Revert all changes in current transaction.
+
+        Returns:
+            True if all files rolled back successfully
+        """
+        if not self.transaction_id:
+            logger.warning("No active transaction to rollback")
+            return False
+
+        logger.warning(f"Rolling back transaction: {self.transaction_id}")
+
+        success = True
+        for file_path in self.backed_up_files.keys():
+            if not self.rollback_file(file_path):
+                success = False
+
+        # Clear transaction state
+        self.transaction_id = None
+        self.backed_up_files = {}
+
+        return success
+
+    def _schedule_cleanup(self, days: int = 7) -> None:
+        """
+        Schedule cleanup of old backups.
+
+        Note: Currently just marks with timestamp.
+        Actual cleanup should be done by separate process.
+
+        Args:
+            days: Keep backups for this many days
+        """
+        cleanup_marker = self.backup_dir / self.transaction_id / '.cleanup_after'
+        cleanup_date = datetime.now() + timedelta(days=days)
+        cleanup_marker.write_text(cleanup_date.isoformat())
+
+    def cleanup_old_backups(self, days: int = 7) -> int:
+        """
+        Remove backups older than specified days.
+
+        Args:
+            days: Remove backups older than this many days
+
+        Returns:
+            Number of backup directories removed
+        """
+        removed = 0
+        cutoff_date = datetime.now() - timedelta(days=days)
+
+        for transaction_dir in self.backup_dir.iterdir():
+            if not transaction_dir.is_dir():
+                continue
+
+            # Check if marked for cleanup
+            cleanup_marker = transaction_dir / '.cleanup_after'
+            if cleanup_marker.exists():
+                cleanup_date = datetime.fromisoformat(cleanup_marker.read_text())
+                if datetime.now() >= cleanup_date:
+                    shutil.rmtree(transaction_dir)
+                    removed += 1
+                    logger.info(f"Removed old backup: {transaction_dir.name}")
+
+        return removed
+
+    def list_backups(self) -> List[Dict[str, any]]:
+        """
+        List all available backups.
+
+        Returns:
+            List of backup info dicts
+        """
+        backups = []
+
+        for transaction_dir in sorted(self.backup_dir.iterdir()):
+            if not transaction_dir.is_dir():
+                continue
+
+            # Parse transaction ID
+            timestamp_str = transaction_dir.name.replace('fix_', '')
+            try:
+                timestamp = datetime.strptime(timestamp_str[:15], '%Y%m%d_%H%M%S')
+            except ValueError:
+                continue
+
+            # Count files
+            files = list(transaction_dir.rglob('*.py'))
+
+            backups.append({
+                'transaction_id': transaction_dir.name,
+                'timestamp': timestamp,
+                'file_count': len(files),
+                'path': transaction_dir,
+            })
+
+        return backups

django_cfg/modules/django_client/management/__init__.py

@@ -0,0 +1,3 @@
+"""
+Django management commands for django-client.
+"""

django_cfg/modules/django_client/management/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+Django management commands.
+"""