ballpython 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

pycleaner/complexity_analyzer.py

@@ -9,10 +9,12 @@ and maximum nesting depth.
 from __future__ import annotations
 
 import ast
-import os
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 
+from pycleaner.discovery import collect_project_python_files
+
 
 @dataclass(slots=True)
 class ComplexityMetrics:
@@ -328,23 +330,6 @@ class _NestingDepthCounter(ast.NodeVisitor):
 class ComplexityAnalyzer:
     """Analyzes per-function complexity metrics across Python source files."""
 
-    IGNORE_DIRS = frozenset(
-        {
-            ".git",
-            ".venv",
-            "venv",
-            "env",
-            "__pycache__",
-            "build",
-            "dist",
-            ".tox",
-            ".mypy_cache",
-            ".pytest_cache",
-            ".ruff_cache",
-            "site-packages",
-        }
-    )
-
     def analyze_source(
         self, source: str, filename: str = "<unknown>"
     ) -> ComplexityReport:
@@ -369,21 +354,24 @@ class ComplexityAnalyzer:
         except OSError:
             return None
 
-    def analyze_project(self, root_dir: Path | str) -> ComplexityReport:
+    def analyze_project(
+        self, root_dir: Path | str, exclude_patterns: Sequence[str] = ()
+    ) -> ComplexityReport:
         """Analyze complexity across all Python files in a project."""
         root = Path(root_dir).resolve()
         all_functions: list[ComplexityMetrics] = []
         files_scanned = 0
 
-        for current_root, dirs, filenames in os.walk(root):
-            dirs[:] = [
-                d for d in dirs if d not in self.IGNORE_DIRS and not d.startswith(".")
-            ]
-            for fname in filenames:
-                file_funcs = self._collect_file_metrics(current_root, fname)
-                if file_funcs is not None:
-                    all_functions.extend(file_funcs)
-                    files_scanned += 1
+        for fpath in collect_project_python_files(
+            root, exclude_patterns=exclude_patterns
+        ):
+            try:
+                content = fpath.read_text(encoding="utf-8", errors="replace")
+                metrics = self.analyze_source(content, filename=str(fpath)).functions
+                all_functions.extend(metrics)
+                files_scanned += 1
+            except OSError:
+                continue
 
         all_functions.sort(key=lambda f: f.cyclomatic, reverse=True)
         return ComplexityReport(functions=all_functions, files_scanned=files_scanned)

pycleaner/config.py

@@ -36,6 +36,7 @@ class PyCleanerConfig:
             "generated/",
             "*_pb2.py",
             "*_pb2_grpc.py",
+            "editor-*.py",
         ]
     )
     include: list[str] = field(default_factory=list)
@@ -155,7 +156,13 @@ def load_config(
     """Load and merge configuration from file and CLI overrides."""
     file_config = _resolve_file_config(project_root, explicit_config_file)
     merged: dict[str, Any] = {
-        "exclude": ["migrations/", "generated/", "*_pb2.py", "*_pb2_grpc.py"],
+        "exclude": [
+            "migrations/",
+            "generated/",
+            "*_pb2.py",
+            "*_pb2_grpc.py",
+            "editor-*.py",
+        ],
         "include": [],
         "fix_py2_syntax": True,
         "fix_conditional_assignments": True,

pycleaner/dead_code_detector.py

@@ -8,11 +8,14 @@ unreachable code after return/raise/break/continue, and empty pass branches.
 from __future__ import annotations
 
 import ast
-import os
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import ClassVar
 
+from pycleaner.discovery import collect_project_python_files
+from pycleaner.frameworks import FrameworkRegistry, get_default_registry
+
 
 @dataclass(slots=True)
 class DeadCodeItem:
@@ -46,14 +49,30 @@ class DeadCodeReport:
 class _DefinitionCollector(ast.NodeVisitor):
     """Collects all function and class definitions with their line numbers."""
 
-    def __init__(self, filepath: str) -> None:
+    def __init__(
+        self,
+        filepath: str,
+        tree: ast.AST | None = None,
+        registry: FrameworkRegistry | None = None,
+    ) -> None:
         self.filepath = filepath
+        self.tree = tree
+        self.registry = registry or get_default_registry()
         self.definitions: list[tuple[str, str, int, int | None, str]] = []
         # (name, kind, lineno, end_lineno, scope_context)
         self._scope_stack: list[str] = []
+        self._class_stack: list[ast.ClassDef] = []
 
     def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
         context = ".".join(self._scope_stack) if self._scope_stack else "<module>"
+        if self.tree is not None and self.registry.is_protected(
+            node.name, "function", node, context, self.tree, self.filepath
+        ):
+            self._scope_stack.append(node.name)
+            self.generic_visit(node)
+            self._scope_stack.pop()
+            return
+
         self.definitions.append(
             (node.name, "function", node.lineno, node.end_lineno, context)
         )
@@ -65,14 +84,33 @@ class _DefinitionCollector(ast.NodeVisitor):
 
     def visit_ClassDef(self, node: ast.ClassDef) -> None:
         context = ".".join(self._scope_stack) if self._scope_stack else "<module>"
+        if self.tree is not None and self.registry.is_protected(
+            node.name, "class", node, context, self.tree, self.filepath
+        ):
+            self._scope_stack.append(node.name)
+            self._class_stack.append(node)
+            self.generic_visit(node)
+            self._class_stack.pop()
+            self._scope_stack.pop()
+            return
+
         self.definitions.append(
             (node.name, "class", node.lineno, node.end_lineno, context)
         )
         self._scope_stack.append(node.name)
+        self._class_stack.append(node)
         self.generic_visit(node)
+        self._class_stack.pop()
         self._scope_stack.pop()
 
     def visit_Assign(self, node: ast.Assign) -> None:
+        if self._class_stack and self.tree is not None:
+            if self.registry.is_field_protected(
+                node, self._class_stack[-1], self.tree, self.filepath
+            ):
+                self.generic_visit(node)
+                return
+
         # Module-level constants or class attributes (not local function variables)
         if not self._scope_stack or len(self._scope_stack) == 1:
             for target in node.targets:
@@ -84,12 +122,23 @@ class _DefinitionCollector(ast.NodeVisitor):
                             if self._scope_stack
                             else "<module>"
                         )
+                        if self.tree is not None and self.registry.is_protected(
+                            name, "variable", node, context, self.tree, self.filepath
+                        ):
+                            continue
                         self.definitions.append(
                             (name, "variable", node.lineno, node.end_lineno, context)
                         )
         self.generic_visit(node)
 
     def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+        if self._class_stack and self.tree is not None:
+            if self.registry.is_field_protected(
+                node, self._class_stack[-1], self.tree, self.filepath
+            ):
+                self.generic_visit(node)
+                return
+
         if (not self._scope_stack or len(self._scope_stack) == 1) and isinstance(
             node.target, ast.Name
         ):
@@ -98,6 +147,11 @@ class _DefinitionCollector(ast.NodeVisitor):
                 context = (
                     ".".join(self._scope_stack) if self._scope_stack else "<module>"
                 )
+                if self.tree is not None and self.registry.is_protected(
+                    name, "variable", node, context, self.tree, self.filepath
+                ):
+                    self.generic_visit(node)
+                    return
                 self.definitions.append(
                     (name, "variable", node.lineno, node.end_lineno, context)
                 )
@@ -269,6 +323,7 @@ class _ProjectScanState:
     exports: set[str] = field(default_factory=set)
     decorated: set[str] = field(default_factory=set)
     unreachable: list[DeadCodeItem] = field(default_factory=list)
+    framework_registry: FrameworkRegistry = field(default_factory=get_default_registry)
 
     def process_file(self, py_file: Path) -> None:
         try:
@@ -278,7 +333,9 @@ class _ProjectScanState:
             return
 
         filepath_str = str(py_file)
-        def_collector = _DefinitionCollector(filepath_str)
+        def_collector = _DefinitionCollector(
+            filepath_str, tree=tree, registry=self.framework_registry
+        )
         def_collector.visit(tree)
         for name, kind, lineno, end_lineno, ctx in def_collector.definitions:
             self.definitions.append((filepath_str, name, kind, lineno, end_lineno, ctx))
@@ -297,25 +354,6 @@ class _ProjectScanState:
 class DeadCodeDetector:
     """Detects dead code across a Python project."""
 
-    IGNORE_DIRS = frozenset(
-        {
-            ".git",
-            ".venv",
-            "venv",
-            "env",
-            "__pycache__",
-            "build",
-            "dist",
-            ".tox",
-            ".mypy_cache",
-            ".pytest_cache",
-            ".ruff_cache",
-            "site-packages",
-            "node_modules",
-            ".eggs",
-        }
-    )
-
     # Names that should never be flagged as dead code
     PROTECTED_NAMES = frozenset(
         {
@@ -418,18 +456,27 @@ class DeadCodeDetector:
         self,
         ignore_decorators: set[str] | None = None,
         ignore_names: set[str] | None = None,
+        framework_registry: FrameworkRegistry | None = None,
     ) -> None:
-        self.ignore_decorators = (ignore_decorators or set()) | set(
-            self.FRAMEWORK_DECORATORS
+        self.framework_registry = framework_registry or get_default_registry()
+        extra_decorators: set[str] = set()
+        for p in self.framework_registry.plugins:
+            extra_decorators.update(p.get_protected_decorators())
+        self.ignore_decorators = (
+            (ignore_decorators or set())
+            | set(self.FRAMEWORK_DECORATORS)
+            | extra_decorators
         )
         self.ignore_names = ignore_names or set()
 
-    def scan_project(self, root_dir: Path | str) -> DeadCodeReport:
+    def scan_project(
+        self, root_dir: Path | str, exclude_patterns: Sequence[str] = ()
+    ) -> DeadCodeReport:
         """Scan an entire project directory for dead code."""
         root = Path(root_dir).resolve()
-        py_files = self._discover_files(root)
+        py_files = self._discover_files(root, exclude_patterns=exclude_patterns)
 
-        state = _ProjectScanState()
+        state = _ProjectScanState(framework_registry=self.framework_registry)
         for py_file in py_files:
             state.process_file(py_file)
 
@@ -502,14 +549,204 @@ class DeadCodeDetector:
             return True
         return self._matches_ignore_pattern(name)
 
-    def _discover_files(self, root: Path) -> list[Path]:
-        """Walk the project tree and collect .py files, respecting ignore dirs."""
-        files: list[Path] = []
-        for current_root, dirs, filenames in os.walk(root):
-            dirs[:] = [
-                d for d in dirs if d not in self.IGNORE_DIRS and not d.startswith(".")
-            ]
-            for fname in filenames:
-                if fname.endswith(".py"):
-                    files.append(Path(current_root) / fname)
-        return sorted(files)
+    def _discover_files(
+        self, root: Path, exclude_patterns: Sequence[str] = ()
+    ) -> list[Path]:
+        """Walk the project tree and collect .py files, respecting ignore dirs and gitignore."""
+        return collect_project_python_files(root, exclude_patterns=exclude_patterns)
+
+    def fix_source(self, source: str, filename: str = "<stdin>") -> DeadCodeFixResult:
+        """Surgically fix dead code in in-memory source."""
+        fixer = DeadCodeFixer()
+        return fixer.fix(source, filename=filename)
+
+    def fix_file(
+        self, filepath: Path | str, apply_changes: bool = True
+    ) -> DeadCodeFixResult:
+        """Surgically fix dead code in a file."""
+        path = Path(filepath).resolve()
+        content = path.read_text(encoding="utf-8", errors="replace")
+        res = self.fix_source(content, filename=str(path))
+        if apply_changes and res.changed:
+            path.write_text(res.code, encoding="utf-8")
+        return res
+
+    def fix_project(
+        self, root_dir: Path | str, exclude_patterns: Sequence[str] = ()
+    ) -> dict[Path, DeadCodeFixResult]:
+        """Surgically fix dead code across all project Python files."""
+        root = Path(root_dir).resolve()
+        py_files = self._discover_files(root, exclude_patterns=exclude_patterns)
+        results: dict[Path, DeadCodeFixResult] = {}
+        for pf in py_files:
+            res = self.fix_file(pf, apply_changes=True)
+            if res.changed:
+                results[pf] = res
+        return results
+
+
+@dataclass(slots=True)
+class DeadCodeFixResult:
+    """Outcome of attempting to fix dead code in source code."""
+
+    code: str
+    changed: bool
+    pruned_items: list[str] = field(default_factory=list)
+
+
+class _DeadCodePrunerCollector(ast.NodeVisitor):
+    """Collects line spans of unreachable code, redundant pass, and dead branches."""
+
+    def __init__(self) -> None:
+        self.deletions: list[tuple[int, int, str]] = []
+
+    def _is_terminal_jump(self, stmt: ast.AST) -> bool:
+        if isinstance(stmt, (ast.Return, ast.Raise, ast.Break, ast.Continue)):
+            return True
+        if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+            func = stmt.value.func
+            if isinstance(func, ast.Name) and func.id in ("exit", "quit"):
+                return True
+            if (
+                isinstance(func, ast.Attribute)
+                and isinstance(func.value, ast.Name)
+                and func.value.id == "sys"
+                and func.attr == "exit"
+            ):
+                return True
+        return False
+
+    def _inspect_stmts(self, stmts: list[ast.stmt]) -> None:
+        terminal_seen = False
+        unreachable: list[ast.stmt] = []
+        non_doc = [
+            s
+            for s in stmts
+            if not (
+                isinstance(s, ast.Expr)
+                and isinstance(s.value, ast.Constant)
+                and isinstance(s.value.value, str)
+            )
+        ]
+
+        for stmt in stmts:
+            if terminal_seen:
+                unreachable.append(stmt)
+            elif self._is_terminal_jump(stmt):
+                terminal_seen = True
+            elif isinstance(stmt, ast.Pass) and len(non_doc) > 1:
+                self.deletions.append(
+                    (
+                        stmt.lineno,
+                        getattr(stmt, "end_lineno", stmt.lineno),
+                        f"Pruned redundant 'pass' at line {stmt.lineno}",
+                    )
+                )
+            elif (
+                isinstance(stmt, ast.If)
+                and isinstance(stmt.test, ast.Constant)
+                and stmt.test.value in (False, 0)
+                and not stmt.orelse
+            ):
+                self.deletions.append(
+                    (
+                        stmt.lineno,
+                        getattr(stmt, "end_lineno", stmt.lineno),
+                        f"Pruned dead 'if False' branch at line {stmt.lineno}",
+                    )
+                )
+            self.visit(stmt)
+
+        if unreachable:
+            start_line = unreachable[0].lineno
+            end_line = getattr(unreachable[-1], "end_lineno", unreachable[-1].lineno)
+            self.deletions.append(
+                (
+                    start_line,
+                    end_line,
+                    f"Pruned {len(unreachable)} unreachable statement(s) at lines {start_line}-{end_line}",
+                )
+            )
+
+    def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+        self._inspect_stmts(node.body)
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        self._inspect_stmts(node.body)
+
+    def visit_If(self, node: ast.If) -> None:
+        self._inspect_stmts(node.body)
+        if node.orelse:
+            self._inspect_stmts(node.orelse)
+
+    def visit_For(self, node: ast.For | ast.AsyncFor) -> None:
+        self._inspect_stmts(node.body)
+        if node.orelse:
+            self._inspect_stmts(node.orelse)
+
+    visit_AsyncFor = visit_For
+
+    def visit_While(self, node: ast.While) -> None:
+        self._inspect_stmts(node.body)
+        if node.orelse:
+            self._inspect_stmts(node.orelse)
+
+    def visit_Try(self, node: ast.Try) -> None:
+        self._inspect_stmts(node.body)
+        for h in node.handlers:
+            self._inspect_stmts(h.body)
+        if node.orelse:
+            self._inspect_stmts(node.orelse)
+        if node.finalbody:
+            self._inspect_stmts(node.finalbody)
+
+    def visit_With(self, node: ast.With | ast.AsyncWith) -> None:
+        self._inspect_stmts(node.body)
+
+    visit_AsyncWith = visit_With
+
+    def visit_Match(self, node: ast.AST) -> None:
+        for case in getattr(node, "cases", []):
+            self._inspect_stmts(case.body)
+
+
+class DeadCodeFixer:
+    """Surgically eliminates unreachable statements, dead branches, and redundant pass statements."""
+
+    def fix(self, source: str, filename: str = "<stdin>") -> DeadCodeFixResult:
+        current_code = source
+        all_pruned: list[str] = []
+
+        for _ in range(2):
+            try:
+                tree = ast.parse(current_code, filename=filename)
+            except SyntaxError:
+                break
+
+            collector = _DeadCodePrunerCollector()
+            collector.visit(tree)
+            if not collector.deletions:
+                break
+
+            lines = current_code.splitlines(keepends=True)
+            sorted_deletions = sorted(
+                collector.deletions, key=lambda x: x[0], reverse=True
+            )
+            for start_line, end_line, desc in sorted_deletions:
+                del lines[start_line - 1 : end_line]
+                all_pruned.append(desc)
+
+            candidate = "".join(lines)
+            try:
+                ast.parse(candidate, filename=filename)
+                current_code = candidate
+            except SyntaxError:
+                break
+
+        return DeadCodeFixResult(
+            code=current_code,
+            changed=current_code != source,
+            pruned_items=all_pruned,
+        )