ballpython 2.0.5__tar.gz → 2.0.7__tar.gz

{ballpython-2.0.5 → ballpython-2.0.7}/PKG-INFO

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

ballpython-2.0.7/ballpython/__init__.py

@@ -0,0 +1,13 @@
+"""ballpython - alias and entrypoint wrapper for pycleaner."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pycleaner
+from pycleaner import __all__ as __all__
+from pycleaner import __version__ as __version__
+
+
+def __getattr__(name: str) -> Any:
+    return getattr(pycleaner, name)

{ballpython-2.0.5 → ballpython-2.0.7}/ballpython.egg-info/PKG-INFO

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

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/__init__.py

@@ -20,6 +20,8 @@ from pycleaner.discovery import (
 
 __version__ = "2.0.5"
 __all__ = [
+    "DEFAULT_IGNORED_DIRS",
+    "PROTECTED_FILE_PATTERNS",
     "BaselineFingerprint",
     "BaselineManager",
     "CleanPipeline",
@@ -55,7 +57,10 @@ __all__ = [
     "TypeReport",
     "TypeshedResolver",
     "VerificationTier",
+    "collect_project_python_files",
     "get_explanation",
+    "is_ignored_directory",
+    "is_protected_file",
     "list_rules",
     "load_config",
 ]

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/baseline.py

@@ -54,7 +54,7 @@ class BaselineManager:
             data = json.loads(self.baseline_path.read_text(encoding="utf-8"))
             fingerprints = data.get("fingerprints", [])
             return {
-                fp.get("hash")
+                str(fp["hash"])
                 for fp in fingerprints
                 if isinstance(fp, dict) and fp.get("hash")
             }

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/cli.py

@@ -40,7 +40,6 @@ from pycleaner.verifier import CounterExample, ProofReceipt, VerificationTier
 
 try:
     from rich.console import Console
-    from rich.panel import Panel
     from rich.progress import (
         BarColumn,
         Progress,
@@ -714,17 +713,17 @@ def _report_file_modifications(
     action = "Cleaned" if apply_changes else "Would modify"
     print_msg(f"[green]{action}:[/green] {py_file.name}")
     for repair in result.syntax_repairs:
-        print_msg(f"  • Syntax: {repair}", style="cyan")
+        print_msg(f"  - Syntax: {repair}", style="cyan")
     for mod in result.modernize_transforms:
-        print_msg(f"  • Modernize: {mod}", style="green")
+        print_msg(f"  - Modernize: {mod}", style="green")
     for dc in result.dead_code_pruned:
-        print_msg(f"  • Dead-code: {dc}", style="yellow")
+        print_msg(f"  - Dead-code: {dc}", style="yellow")
     for imp in result.resolved_imports:
-        print_msg(f"  • Import: {imp}", style="magenta")
+        print_msg(f"  - Import: {imp}", style="magenta")
     if result.lint_changed:
-        print_msg("  • Lint: fixed errors and pruned unused imports", style="blue")
+        print_msg("  - Lint: fixed errors and pruned unused imports", style="blue")
     if result.format_changed:
-        print_msg("  • Format: applied PEP 8 formatting", style="blue")
+        print_msg("  - Format: applied PEP 8 formatting", style="blue")
 
 
 def _accumulate_result(
@@ -750,11 +749,11 @@ def _accumulate_result(
     elif result.verification_tier == VerificationTier.TIER_C_REFUSED:
         if not is_json:
             print_msg(
-                f"[bold red]Refused (Tier C):[/bold red] {py_file.name} — transformation falsified by differential fuzzing; rolled back!"
+                f"[bold red]Refused (Tier C):[/bold red] {py_file.name} - transformation falsified by differential fuzzing; rolled back!"
             )
             for ce in result.refused_changes:
                 print_msg(
-                    f"  • {ce.callable_name} diverged on args={ce.arguments} kwargs={ce.keyword_arguments}"
+                    f"  - {ce.callable_name} diverged on args={ce.arguments} kwargs={ce.keyword_arguments}"
                 )
                 print_msg(
                     f"    original={ce.original_result or ce.original_error} vs transformed={ce.transformed_result or ce.transformed_error} (seed {ce.seed})"
@@ -1022,15 +1021,15 @@ def _cmd_fix(
         if not is_json:
             print_msg("\n[bold cyan]Verification Receipts (Trust Ladder):[/bold cyan]")
             print_msg(
-                f"  [bold green]• Proven (Tier A):[/bold green] {total_proven_callables} callable(s) invariant-preserving across {pipeline.proof_iterations} input(s)"
+                f"  [bold green]- Proven (Tier A):[/bold green] {total_proven_callables} callable(s) invariant-preserving across {pipeline.proof_iterations} input(s)"
             )
             if state.suggested_count > 0:
                 print_msg(
-                    f"  [yellow]• Suggested (Tier B):[/yellow] {state.suggested_count} module(s) (not isolated for dynamic fuzzing)"
+                    f"  [yellow]- Suggested (Tier B):[/yellow] {state.suggested_count} module(s) (not isolated for dynamic fuzzing)"
                 )
             if total_refused_callables > 0:
                 print_msg(
-                    f"  [bold red]• Refused (Tier C):[/bold red] {total_refused_callables} transformation(s) diverged; rolled back"
+                    f"  [bold red]- Refused (Tier C):[/bold red] {total_refused_callables} transformation(s) diverged; rolled back"
                 )
 
         output_report_path = getattr(
@@ -1098,20 +1097,20 @@ def _cmd_fix(
             )
             if tolerated:
                 print_msg(
-                    f"  • Baseline tolerated: [yellow]{len(tolerated)}[/yellow] existing issue(s)"
+                    f"  - Baseline tolerated: [yellow]{len(tolerated)}[/yellow] existing issue(s)"
                 )
             if new_debt:
                 print_msg(
-                    f"  • [bold red]Ratchet Violation:[/bold red] {len(new_debt)} new technical debt issue(s) detected!"
+                    f"  - [bold red]Ratchet Violation:[/bold red] {len(new_debt)} new technical debt issue(s) detected!"
                 )
                 for nd in new_debt:
                     print_msg(
-                        f"    [red]• [X] {nd.rule} at {nd.file}:{nd.line} ({nd.symbol})[/red]"
+                        f"    [red]- [X] {nd.rule} at {nd.file}:{nd.line} ({nd.symbol})[/red]"
                     )
                 return 1
             else:
                 print_msg(
-                    "  • [bold green]Ratchet Passed:[/bold green] 0 new technical debt issues introduced."
+                    "  - [bold green]Ratchet Passed:[/bold green] 0 new technical debt issues introduced."
                 )
         elif new_debt:
             return 1
@@ -1223,9 +1222,9 @@ def _cmd_baseline(
     manager = BaselineManager(output_path)
     saved_file = manager.save_baseline(fingerprints, root_dir)
 
-    print_msg(f"\n[bold green]Baseline successfully recorded![/bold green]")
-    print_msg(f"  • Issues snapshotted: [bold yellow]{len(fingerprints)}[/bold yellow]")
-    print_msg(f"  • Output file: [bold]{saved_file}[/bold]")
+    print_msg("\n[bold green]Baseline successfully recorded![/bold green]")
+    print_msg(f"  - Issues snapshotted: [bold yellow]{len(fingerprints)}[/bold yellow]")
+    print_msg(f"  - Output file: [bold]{saved_file}[/bold]")
     print_msg(
         "\n[dim]Ratchet Guarantee: Technical debt in this repository is now locked. Run CI with:[/dim]"
     )
@@ -1501,7 +1500,7 @@ def _render_scan_cli_summary(
         print_msg(f"\n  Findings by category: {cat_summary}")
 
     print_msg(
-        f"\n  Total: {report.count} finding(s) — "
+        f"\n  Total: {report.count} finding(s) - "
         f"[red]{report.critical_count} critical[/red], [red]{report.high_count} high[/red]"
     )
     return 1 if report.critical_count > 0 else 0
@@ -1604,7 +1603,7 @@ def _render_complexity_cli_output(
     else:
         for f in violations:
             print_msg(
-                f"  {f.qualified_name} — CC:{f.cyclomatic} Cog:{f.cognitive} Ln:{f.lines} Args:{f.args}"
+                f"  {f.qualified_name} - CC:{f.cyclomatic} Cog:{f.cognitive} Ln:{f.lines} Args:{f.args}"
             )
     print_msg(f"\n  {len(violations)} function(s) exceed threshold(s).")
     return 1
@@ -1661,7 +1660,7 @@ def _render_dead_code_kind_group(
         rel_path = _try_relative(item.filepath, target_base)
         conf_tag = f" [{item.confidence}]" if item.confidence != "high" else ""
         print_msg(
-            f"    L{item.lineno} {rel_path}: {item.name} — {item.reason}{conf_tag}"
+            f"    L{item.lineno} {rel_path}: {item.name} - {item.reason}{conf_tag}"
         )
     if len(kind_items) > 20:
         print_msg(f"    ... and {len(kind_items) - 20} more")
@@ -1781,7 +1780,7 @@ def _render_types_cli_summary(
         for f in report.findings:
             rel = _try_relative(f.filepath, target_base)
             print_msg(
-                f"  [{f.severity.upper()}] {rel}:{f.lineno} — {f.message} (expected {f.expected_type}, got {f.actual_type})"
+                f"  [{f.severity.upper()}] {rel}:{f.lineno} - {f.message} (expected {f.expected_type}, got {f.actual_type})"
             )
 
     print_msg(f"\n  Total: {report.count} type finding(s) detected.")

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/complexity_analyzer.py

@@ -318,7 +318,7 @@ class _NestingDepthCounter(ast.NodeVisitor):
     def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
         self._function_depth += 1
         if self._function_depth == 1:
-            # Entry function being scored — walk its body normally.
+            # Entry function being scored - walk its body normally.
             self.generic_visit(node)
         # A nested def starts counting from its own zero depth in its own
         # report entry; it must not extend the enclosing function's depth.

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/dead_code_detector.py

@@ -346,6 +346,12 @@ class _ProjectScanState:
         self.exports.update(ref_collector.all_exports)
         self.decorated.update(ref_collector.decorated_names)
 
+        # In __init__.py files, all module-level non-private definitions represent public package exports
+        if py_file.name == "__init__.py":
+            for name, kind, lineno, end_lineno, ctx in def_collector.definitions:
+                if ctx == "<module>" and not name.startswith("_"):
+                    self.exports.add(name)
+
         unreachable = _UnreachableCodeDetector(filepath_str, content.splitlines())
         unreachable.visit(tree)
         self.unreachable.extend(unreachable.items)
@@ -532,7 +538,9 @@ class DeadCodeDetector:
     def _is_name_exempt(self, name: str) -> bool:
         if name in self.PROTECTED_NAMES:
             return True
-        exempt_prefixes = ("_", "test_", "Test", "visit_")
+        if name == "_" or (name.startswith("__") and name.endswith("__")):
+            return True
+        exempt_prefixes = ("test_", "Test", "visit_")
         return name.startswith(exempt_prefixes) or name == "generic_visit"
 
     def _should_skip(

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/dependency_auditor.py

@@ -59,7 +59,6 @@ class DependencyAuditor:
         "Bio": "biopython",
         "OpenGL": "PyOpenGL",
         "attr": "attrs",
-        "google": "protobuf",
         # High-frequency PyPI packages
         "nmap": "python-nmap",
         "dns": "dnspython",
@@ -77,6 +76,52 @@ class DependencyAuditor:
         "playwright": "playwright",
     }
 
+    def _find_venv_site_packages(self) -> Path | None:
+        """Locate site-packages directory inside project virtual environment."""
+        for venv_name in (".venv", "venv", "env"):
+            candidate = self.root_dir / venv_name
+            if not candidate.is_dir():
+                continue
+            win_site = candidate / "Lib" / "site-packages"
+            if win_site.is_dir():
+                return win_site
+            lib_dir = candidate / "lib"
+            if lib_dir.is_dir():
+                for py_dir in lib_dir.glob("python*"):
+                    site = py_dir / "site-packages"
+                    if site.is_dir():
+                        return site
+        return None
+
+    def _load_distributions(self) -> dict[str, list[str]]:
+        """Load distribution mappings from project virtual environment or host environment."""
+        dists: dict[str, list[str]] = {}
+        try:
+            dists.update(importlib.metadata.packages_distributions())
+        except AttributeError:
+            pass
+
+        site_packages = self._find_venv_site_packages()
+        if site_packages and site_packages.is_dir():
+            try:
+                for dist_info in site_packages.glob("*.dist-info"):
+                    dist_name = dist_info.name.split("-")[0]
+                    top_level_file = dist_info / "top_level.txt"
+                    if top_level_file.is_file():
+                        try:
+                            for top_mod in top_level_file.read_text(
+                                encoding="utf-8", errors="ignore"
+                            ).splitlines():
+                                top_mod = top_mod.strip()
+                                if top_mod:
+                                    dists.setdefault(top_mod, []).insert(0, dist_name)
+                        except OSError:
+                            pass
+            except OSError:
+                pass
+
+        return dists
+
     def __init__(
         self, root_dir: str | Path, exclude_patterns: Sequence[str] = ()
     ) -> None:
@@ -84,10 +129,7 @@ class DependencyAuditor:
         self.exclude_patterns = tuple(exclude_patterns)
         self.stdlib_names = set(sys.stdlib_module_names)
         self._last_optional_packages: set[str] = set()
-        try:
-            self.dist_map = importlib.metadata.packages_distributions()
-        except AttributeError:
-            self.dist_map = {}
+        self.dist_map = self._load_distributions()
 
     _KNOWN_DEV_TOOLS: ClassVar[frozenset[str]] = frozenset(
         {
@@ -127,12 +169,18 @@ class DependencyAuditor:
         for node in ast.walk(tree):
             if isinstance(node, ast.Import):
                 for alias in node.names:
-                    root_pkg = alias.name.split(".")[0]
-                    imports.add(root_pkg)
+                    parts = alias.name.split(".")
+                    if len(parts) >= 2 and parts[0] in ("google", "azure"):
+                        imports.add(f"{parts[0]}.{parts[1]}")
+                    else:
+                        imports.add(parts[0])
             elif isinstance(node, ast.ImportFrom):
                 if node.level == 0 and node.module:
-                    root_pkg = node.module.split(".")[0]
-                    imports.add(root_pkg)
+                    parts = node.module.split(".")
+                    if len(parts) >= 2 and parts[0] in ("google", "azure"):
+                        imports.add(f"{parts[0]}.{parts[1]}")
+                    else:
+                        imports.add(parts[0])
         return imports
 
     def scan_codebase_imports(
@@ -206,6 +254,13 @@ class DependencyAuditor:
 
     def module_to_distribution(self, module_name: str) -> str:
         """Map a Python import module name to its PyPI distribution package name."""
+        if module_name.startswith("google."):
+            sub = module_name.split(".")[1]
+            return f"google-{sub}"
+        if module_name.startswith("azure."):
+            sub = module_name.split(".")[1]
+            return f"azure-{sub}"
+
         if module_name in self._KNOWN_IMPORT_TO_DIST:
             return self._KNOWN_IMPORT_TO_DIST[module_name]
 

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/frameworks/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 import ast
 from pathlib import Path
-from typing import ClassVar, Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 
 @runtime_checkable

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/frameworks/plugins.py

@@ -361,4 +361,3 @@ class PyTorchPlugin:
         tree: ast.AST,
     ) -> bool:
         return name in self._PROTECTED_METHODS
-

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/import_resolver.py

@@ -82,7 +82,10 @@ class UndefinedSymbolFinder(ast.NodeVisitor):
     def _is_defined(self, name: str) -> bool:
         if name in self.builtin_names:
             return True
-        for scope in reversed(self.scopes):
+        in_function = any(kind == "function" for kind in self.scope_kinds)
+        for scope, kind in zip(reversed(self.scopes), reversed(self.scope_kinds)):
+            if in_function and kind == "class":
+                continue
             if name in scope:
                 return True
         return False
@@ -167,6 +170,13 @@ class UndefinedSymbolFinder(ast.NodeVisitor):
             finally:
                 self._in_annotation = False
 
+        # Defaults are evaluated in enclosing scope at definition time
+        for default in node.args.defaults:
+            self.visit(default)
+        for kw_default in node.args.kw_defaults:
+            if kw_default is not None:
+                self.visit(kw_default)
+
         self.scopes.append(set())
         self.scope_kinds.append("function")
 
@@ -180,22 +190,16 @@ class UndefinedSymbolFinder(ast.NodeVisitor):
 
     visit_AsyncFunctionDef = visit_FunctionDef
 
-    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
-        if node.value:
-            self.visit(node.value)
-        if isinstance(node.target, ast.Name):
-            self._current_scope().add(node.target.id)
-        else:
-            self.visit(node.target)
-        self._in_annotation = True
-        try:
-            self.visit(node.annotation)
-        finally:
-            self._in_annotation = False
-
     def visit_Lambda(self, node: ast.Lambda) -> None:
+        for default in node.args.defaults:
+            self.visit(default)
+        for kw_default in node.args.kw_defaults:
+            if kw_default is not None:
+                self.visit(kw_default)
+
         self.scopes.append(set())
         self.scope_kinds.append("function")
+
         all_args = node.args.posonlyargs + node.args.args + node.args.kwonlyargs
         for arg in all_args:
             self._current_scope().add(arg.arg)
@@ -205,9 +209,23 @@ class UndefinedSymbolFinder(ast.NodeVisitor):
             self._current_scope().add(node.args.kwarg.arg)
 
         self.visit(node.body)
+
         self.scopes.pop()
         self.scope_kinds.pop()
 
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+        if node.value:
+            self.visit(node.value)
+        if isinstance(node.target, ast.Name):
+            self._current_scope().add(node.target.id)
+        else:
+            self.visit(node.target)
+        self._in_annotation = True
+        try:
+            self.visit(node.annotation)
+        finally:
+            self._in_annotation = False
+
     def visit_NamedExpr(self, node: ast.NamedExpr) -> None:
         # PEP 572: an assignment expression's target binds in the nearest
         # enclosing scope that is a function or module scope, explicitly

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/linter_formatter.py

@@ -49,9 +49,10 @@ class _UsageCollector(ast.NodeVisitor):
 
     def visit_Constant(self, node: ast.Constant) -> None:
         if isinstance(node.value, str):
-            # Extract identifier words from string (e.g. forward references like 'Card' or __all__ = ['Card'])
-            for ident in re.findall(r"\b[a-zA-Z_]\w*\b", node.value):
-                self.used_names.add(ident)
+            val = node.value.strip()
+            # Only treat single valid Python identifiers as used names (e.g. forward references like 'Card' or __all__ = ['Card'])
+            if re.fullmatch(r"[a-zA-Z_]\w*", val):
+                self.used_names.add(val)
         self.generic_visit(node)
 
 
@@ -134,8 +135,8 @@ class LinterFormatter:
             proc = subprocess.run(
                 cmd, input=source.encode("utf-8"), capture_output=True, check=False
             )
-            output = proc.stdout.decode("utf-8")
-            stderr = proc.stderr.decode("utf-8").strip()
+            output = proc.stdout.decode("utf-8", errors="replace")
+            stderr = proc.stderr.decode("utf-8", errors="replace").strip()
             diag = [stderr] if stderr else []
             if proc.returncode in (0, 1) and output:
                 return output, output != source, diag
@@ -162,7 +163,7 @@ class LinterFormatter:
                 cmd, input=source.encode("utf-8"), capture_output=True, check=False
             )
             if proc.returncode == 0 and proc.stdout:
-                output = proc.stdout.decode("utf-8")
+                output = proc.stdout.decode("utf-8", errors="replace")
                 if output != source:
                     diagnostics.append("Pruned unused imports using autoflake fallback")
                     return output, True
@@ -182,7 +183,7 @@ class LinterFormatter:
                 check=False,
             )
             if proc.returncode == 0 and proc.stdout:
-                res = proc.stdout.decode("utf-8")
+                res = proc.stdout.decode("utf-8", errors="replace")
                 return res if res != code else None
         except OSError:
             # Fall back to isort Python module or pure-Python import sorter
@@ -264,7 +265,7 @@ class LinterFormatter:
                 cmd, input=source.encode("utf-8"), capture_output=True, check=False
             )
             if proc.returncode == 0:
-                res = proc.stdout.decode("utf-8")
+                res = proc.stdout.decode("utf-8", errors="replace")
                 return res, res != source
         except OSError:
             # Fall back to Black or pure-Python formatter if ruff CLI execution fails
@@ -281,7 +282,7 @@ class LinterFormatter:
                     check=False,
                 )
                 if proc.returncode == 0 and proc.stdout:
-                    res = proc.stdout.decode("utf-8")
+                    res = proc.stdout.decode("utf-8", errors="replace")
                     return res, res != source, ["Formatted with black CLI fallback"]
             except OSError:
                 # Fall back to black module or pure-Python formatter

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/modernizer.py

@@ -40,15 +40,18 @@ class _AnnotationTransformer(ast.NodeTransformer):
         "Type": "type",
     }
 
-    def __init__(self) -> None:
+    def __init__(self, typing_imports: set[str] | None = None) -> None:
         self.changed = False
         self.transformations: list[str] = []
+        self.typing_imports = typing_imports if typing_imports is not None else set()
 
     def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
         self.generic_visit(node)
         name: str | None = None
         if isinstance(node.value, ast.Name):
-            name = node.value.id
+            # Only rewrite bare names if they were imported from typing or if typing imports exist
+            if not self.typing_imports or node.value.id in self.typing_imports:
+                name = node.value.id
         elif (
             isinstance(node.value, ast.Attribute)
             and isinstance(node.value.value, ast.Name)
@@ -188,12 +191,60 @@ class Modernizer:
                 isinstance(node, ast.Compare)
                 and len(node.ops) == 1
                 and len(node.comparators) == 1
+                and node.end_lineno is not None
+                and node.end_col_offset is not None
             ):
                 op = node.ops[0]
                 comparator = node.comparators[0]
-                if isinstance(comparator, ast.Constant) and (
-                    comparator.value is None or isinstance(comparator.value, bool)
+                # Only modernize explicit None comparisons (never bool comparisons, which break vectorized/ORM masks)
+                if isinstance(comparator, ast.Constant) and comparator.value is None:
+                    if isinstance(op, ast.Eq):
+                        replacement_op = "is"
+                        transforms.append("Modernized '== None' to 'is None'")
+                    elif isinstance(op, ast.NotEq):
+                        replacement_op = "is not"
+                        transforms.append("Modernized '!= None' to 'is not None'")
+                    else:
+                        continue
+
+                    left_unparsed = ast.unparse(node.left)
+                    new_expr = f"{left_unparsed} {replacement_op} None"
+                    edits.append(
+                        (
+                            node.lineno,
+                            node.col_offset,
+                            node.end_lineno,
+                            node.end_col_offset,
+                            new_expr,
+                        )
+                    )
+                elif isinstance(node.left, ast.Constant) and node.left.value is None:
+                    if isinstance(op, ast.Eq):
+                        replacement_op = "is"
+                        transforms.append("Modernized 'None ==' to 'is None'")
+                    elif isinstance(op, ast.NotEq):
+                        replacement_op = "is not"
+                        transforms.append("Modernized 'None !=' to 'is not None'")
+                    else:
+                        continue
+
+                    comp_unparsed = ast.unparse(comparator)
+                    new_expr = f"{comp_unparsed} {replacement_op} None"
+                    edits.append(
+                        (
+                            node.lineno,
+                            node.col_offset,
+                            node.end_lineno,
+                            node.end_col_offset,
+                            new_expr,
+                        )
+                    )
+                elif (
+                    isinstance(comparator, ast.Constant)
+                    and isinstance(comparator.value, bool)
+                    and isinstance(node.left, ast.Name)
                 ):
+                    # Only modernize simple scalar identifier bool comparisons (never subscripts, attributes, or calls)
                     val = comparator.value
                     if isinstance(op, ast.Eq):
                         replacement_op = "is"
@@ -225,6 +276,12 @@ class Modernizer:
                 idx = lineno - 1
                 line = lines[idx]
                 lines[idx] = line[:col_offset] + new_text + line[end_col_offset:]
+            elif lineno < end_lineno:
+                start_idx = lineno - 1
+                end_idx = end_lineno - 1
+                prefix = lines[start_idx][:col_offset]
+                suffix = lines[end_idx][end_col_offset:]
+                lines[start_idx : end_idx + 1] = [prefix + new_text + suffix]
 
         return "".join(lines), transforms
 
@@ -267,14 +324,27 @@ class Modernizer:
 
         lines = source.splitlines(keepends=True)
         edits: list[tuple[int, int, int, int, str]] = []
-        transformer = _AnnotationTransformer()
+
+        typing_imports: set[str] = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom) and node.module == "typing":
+                for alias in node.names:
+                    if alias.name == "*":
+                        typing_imports.update(
+                            _AnnotationTransformer._PEP_585_MAP.keys()
+                        )
+                        typing_imports.update({"Optional", "Union"})
+                    else:
+                        typing_imports.add(alias.asname or alias.name)
+
+        transformer = _AnnotationTransformer(typing_imports=typing_imports)
 
         def process_annotation(node: ast.AST | None) -> None:
-            if node is None:
+            if not isinstance(node, ast.expr):
                 return
-            if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
+            if node.end_lineno is None or node.end_col_offset is None:
                 return
-            sub = _AnnotationTransformer()
+            sub = _AnnotationTransformer(typing_imports=typing_imports)
             new_node = sub.visit(node)
             if sub.changed:
                 transformer.changed = True
@@ -313,6 +383,12 @@ class Modernizer:
                 idx = lineno - 1
                 line = lines[idx]
                 lines[idx] = line[:col_offset] + new_text + line[end_col_offset:]
+            elif lineno < end_lineno:
+                start_idx = lineno - 1
+                end_idx = end_lineno - 1
+                prefix = lines[start_idx][:col_offset]
+                suffix = lines[end_idx][end_col_offset:]
+                lines[start_idx : end_idx + 1] = [prefix + new_text + suffix]
 
         res = "".join(lines)
 

{ballpython-2.0.5 → ballpython-2.0.7}/pycleaner/security_scanner.py

@@ -245,7 +245,9 @@ class _DangerousCallDetector(ast.NodeVisitor):
         return False
 
     def _add_finding(self, finding: SecurityFinding) -> None:
-        if not self._is_suppressed(finding.lineno, finding.category, finding.end_lineno):
+        if not self._is_suppressed(
+            finding.lineno, finding.category, finding.end_lineno
+        ):
             self.findings.append(finding)
 
     def visit_Call(self, node: ast.Call) -> None: