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

ballpython/__init__.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 import pycleaner
-from pycleaner import *
+from pycleaner import __all__ as __all__
+from pycleaner import __version__ as __version__
+
 
-__version__ = pycleaner.__version__
-__all__ = pycleaner.__all__
+def __getattr__(name: str) -> Any:
+    return getattr(pycleaner, name)

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

@@ -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.dist-info/RECORD

@@ -0,0 +1,34 @@
+ballpython/__init__.py,sha256=GSB-LHdou1Un6DS6Zmh8tv_zrwh6HQHO3Py2z8GO39o,304
+ballpython/__main__.py,sha256=aCRr0vnZfKYHDrPHBsYSjX5xTxtFJpTTSPVUSZTBK-I,136
+ballpython/cli.py,sha256=LllCLRAQQ-fRR_lIXwmd2e3Q7DLCIvf-5jHBXsAhJWs,125
+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/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/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/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/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/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,,

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",
 ]

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")
             }

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.")

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.

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(

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]
 

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

pycleaner/frameworks/plugins.py

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

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

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

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)
 

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:

pycleaner/syntax_healer.py

@@ -327,7 +327,7 @@ class SyntaxHealer:
         pointer_indent = " " * max(0, offset - 1)
 
         diagnostic_lines = [
-            f"❌ SyntaxError in {filename}:{lineno}:{offset}",
+            f"[!] SyntaxError in {filename}:{lineno}:{offset}",
             f"   --> {filename}:{lineno}:{offset}",
             "    |",
             f"{lineno:3d} | {error_line}",
@@ -525,6 +525,7 @@ class SyntaxHealer:
 
     def _fix_missing_colons(self, code: str) -> tuple[str, int]:
         """Detect compound statement headers without trailing colons and append them."""
+        tokens: list[tokenize.TokenInfo] | None
         try:
             tokens = list(tokenize.generate_tokens(io.StringIO(code).readline))
         except tokenize.TokenError:
@@ -561,8 +562,8 @@ class SyntaxHealer:
             return None
 
     @staticmethod
-    def _is_standalone_assignment(chars: Sequence[str], i: int, depth: int) -> bool:
-        if chars[i] != "=" or depth != 0:
+    def _is_standalone_assignment(chars: Sequence[str], i: int, in_call: bool) -> bool:
+        if chars[i] != "=" or in_call:
             return False
         prev_c = chars[i - 1] if i > 0 else ""
         next_c = chars[i + 1] if i + 1 < len(chars) else ""
@@ -581,7 +582,7 @@ class SyntaxHealer:
     @classmethod
     def _replace_condition_equals(cls, condition: str) -> tuple[str, int]:
         chars = list(condition)
-        depth = 0
+        call_bracket_stack: list[bool] = []
         in_s = False
         in_d = False
         escaped = False
@@ -596,12 +597,24 @@ class SyntaxHealer:
             elif in_s or in_d or c in ("'", '"'):
                 in_s, in_d = cls._update_quote_flag(c, in_s, in_d)
             elif c in "([{":
-                depth += 1
+                prev_non_ws = ""
+                for j in range(i - 1, -1, -1):
+                    if not chars[j].isspace():
+                        prev_non_ws = chars[j]
+                        break
+                is_call_or_subscript = bool(
+                    prev_non_ws
+                    and (prev_non_ws.isalnum() or prev_non_ws in ("_", ")", "]"))
+                )
+                call_bracket_stack.append(is_call_or_subscript)
             elif c in ")]}":
-                depth = max(0, depth - 1)
-            elif cls._is_standalone_assignment(chars, i, depth):
-                chars[i] = "=="
-                count += 1
+                if call_bracket_stack:
+                    call_bracket_stack.pop()
+            else:
+                in_call = any(call_bracket_stack)
+                if cls._is_standalone_assignment(chars, i, in_call):
+                    chars[i] = "=="
+                    count += 1
             i += 1
         return "".join(chars), count
 

pycleaner/taint_engine.py

@@ -323,8 +323,13 @@ class TaintEngine:
         if not spec:
             return
         for arg in child.args:
-            if isinstance(arg, ast.Name) and arg.id in param_names:
-                summary.param_to_sink[arg.id] = (
+            referenced_params = [
+                n.id
+                for n in ast.walk(arg)
+                if isinstance(n, ast.Name) and n.id in param_names
+            ]
+            for p in referenced_params:
+                summary.param_to_sink[p] = (
                     spec[0],
                     spec[1],
                     getattr(child, "lineno", default_lineno),
@@ -361,10 +366,16 @@ class TaintEngine:
         """Check if an expression immediately calls or accesses a known untrusted source."""
         if isinstance(node, ast.Call):
             call_name = self._resolve_call_name(node.func)
-            if call_name in self.KNOWN_SOURCES or any(
-                call_name.startswith(src) for src in self.KNOWN_SOURCES
+            if (
+                call_name in self.KNOWN_SOURCES
+                or any(call_name.startswith(src) for src in self.KNOWN_SOURCES)
+                or (
+                    isinstance(node.func, ast.Attribute)
+                    and node.func.attr in ("read", "readline", "readlines")
+                )
             ):
-                return call_name, getattr(node, "lineno", 0)
+                source_name = call_name or "file.read"
+                return source_name, getattr(node, "lineno", 0)
         elif isinstance(node, ast.Subscript):
             # e.g., sys.argv[1], request.args['q']
             val_name = self._resolve_call_name(node.value)

pycleaner/test_generator.py

@@ -54,7 +54,7 @@ class AstMutator(ast.NodeTransformer):
 
     def visit_Compare(self, node: ast.Compare) -> ast.AST:
         self.generic_visit(node)
-        new_ops = []
+        new_ops: list[ast.cmpop] = []
         for op in node.ops:
             if isinstance(op, ast.Lt):
                 new_ops.append(ast.GtE())

pycleaner/type_checker.py

@@ -24,40 +24,74 @@ from pycleaner.typeshed_resolver import TypeshedResolver
 class PyType:
     """Base algebraic type representation."""
 
-    def is_assignable_to(self, target: PyType) -> bool:
+    def is_assignable_to(
+        self,
+        target: PyType,
+        class_hierarchy: dict[str, list[str]] | None = None,
+    ) -> bool:
         """Check if this type can be assigned to target type."""
         if isinstance(target, AnyType) or isinstance(self, AnyType) or target == self:
             return True
+        if (
+            isinstance(self, CustomClassType)
+            and isinstance(target, CustomClassType)
+            and class_hierarchy
+            and self._is_subclass(self.name, target.name, class_hierarchy)
+        ):
+            return True
         if isinstance(target, UnionType):
-            return self._assignable_to_union(target)
+            return self._assignable_to_union(target, class_hierarchy)
         if isinstance(self, UnionType):
-            return self._union_assignable_to(target)
+            return self._union_assignable_to(target, class_hierarchy)
         if isinstance(target, CustomClassType) and self._check_custom_target(target):
             return True
         if isinstance(self, CustomClassType) and self._check_custom_source(target):
             return True
         return self._check_numeric_promotions(target)
 
-    def _assignable_to_union(self, target: PyType) -> bool:
+    @staticmethod
+    def _is_subclass(
+        child: str,
+        parent: str,
+        class_hierarchy: dict[str, list[str]],
+        visited: set[str] | None = None,
+    ) -> bool:
+        if child == parent:
+            return True
+        if visited is None:
+            visited = set()
+        if child in visited:
+            return False
+        visited.add(child)
+        for base in class_hierarchy.get(child, []):
+            if PyType._is_subclass(base, parent, class_hierarchy, visited):
+                return True
+        return False
+
+    def _assignable_to_union(
+        self, target: PyType, class_hierarchy: dict[str, list[str]] | None = None
+    ) -> bool:
         types = getattr(target, "types", [])
         for u in types:
-            if self.is_assignable_to(u):
+            if self.is_assignable_to(u, class_hierarchy):
                 return True
         return False
 
-    def _union_assignable_to(self, target: PyType) -> bool:
+    def _union_assignable_to(
+        self, target: PyType, class_hierarchy: dict[str, list[str]] | None = None
+    ) -> bool:
         types = getattr(self, "types", [])
         non_none = [u for u in types if not isinstance(u, NoneType)]
         if non_none:
             all_match = True
             for u in non_none:
-                if not u.is_assignable_to(target):
+                if not u.is_assignable_to(target, class_hierarchy):
                     all_match = False
                     break
             if all_match:
                 return True
         for u in types:
-            if not u.is_assignable_to(target):
+            if not u.is_assignable_to(target, class_hierarchy):
                 return False
         return True
 
@@ -183,10 +217,12 @@ class ListType(PyType):
     def __init__(self, item_type: PyType) -> None:
         self.item_type = item_type
 
-    def is_assignable_to(self, target: PyType) -> bool:
+    def is_assignable_to(
+        self, target: PyType, class_hierarchy: dict[str, list[str]] | None = None
+    ) -> bool:
         if _is_collection_assignable(self.item_type, target):
             return True
-        return super().is_assignable_to(target)
+        return super().is_assignable_to(target, class_hierarchy)
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, ListType) and self.item_type == other.item_type
@@ -199,10 +235,12 @@ class SetType(PyType):
     def __init__(self, item_type: PyType) -> None:
         self.item_type = item_type
 
-    def is_assignable_to(self, target: PyType) -> bool:
+    def is_assignable_to(
+        self, target: PyType, class_hierarchy: dict[str, list[str]] | None = None
+    ) -> bool:
         if _is_collection_assignable(self.item_type, target):
             return True
-        return super().is_assignable_to(target)
+        return super().is_assignable_to(target, class_hierarchy)
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, SetType) and self.item_type == other.item_type
@@ -216,20 +254,22 @@ class DictType(PyType):
         self.key_type = key_type
         self.value_type = value_type
 
-    def is_assignable_to(self, target: PyType) -> bool:
+    def is_assignable_to(
+        self, target: PyType, class_hierarchy: dict[str, list[str]] | None = None
+    ) -> bool:
         if isinstance(target, AnyType):
             return True
         if isinstance(target, DictType):
             return self.key_type.is_assignable_to(
-                target.key_type
-            ) and self.value_type.is_assignable_to(target.value_type)
+                target.key_type, class_hierarchy
+            ) and self.value_type.is_assignable_to(target.value_type, class_hierarchy)
         if isinstance(target, CustomClassType) and target.name in (
             "dict",
             "Dict",
             "Mapping",
         ):
             return True
-        return super().is_assignable_to(target)
+        return super().is_assignable_to(target, class_hierarchy)
 
     def __eq__(self, other: object) -> bool:
         return (
@@ -418,6 +458,7 @@ class _FileContext:
     local_functions: dict[str, tuple[dict[str, PyType], PyType]] = field(
         default_factory=dict
     )
+    class_hierarchy: dict[str, list[str]] = field(default_factory=dict)
 
 
 class TypeChecker:
@@ -440,6 +481,20 @@ class TypeChecker:
 
         return self.check_ast(tree, filepath=str(path), source=content)
 
+    @staticmethod
+    def _collect_class_hierarchy(tree: ast.Module) -> dict[str, list[str]]:
+        hierarchy: dict[str, list[str]] = {}
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                bases: list[str] = []
+                for b in node.bases:
+                    if isinstance(b, ast.Name):
+                        bases.append(b.id)
+                    elif isinstance(b, ast.Attribute):
+                        bases.append(b.attr)
+                hierarchy[node.name] = bases
+        return hierarchy
+
     @staticmethod
     def _collect_local_signatures(
         tree: ast.Module,
@@ -473,6 +528,7 @@ class TypeChecker:
             filepath=filepath,
             source_lines=source.splitlines() if source else [],
             local_functions=self._collect_local_signatures(tree),
+            class_hierarchy=self._collect_class_hierarchy(tree),
         )
 
         for node in ast.walk(tree):
@@ -548,14 +604,16 @@ class TypeChecker:
             return []
 
         findings: list[TypeFinding] = []
+        has_return = False
         for child in ast.walk(func):
             if not isinstance(child, ast.Return):
                 continue
             if self._is_nested_in_other_func(child, func):
                 continue
 
+            has_return = True
             actual_type = self._infer_expr_type(child.value, scope, ctx.local_functions)
-            if not actual_type.is_assignable_to(declared_return):
+            if not actual_type.is_assignable_to(declared_return, ctx.class_hierarchy):
                 snippet = (
                     ctx.source_lines[child.lineno - 1]
                     if 0 <= child.lineno - 1 < len(ctx.source_lines)
@@ -578,6 +636,43 @@ class TypeChecker:
                     )
                 )
 
+        # Check for missing return paths if declared return is non-None/non-Any
+        if (
+            has_return
+            and not isinstance(declared_return, (AnyType, NoneType))
+            and not (
+                isinstance(declared_return, UnionType)
+                and any(
+                    isinstance(t, NoneType)
+                    for t in getattr(declared_return, "types", [])
+                )
+            )
+        ):
+            last_stmt = func.body[-1] if func.body else None
+            ends_with_terminal = isinstance(last_stmt, (ast.Return, ast.Raise))
+            if not ends_with_terminal:
+                snippet = (
+                    ctx.source_lines[func.lineno - 1]
+                    if 0 <= func.lineno - 1 < len(ctx.source_lines)
+                    else ""
+                )
+                findings.append(
+                    TypeFinding(
+                        filepath=ctx.filepath,
+                        lineno=func.lineno,
+                        column=func.col_offset,
+                        symbol=func.name,
+                        expected_type=str(declared_return),
+                        actual_type="None",
+                        message=(
+                            f"Missing return path: function '{func.name}' declared to return "
+                            f"'{declared_return}' can fall through without returning a value"
+                        ),
+                        severity="ERROR",
+                        code_snippet=snippet.strip(),
+                    )
+                )
+
         return findings
 
     def _check_function(
@@ -613,7 +708,7 @@ class TypeChecker:
 
         actual_type = self._infer_expr_type(node.value, {}, ctx.local_functions)
         if isinstance(actual_type, AnyType) or actual_type.is_assignable_to(
-            declared_type
+            declared_type, ctx.class_hierarchy
         ):
             return []
 
@@ -768,7 +863,9 @@ class TypeChecker:
                 continue
 
             actual = self._infer_expr_type(arg_expr, scope, ctx.local_functions)
-            if isinstance(actual, AnyType) or actual.is_assignable_to(expected):
+            if isinstance(actual, AnyType) or actual.is_assignable_to(
+                expected, ctx.class_hierarchy
+            ):
                 continue
 
             findings.append(

pycleaner/verifier.py

@@ -17,7 +17,9 @@ import enum
 import inspect
 import multiprocessing as mp
 import random
+import sys
 import time
+from pathlib import Path
 from typing import Any
 
 
@@ -65,25 +67,39 @@ def _worker_differential_fuzz(
     callable_name: str,
     inputs: list[tuple[tuple[Any, ...], dict[str, Any]]],
     conn: Any,
+    filepath: str = "<sandbox>",
 ) -> None:
     """Child process worker: executes differential equivalence loop across all synthesized inputs."""
     try:
+        file_path_obj = (
+            Path(filepath).resolve() if filepath and filepath != "<sandbox>" else None
+        )
+        package_name = ""
+        if file_path_obj and file_path_obj.parent.is_dir():
+            parent_dir = file_path_obj.parent
+            if (parent_dir / "__init__.py").exists():
+                package_name = parent_dir.name
+            if str(parent_dir) not in sys.path:
+                sys.path.insert(0, str(parent_dir))
+            if str(parent_dir.parent) not in sys.path:
+                sys.path.insert(0, str(parent_dir.parent))
+
         orig_ns: dict[str, Any] = {
             "__name__": "__verifier__",
+            "__file__": str(file_path_obj) if file_path_obj else "<orig_sandbox>",
+            "__package__": package_name,
             "__builtins__": __builtins__,
         }
         trans_ns: dict[str, Any] = {
             "__name__": "__verifier__",
+            "__file__": str(file_path_obj) if file_path_obj else "<trans_sandbox>",
+            "__package__": package_name,
             "__builtins__": __builtins__,
         }
 
         try:
-            orig_code = compile(
-                orig_source, "<orig_sandbox>", "exec"
-            )  # nosec: B102 - intentionally isolated in worker process
-            exec(
-                orig_code, orig_ns
-            )  # nosec: B102 - intentionally isolated in worker process
+            orig_code = compile(orig_source, "<orig_sandbox>", "exec")  # nosec: B102 - intentionally isolated in worker process
+            exec(orig_code, orig_ns)  # nosec: B102 - intentionally isolated in worker process
         except BaseException as e:
             conn.send(
                 {
@@ -94,12 +110,8 @@ def _worker_differential_fuzz(
             return
 
         try:
-            trans_code = compile(
-                trans_source, "<trans_sandbox>", "exec"
-            )  # nosec: B102 - intentionally isolated in worker process
-            exec(
-                trans_code, trans_ns
-            )  # nosec: B102 - intentionally isolated in worker process
+            trans_code = compile(trans_source, "<trans_sandbox>", "exec")  # nosec: B102 - intentionally isolated in worker process
+            exec(trans_code, trans_ns)  # nosec: B102 - intentionally isolated in worker process
         except BaseException as e:
             conn.send(
                 {
@@ -109,8 +121,21 @@ def _worker_differential_fuzz(
             )
             return
 
-        orig_fn = orig_ns.get(callable_name)
-        trans_fn = trans_ns.get(callable_name)
+        def _resolve_callable(ns: dict[str, Any], target_name: str) -> Any:
+            if "." in target_name:
+                parts = target_name.split(".")
+                curr: Any = ns.get(parts[0])
+                for p in parts[1:]:
+                    if curr is None:
+                        return None
+                    curr = getattr(curr, p, None)
+                if isinstance(curr, (staticmethod, classmethod)):
+                    return curr.__func__
+                return curr
+            return ns.get(target_name)
+
+        orig_fn = _resolve_callable(orig_ns, callable_name)
+        trans_fn = _resolve_callable(trans_ns, callable_name)
 
         if not callable(orig_fn) or not callable(trans_fn):
             conn.send(
@@ -212,7 +237,7 @@ class DeterministicInputSynthesizer:
             )
         if annotation is str or annotation == "str":
             return self._rng.choice(
-                ["", "test", " ", "a" * 100, "\n\t", "null", "123", "utf8_🐍"]
+                ["", "test", " ", "a" * 100, "\n\t", "null", "123", "utf8_\U0001f40d"]
             )
         if annotation is bool or annotation == "bool":
             return self._rng.choice([True, False])
@@ -407,6 +432,7 @@ class IsolatedDifferentialVerifier:
                 target_callable,
                 inputs,
                 child_conn,
+                filepath,
             ),
         )
         process.daemon = True

ballpython-2.0.5.dist-info/RECORD

@@ -1,34 +0,0 @@
-ballpython/__init__.py,sha256=d8ONxgaz9jml_fHPVvg867Vt5jGRhGTqzWPtux3WJOc,206
-ballpython/__main__.py,sha256=aCRr0vnZfKYHDrPHBsYSjX5xTxtFJpTTSPVUSZTBK-I,136
-ballpython/cli.py,sha256=LllCLRAQQ-fRR_lIXwmd2e3Q7DLCIvf-5jHBXsAhJWs,125
-ballpython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycleaner/__init__.py,sha256=G8pQ2M9iH32OK4bKf5Koao554EdGiiHue5rdZ5AS7sM,2894
-pycleaner/__main__.py,sha256=8QBFrPyxId563F6cipPMNVEBTG8TIZUgxQfp8gk1VSI,135
-pycleaner/baseline.py,sha256=DS32C8_G8khYYNJo42FVv6Cc58lJj7NUmPOzWNfQwlU,3856
-pycleaner/cache.py,sha256=WhCiMkuL6ryWVr3l3XrYLLoI7A3bRF8jNxpOyedNW8M,10761
-pycleaner/cli.py,sha256=MMK0U57pam-FuvB1UL7jwVk7m9Z_Cosuwuu5FIfrPp0,73029
-pycleaner/complexity_analyzer.py,sha256=uGC40cHCcr1tshzfIUw56sodEDySMFR3kGmjo7nq_1c,14977
-pycleaner/config.py,sha256=XhloyaY_9pdwbQuc3QaAPCerLeXz-i1da4xT50h-pjY,8514
-pycleaner/dead_code_detector.py,sha256=1DwtBSZL1ug1OI9-6jcJyxkhqHmJ0F8ZR19POI2zO3c,26549
-pycleaner/dependency_auditor.py,sha256=yQhpN_nfJhEFaBPKVTzndpGas_U2OHyKP_Pifa5YrWA,16070
-pycleaner/discovery.py,sha256=dt3OmHg886hy_Z0p80ccMyDkITQxz4biaJY_zB3MU_g,6151
-pycleaner/explanations.py,sha256=2OOU_l3YL5o_Br_6fP6MF8HlY75-1JRmw3eTYT2lu8M,14219
-pycleaner/import_resolver.py,sha256=JnAysZeYtXlmmM0LEnb9HBdkHnEsNwwp4QlxebRxGNE,32189
-pycleaner/linter_formatter.py,sha256=LB5j66OCASU8WG8QgRFpSX7C2c7_UNMBgkJh2hSWxAY,20857
-pycleaner/modernizer.py,sha256=L9hxXXfdyTwf8itDO58y6bW5LobGo6dg8q537QdiYbM,12946
-pycleaner/pipeline.py,sha256=ZG7_9PNz0jBadFrZoiI7juLtUJXglGQhLgQhrLJqEac,20612
-pycleaner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycleaner/security_scanner.py,sha256=cWf4cAGQrgwsGslSQDfZv0XUN3sWvlcOIQaogpmv6C0,23422
-pycleaner/syntax_healer.py,sha256=TlIMKIJhaX9GED3e2JNzNMJ5aXmL9eLJMCu7xKSjdv8,26711
-pycleaner/taint_engine.py,sha256=96cZdDpSPbo5b13zIZY18f_4GJm_tw0clqCZMBtjXMQ,26481
-pycleaner/test_generator.py,sha256=TJsNJSojc6eIsaKZkwMlpnb-MKHuDpNLZCPnMlO-a8M,19663
-pycleaner/type_checker.py,sha256=h09QI_8MRHv83s23myjSYFdMTsWoQ900ffBJHtRuhmE,34087
-pycleaner/typeshed_resolver.py,sha256=N-kWU_CI5DG59lQMkt7wMW9sHYjNCBdfFS42b4y2Kr4,12742
-pycleaner/verifier.py,sha256=pOfSLRNHe4qDUYJG8mxDxjY6Ph8QKBdJZmqBtoJX87w,17937
-pycleaner/frameworks/__init__.py,sha256=-W24zqvug8eUkkwqla5oh7rFOqQR-WI4TohQhbXGYoo,3472
-pycleaner/frameworks/plugins.py,sha256=sMhP9mZ82sx10OI3opgXIEPXNAWFZRe2I__6yh2Uq_E,11453
-ballpython-2.0.5.dist-info/METADATA,sha256=LqjBIVBjanDL5rdXJ7gES5vF4ezSqbG2Y1SKMG6rXx4,3466
-ballpython-2.0.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ballpython-2.0.5.dist-info/entry_points.txt,sha256=6ux-5UxoVSmlK5p9M-GDVt24sCdwTQq9wgRDkpMIYU8,81
-ballpython-2.0.5.dist-info/top_level.txt,sha256=u6lmy8RWZ_saxCZAQTL7EijB4sunegOiVyk5fHjpwLk,21
-ballpython-2.0.5.dist-info/RECORD,,