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

pycleaner/syntax_healer.py

@@ -146,53 +146,95 @@ class SyntaxHealer:
         code = source
         repairs: list[str] = []
 
-        def apply_step(fn: Any, msg_fmt: str) -> bool:
+        def apply_step(fn: Any, msg_fmt: str) -> None:
             nonlocal code
-            new_code, count = fn(code)
-            if count > 0:
-                code = new_code
-                repairs.append(msg_fmt.format(count=count))
-                return self._check_syntax(code, filename) is None
-            return False
+            try:
+                prev_err = self._check_syntax(code, filename)
+                new_code, count = fn(code)
+                if count > 0 and new_code != code:
+                    new_err = self._check_syntax(new_code, filename)
+                    # If previously valid code was broken by this repair pass, roll back:
+                    if prev_err is None and new_err is not None:
+                        logging.getLogger(__name__).warning(
+                            "Healing step %s introduced a syntax error; rolling back",
+                            getattr(fn, "__name__", str(fn)),
+                        )
+                        return
+                    if prev_err is not None and new_err is not None:
+                        if "::" in new_code and "::" not in code:
+                            cleaned = re.sub(r"(?<!:)::(?!:)", ":", new_code)
+                            c_err = self._check_syntax(cleaned, filename)
+                            if c_err is None or c_err != new_err:
+                                new_code = cleaned
+                                new_err = c_err
+                        if prev_err is not None and new_err is not None:
+                            if new_err[1] < prev_err[1]:
+                                logging.getLogger(__name__).warning(
+                                    "Healing step %s broke earlier line %d (previous error was line %d); rolling back",
+                                    getattr(fn, "__name__", str(fn)),
+                                    new_err[1],
+                                    prev_err[1],
+                                )
+                                return
+                    code = new_code
+                    repairs.append(msg_fmt.format(count=count))
+            except Exception:
+                logging.getLogger(__name__).debug(
+                    "Suppressed exception in syntax healing step", exc_info=True
+                )
 
         if "\t" in code:
             code = code.expandtabs(4)
             repairs.append("Normalized tab characters to 4 spaces")
-            if self._check_syntax(code, filename) is None:
-                return code, repairs
 
         if self.fix_py2_syntax:
-            if apply_step(
+            apply_step(
                 self._fix_py2_except,
                 "Converted {count} legacy Python 2 except clause(s) to 'as'",
-            ):
-                return code, repairs
-            if apply_step(
+            )
+            apply_step(
                 self._fix_py2_print,
                 "Converted {count} legacy print statement(s) to print() calls",
-            ):
-                return code, repairs
+            )
 
-        if self.fix_conditional_assignments and apply_step(
-            self._fix_conditional_assignments,
-            "Replaced {count} accidental '=' assignment(s) with '==' in conditionals",
-        ):
-            return code, repairs
+        if self.fix_conditional_assignments:
+            apply_step(
+                self._fix_conditional_assignments,
+                "Replaced {count} accidental '=' assignment(s) with '==' in conditionals",
+            )
+
+        apply_step(
+            self._fix_double_colons,
+            "Normalized {count} duplicate colon(s) on compound statement header(s)",
+        )
 
-        if apply_step(
+        apply_step(
             self._fix_missing_colons,
             "Appended missing ':' to {count} compound statement header(s)",
-        ):
-            return code, repairs
+        )
 
-        if apply_step(
+        apply_step(
             self._fix_unindented_blocks,
             "Re-indented {count} under-indented block(s) following compound statement headers",
-        ):
-            return code, repairs
+        )
+
+        try:
+            prev_err = self._check_syntax(code, filename)
+            d_code, d_repairs = self._fix_unbalanced_delimiters(code, filename=filename)
+            if d_code != code:
+                d_err = self._check_syntax(d_code, filename)
+                if prev_err is None and d_err is not None:
+                    logging.getLogger(__name__).warning(
+                        "Delimiter healing broke valid syntax; rolling back"
+                    )
+                else:
+                    code = d_code
+                    repairs.extend(d_repairs)
+        except Exception:
+            logging.getLogger(__name__).debug(
+                "Suppressed exception closing delimiters", exc_info=True
+            )
 
-        code, d_repairs = self._fix_unbalanced_delimiters(code, filename=filename)
-        repairs.extend(d_repairs)
         return code, repairs
 
     def heal(self, source: str, filename: str = "<unknown>") -> SyntaxHealResult:
@@ -497,11 +539,16 @@ class SyntaxHealer:
         logical_tokens: list[tokenize.TokenInfo] = []
 
         def flush() -> None:
+            if not logical_tokens:
+                return
             header_idx = self._get_compound_header_idx(logical_tokens)
             if header_idx is None:
                 return
             if self._has_colon_at_depth_zero(logical_tokens, header_idx + 1):
                 return
+            # If the last token is already a colon, do not append another one
+            if logical_tokens[-1].string == ":":
+                return
             last = logical_tokens[-1]
             insertions.append((last.end[0] - 1, last.end[1]))
 
@@ -524,28 +571,146 @@ class SyntaxHealer:
         flush()
         return insertions
 
+    _DOUBLE_COLON_RE = re.compile(
+        r"^([ \t]*(?:async\s+)?(?:def\s+[a-zA-Z_]\w*|class\s+[a-zA-Z_]\w*|if\b|elif\b|else\b|for\b|while\b|try\b|except\b|finally\b|with\b)[^\n#]*?):{2,}(\s*(?:#.*)?)$"
+    )
+
+    def _fix_double_colons(self, code: str) -> tuple[str, int]:
+        """Normalize multiple consecutive colons on compound statement headers."""
+        if "::" not in code:
+            return code, 0
+        lines = code.splitlines(keepends=True)
+        count = 0
+        new_lines: list[str] = []
+        for line in lines:
+            m = self._DOUBLE_COLON_RE.match(line.rstrip("\r\n"))
+            if m:
+                header = m.group(1).rstrip()
+                suffix = m.group(2)
+                ending = (
+                    "\r\n"
+                    if line.endswith("\r\n")
+                    else ("\n" if line.endswith("\n") else "")
+                )
+                new_lines.append(f"{header}:{suffix}{ending}")
+                count += 1
+            else:
+                new_lines.append(line)
+        return "".join(new_lines), count
+
+    _COMPOUND_HEADER_FALLBACK = re.compile(
+        r"^([ \t]*(?:async\s+)?(?:def\s+[a-zA-Z_]\w*|class\s+[a-zA-Z_]\w*|if\b|elif\b|else\b|for\b|while\b|try\b|except\b|finally\b|with\b)[^\n#]*?)(?<!:)(\s*(?:#.*)?)$"
+    )
+
+    def _fix_missing_colons_fallback(self, code: str) -> tuple[str, int]:
+        """Line-by-line regex fallback to append missing colons to compound statements."""
+        lines = code.splitlines(keepends=True)
+        count = 0
+        new_lines: list[str] = []
+        for line in lines:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                new_lines.append(line)
+                continue
+
+            # If the non-comment portion of the line already ends with ':', skip it
+            clean_line = re.sub(r"#.*$", "", line.rstrip("\r\n")).rstrip()
+            if clean_line.endswith(":"):
+                new_lines.append(line)
+                continue
+
+            m = self._COMPOUND_HEADER_FALLBACK.match(line.rstrip("\r\n"))
+            if m:
+                header = m.group(1).rstrip()
+                # Before appending ':', check that the header does not already end with ':'
+                if header.endswith(":"):
+                    new_lines.append(line)
+                    continue
+
+                # If this line already has a colon at depth 0 (e.g. one-liner: if cond: return x, or else: return 0), skip it!
+                depth = 0
+                has_colon_at_depth_0 = False
+                in_quote = False
+                quote_char = ""
+                for char in header:
+                    if in_quote:
+                        if char == quote_char:
+                            in_quote = False
+                    elif char in ("'", '"'):
+                        in_quote = True
+                        quote_char = char
+                    elif char in "([{":
+                        depth += 1
+                    elif char in ")]}":
+                        depth = max(0, depth - 1)
+                    elif char == ":" and depth == 0:
+                        has_colon_at_depth_0 = True
+                        break
+
+                if has_colon_at_depth_0:
+                    new_lines.append(line)
+                    continue
+
+                # If brackets on this line are unbalanced (e.g. def foo(\n), skip appending colon to this line
+                open_cnt = sum(header.count(c) for c in "([{")
+                close_cnt = sum(header.count(c) for c in ")]}")
+                if open_cnt > close_cnt:
+                    new_lines.append(line)
+                    continue
+
+                suffix = m.group(2)
+                ending = (
+                    "\r\n"
+                    if line.endswith("\r\n")
+                    else ("\n" if line.endswith("\n") else "")
+                )
+                new_lines.append(f"{header}:{suffix}{ending}")
+                count += 1
+            else:
+                new_lines.append(line)
+        return "".join(new_lines), count
+
     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
+        tokens: list[tokenize.TokenInfo] | None = None
         try:
             tokens = list(tokenize.generate_tokens(io.StringIO(code).readline))
         except tokenize.TokenError:
             tokens = self._tokenize_with_recovered_delimiters(code)
-            if tokens is None:
-                return code, 0
-
-        insertions = self._find_missing_colon_insertions(tokens)
-        if not insertions:
-            return code, 0
-
-        lines = code.splitlines(keepends=True)
-        insertions.sort(key=lambda pos: (pos[0], pos[1]), reverse=True)
-        for line_idx, col in insertions:
-            if 0 <= line_idx < len(lines):
-                target = lines[line_idx]
-                lines[line_idx] = target[:col] + ":" + target[col:]
 
-        return "".join(lines), len(insertions)
+        cur_code = code
+        total_count = 0
+
+        if tokens is not None:
+            insertions = self._find_missing_colon_insertions(tokens)
+            if insertions:
+                lines = cur_code.splitlines(keepends=True)
+                insertions.sort(key=lambda pos: (pos[0], pos[1]), reverse=True)
+                applied_insertions = 0
+                for line_idx, col in insertions:
+                    if 0 <= line_idx < len(lines):
+                        target = lines[line_idx]
+                        before = target[:col].rstrip()
+                        after = target[col:].lstrip()
+                        if before.endswith(":") or after.startswith(":"):
+                            continue
+                        clean_line = re.sub(r"#.*$", "", target).rstrip()
+                        if clean_line.endswith(":"):
+                            continue
+                        lines[line_idx] = target[:col] + ":" + target[col:]
+                        applied_insertions += 1
+                cur_code = "".join(lines)
+                total_count += applied_insertions
+
+        # Also run fallback to catch any compound headers missed (e.g. disrupted by unclosed delimiters)
+        cur_code, fb_count = self._fix_missing_colons_fallback(cur_code)
+        total_count += fb_count
+
+        # Clean up any accidental double colons created on compound headers
+        if "::" in cur_code and "::" not in code:
+            cur_code = re.sub(r"(?<!:)::(?!:)", ":", cur_code)
+
+        return cur_code, total_count
 
     def _tokenize_with_recovered_delimiters(
         self, code: str

pycleaner/taint_engine.py

@@ -262,20 +262,8 @@ class TaintEngine:
     def __init__(self) -> None:
         self.function_summaries: dict[str, FunctionTaintSummary] = {}
 
-    def scan_path(
-        self, target: str | Path, exclude_patterns: Sequence[str] = ()
-    ) -> TaintReport:
-        """Scan a file or directory for dataflow taint vulnerabilities."""
-        path = Path(target)
-        if path.is_file():
-            files = [path] if path.suffix == ".py" else []
-        elif path.is_dir():
-            files = collect_project_python_files(
-                path, exclude_patterns=exclude_patterns
-            )
-        else:
-            return TaintReport()
-
+    def scan_files(self, files: Sequence[Path]) -> TaintReport:
+        """Scan a specific sequence of Python files for dataflow taint vulnerabilities."""
         report = TaintReport()
         parsed_files: list[tuple[Path, ast.Module]] = []
 
@@ -286,7 +274,7 @@ class TaintEngine:
                 tree = ast.parse(code, filename=str(fpath))
                 parsed_files.append((fpath, tree))
                 self._collect_function_summaries(str(fpath), tree)
-            except SyntaxError:
+            except (SyntaxError, OSError):
                 continue
 
         # Pass 2: Interprocedural and intraprocedural taint flow analysis
@@ -299,6 +287,22 @@ class TaintEngine:
 
         return report
 
+    def scan_path(
+        self, target: str | Path, exclude_patterns: Sequence[str] = ()
+    ) -> TaintReport:
+        """Scan a file or directory for dataflow taint vulnerabilities."""
+        path = Path(target)
+        if path.is_file():
+            files = [path] if path.suffix == ".py" else []
+        elif path.is_dir():
+            files = collect_project_python_files(
+                path, exclude_patterns=exclude_patterns
+            )
+        else:
+            return TaintReport()
+
+        return self.scan_files(files)
+
     def _inspect_return_child(
         self, child: ast.AST, summary: FunctionTaintSummary
     ) -> None:

pycleaner/type_checker.py

@@ -32,6 +32,8 @@ class PyType:
         """Check if this type can be assigned to target type."""
         if isinstance(target, AnyType) or isinstance(self, AnyType) or target == self:
             return True
+        if getattr(target, "name", None) == "object":
+            return True
         if (
             isinstance(self, CustomClassType)
             and isinstance(target, CustomClassType)
@@ -116,7 +118,8 @@ class PyType:
         )
 
     def _check_custom_source(self, target: PyType) -> bool:
-        if self.name in ("StrPath", "PathLike", "AnyStr"):  # type: ignore[attr-defined]
+        src_name = getattr(self, "name", "")
+        if src_name in ("StrPath", "PathLike", "AnyStr"):
             if isinstance(target, PrimitiveType) and target.name in ("str", "bytes"):
                 return True
             if isinstance(target, CustomClassType) and target.name in (
@@ -127,6 +130,31 @@ class PyType:
                 "bytes",
             ):
                 return True
+        if (
+            src_name.startswith("Supports")
+            or src_name.startswith("_")
+            or src_name in ("T", "Any")
+        ):
+            return True
+        if src_name in (
+            "zip",
+            "enumerate",
+            "range",
+            "generator",
+            "iter",
+            "map",
+            "filter",
+        ):
+            if isinstance(target, (ListType, SetType)):
+                return True
+            if isinstance(target, CustomClassType) and target.name in (
+                "list",
+                "List",
+                "Sequence",
+                "Iterable",
+                "Collection",
+            ):
+                return True
         return False
 
     def _check_numeric_promotions(self, target: PyType) -> bool:
@@ -556,25 +584,33 @@ class TypeChecker:
         except SyntaxError:
             return 0
 
-    def check_project(
-        self, root_dir: str | Path, exclude_patterns: Sequence[str] = ()
-    ) -> TypeReport:
-        """Type-check all Python files across an entire project directory."""
-        root = Path(root_dir).resolve()
+    def check_files(self, target_files: Sequence[Path]) -> TypeReport:
+        """Type-check a specific sequence of Python files without walking directories."""
         findings: list[TypeFinding] = []
         functions_checked = 0
-        py_files = self._discover_python_files(root, exclude_patterns=exclude_patterns)
-
-        for fpath in py_files:
-            findings.extend(self.check_file(fpath))
-            functions_checked += self._count_functions(fpath)
+        scanned_count = 0
+        for fpath in target_files:
+            try:
+                findings.extend(self.check_file(fpath))
+                functions_checked += self._count_functions(fpath)
+                scanned_count += 1
+            except OSError:
+                continue
 
         return TypeReport(
             findings=findings,
-            files_scanned=len(py_files),
+            files_scanned=scanned_count,
             functions_checked=functions_checked,
         )
 
+    def check_project(
+        self, root_dir: str | Path, exclude_patterns: Sequence[str] = ()
+    ) -> TypeReport:
+        """Type-check all Python files across an entire project directory."""
+        root = Path(root_dir).resolve()
+        py_files = self._discover_python_files(root, exclude_patterns=exclude_patterns)
+        return self.check_files(py_files)
+
     def _fallback_walk(self, root: Path):
         import os
 
@@ -593,6 +629,58 @@ class TypeChecker:
             )
         return scope
 
