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

{ballpython-2.0.7.dist-info → ballpython-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ballpython
-Version: 2.0.7
+Version: 2.1.0
 Summary: The Ultimate Static Python Intelligence, Healing, Type Verification, and Security Suite
 Author: Developer
 License-Expression: MIT

{ballpython-2.0.7.dist-info → ballpython-2.1.0.dist-info}/RECORD

@@ -5,30 +5,30 @@ ballpython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycleaner/__init__.py,sha256=VzmbjUip6i0wpKh-s6XBwgBkIeUgI1duGyKDIiv7Pls,3042
 pycleaner/__main__.py,sha256=8QBFrPyxId563F6cipPMNVEBTG8TIZUgxQfp8gk1VSI,135
 pycleaner/baseline.py,sha256=ljED3x3akie0SB3fzhVno_1UHlI2id-9vta0NIGC0mw,3857
-pycleaner/cache.py,sha256=WhCiMkuL6ryWVr3l3XrYLLoI7A3bRF8jNxpOyedNW8M,10761
-pycleaner/cli.py,sha256=ELGV5hzerbER4uSNmioKCRDpMUYWd6HjJnwVgUyjfE0,72953
+pycleaner/cache.py,sha256=T3JIxYg8ZezRbSpXYXPD-SyMUkjg4nfKsdO0IuNypOY,10774
+pycleaner/cli.py,sha256=NswwV_3cbHiL63Pj6qDtSpV_98zXvGo7UuBHwNAxpQ8,73752
 pycleaner/complexity_analyzer.py,sha256=j2ktzgR-isWE4xWMe56N3JFLLuYCi-S84BIlRBe0v-I,14975
 pycleaner/config.py,sha256=XhloyaY_9pdwbQuc3QaAPCerLeXz-i1da4xT50h-pjY,8514
-pycleaner/dead_code_detector.py,sha256=4JhZujswvPIcYbF_is3_umTGf6q5Iu6iDWbmRQsDy7s,26984
-pycleaner/dependency_auditor.py,sha256=CsNMboUdB5Ug-xaeajAykMBCpUzCXQDCCbwwVjt5awk,18456
+pycleaner/dead_code_detector.py,sha256=uufGt7EtGusQdtbX3rUCHIrF8IAu-S16jrViBJdnV-g,52092
+pycleaner/dependency_auditor.py,sha256=EmSqr_ayUqmdSZ7Nm4QAT4qfikF9VToLL8eXVecIDpw,23395
 pycleaner/discovery.py,sha256=dt3OmHg886hy_Z0p80ccMyDkITQxz4biaJY_zB3MU_g,6151
 pycleaner/explanations.py,sha256=2OOU_l3YL5o_Br_6fP6MF8HlY75-1JRmw3eTYT2lu8M,14219
 pycleaner/import_resolver.py,sha256=Wgrch335AQVsnDv5-7F0l4Zm2oQPkNebPEgTRa7ayAg,32855
-pycleaner/linter_formatter.py,sha256=gGl4sLTC5CcuTVHC2QkrkqGaqS_HJ9uUa1TFS5qkmoU,21001
-pycleaner/modernizer.py,sha256=WpOLNYPDxKCAe3fj5tF4iHliR-8nzvjHU79SVZYWepk,16797
+pycleaner/linter_formatter.py,sha256=wdTjwguPWzkJ9KRMcQpFHEirb3ogc9qay69yiphz16Y,21356
+pycleaner/modernizer.py,sha256=kd9_G5EzdW_O-9zm1hA6v33Sb__UbpMZzSvopF-UK5w,16820
 pycleaner/pipeline.py,sha256=ZG7_9PNz0jBadFrZoiI7juLtUJXglGQhLgQhrLJqEac,20612
 pycleaner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycleaner/security_scanner.py,sha256=ik485wW_aDbjV2X7HVPQy8uArkj406Jnn_Me78Og_n8,23444
-pycleaner/syntax_healer.py,sha256=RLuUjxMLqgHYzllX_juriJxIgaQv8e0cQIryVvzZeOE,27325
+pycleaner/security_scanner.py,sha256=8nyRtoCjBYAB_sI5azlNsEMm2S0s2zE7fPhc7QCHWR0,23527
+pycleaner/syntax_healer.py,sha256=5VYclqkI3WFnm6yfG0zRLMkHN4QMU4aN4ZYCcSUsmZk,27408
 pycleaner/taint_engine.py,sha256=-bBq38YoQgbO2FHCDxDctZpXWQTqwuS56CEWFNOY000,26870
 pycleaner/test_generator.py,sha256=MM3t0Dx5lyJB5s144IKXq2tXrE8ohKcSvicPR3c9MlU,19680
 pycleaner/type_checker.py,sha256=zkUqi-BNLUzJT0tIECNh7_7GP29Y7_6fMXhVuguwMKg,37881
 pycleaner/typeshed_resolver.py,sha256=N-kWU_CI5DG59lQMkt7wMW9sHYjNCBdfFS42b4y2Kr4,12742
-pycleaner/verifier.py,sha256=IEopcBfPLQXWOJxKV297150lpXBd3uGe7iv6CODJr6k,19305
+pycleaner/verifier.py,sha256=QlBwnsrhWWRK3LzvJjpNix474drCNp6LP7FiUgJxMsg,19333
 pycleaner/frameworks/__init__.py,sha256=SOuSRl39af86eoQx7Qm8rTJGD4jsnEvgyhhQ6cVmRVA,3462
 pycleaner/frameworks/plugins.py,sha256=qunMzS3q7xp1GEGxqkuhrnm-raiSRhYQMzmDxsEhSUg,11452
-ballpython-2.0.7.dist-info/METADATA,sha256=RNLcZfpGvUsfStSio5seuuMfq9p3YGWn86Z0IstIk6o,3466
-ballpython-2.0.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ballpython-2.0.7.dist-info/entry_points.txt,sha256=6ux-5UxoVSmlK5p9M-GDVt24sCdwTQq9wgRDkpMIYU8,81
-ballpython-2.0.7.dist-info/top_level.txt,sha256=u6lmy8RWZ_saxCZAQTL7EijB4sunegOiVyk5fHjpwLk,21
-ballpython-2.0.7.dist-info/RECORD,,
+ballpython-2.1.0.dist-info/METADATA,sha256=98OjKH0i9ih05fQ9JX2eriRljEboAEOVIgk4TwQ9hQ8,3466
+ballpython-2.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ballpython-2.1.0.dist-info/entry_points.txt,sha256=6ux-5UxoVSmlK5p9M-GDVt24sCdwTQq9wgRDkpMIYU8,81
+ballpython-2.1.0.dist-info/top_level.txt,sha256=u6lmy8RWZ_saxCZAQTL7EijB4sunegOiVyk5fHjpwLk,21
+ballpython-2.1.0.dist-info/RECORD,,

pycleaner/cache.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import ast
 import hashlib
 import json
+import logging
 import sqlite3
 import time
 from pathlib import Path
@@ -22,6 +23,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pycleaner.pipeline import CleanResult
+
 from pycleaner.verifier import VerificationTier
 
 
@@ -46,7 +48,7 @@ def extract_file_dependencies(source: str) -> list[str]:
             elif isinstance(node, ast.ImportFrom) and node.module:
                 deps.append(node.module.split(".")[0])
     except SyntaxError:
-        pass  # Best-effort dependency extraction; syntax errors handled downstream
+        logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
     return sorted(set(deps))
 
 

pycleaner/cli.py

@@ -157,6 +157,11 @@ def _register_fix_subparsers(subparsers: Any) -> None:
 def _register_analysis_subparsers(subparsers: Any) -> None:
     audit_p = subparsers.add_parser("audit", help="Audit project dependencies")
     _add_common_args(audit_p)
+    audit_p.add_argument(
+        "--fix",
+        action="store_true",
+        help="Auto-fix requirements.txt and pyproject.toml and prune unused packages",
+    )
     audit_p.add_argument(
         "--fix-deps", action="store_true", help="Auto-fix requirements.txt"
     )
@@ -897,15 +902,13 @@ def _render_audit_terminal_output(
             f"  [red]Missing:[/red] {', '.join(sorted(audit_report.missing_packages))}"
         )
         if not should_fix:
-            print_msg(
-                "  [dim]Tip: Run with -a/--all or --fix-deps to append them[/dim]"
-            )
+            print_msg("  [dim]Tip: Run with -a/--all or --fix to append them[/dim]")
     if audit_report.unused_packages:
         print_msg(
             f"  [yellow]Unused:[/yellow] {', '.join(sorted(audit_report.unused_packages))}"
         )
     if audit_report.fixed_requirements:
-        print_msg("  [green]requirements.txt synchronized.[/green]")
+        print_msg("  [green]Project dependencies synchronized on disk.[/green]")
 
 
 def _run_fix_audit(
@@ -918,8 +921,18 @@ def _run_fix_audit(
 ) -> DependencyAuditReport:
     exclude_patterns = config.exclude if config else ()
     auditor = DependencyAuditor(root_dir, exclude_patterns=exclude_patterns)
-    fix_any = getattr(args, "fix_deps", False) or getattr(args, "fix_all", False)
-    prune_any = getattr(args, "prune_deps", False) or getattr(args, "fix_all", False)
+    fix_any = (
+        getattr(args, "fix_deps", False)
+        or getattr(args, "fix_all", False)
+        or getattr(args, "fix", False)
+        or apply_changes
+    )
+    prune_any = (
+        getattr(args, "prune_deps", False)
+        or getattr(args, "fix_all", False)
+        or getattr(args, "fix", False)
+        or apply_changes
+    )
     should_fix = apply_changes and fix_any
     should_prune = apply_changes and prune_any
     audit_report = auditor.audit(
@@ -1009,6 +1022,12 @@ def _cmd_fix(
         config=config,
         target_files=py_files,
     )
+    if opts.apply_changes and (
+        audit_report.fixed_requirements
+        or getattr(audit_report, "fixed_pyproject", False)
+    ):
+        state.changed_count += 1
+
     print_msg(
         f"\n[bold]Summary: {len(py_files)} inspected, {state.changed_count} updated, {state.error_count} errors.[/bold]"
     )
@@ -1412,8 +1431,10 @@ def _render_audit_cli_output(
         )
     if not audit_report.missing_packages and not audit_report.unused_packages:
         print_msg("  [green]All dependencies clean.[/green]")
-    if audit_report.fixed_requirements:
-        print_msg("  [green]requirements.txt synchronized.[/green]")
+    if audit_report.fixed_requirements or getattr(
+        audit_report, "fixed_pyproject", False
+    ):
+        print_msg("  [green]Project dependencies synchronized on disk.[/green]")
 
     return (
         1
@@ -1427,10 +1448,12 @@ def _cmd_audit(args: argparse.Namespace, config: PyCleanerConfig, print_msg) ->
     root_dir = find_project_root(args.paths[0] if args.paths else None)
 
     is_check = getattr(args, "check", False)
+    fix_flag = getattr(args, "fix", False) or getattr(args, "fix_deps", False)
+    prune_flag = getattr(args, "fix", False) or getattr(args, "prune_deps", False)
     auditor = DependencyAuditor(root_dir, exclude_patterns=config.exclude)
     audit_report = auditor.audit(
-        fix=getattr(args, "fix_deps", False) and not is_check,
-        prune_unused=getattr(args, "prune_deps", False) and not is_check,
+        fix=fix_flag and not is_check,
+        prune_unused=prune_flag and not is_check,
     )
 
     if getattr(args, "json", False):
@@ -1964,6 +1987,8 @@ def _run_ultimate_phases(
     print_msg(
         "\n[bold blue]Phase 2: Project Dependency Audit & Reconciliation[/bold blue]"
     )
+    args.fix = True
+    args.prune_deps = True
     audit_rc = _cmd_audit(args, config, print_msg)
     print_msg(
         "\n[bold blue]Phase 3: Bidirectional Type Verification & Typeshed Resolution[/bold blue]"
@@ -1981,7 +2006,7 @@ def _run_ultimate_phases(
 def _cmd_ultimate(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg: Any, console: Any
 ) -> int:
-    """The Ultimate Python Tool flagship runner: executes full multi-layer analysis."""
+    """The Ultimate Python Tool flagship runner: executes full multi-layer analysis and automated healing."""
     print_msg(
         "[bold magenta]=== PyCleaner Ultimate: Full Spectrum Analysis & Healing ===[/bold magenta]\n"
     )
@@ -1989,14 +2014,15 @@ def _cmd_ultimate(
         args, config, print_msg, console
     )
     print_msg(
-        "\n[bold blue]Phase 6: Structural Complexity & Dead Code Discovery[/bold blue]"
+        "\n[bold blue]Phase 6: Structural Complexity & Dead Code Discovery & Healing[/bold blue]"
     )
     _cmd_complexity(args, config, print_msg, console)
-    _cmd_dead_code(args, config, print_msg, console)
+    args.fix = True
+    dead_rc = _cmd_dead_code(args, config, print_msg, console)
     print_msg(
         "\n[bold magenta]=== Ultimate Python Tool: Analysis Complete ===[/bold magenta]"
     )
-    return max(fix_rc, audit_rc, type_rc, taint_rc, scan_rc)
+    return max(fix_rc, audit_rc, type_rc, taint_rc, scan_rc, dead_rc)
 
 
 def _collect_file_mtimes(files: Sequence[Path]) -> dict[Path, float]:

pycleaner/dead_code_detector.py

@@ -8,6 +8,7 @@ unreachable code after return/raise/break/continue, and empty pass branches.
 from __future__ import annotations
 
 import ast
+import logging
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -201,6 +202,199 @@ class _ReferenceCollector(ast.NodeVisitor):
         self.generic_visit(node)
 
 
+def _is_pure_expression(node: ast.AST | None) -> bool:
+    """Determine if an AST expression is pure (guaranteed free of side effects)."""
+    if node is None:
+        return True
+    if isinstance(node, ast.Constant):
+        return True
+    if isinstance(node, ast.Name):
+        return True
+    if isinstance(node, (ast.Tuple, ast.List, ast.Set)):
+        return all(_is_pure_expression(elt) for elt in node.elts)
+    if isinstance(node, ast.Dict):
+        return all(
+            (k is None or _is_pure_expression(k)) and _is_pure_expression(v)
+            for k, v in zip(node.keys, node.values)
+        )
+    if isinstance(node, ast.UnaryOp):
+        return _is_pure_expression(node.operand)
+    if isinstance(node, ast.BinOp):
+        return _is_pure_expression(node.left) and _is_pure_expression(node.right)
+    if isinstance(node, ast.BoolOp):
+        return all(_is_pure_expression(v) for v in node.values)
+    if isinstance(node, ast.Compare):
+        return _is_pure_expression(node.left) and all(
+            _is_pure_expression(c) for c in node.comparators
+        )
+    if isinstance(node, ast.JoinedStr):
+        for val in node.values:
+            if isinstance(val, ast.FormattedValue) and not _is_pure_expression(
+                val.value
+            ):
+                return False
+        return True
+    if isinstance(node, ast.Lambda):
+        return True
+    return False
+
+
+def _walk_stmts_in_scope(body: list[ast.stmt]) -> list[tuple[ast.stmt, list[ast.stmt]]]:
+    """Yield (stmt, parent_body) for statements within this scope without descending into nested functions/classes."""
+    result: list[tuple[ast.stmt, list[ast.stmt]]] = []
+    for s in body:
+        result.append((s, body))
+        if isinstance(s, (ast.If, ast.While, ast.For, ast.AsyncFor)):
+            result.extend(_walk_stmts_in_scope(s.body))
+            if s.orelse:
+                result.extend(_walk_stmts_in_scope(s.orelse))
+        elif isinstance(s, ast.Try):
+            result.extend(_walk_stmts_in_scope(s.body))
+            for h in s.handlers:
+                result.extend(_walk_stmts_in_scope(h.body))
+            if s.orelse:
+                result.extend(_walk_stmts_in_scope(s.orelse))
+            if s.finalbody:
+                result.extend(_walk_stmts_in_scope(s.finalbody))
+        elif isinstance(s, (ast.With, ast.AsyncWith)):
+            result.extend(_walk_stmts_in_scope(s.body))
+        elif hasattr(ast, "Match") and isinstance(s, ast.Match):
+            for case in s.cases:
+                result.extend(_walk_stmts_in_scope(case.body))
+    return result
+
+
+def _has_logging_import(tree: ast.AST) -> bool:
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "logging":
+                    return True
+        elif isinstance(node, ast.ImportFrom):
+            if node.module and (
+                node.module == "logging" or node.module.startswith("logging.")
+            ):
+                return True
+    return False
+
+
+def _detect_unused_locals_in_function(
+    func_node: ast.FunctionDef | ast.AsyncFunctionDef,
+    filepath: str,
+) -> list[DeadCodeItem]:
+    items: list[DeadCodeItem] = []
+    args_set: set[str] = set()
+    for a in func_node.args.posonlyargs:
+        args_set.add(a.arg)
+    for a in func_node.args.args:
+        args_set.add(a.arg)
+    for a in func_node.args.kwonlyargs:
+        args_set.add(a.arg)
+    if func_node.args.vararg:
+        args_set.add(func_node.args.vararg.arg)
+    if func_node.args.kwarg:
+        args_set.add(func_node.args.kwarg.arg)
+
+    explicit_globals: set[str] = set()
+    has_dynamic = False
+    loaded_names: set[str] = set()
+
+    for sub in ast.walk(func_node):
+        if isinstance(sub, (ast.Global, ast.Nonlocal)):
+            explicit_globals.update(sub.names)
+        elif isinstance(sub, ast.Name) and isinstance(sub.ctx, ast.Load):
+            loaded_names.add(sub.id)
+        elif isinstance(sub, ast.Call):
+            func = sub.func
+            if isinstance(func, ast.Name) and func.id in (
+                "locals",
+                "vars",
+                "eval",
+                "exec",
+            ):
+                has_dynamic = True
+
+    if has_dynamic:
+        return items
+
+    stmts_in_scope = _walk_stmts_in_scope(func_node.body)
+    seen_unused: set[str] = set()
+    for stmt, _ in stmts_in_scope:
+        if isinstance(stmt, ast.Assign):
+            for target in stmt.targets:
+                if isinstance(target, ast.Name):
+                    name = target.id
+                    if (
+                        not name.startswith("_")
+                        and name not in args_set
+                        and name not in explicit_globals
+                        and name not in loaded_names
+                        and name not in seen_unused
+                    ):
+                        seen_unused.add(name)
+                        items.append(
+                            DeadCodeItem(
+                                filepath=filepath,
+                                lineno=target.lineno,
+                                end_lineno=getattr(target, "end_lineno", target.lineno),
+                                name=name,
+                                kind="variable",
+                                reason=f"Local variable '{name}' is assigned in '{func_node.name}' but never used",
+                                confidence="high",
+                            )
+                        )
+                elif isinstance(target, (ast.Tuple, ast.List)):
+                    for elt in target.elts:
+                        if isinstance(elt, ast.Name):
+                            name = elt.id
+                            if (
+                                not name.startswith("_")
+                                and name not in args_set
+                                and name not in explicit_globals
+                                and name not in loaded_names
+                                and name not in seen_unused
+                            ):
+                                seen_unused.add(name)
+                                items.append(
+                                    DeadCodeItem(
+                                        filepath=filepath,
+                                        lineno=elt.lineno,
+                                        end_lineno=getattr(
+                                            elt, "end_lineno", elt.lineno
+                                        ),
+                                        name=name,
+                                        kind="variable",
+                                        reason=f"Local variable '{name}' is assigned in '{func_node.name}' but never used",
+                                        confidence="high",
+                                    )
+                                )
+        elif isinstance(stmt, ast.AnnAssign):
+            if isinstance(stmt.target, ast.Name):
+                name = stmt.target.id
+                if (
+                    not name.startswith("_")
+                    and name not in args_set
+                    and name not in explicit_globals
+                    and name not in loaded_names
+                    and name not in seen_unused
+                ):
+                    seen_unused.add(name)
+                    items.append(
+                        DeadCodeItem(
+                            filepath=filepath,
+                            lineno=stmt.target.lineno,
+                            end_lineno=getattr(
+                                stmt.target, "end_lineno", stmt.target.lineno
+                            ),
+                            name=name,
+                            kind="variable",
+                            reason=f"Local variable '{name}' is assigned in '{func_node.name}' but never used",
+                            confidence="high",
+                        )
+                    )
+    return items
+
+
 class _UnreachableCodeDetector(ast.NodeVisitor):
     """Detects code after unconditional return/raise/break/continue and empty branches."""
 
@@ -215,6 +409,7 @@ class _UnreachableCodeDetector(ast.NodeVisitor):
 
     def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
         self._check_body(node.body)
+        self.items.extend(_detect_unused_locals_in_function(node, self.filepath))
         self.generic_visit(node)
 
     visit_AsyncFunctionDef = visit_FunctionDef
@@ -721,38 +916,380 @@ class _DeadCodePrunerCollector(ast.NodeVisitor):
 
 
 class DeadCodeFixer:
-    """Surgically eliminates unreachable statements, dead branches, and redundant pass statements."""
+    """Surgically eliminates unreachable statements, dead branches, heals empty except blocks, and fixes unused variables."""
 
     def fix(self, source: str, filename: str = "<stdin>") -> DeadCodeFixResult:
         current_code = source
         all_pruned: list[str] = []
 
-        for _ in range(2):
+        for _ in range(3):
+            changed_this_pass = False
+
+            # --- Pass 1: Empty Except Healer ---
             try:
                 tree = ast.parse(current_code, filename=filename)
             except SyntaxError:
                 break
 
-            collector = _DeadCodePrunerCollector()
-            collector.visit(tree)
-            if not collector.deletions:
+            except_handlers_to_heal: list[tuple[int, int]] = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ExceptHandler):
+                    if len(node.body) == 1 and isinstance(node.body[0], ast.Pass):
+                        pass_node = node.body[0]
+                        except_handlers_to_heal.append((node.lineno, pass_node.lineno))
+
+            if except_handlers_to_heal:
+                lines = current_code.splitlines(keepends=True)
+                needs_logging_import = not _has_logging_import(tree)
+
+                # Sort by line number descending so replacements do not shift earlier lines
+                for handler_line, pass_line in sorted(
+                    except_handlers_to_heal, key=lambda x: x[1], reverse=True
+                ):
+                    idx = pass_line - 1
+                    if 0 <= idx < len(lines):
+                        orig_line = lines[idx]
+                        indent = orig_line[: len(orig_line) - len(orig_line.lstrip())]
+                        lines[idx] = (
+                            f"{indent}logging.getLogger(__name__).debug("
+                            f"'Suppressed exception', exc_info=True)\n"
+                        )
+                        all_pruned.append(
+                            f"Healed empty except block at line {handler_line} with debug logging"
+                        )
+                        changed_this_pass = True
+
+                if needs_logging_import and changed_this_pass:
+                    insert_idx = 0
+                    while insert_idx < len(lines) and (
+                        lines[insert_idx].startswith("#!")
+                        or "coding:" in lines[insert_idx]
+                        or "coding=" in lines[insert_idx]
+                    ):
+                        insert_idx += 1
+
+                    doc_node = (
+                        tree.body[0]
+                        if tree.body
+                        and isinstance(tree.body[0], ast.Expr)
+                        and isinstance(tree.body[0].value, ast.Constant)
+                        and isinstance(tree.body[0].value.value, str)
+                        else None
+                    )
+                    if (
+                        doc_node
+                        and hasattr(doc_node, "end_lineno")
+                        and doc_node.end_lineno is not None
+                    ):
+                        insert_idx = max(insert_idx, doc_node.end_lineno)
+
+                    for stmt in tree.body:
+                        if (
+                            isinstance(stmt, ast.ImportFrom)
+                            and stmt.module == "__future__"
+                            and hasattr(stmt, "end_lineno")
+                            and stmt.end_lineno is not None
+                        ):
+                            insert_idx = max(insert_idx, stmt.end_lineno)
+
+                    lines.insert(insert_idx, "import logging\n")
+                    all_pruned.append("Added 'import logging' for healed except block")
+
+                candidate = "".join(lines)
+                try:
+                    ast.parse(candidate, filename=filename)
+                    current_code = candidate
+                except SyntaxError:
+                    logging.getLogger(__name__).debug(
+                        "Suppressed exception", exc_info=True
+                    )
+
+            # --- Pass 2: Dead Variable Fixer ---
+            try:
+                tree = ast.parse(current_code, filename=filename)
+            except SyntaxError:
                 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)
+            renames: list[tuple[int, int, int, str, str]] = []
+            deletions: list[tuple[int, int, list[ast.stmt], str]] = []
+
+            # 2a. Function-level local variables
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    args_set: set[str] = set()
+                    for a in node.args.posonlyargs:
+                        args_set.add(a.arg)
+                    for a in node.args.args:
+                        args_set.add(a.arg)
+                    for a in node.args.kwonlyargs:
+                        args_set.add(a.arg)
+                    if node.args.vararg:
+                        args_set.add(node.args.vararg.arg)
+                    if node.args.kwarg:
+                        args_set.add(node.args.kwarg.arg)
+
+                    explicit_globals: set[str] = set()
+                    has_dynamic = False
+                    loaded_names: set[str] = set()
+
+                    for sub in ast.walk(node):
+                        if isinstance(sub, (ast.Global, ast.Nonlocal)):
+                            explicit_globals.update(sub.names)
+                        elif isinstance(sub, ast.Name) and isinstance(
+                            sub.ctx, ast.Load
+                        ):
+                            loaded_names.add(sub.id)
+                        elif isinstance(sub, ast.Call):
+                            func = sub.func
+                            if isinstance(func, ast.Name) and func.id in (
+                                "locals",
+                                "vars",
+                                "eval",
+                                "exec",
+                            ):
+                                has_dynamic = True
+
+                    if has_dynamic:
+                        continue
 
-            candidate = "".join(lines)
+                    stmts_in_scope = _walk_stmts_in_scope(node.body)
+                    for stmt, parent_body in stmts_in_scope:
+                        if isinstance(stmt, ast.Assign):
+                            if len(stmt.targets) == 1 and isinstance(
+                                stmt.targets[0], ast.Name
+                            ):
+                                target = stmt.targets[0]
+                                name = target.id
+                                if (
+                                    not name.startswith("_")
+                                    and name not in args_set
+                                    and name not in explicit_globals
+                                    and name not in loaded_names
+                                ):
+                                    if _is_pure_expression(stmt.value):
+                                        deletions.append(
+                                            (
+                                                stmt.lineno,
+                                                getattr(
+                                                    stmt, "end_lineno", stmt.lineno
+                                                ),
+                                                parent_body,
+                                                name,
+                                            )
+                                        )
+                                    else:
+                                        if hasattr(target, "col_offset") and hasattr(
+                                            target, "end_col_offset"
+                                        ):
+                                            renames.append(
+                                                (
+                                                    target.lineno,
+                                                    target.col_offset,
+                                                    target.end_col_offset,
+                                                    f"_{name}",
+                                                    name,
+                                                )
+                                            )
+                            elif len(stmt.targets) == 1 and isinstance(
+                                stmt.targets[0], (ast.Tuple, ast.List)
+                            ):
+                                for elt in stmt.targets[0].elts:
+                                    if isinstance(elt, ast.Name):
+                                        name = elt.id
+                                        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")
+                                        ):
+                                            renames.append(
+                                                (
+                                                    elt.lineno,
+                                                    elt.col_offset,
+                                                    elt.end_col_offset,
+                                                    f"_{name}",
+                                                    name,
+                                                )
+                                            )
+                        elif isinstance(stmt, ast.AnnAssign):
+                            if isinstance(stmt.target, ast.Name):
+                                name = stmt.target.id
+                                if (
+                                    not name.startswith("_")
+                                    and name not in args_set
+                                    and name not in explicit_globals
+                                    and name not in loaded_names
+                                ):
+                                    if stmt.value is not None and _is_pure_expression(
+                                        stmt.value
+                                    ):
+                                        deletions.append(
+                                            (
+                                                stmt.lineno,
+                                                getattr(
+                                                    stmt, "end_lineno", stmt.lineno
+                                                ),
+                                                parent_body,
+                                                name,
+                                            )
+                                        )
+                                    else:
+                                        target = stmt.target
+                                        if hasattr(target, "col_offset") and hasattr(
+                                            target, "end_col_offset"
+                                        ):
+                                            renames.append(
+                                                (
+                                                    target.lineno,
+                                                    target.col_offset,
+                                                    target.end_col_offset,
+                                                    f"_{name}",
+                                                    name,
+                                                )
+                                            )
+
+            # 2b. Module-level script variables (when not an __init__.py package export)
+            if not filename.endswith("__init__.py"):
+                module_loads: set[str] = set()
+                module_exports: set[str] = set()
+                for sub in ast.walk(tree):
+                    if isinstance(sub, ast.Name) and isinstance(sub.ctx, ast.Load):
+                        module_loads.add(sub.id)
+                    elif (
+                        isinstance(sub, ast.Assign)
+                        and any(
+                            isinstance(t, ast.Name) and t.id == "__all__"
+                            for t in sub.targets
+                        )
+                        and isinstance(sub.value, (ast.List, ast.Tuple, ast.Set))
+                    ):
+                        for elt in sub.value.elts:
+                            if isinstance(elt, ast.Constant) and isinstance(
+                                elt.value, str
+                            ):
+                                module_exports.add(elt.value)
+
+                for stmt in tree.body:
+                    if (
+                        isinstance(stmt, ast.Assign)
+                        and len(stmt.targets) == 1
+                        and isinstance(stmt.targets[0], ast.Name)
+                    ):
+                        target = stmt.targets[0]
+                        name = target.id
+                        if (
+                            not name.startswith("_")
+                            and name != "__all__"
+                            and name not in module_loads
+                            and name not in module_exports
+                        ):
+                            if _is_pure_expression(stmt.value):
+                                deletions.append(
+                                    (
+                                        stmt.lineno,
+                                        getattr(stmt, "end_lineno", stmt.lineno),
+                                        tree.body,
+                                        name,
+                                    )
+                                )
+                            else:
+                                if hasattr(target, "col_offset") and hasattr(
+                                    target, "end_col_offset"
+                                ):
+                                    renames.append(
+                                        (
+                                            target.lineno,
+                                            target.col_offset,
+                                            target.end_col_offset,
+                                            f"_{name}",
+                                            name,
+                                        )
+                                    )
+
+            if renames or deletions:
+                lines = current_code.splitlines(keepends=True)
+
+                # 1. Apply renames line-by-line, ordered by column descending
+                renames_by_line: dict[int, list[tuple[int, int, str, str]]] = {}
+                for lineno, col, end_col, new_text, name in renames:
+                    renames_by_line.setdefault(lineno, []).append(
+                        (col, end_col, new_text, name)
+                    )
+
+                for lineno, line_renames in renames_by_line.items():
+                    idx = lineno - 1
+                    if 0 <= idx < len(lines):
+                        line_str = lines[idx]
+                        for col, end_col, new_text, name in sorted(
+                            line_renames, key=lambda x: x[0], reverse=True
+                        ):
+                            line_str = line_str[:col] + new_text + line_str[end_col:]
+                            all_pruned.append(
+                                f"Prefixed unused variable '{name}' with '_' at line {lineno} to preserve side effects"
+                            )
+                            changed_this_pass = True
+                        lines[idx] = line_str
+
+                # 2. Apply deletions ordered by start line descending
+                for start_line, end_line, parent_body, name in sorted(
+                    deletions, key=lambda x: x[0], reverse=True
+                ):
+                    start_idx = start_line - 1
+                    if 0 <= start_idx < len(lines):
+                        if len(parent_body) == 1:
+                            orig_line = lines[start_idx]
+                            indent = orig_line[
+                                : len(orig_line) - len(orig_line.lstrip())
+                            ]
+                            lines[start_idx:end_line] = [f"{indent}pass\n"]
+                        else:
+                            del lines[start_idx:end_line]
+                        all_pruned.append(
+                            f"Pruned unused local variable '{name}' assignment at line {start_line}"
+                        )
+                        changed_this_pass = True
+
+                candidate = "".join(lines)
+                try:
+                    ast.parse(candidate, filename=filename)
+                    current_code = candidate
+                except SyntaxError:
+                    logging.getLogger(__name__).debug(
+                        "Suppressed exception", exc_info=True
+                    )
+
+            # --- Pass 3: Unreachable Code & Redundant Pass ---
             try:
-                ast.parse(candidate, filename=filename)
-                current_code = candidate
+                tree = ast.parse(current_code, filename=filename)
             except SyntaxError:
                 break
 
+            collector = _DeadCodePrunerCollector()
+            collector.visit(tree)
+            if collector.deletions:
+                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)
+                    changed_this_pass = True
+
+                candidate = "".join(lines)
+                try:
+                    ast.parse(candidate, filename=filename)
+                    current_code = candidate
+                except SyntaxError:
+                    logging.getLogger(__name__).debug(
+                        "Suppressed exception", exc_info=True
+                    )
+
+            if not changed_this_pass:
+                break
+
         return DeadCodeFixResult(
             code=current_code,
             changed=current_code != source,

pycleaner/dependency_auditor.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import ast
 import importlib.metadata
+import logging
 import re
 import shutil
 import sys
@@ -31,6 +32,7 @@ class DependencyAuditReport:
     missing_packages: set[str] = field(default_factory=set)
     unused_packages: set[str] = field(default_factory=set)
     fixed_requirements: bool = False
+    fixed_pyproject: bool = False
     details: list[str] = field(default_factory=list)
 
 
@@ -99,7 +101,7 @@ class DependencyAuditor:
         try:
             dists.update(importlib.metadata.packages_distributions())
         except AttributeError:
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
         site_packages = self._find_venv_site_packages()
         if site_packages and site_packages.is_dir():
@@ -116,9 +118,11 @@ class DependencyAuditor:
                                 if top_mod:
                                     dists.setdefault(top_mod, []).insert(0, dist_name)
                         except OSError:
-                            pass
+                            logging.getLogger(__name__).debug(
+                                "Suppressed exception", exc_info=True
+                            )
             except OSError:
-                pass
+                logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
         return dists
 
@@ -226,7 +230,7 @@ class DependencyAuditor:
                     local_mods.add(str(proj_name))
                     local_mods.add(str(proj_name).replace("-", "_"))
             except Exception:
-                pass  # Ignore invalid or non-standard pyproject.toml configuration
+                logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
         # 3. Discover local .py files and subpackages (including PEP 420 namespace packages)
         search_dirs = [self.root_dir]
@@ -331,7 +335,7 @@ class DependencyAuditor:
                                 declared[canon] = dep
                                 optional_pkgs.add(canon)
         except Exception:
-            pass  # Best-effort reading; continue if pyproject.toml is unparseable
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return declared, optional_pkgs
 
     def read_declared_dependencies(self) -> dict[str, str]:
@@ -374,7 +378,10 @@ class DependencyAuditor:
 
     @staticmethod
     def _build_audit_details(
-        missing: set[str], unused: set[str], fixed: bool
+        missing: set[str],
+        unused: set[str],
+        fixed_reqs: bool,
+        fixed_pyproj: bool = False,
     ) -> list[str]:
         details: list[str] = []
         if missing:
@@ -385,10 +392,14 @@ class DependencyAuditor:
             details.append(
                 f"Unused dependencies (declared but not imported): {', '.join(sorted(unused))}"
             )
-        if fixed:
+        if fixed_reqs:
             details.append(
                 "Updated requirements.txt successfully (backup saved as requirements.txt.bak)"
             )
+        if fixed_pyproj:
+            details.append(
+                "Updated pyproject.toml successfully (backup saved as pyproject.toml.bak)"
+            )
         return details
 
     def audit(
@@ -397,7 +408,7 @@ class DependencyAuditor:
         prune_unused: bool = False,
         target_files: Sequence[Path] | None = None,
     ) -> DependencyAuditReport:
-        """Audit dependencies and optionally update requirements.txt."""
+        """Audit dependencies and optionally update requirements.txt and pyproject.toml."""
         all_imports = self.scan_codebase_imports(target_files=target_files)
         local_mods = self.identify_local_modules()
 
@@ -414,13 +425,18 @@ class DependencyAuditor:
         )
 
         fixed_reqs = False
+        fixed_pyproj = False
         if fix and (missing_packages or (prune_unused and unused_packages)):
-            fixed_reqs = self._update_requirements(
-                missing_packages, unused_packages if prune_unused else set()
-            )
+            to_remove = unused_packages if prune_unused else set()
+            if (self.root_dir / "pyproject.toml").is_file():
+                fixed_pyproj = self._update_pyproject_toml(missing_packages, to_remove)
+            if (self.root_dir / "requirements.txt").is_file():
+                fixed_reqs = self._update_requirements(missing_packages, to_remove)
+            elif not fixed_pyproj and missing_packages:
+                fixed_reqs = self._update_requirements(missing_packages, set())
 
         details = self._build_audit_details(
-            missing_packages, unused_packages, fixed_reqs
+            missing_packages, unused_packages, fixed_reqs, fixed_pyproj
         )
 
         return DependencyAuditReport(
@@ -429,10 +445,109 @@ class DependencyAuditor:
             required_packages=set(declared.keys()),
             missing_packages=missing_packages,
             unused_packages=unused_packages,
-            fixed_requirements=fixed_reqs,
+            fixed_requirements=fixed_reqs or fixed_pyproj,
+            fixed_pyproject=fixed_pyproj,
             details=details,
         )
 
+    def _update_pyproject_toml(
+        self, missing: set[str], unused_to_remove: set[str]
+    ) -> bool:
+        """Prune unused dependencies and append missing ones in pyproject.toml with safety checks."""
+        pyproject_file = self.root_dir / "pyproject.toml"
+        if not pyproject_file.is_file():
+            return False
+
+        content = pyproject_file.read_text(encoding="utf-8", errors="ignore")
+        remove_canons = {
+            self.canonicalize_name(m.group(1))
+            for u in unused_to_remove
+            if (m := re.match(r"^([a-zA-Z0-9_.-]+)", u))
+        }
+        local_canons = {
+            self.canonicalize_name(m) for m in self.identify_local_modules()
+        }
+        safe_missing = {
+            pkg for pkg in missing if self.canonicalize_name(pkg) not in local_canons
+        }
+
+        if not remove_canons and not safe_missing:
+            return False
+
+        lines = content.splitlines(keepends=True)
+        new_lines: list[str] = []
+        in_dependencies_array = False
+        modified = False
+
+        for line in lines:
+            stripped = line.strip()
+
+            if re.match(r"^dependencies\s*=\s*\[", stripped):
+                if "]" in stripped:
+                    bracket_content = stripped[
+                        stripped.find("[") + 1 : stripped.rfind("]")
+                    ]
+                    items = [
+                        it.strip() for it in bracket_content.split(",") if it.strip()
+                    ]
+                    kept_items: list[str] = []
+                    for item in items:
+                        m = re.search(r'["\']([a-zA-Z0-9_.-]+)', item)
+                        if m and self.canonicalize_name(m.group(1)) in remove_canons:
+                            modified = True
+                            continue
+                        kept_items.append(item)
+                    for sm in sorted(safe_missing):
+                        kept_items.append(f'"{sm}"')
+                        modified = True
+                    indent = line[: len(line) - len(line.lstrip())]
+                    new_lines.append(
+                        f"{indent}dependencies = [{', '.join(kept_items)}]\n"
+                    )
+                    continue
+                else:
+                    in_dependencies_array = True
+                    new_lines.append(line)
+                    continue
+
+            if in_dependencies_array:
+                if "]" in stripped:
+                    in_dependencies_array = False
+                    for sm in sorted(safe_missing):
+                        indent = "    "
+                        new_lines.append(f'{indent}"{sm}",\n')
+                        modified = True
+                    new_lines.append(line)
+                    continue
+
+                pkg_match = re.search(r'["\']([a-zA-Z0-9_.-]+)', stripped)
+                if pkg_match:
+                    canon = self.canonicalize_name(pkg_match.group(1))
+                    if canon in remove_canons:
+                        modified = True
+                        continue
+                new_lines.append(line)
+                continue
+
+            poetry_pkg_match = re.match(r"^([a-zA-Z0-9_.-]+)\s*=", stripped)
+            if poetry_pkg_match:
+                canon = self.canonicalize_name(poetry_pkg_match.group(1))
+                if canon in remove_canons and canon != "python":
+                    modified = True
+                    continue
+
+            new_lines.append(line)
+
+        if modified:
+            backup_file = pyproject_file.with_suffix(".toml.bak")
+            try:
+                shutil.copy2(pyproject_file, backup_file)
+            except OSError:
+                logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
+            pyproject_file.write_text("".join(new_lines), encoding="utf-8")
+            return True
+        return False
+
     def _update_requirements(
         self, missing: set[str], unused_to_remove: set[str]
     ) -> bool:
@@ -445,7 +560,7 @@ class DependencyAuditor:
             try:
                 shutil.copy2(req_file, backup_file)
             except OSError:
-                pass  # Continue if backup creation fails
+                logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
             existing_lines = req_file.read_text(
                 encoding="utf-8", errors="ignore"
             ).splitlines()

pycleaner/linter_formatter.py

@@ -9,6 +9,7 @@ fallbacks via autoflake, isort, black, and built-in pure-Python AST pruning.
 from __future__ import annotations
 
 import ast
+import logging
 import re
 import shutil
 import subprocess
@@ -169,7 +170,7 @@ class LinterFormatter:
                     return output, True
         except OSError:
             # Fall back to pure-Python import pruning if autoflake CLI fails
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return source, False
 
     def _isort_cli_sort(self, code: str) -> str | None:
@@ -187,7 +188,7 @@ class LinterFormatter:
                 return res if res != code else None
         except OSError:
             # Fall back to isort Python module or pure-Python import sorter
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return None
 
     def _isort_module_sort(self, code: str) -> str | None:
@@ -269,7 +270,7 @@ class LinterFormatter:
                 return res, res != source
         except OSError:
             # Fall back to Black or pure-Python formatter if ruff CLI execution fails
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return None
 
     def _format_with_black(self, source: str) -> tuple[str, bool, list[str]] | None:
@@ -286,7 +287,7 @@ class LinterFormatter:
                     return res, res != source, ["Formatted with black CLI fallback"]
             except OSError:
                 # Fall back to black module or pure-Python formatter
-                pass
+                logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         try:
             import black  # type: ignore
 
@@ -443,7 +444,7 @@ class LinterFormatter:
                 )
         except SyntaxError:
             # Return unmodified source if candidate code has syntax issues
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return source, False, []
 
     def _pure_python_sort_imports(self, source: str) -> tuple[str, bool, list[str]]:

pycleaner/modernizer.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import ast
 import io
+import logging
 import re
 import tokenize
 from dataclasses import dataclass, field
@@ -414,7 +415,7 @@ class Modernizer:
             ):
                 insert_idx = getattr(tree.body[0], "end_lineno", 1)
         except SyntaxError:
-            pass  # Fall back to default index if docstring extraction fails
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
         future_stmt = "from __future__ import annotations\n\n"
         if insert_idx < len(lines):

pycleaner/security_scanner.py

@@ -9,6 +9,7 @@ and assert statements used for input validation.
 from __future__ import annotations
 
 import ast
+import logging
 import re
 from collections.abc import Sequence
 from dataclasses import dataclass, field
@@ -524,7 +525,7 @@ class SecurityScanner:
             findings.extend(detector.findings)
         except SyntaxError:
             # Code with syntax errors cannot be AST-parsed; regex checks still run
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
         findings.extend(self._detect_secrets(source, filename))
 

pycleaner/syntax_healer.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import ast
 import io
+import logging
 import re
 import tokenize
 from collections.abc import Sequence
@@ -695,7 +696,7 @@ class SyntaxHealer:
                         stack.pop()
         except tokenize.TokenError:
             # Incomplete token stream will be healed by delimiter reconstruction
-            pass
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
         return stack
 
     @staticmethod

pycleaner/verifier.py

@@ -15,6 +15,7 @@ import ast
 import dataclasses
 import enum
 import inspect
+import logging
 import multiprocessing as mp
 import random
 import sys
@@ -211,12 +212,12 @@ def _worker_differential_fuzz(
                 }
             )
         except Exception:
-            pass  # Suppress secondary exceptions if IPC pipe fails to send crash reason
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
     finally:
         try:
             conn.close()
         except Exception:
-            pass  # Best-effort resource cleanup for IPC connection
+            logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
 
 
 class DeterministicInputSynthesizer: