ballpython 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

pycleaner/dead_code_detector.py

@@ -16,6 +16,48 @@ from typing import ClassVar
 
 from pycleaner.discovery import collect_project_python_files
 from pycleaner.frameworks import FrameworkRegistry, get_default_registry
+from pycleaner.security_scanner import is_secret_ast_node
+
+PROTECTED_NAMES: frozenset[str] = frozenset(
+    {
+        "AWS_KEY",
+        "AWS_SECRET",
+        "GITHUB_TOKEN",
+        "STRIPE_KEY",
+        "SLACK_TOKEN",
+        "SENDGRID",
+        "DSN",
+        "DATABASE_URL",
+        "PRIVATE_KEY",
+        "PEM",
+        "SECRET_KEY",
+        "API_KEY",
+    }
+)
+
+
+def _is_protected_variable(name: str, value_node: ast.AST | None = None) -> bool:
+    """Check if a variable name or assigned value represents a protected secret or config."""
+    name_upper = name.upper()
+    if name_upper in PROTECTED_NAMES:
+        return True
+    if any(
+        kw in name_upper
+        for kw in (
+            "SECRET",
+            "TOKEN",
+            "API_KEY",
+            "APIKEY",
+            "PASSWORD",
+            "PASSWD",
+            "PRIVATE_KEY",
+            "CREDENTIAL",
+        )
+    ):
+        return True
+    if value_node is not None and is_secret_ast_node(value_node):
+        return True
+    return False
 
 
 @dataclass(slots=True)
@@ -113,7 +155,9 @@ class _DefinitionCollector(ast.NodeVisitor):
                 return
 
         # Module-level constants or class attributes (not local function variables)
-        if not self._scope_stack or len(self._scope_stack) == 1:
+        if not self._scope_stack or (
+            self._class_stack and len(self._scope_stack) == len(self._class_stack)
+        ):
             for target in node.targets:
                 if isinstance(target, ast.Name):
                     name = target.id
@@ -127,6 +171,8 @@ class _DefinitionCollector(ast.NodeVisitor):
                             name, "variable", node, context, self.tree, self.filepath
                         ):
                             continue
+                        if _is_protected_variable(name, node.value):
+                            continue
                         self.definitions.append(
                             (name, "variable", node.lineno, node.end_lineno, context)
                         )
@@ -140,9 +186,12 @@ class _DefinitionCollector(ast.NodeVisitor):
                 self.generic_visit(node)
                 return
 
-        if (not self._scope_stack or len(self._scope_stack) == 1) and isinstance(
-            node.target, ast.Name
-        ):
+        if (
+            not self._scope_stack
+            or (
+                self._class_stack and len(self._scope_stack) == len(self._class_stack)
+            )
+        ) and isinstance(node.target, ast.Name):
             name = node.target.id
             if not name.startswith("__"):
                 context = (
@@ -153,6 +202,9 @@ class _DefinitionCollector(ast.NodeVisitor):
                 ):
                     self.generic_visit(node)
                     return
+                if _is_protected_variable(name, node.value):
+                    self.generic_visit(node)
+                    return
                 self.definitions.append(
                     (name, "variable", node.lineno, node.end_lineno, context)
                 )
