Projektarbeit-MYP/backend/cleanup_imports_safe.py

#!/usr/bin/env python3
"""
Automatische Import-Bereinigung für MYP Backend
Entfernt sichere, ungenutzte Imports ohne Risiko für die Funktionalität
"""
import os
import re
import shutil
from pathlib import Path
from datetime import datetime

def backup_file(filepath):
    """Erstelle Backup einer Datei"""
    backup_path = f"{filepath}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
    shutil.copy2(filepath, backup_path)
    return backup_path

def clean_typing_imports(content):
    """Entferne ungenutzte typing-Imports"""
    # Pattern für typing-Imports
    typing_pattern = r'^from typing import.*?$'
    typing_imports = re.findall(typing_pattern, content, re.MULTILINE)
    
    cleaned_content = content
    for import_line in typing_imports:
        # Prüfe ob typing-Elemente verwendet werden
        typing_elements = import_line.replace('from typing import ', '').split(', ')
        used_elements = []
        
        for element in typing_elements:
            element = element.strip()
            # Prüfe ob Element im Code verwendet wird (außer im Import)
            if re.search(rf'\b{element}\b', content.replace(import_line, '')):
                used_elements.append(element)
        
        # Wenn keine Elemente verwendet werden, entferne gesamte Zeile
        if not used_elements:
            cleaned_content = re.sub(re.escape(import_line) + r'\n?', '', cleaned_content)
            print(f"  ❌ Entfernt: {import_line}")
        elif len(used_elements) < len(typing_elements):
            # Wenn nur einige Elemente verwendet werden, kürze Import
            new_import = f"from typing import {', '.join(used_elements)}"
            cleaned_content = cleaned_content.replace(import_line, new_import)
            print(f"  ✂️ Gekürzt: {import_line} → {new_import}")
    
    return cleaned_content

def clean_unused_imports(content):
    """Entferne definitiv ungenutzte Imports"""
    lines = content.split('\n')
    cleaned_lines = []
    
    # Liste sicherer, ungenutzter Imports
    safe_removals = [
        'import uuid',
        'from uuid import uuid4',
        'import json',  # Nur wenn nicht verwendet
        'import time',  # Nur wenn nicht verwendet
        'from contextlib import contextmanager',
        'import threading',  # Nur wenn nicht verwendet
        'import secrets',  # Nur wenn nicht verwendet
        'import string',  # Nur wenn nicht verwendet
    ]
    
    for line in lines:
        line_stripped = line.strip()
        should_remove = False
        
        for safe_removal in safe_removals:
            if line_stripped == safe_removal:
                # Prüfe ob tatsächlich nicht verwendet
                module_name = safe_removal.split()[-1]  # Letztes Wort ist meist der Name
                if not re.search(rf'\b{module_name}\b', '\n'.join([l for l in lines if l != line])):
                    should_remove = True
                    print(f"  ❌ Entfernt: {line_stripped}")
                    break
        
        if not should_remove:
            cleaned_lines.append(line)
    
    return '\n'.join(cleaned_lines)

def clean_file_imports(filepath):
    """Bereinige Imports in einer einzelnen Datei"""
    print(f"\n🔄 Bearbeite: {filepath}")
    
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            original_content = f.read()
        
        # Backup erstellen
        backup_path = backup_file(filepath)
        print(f"  💾 Backup: {backup_path}")
        
        # Import-Bereinigung
        cleaned_content = original_content
        cleaned_content = clean_typing_imports(cleaned_content)
        cleaned_content = clean_unused_imports(cleaned_content)
        
        # Nur schreiben wenn Änderungen vorgenommen wurden
        if cleaned_content != original_content:
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(cleaned_content)
            
            # Zeilen-Vergleich
            original_lines = len(original_content.split('\n'))
            new_lines = len(cleaned_content.split('\n'))
            saved_lines = original_lines - new_lines
            
            print(f"  ✅ Gespeichert: -{saved_lines} Zeilen")
            return saved_lines
        else:
            # Backup löschen wenn keine Änderungen
            os.remove(backup_path)
            print(f"  ℹ️ Keine Änderungen nötig")
            return 0
            
    except Exception as e:
        print(f"  ⚠️ Fehler bei {filepath}: {e}")
        return 0

def main():
    """Hauptfunktion für Import-Bereinigung"""
    print("🧹 MYP Backend Import-Bereinigung (Sichere Modus)")
    print("=" * 50)
    
    # Sichere Dateien für Bereinigung (niedrigstes Risiko)
    safe_files = [
        # Test- und Script-Dateien
        'test_development.py',
        'test_flask_minimal.py',
        'setup_development.py',
        'start_development.py', 
        'start_production.py',
        
        # Utils mit wenig Abhängigkeiten
        'utils/audit_logger.py',
        'utils/ip_validation.py',
        'utils/utilities_collection.py',
        
        # Debug-Dateien
        'debug/debug_admin.py',
    ]
    
    total_saved_lines = 0
    processed_files = 0
    
    for file_pattern in safe_files:
        if os.path.exists(file_pattern):
            saved_lines = clean_file_imports(file_pattern)
            total_saved_lines += saved_lines
            processed_files += 1
    
    print(f"\n🎯 Bereinigung abgeschlossen!")
    print(f"📁 Dateien bearbeitet: {processed_files}")
    print(f"📉 Zeilen gespart: {total_saved_lines}")
    print(f"💾 Backups erstellt in: *.backup_*")
    
    if total_saved_lines > 0:
        print(f"\n✅ Import-Bereinigung erfolgreich!")
        print(f"🔄 Nächster Schritt: Manuelle Bereinigung von app.py und models.py")
    else:
        print(f"\nℹ️ Keine ungenutzten Imports in sicheren Dateien gefunden.")

if __name__ == "__main__":
    main()