+    @staticmethod
+    def _is_terminal_statement(stmt: ast.stmt | None) -> bool:
+        """Check if an AST statement terminates all control flow paths (returns or raises)."""
+        if stmt is None:
+            return False
+        if isinstance(stmt, (ast.Return, ast.Raise)):
+            return True
+        if isinstance(stmt, (ast.With, ast.AsyncWith)):
+            return bool(stmt.body) and TypeChecker._is_terminal_statement(stmt.body[-1])
+        if isinstance(stmt, ast.Try):
+            if not (
+                bool(stmt.body) and TypeChecker._is_terminal_statement(stmt.body[-1])
+            ):
+                return False
+            for handler in stmt.handlers:
+                if not (
+                    bool(handler.body)
+                    and TypeChecker._is_terminal_statement(handler.body[-1])
+                ):
+                    return False
+            if stmt.orelse and not TypeChecker._is_terminal_statement(stmt.orelse[-1]):
+                return False
+            return True
+        if isinstance(stmt, ast.If):
+            if not (
+                bool(stmt.body) and TypeChecker._is_terminal_statement(stmt.body[-1])
+            ):
+                return False
+            if not (
+                bool(stmt.orelse)
+                and TypeChecker._is_terminal_statement(stmt.orelse[-1])
+            ):
+                return False
+            return True
+        if isinstance(stmt, ast.While):
+            if isinstance(stmt.test, ast.Constant) and bool(stmt.test.value):
+                has_return = any(
+                    isinstance(n, (ast.Return, ast.Raise)) for n in ast.walk(stmt)
+                )
+                has_break = any(isinstance(n, ast.Break) for n in ast.walk(stmt))
+                if has_return and not has_break:
+                    return True
+        if isinstance(stmt, getattr(ast, "Match", ())):
+            cases = getattr(stmt, "cases", [])
+            if not cases:
+                return False
+            return all(
+                bool(c.body) and TypeChecker._is_terminal_statement(c.body[-1])
+                for c in cases
+            )
+        return False
+
     def _check_return_paths(
         self,
         func: ast.FunctionDef | ast.AsyncFunctionDef,
@@ -649,7 +737,7 @@ class TypeChecker:
             )
         ):
             last_stmt = func.body[-1] if func.body else None