@@ -330,6 +382,7 @@ def _detect_unused_locals_in_function(
                         and name not in explicit_globals
                         and name not in loaded_names
                         and name not in seen_unused
+                        and not _is_protected_variable(name, stmt.value)
                     ):
                         seen_unused.add(name)
                         items.append(
@@ -353,6 +406,7 @@ def _detect_unused_locals_in_function(
                                 and name not in explicit_globals
                                 and name not in loaded_names
                                 and name not in seen_unused
+                                and not _is_protected_variable(name, stmt.value)
                             ):
                                 seen_unused.add(name)
                                 items.append(
@@ -377,6 +431,7 @@ def _detect_unused_locals_in_function(
                     and name not in explicit_globals
                     and name not in loaded_names
                     and name not in seen_unused
+                    and not _is_protected_variable(name, stmt.value)
                 ):
                     seen_unused.add(name)
                     items.append(
@@ -523,9 +578,23 @@ class _ProjectScanState:
     def process_file(self, py_file: Path) -> None:
         try:
             content = py_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return
+
+        try:
             tree = ast.parse(content, filename=str(py_file))
         except SyntaxError:
-            return
+            from pycleaner.syntax_healer import SyntaxHealer
+
+            heal_res = SyntaxHealer().heal(content, filename=str(py_file))
+            if heal_res.is_valid:
+                try:
+                    tree = ast.parse(heal_res.code, filename=str(py_file))
+                    content = heal_res.code
+                except SyntaxError:
+                    return
+            else:
+                return
 
         filepath_str = str(py_file)
         def_collector = _DefinitionCollector(
@@ -670,16 +739,13 @@ class DeadCodeDetector:
         )
         self.ignore_names = ignore_names or set()
 
-    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, exclude_patterns=exclude_patterns)
-
+    def scan_files(self, target_files: Sequence[Path]) -> DeadCodeReport:
+        """Scan a specific sequence of Python files for dead code without walking parent directories."""
         state = _ProjectScanState(framework_registry=self.framework_registry)
-        for py_file in py_files:
+        scanned_count = 0
+        for py_file in target_files:
             state.process_file(py_file)
+            scanned_count += 1
 
         items: list[DeadCodeItem] = list(state.unreachable)
         for filepath, name, kind, lineno, end_lineno, _ in state.definitions:
@@ -702,22 +768,41 @@ class DeadCodeDetector:
         items.sort(key=lambda x: (x.filepath, x.lineno))
         return DeadCodeReport(
             items=items,
-            files_scanned=len(py_files),
+            files_scanned=scanned_count,
             total_definitions=len(state.definitions),
         )
 
+    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, exclude_patterns=exclude_patterns)
+        return self.scan_files(py_files)
+
     def scan_source(self, source: str, filename: str = "<unknown>") -> DeadCodeReport:
-        """Scan a single source string for dead code patterns (unreachable/empty only)."""
+        """Scan a single source string for dead code patterns (unreachable, empty branches, and local dead variables)."""
         try:
             tree = ast.parse(source, filename=filename)
         except SyntaxError:
-            return DeadCodeReport()
+            from pycleaner.syntax_healer import SyntaxHealer
+
+            heal_res = SyntaxHealer().heal(source, filename=filename)
+            if heal_res.is_valid:
+                try:
+                    tree = ast.parse(heal_res.code, filename=filename)
+                except SyntaxError:
+                    return DeadCodeReport()
+            else:
+                return DeadCodeReport()
 
         unreachable = _UnreachableCodeDetector(filename, source.splitlines())
         unreachable.visit(tree)
 
+        items = list(unreachable.items)
+        items.sort(key=lambda x: (x.filepath, x.lineno))
         return DeadCodeReport(
-            items=unreachable.items,
+            items=items,
             files_scanned=1,
             total_definitions=0,
         )
@@ -766,26 +851,38 @@ class DeadCodeDetector:
     def fix_file(
         self, filepath: Path | str, apply_changes: bool = True
     ) -> DeadCodeFixResult:
-        """Surgically fix dead code in a file."""
+        """Surgically fix dead code in a file with safe read-only handling."""
         path = Path(filepath).resolve()
-        content = path.read_text(encoding="utf-8", errors="replace")
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return DeadCodeFixResult(code="", changed=False, pruned_items=[])
         res = self.fix_source(content, filename=str(path))
         if apply_changes and res.changed:
-            path.write_text(res.code, encoding="utf-8")
+            try:
+                path.write_text(res.code, encoding="utf-8")
+            except OSError:
+                return DeadCodeFixResult(code=content, changed=False, pruned_items=[])
         return res
 
+    def fix_files(
+        self, target_files: Sequence[Path], apply_changes: bool = True
+    ) -> dict[Path, DeadCodeFixResult]:
+        """Surgically fix dead code across a specific sequence of Python files."""
+        results: dict[Path, DeadCodeFixResult] = {}
+        for pf in target_files:
+            res = self.fix_file(pf, apply_changes=apply_changes)
+            if res.changed:
+                results[pf] = res
+        return results
+
     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
+        return self.fix_files(py_files, apply_changes=True)
 
 
 @dataclass(slots=True)
@@ -1065,6 +1162,7 @@ class DeadCodeFixer:
                                     and name not in args_set
                                     and name not in explicit_globals
                                     and name not in loaded_names
+                                    and not _is_protected_variable(name, stmt.value)
                                 ):
                                     if _is_pure_expression(stmt.value):
                                         deletions.append(
@@ -1078,14 +1176,18 @@ class DeadCodeFixer:
                                             )
                                         )
                                     else:
-                                        if hasattr(target, "col_offset") and hasattr(
-                                            target, "end_col_offset"
+                                        col = getattr(target, "col_offset", None)
+                                        end_col = getattr(
+                                            target, "end_col_offset", None
+                                        )
+                                        if isinstance(col, int) and isinstance(
+                                            end_col, int
                                         ):
                                             renames.append(
                                                 (
                                                     target.lineno,
-                                                    target.col_offset,
-                                                    target.end_col_offset,
+                                                    col,
+                                                    end_col,
                                                     f"_{name}",
                                                     name,
                                                 )
@@ -1096,19 +1198,24 @@ class DeadCodeFixer:
                                 for elt in stmt.targets[0].elts:
                                     if isinstance(elt, ast.Name):
                                         name = elt.id
+                                        col = getattr(elt, "col_offset", None)
+                                        end_col = getattr(elt, "end_col_offset", None)
                                         if (
                                             not name.startswith("_")
                                             and name not in args_set
                                             and name not in explicit_globals
                                             and name not in loaded_names
-                                            and hasattr(elt, "col_offset")
-                                            and hasattr(elt, "end_col_offset")
+                                            and not _is_protected_variable(
+                                                name, stmt.value
+                                            )
+                                            and isinstance(col, int)
+                                            and isinstance(end_col, int)
                                         ):
                                             renames.append(
                                                 (
                                                     elt.lineno,
-                                                    elt.col_offset,
-                                                    elt.end_col_offset,
+                                                    col,
+                                                    end_col,
                                                     f"_{name}",
                                                     name,
                                                 )
@@ -1121,6 +1228,7 @@ class DeadCodeFixer:
                                     and name not in args_set
                                     and name not in explicit_globals
                                     and name not in loaded_names
+                                    and not _is_protected_variable(name, stmt.value)
                                 ):
                                     if stmt.value is not None and _is_pure_expression(
                                         stmt.value
@@ -1137,14 +1245,18 @@ class DeadCodeFixer:
                                         )
                                     else:
                                         target = stmt.target
-                                        if hasattr(target, "col_offset") and hasattr(
-                                            target, "end_col_offset"
+                                        col = getattr(target, "col_offset", None)
+                                        end_col = getattr(
+                                            target, "end_col_offset", None
+                                        )
+                                        if isinstance(col, int) and isinstance(
+                                            end_col, int
                                         ):
                                             renames.append(
                                                 (
                                                     target.lineno,
-                                                    target.col_offset,
-                                                    target.end_col_offset,
+                                                    col,
+                                                    end_col,
                                                     f"_{name}",
                                                     name,
                                                 )
@@ -1184,6 +1296,7 @@ class DeadCodeFixer:
                             and name != "__all__"
                             and name not in module_loads
                             and name not in module_exports
+                            and not _is_protected_variable(name, stmt.value)
                         ):
                             if _is_pure_expression(stmt.value):
                                 deletions.append(
@@ -1195,14 +1308,14 @@ class DeadCodeFixer:
                                     )
                                 )
                             else:
-                                if hasattr(target, "col_offset") and hasattr(
-                                    target, "end_col_offset"
-                                ):
+                                col = getattr(target, "col_offset", None)
+                                end_col = getattr(target, "end_col_offset", None)
+                                if isinstance(col, int) and isinstance(end_col, int):
                                     renames.append(
                                         (
                                             target.lineno,
-                                            target.col_offset,
-                                            target.end_col_offset,
+                                            col,
+                                            end_col,
                                             f"_{name}",
                                             name,
                                         )

pycleaner/dependency_auditor.py

@@ -450,6 +450,20 @@ class DependencyAuditor:
             details=details,
         )
 
+    @staticmethod
+    def _is_array_closing_bracket(line: str) -> bool:
+        """Check if ']' appears outside of quoted strings."""
+        in_quote: str | None = None
+        for char in line:
+            if char in ('"', "'"):
+                if in_quote is None:
+                    in_quote = char
+                elif in_quote == char:
+                    in_quote = None
+            elif char == "]" and in_quote is None:
+                return True
+        return False
+
     def _update_pyproject_toml(
         self, missing: set[str], unused_to_remove: set[str]
     ) -> bool:
@@ -483,7 +497,7 @@ class DependencyAuditor:
             stripped = line.strip()
 
             if re.match(r"^dependencies\s*=\s*\[", stripped):
-                if "]" in stripped:
+                if self._is_array_closing_bracket(stripped):
                     bracket_content = stripped[
                         stripped.find("[") + 1 : stripped.rfind("]")
                     ]
@@ -511,7 +525,7 @@ class DependencyAuditor:
                     continue
 
             if in_dependencies_array:
-                if "]" in stripped:
+                if self._is_array_closing_bracket(stripped):
                     in_dependencies_array = False
                     for sm in sorted(safe_missing):
                         indent = "    "
@@ -580,6 +594,7 @@ class DependencyAuditor:
         }
 
         new_lines: list[str] = []
+        modified = False
         for line in existing_lines:
             stripped = line.strip()
             if not stripped or stripped.startswith(("#", "-")):
@@ -591,11 +606,17 @@ class DependencyAuditor:
                 pkg_name = pkg_match.group(1)
                 canon = self.canonicalize_name(pkg_name)
                 if canon in remove_canons:
+                    modified = True
                     continue
             new_lines.append(line)
 
         # Append missing packages
-        new_lines.extend(sorted(safe_missing))
+        for sm in sorted(safe_missing):
+            new_lines.append(sm)
+            modified = True
+
+        if modified or (not req_file.exists() and safe_missing):
+            req_file.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+            return True
+        return False
 
-        req_file.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
-        return True

pycleaner/discovery.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import fnmatch
 import os
+import tempfile
 from collections.abc import Sequence
 from pathlib import Path
 
@@ -93,7 +94,23 @@ def find_project_root(path: Path | str | None = None) -> Path:
     if start.is_file():
         start = start.parent
 
+    try:
+        user_home = Path.home().resolve()
+    except Exception:
+        user_home = None
+
+    try:
+        temp_dir = Path(tempfile.gettempdir()).resolve()
+    except Exception:
+        temp_dir = None
+
     for candidate in [start, *start.parents]:
+        # Do not climb above temp_dir if start was inside a temporary directory
+        if temp_dir and candidate == temp_dir and start != temp_dir:
+            break
+        # Do not climb into user home directory unless start is user home itself
+        if user_home and candidate == user_home and start != user_home:
+            break
         if (
             (candidate / "pyproject.toml").is_file()
             or (candidate / "setup.py").is_file()

pycleaner/frameworks/__init__.py

@@ -55,9 +55,11 @@ class FrameworkRegistry:
 
     def __init__(self) -> None:
         self._plugins: list[FrameworkPlugin] = []
+        self._applicable_cache: dict[tuple[int, str], list[FrameworkPlugin]] = {}
 
     def register(self, plugin: FrameworkPlugin) -> None:
         self._plugins.append(plugin)
+        self._applicable_cache.clear()
 
     @property
     def plugins(self) -> list[FrameworkPlugin]:
@@ -66,7 +68,12 @@ class FrameworkRegistry:
     def get_applicable_plugins(
         self, tree: ast.AST, filepath: Path | str
     ) -> list[FrameworkPlugin]:
-        return [p for p in self._plugins if p.is_applicable(tree, filepath)]
+        cache_key = (id(tree), str(filepath))
+        if cache_key in self._applicable_cache:
+            return self._applicable_cache[cache_key]
+        applicable = [p for p in self._plugins if p.is_applicable(tree, filepath)]
+        self._applicable_cache[cache_key] = applicable
+        return applicable
 
     def is_protected(
         self,

pycleaner/linter_formatter.py

@@ -57,6 +57,25 @@ class _UsageCollector(ast.NodeVisitor):
         self.generic_visit(node)
 
 
+def _find_executable(name: str) -> str | None:
+    """Find CLI tool executable in PATH, virtual environment Scripts/bin, or python directory."""
+    found = shutil.which(name)
+    if found:
+        return found
+    from pathlib import Path
+    scripts_dir = Path(sys.prefix) / ("Scripts" if sys.platform == "win32" else "bin")
+    for ext in (".exe", ""):
+        candidate = scripts_dir / f"{name}{ext}"
+        if candidate.is_file():
+            return str(candidate)
+    parent_dir = Path(sys.executable).parent
+    for ext in (".exe", ""):
+        candidate = parent_dir / f"{name}{ext}"
+        if candidate.is_file():
+            return str(candidate)
+    return None
+
+
 class LinterFormatter:
     """Orchestrates static lint autofixes and canonical formatting."""
 
@@ -72,10 +91,10 @@ class LinterFormatter:
     DEFAULT_SELECT_RULES = "F401,F841,I,UP,E,W,B,SIM,RUF"
 
     def __init__(self, ruff_path: str | None = None) -> None:
-        self.ruff_cmd: str | None = ruff_path or shutil.which("ruff")
-        self.autoflake_cmd: str | None = shutil.which("autoflake")
-        self.black_cmd: str | None = shutil.which("black")
-        self.isort_cmd: str | None = shutil.which("isort")
+        self.ruff_cmd: str | None = ruff_path or _find_executable("ruff")
+        self.autoflake_cmd: str | None = _find_executable("autoflake")
+        self.black_cmd: str | None = _find_executable("black")
+        self.isort_cmd: str | None = _find_executable("isort")
 
     def fix_and_format(
         self,