Code Cleaner: Automatisch sauberen Python-Code schreiben

🧼 Warum automatisierte Code-Bereinigung?

Entwickler verbringen durchschnittlich 15–20% ihrer Zeit mit manueller Code-Formatierung und Code-Review-Ping-Pong wegen Stil-Fragen. Ein automatisierter Cleaner eliminiert diese Diskussionen komplett — der Code kommt garantiert sauber aus der Pipeline.

⚙️ Clean-Pipeline: 4 Schritte zum sauberen Code

💻 Technische Umsetzung

🐍 Der AST-Analyzer-Kern

import ast
from pathlib import Path

class CodeAnalyzer(ast.NodeVisitor):
    """AST-Walker zur Erkennung von Code-Smells."""
    
    def __init__(self, max_complexity: int = 10):
        self.issues = []
        self.max_complexity = max_complexity
        self.current_function = None
    
    def visit_FunctionDef(self, node):
        self.current_function = node.name
        complexity = self._cyclomatic_complexity(node)
        
        if complexity > self.max_complexity:
            self.issues.append({
                'type': 'high_complexity',
                'function': node.name,
                'line': node.lineno,
                'complexity': complexity,
                'suggestion': f'Funktion aufteilen (Komplexität: {complexity})'
            })
        
        self.generic_visit(node)
    
    def visit_Import(self, node):
        for alias in node.names:
            if alias.name not in self.used_names:
                self.issues.append({
                    'type': 'unused_import',
                    'name': alias.name,
                    'line': node.lineno
                })
    
    def _cyclomatic_complexity(self, node) -> int:
        complexity = 1
        for child in ast.walk(node):
            if isinstance(child, (ast.If, ast.For, ast.While, ast.ExceptHandler)):
                complexity += 1
            elif isinstance(child, ast.BoolOp):
                complexity += len(child.values) - 1
        return complexity

🔄 Automation Pipeline

class CleanPipeline:
    """Führt alle Cleaner in der richtigen Reihenfolge aus."""
    
    CLEANERS = ['isort', 'black', 'analyze']
    
    def run(self, path: Path, check_only: bool = False):
        results = {'files': 0, 'issues': 0, 'fixed': 0}
        
        for py_file in path.rglob('*.py'):
            results['files'] += 1
            file_results = self._clean_file(py_file, check_only)
            results['issues'] += len(file_results.get('issues', []))
            results['fixed'] += file_results.get('fixed', 0)
        
        # JSON-Report generieren
        report_path = path / '.clean-report.json'
        json.dump(results, report_path.open('w'), indent=2)
        
        return results

    def _clean_file(self, file: Path, check_only: bool):
        original = file.read_text()
        
        # 1. Imports sortieren
        cleaned = subprocess.run(
            ['isort', '--check-only' if check_only else '-q', str(file)],
            capture_output=True
        )
        
        # 2. Formatieren mit Black
        cleaned = subprocess.run(
            ['black', '--check' if check_only else '--quiet', str(file)],
            capture_output=True
        )
        
        # 3. AST-Analyse
        analyzer = CodeAnalyzer()
        analyzer.analyze_file(file)
        
        return {
            'issues': analyzer.issues,
            'fixed': 1 if original != file.read_text() else 0
        }