-            ends_with_terminal = isinstance(last_stmt, (ast.Return, ast.Raise))
+            ends_with_terminal = self._is_terminal_statement(last_stmt)
             if not ends_with_terminal:
                 snippet = (
                     ctx.source_lines[func.lineno - 1]
@@ -1009,18 +1097,21 @@ class TypeChecker:
                 return parse_type_annotation(cls_sig.methods[func.attr].return_type)
         return None
 
-    def _infer_typeshed_lookup(self, target: str, func_name: str) -> PyType:
+    def _infer_typeshed_lookup(
+        self, target: str, func_name: str, is_attribute: bool = False
+    ) -> PyType:
         if target:
             sig = self.typeshed.resolve_function(target)
             if sig and sig.return_type and sig.return_type != "Any":
                 return parse_type_annotation(sig.return_type)
 
-        builtin_ret = self.typeshed.get_builtin_return_type(func_name)
-        if builtin_ret:
-            return parse_type_annotation(builtin_ret)
+        if not is_attribute:
+            builtin_ret = self.typeshed.get_builtin_return_type(func_name)
+            if builtin_ret:
+                return parse_type_annotation(builtin_ret)
 
-        if func_name and self.typeshed.resolve_class("builtins", func_name):
-            return CustomClassType(func_name)
+            if func_name and self.typeshed.resolve_class("builtins", func_name):
+                return CustomClassType(func_name)
 
         return AnyType()
 
@@ -1031,21 +1122,33 @@ class TypeChecker:
         local_functions: dict[str, tuple[dict[str, PyType], PyType]],
     ) -> PyType:
         func_name, dotted_name = self._resolve_call_names(expr)
-        ctor = self._infer_constructor_call(
-            func_name, expr.args, scope, local_functions
-        )
-        if ctor is not None:
-            return ctor
+        if not isinstance(expr.func, ast.Attribute):
+            ctor = self._infer_constructor_call(
+                func_name, expr.args, scope, local_functions
+            )
+            if ctor is not None:
+                return ctor
 
         if isinstance(expr.func, ast.Attribute):
             meth = self._infer_attribute_method(expr.func, scope, local_functions)
             if meth is not None:
                 return meth
+            if isinstance(expr.func.value, ast.Name) and expr.func.value.id in (
+                "self",
+                "cls",
+            ):
+                if func_name in local_functions:
+                    return local_functions[func_name][1]
+            return self._infer_typeshed_lookup(
+                dotted_name, func_name, is_attribute=True
+            )
 
         if func_name in local_functions:
             return local_functions[func_name][1]
 
-        return self._infer_typeshed_lookup(dotted_name or func_name, func_name)
+        return self._infer_typeshed_lookup(
+            dotted_name or func_name, func_name, is_attribute=False
+        )
 
     def _infer_expr_type(
         self,

pycleaner/verifier.py

@@ -99,8 +99,12 @@ def _worker_differential_fuzz(
         }
 
         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(
                 {
@@ -111,8 +115,12 @@ 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(
                 {

ballpython-2.1.0.dist-info/RECORD

@@ -1,34 +0,0 @@
-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=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=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=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=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=QlBwnsrhWWRK3LzvJjpNix474drCNp6LP7FiUgJxMsg,19333
-pycleaner/frameworks/__init__.py,sha256=SOuSRl39af86eoQx7Qm8rTJGD4jsnEvgyhhQ6cVmRVA,3462
-pycleaner/frameworks/plugins.py,sha256=qunMzS3q7xp1GEGxqkuhrnm-raiSRhYQMzmDxsEhSUg,11452
-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,,