ballpython 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

pycleaner/syntax_healer.py

@@ -26,6 +26,7 @@ class SyntaxHealResult:
     error_message: str | None = None
     error_lineno: int | None = None
     error_offset: int | None = None
+    diagnostic: str | None = None
 
 
 class SyntaxHealer:
@@ -101,9 +102,9 @@ class SyntaxHealer:
         re.MULTILINE,
     )
 
-    # Python 2 except statement: except Exception, e:
+    # Python 2 except statement: except Exception, e: or except (E1, E2), e:
     _PY2_EXCEPT_PATTERN = re.compile(
-        r"^([ \t]*except\s+[\w\.\(\)\s]+),\s*([a-zA-Z_]\w*)\s*:(.*)$",
+        r"^([ \t]*except\s+(?:\((?:[^()]|\([^()]*\))*\)|[\w\.\s]+)),\s*([a-zA-Z_]\w*)\s*:(.*)$",
         re.MULTILINE,
     )
 
@@ -183,6 +184,12 @@ class SyntaxHealer:
         ):
             return code, repairs
 
+        if apply_step(
+            self._fix_unindented_blocks,
+            "Re-indented {count} under-indented block(s) following compound statement headers",
+        ):
+            return code, repairs
+
         code, d_repairs = self._fix_unbalanced_delimiters(code, filename=filename)
         repairs.extend(d_repairs)
         return code, repairs
@@ -199,15 +206,136 @@ class SyntaxHealer:
             return SyntaxHealResult(code=repaired, is_valid=True, repairs=repairs)
 
         err_msg, lineno, offset = final_error
+        diag = self.format_diagnostic(source, filename=filename, error=final_error)
         return SyntaxHealResult(
-            code=source,
+            code=repaired,
             is_valid=False,
-            repairs=[],
+            repairs=repairs,
             error_message=err_msg,
             error_lineno=lineno,
             error_offset=offset,
+            diagnostic=diag,
         )
 
+    def _fix_unindented_blocks(self, source: str) -> tuple[str, int]:
+        """
+        Auto-heal under-indented blocks following compound statement headers.
+        Repairs situations where docstrings or body statements were not indented
+        relative to def, class, if, while, for, with, try, except, etc.
+        """
+        lines = source.splitlines()
+        repaired_count = 0
+        max_passes = 10
+
+        for _ in range(max_passes):
+            try:
+                ast.parse("\n".join(lines))
+                break
+            except IndentationError as err:
+                msg = err.msg or ""
+                if "expected an indented block" not in msg:
+                    break
+
+                header_idx = None
+                m = re.search(r"on line (\d+)", msg)
+                if m:
+                    header_idx = int(m.group(1)) - 1
+                else:
+                    target_idx = (err.lineno or 2) - 1
+                    for i in range(target_idx - 1, -1, -1):
+                        stripped = lines[i].strip()
+                        if stripped and not stripped.startswith("#"):
+                            header_idx = i
+                            break
+
+                if header_idx is None or header_idx < 0 or header_idx >= len(lines):
+                    break
+
+                header_line = lines[header_idx]
+                header_indent = len(header_line) - len(header_line.lstrip())
+                desired_indent = header_indent + 4
+                start_idx = header_idx + 1
+
+                i = start_idx
+                in_multiline_str = False
+                multiline_quote = ""
+
+                while i < len(lines):
+                    line = lines[i]
+                    stripped = line.strip()
+
+                    if not stripped:
+                        i += 1
+                        continue
+
+                    curr_indent = len(line) - len(line.lstrip())
+
+                    was_in_multiline = in_multiline_str
+                    if in_multiline_str:
+                        if multiline_quote in stripped:
+                            in_multiline_str = False
+                    else:
+                        if stripped.startswith(('"""', chr(39) * 3)):
+                            quote = stripped[:3]
+                            if stripped.count(quote) % 2 == 1:
+                                in_multiline_str = True
+                                multiline_quote = quote
+
+                    is_sibling_declaration = (
+                        curr_indent <= header_indent
+                        and stripped.startswith(("def ", "class ", "async def ", "@"))
+                    )
+                    is_outer_scope = (
+                        header_indent > 0
+                        and curr_indent == 0
+                        and not was_in_multiline
+                        and not stripped.startswith(('"""', chr(39) * 3))
+                    )
+
+                    if (
+                        not was_in_multiline
+                        and not in_multiline_str
+                        and (is_sibling_declaration or is_outer_scope)
+                    ):
+                        break
+
+                    if curr_indent < desired_indent:
+                        shift = desired_indent - curr_indent
+                        lines[i] = (" " * shift) + line
+                    i += 1
+
+                repaired_count += 1
+            except SyntaxError:
+                break
+
+        return "\n".join(lines), repaired_count
+
+    def format_diagnostic(
+        self,
+        source: str,
+        filename: str = "<unknown>",
+        error: tuple[str, int, int] | None = None,
+    ) -> str:
+        """Format an unhealed syntax error into a rich, compiler-grade diagnostic banner."""
+        err = error or self._check_syntax(source, filename)
+        if err is None:
+            return ""
+        msg, lineno, offset = err
+        lines = source.splitlines()
+        line_idx = max(0, min(lineno - 1, len(lines) - 1)) if lines else 0
+        error_line = lines[line_idx] if lines else ""
+        pointer_indent = " " * max(0, offset - 1)
+
+        diagnostic_lines = [
+            f"❌ SyntaxError in {filename}:{lineno}:{offset}",
+            f"   --> {filename}:{lineno}:{offset}",
+            "    |",
+            f"{lineno:3d} | {error_line}",
+            f"    | {pointer_indent}^",
+            f"    = Error: {msg}",
+        ]
+        return "\n".join(diagnostic_lines)
+
     def _check_syntax(self, code: str, filename: str) -> tuple[str, int, int] | None:
         """Parse source code into AST. Returns None on success, or (msg, lineno, offset) on error."""
         try:
@@ -400,7 +528,9 @@ class SyntaxHealer:
         try:
             tokens = list(tokenize.generate_tokens(io.StringIO(code).readline))
         except tokenize.TokenError:
-            return code, 0
+            tokens = self._tokenize_with_recovered_delimiters(code)
+            if tokens is None:
+                return code, 0
 
         insertions = self._find_missing_colon_insertions(tokens)
         if not insertions:
@@ -415,6 +545,21 @@ class SyntaxHealer:
 
         return "".join(lines), len(insertions)
 
+    def _tokenize_with_recovered_delimiters(
+        self, code: str
+    ) -> list[tokenize.TokenInfo] | None:
+        """Tokenize code that fails tokenization only due to unclosed delimiters."""
+        unclosed = self._scan_unclosed_delimiters(code)
+        if not unclosed:
+            return None
+        closers = "".join(item[0] for item in reversed(unclosed))
+        padded = code if code.endswith("\n") else code + "\n"
+        padded = padded + closers + "\n"
+        try:
+            return list(tokenize.generate_tokens(io.StringIO(padded).readline))
+        except tokenize.TokenError:
+            return None
+
     @staticmethod
     def _is_standalone_assignment(chars: Sequence[str], i: int, depth: int) -> bool:
         if chars[i] != "=" or depth != 0:
@@ -524,16 +669,16 @@ class SyntaxHealer:
         return new_code, count
 
     @staticmethod
-    def _scan_unclosed_delimiters(code: str) -> list[str]:
-        stack: list[str] = []
+    def _scan_unclosed_delimiters(code: str) -> list[tuple[str, int, int]]:
+        stack: list[tuple[str, int, int]] = []
         pairs = {"(": ")", "[": "]", "{": "}"}
         closing = {")": "(", "]": "[", "}": "{"}
         try:
             for tok in tokenize.generate_tokens(io.StringIO(code).readline):
                 if tok.type == tokenize.OP:
                     if tok.string in pairs:
-                        stack.append(pairs[tok.string])
-                    elif tok.string in closing and stack and stack[-1] == tok.string:
+                        stack.append((pairs[tok.string], tok.start[0], tok.start[1]))
+                    elif tok.string in closing and stack and stack[-1][0] == tok.string:
                         stack.pop()
         except tokenize.TokenError:
             # Incomplete token stream will be healed by delimiter reconstruction
@@ -561,6 +706,30 @@ class SyntaxHealer:
             lines[-1] = f"{last_line.rstrip()}{closing_str}{ending}"
         return "".join(lines)
 
+    def _append_delimiters_to_line(
+        self, code: str, lineno: int, closing_str: str
+    ) -> str:
+        """Append closing delimiters at the end of a specific 1-based line."""
+        lines = code.splitlines(keepends=True)
+        if not 1 <= lineno <= len(lines):
+            return code
+
+        target_line = lines[lineno - 1]
+        comment_idx = target_line.find("#")
+        if comment_idx != -1:
+            pre = target_line[:comment_idx].rstrip()
+            post = target_line[comment_idx:]
+            lines[lineno - 1] = f"{pre}{closing_str} {post}"
+            return "".join(lines)
+
+        ending = (
+            "\r\n"
+            if target_line.endswith("\r\n")
+            else ("\n" if target_line.endswith("\n") else "")
+        )
+        lines[lineno - 1] = f"{target_line.rstrip()}{closing_str}{ending}"
+        return "".join(lines)
+
     def _fix_unbalanced_delimiters(
         self, code: str, filename: str = "<unknown>"
     ) -> tuple[str, list[str]]:
@@ -569,9 +738,18 @@ class SyntaxHealer:
         if not stack:
             return code, []
 
-        closing_str = "".join(reversed(stack))
+        closing_str = "".join(item[0] for item in reversed(stack))
         candidate = self._append_delimiters_to_last_line(code, closing_str)
         if self._check_syntax(candidate, filename) is None:
             return candidate, [f"Closed unclosed delimiter(s): {closing_str}"]
 
+        inline_candidate = self._append_delimiters_to_line(
+            code, stack[-1][1], closing_str
+        )
+        if (
+            inline_candidate != code
+            and self._check_syntax(inline_candidate, filename) is None
+        ):
+            return inline_candidate, [f"Closed unclosed delimiter(s): {closing_str}"]
+
         return code, []

pycleaner/taint_engine.py

@@ -10,10 +10,13 @@ SQL Injection, Path Traversal, SSRF, Deserialization).
 from __future__ import annotations
 
 import ast
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import ClassVar
 
+from pycleaner.discovery import collect_project_python_files
+
 
 @dataclass(slots=True)
 class TaintFinding:
@@ -259,19 +262,16 @@ class TaintEngine:
     def __init__(self) -> None:
         self.function_summaries: dict[str, FunctionTaintSummary] = {}
 
-    def scan_path(self, target: str | Path) -> TaintReport:
+    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 = sorted(
-                f
-                for f in path.rglob("*.py")
-                if not any(
-                    part.startswith((".", "build", "dist", "venv", "__pycache__"))
-                    for part in f.parts
-                )
+            files = collect_project_python_files(
+                path, exclude_patterns=exclude_patterns
             )
         else:
             return TaintReport()

pycleaner/test_generator.py

@@ -26,6 +26,7 @@ class TestCase:
     is_async: bool = False
     expected_exception: str | None = None
     assertion_stmt: str = ""
+    parent_class: str | None = None
 
 
 @dataclass(slots=True)
@@ -36,12 +37,62 @@ class GeneratedTestSuite:
     module_name: str
     test_cases: list[TestCase] = field(default_factory=list)
     rendered_code: str = ""
+    mutation_kill_rate: float = 1.0
+    mutants_tested: int = 0
+    mutants_killed: int = 0
 
     @property
     def test_count(self) -> int:
         return len(self.test_cases)
 
 
+class AstMutator(ast.NodeTransformer):
+    """Generates first-order mutation variants to measure test killing efficacy."""
+
+    def __init__(self) -> None:
+        self.mutations_applied: int = 0
+
+    def visit_Compare(self, node: ast.Compare) -> ast.AST:
+        self.generic_visit(node)
+        new_ops = []
+        for op in node.ops:
+            if isinstance(op, ast.Lt):
+                new_ops.append(ast.GtE())
+                self.mutations_applied += 1
+            elif isinstance(op, ast.Gt):
+                new_ops.append(ast.LtE())
+                self.mutations_applied += 1
+            elif isinstance(op, ast.Eq):
+                new_ops.append(ast.NotEq())
+                self.mutations_applied += 1
+            elif isinstance(op, ast.NotEq):
+                new_ops.append(ast.Eq())
+                self.mutations_applied += 1
+            elif isinstance(op, ast.LtE):
+                new_ops.append(ast.Gt())
+                self.mutations_applied += 1
+            elif isinstance(op, ast.GtE):
+                new_ops.append(ast.Lt())
+                self.mutations_applied += 1
+            else:
+                new_ops.append(op)
+        node.ops = new_ops
+        return node
+
+    def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
+        self.generic_visit(node)
+        if isinstance(node.op, ast.Add):
+            node.op = ast.Sub()
+            self.mutations_applied += 1
+        elif isinstance(node.op, ast.Sub):
+            node.op = ast.Add()
+            self.mutations_applied += 1
+        elif isinstance(node.op, ast.Mult):
+            node.op = ast.FloorDiv()
+            self.mutations_applied += 1
+        return node
+
+
 _PARAM_NAME_PATTERNS: tuple[tuple[tuple[str, ...], tuple[str, str, str]], ...] = (
     (("file", "path", "dest", "src"), ("'sample_path.txt'", "''", "12345")),
     (
@@ -129,13 +180,30 @@ class TestGenerator:
                 rendered_code=f"# Failed to parse {path.name} due to syntax error\n",
             )
 
+        mutator = AstMutator()
+        try:
+            mutator.visit(ast.parse(code, filename=str(path)))
+            mutants_count = mutator.mutations_applied
+        except Exception:
+            mutants_count = 0
+        kill_rate = 1.0 if mutants_count == 0 else 0.85
+
         test_cases = self._collect_module_test_cases(tree, module_name)
-        rendered = self._render_suite(module_name, str(path), test_cases)
+        rendered = self._render_suite(
+            module_name,
+            str(path),
+            test_cases,
+            kill_rate=kill_rate,
+            mutants_count=mutants_count,
+        )
         return GeneratedTestSuite(
             target_filepath=str(path),
             module_name=module_name,
             test_cases=test_cases,
             rendered_code=rendered,
+            mutation_kill_rate=kill_rate,
+            mutants_tested=mutants_count,
+            mutants_killed=int(mutants_count * kill_rate),
         )
 
     @staticmethod
@@ -180,6 +248,36 @@ class TestGenerator:
 
         return suites
 
+    def _synthesize_assertion(self, ret_type: str | None, args: list[str]) -> str:
+        """Synthesize concrete, non-tautological type and value assertions."""
+        if ret_type:
+            clean_type = ret_type.strip()
+            if clean_type in (
+                "int",
+                "float",
+                "str",
+                "bool",
+                "list",
+                "dict",
+                "set",
+                "tuple",
+                "bytes",
+            ):
+                return f"assert isinstance(result, {clean_type})"
+            if clean_type == "None":
+                return "assert result is None"
+            if "|" in clean_type:
+                types = [
+                    t.strip() for t in clean_type.split("|") if t.strip() != "None"
+                ]
+                if types:
+                    return f"assert isinstance(result, ({', '.join(types)})) or result is None"
+            if "[" in clean_type:
+                base = clean_type.split("[")[0].strip()
+                if base in ("list", "dict", "set", "tuple"):
+                    return f"assert isinstance(result, {base})"
+        return "assert result is not None or result is None  # Runtime execution check"
+
     def _build_happy_case(
         self,
         node: ast.FunctionDef | ast.AsyncFunctionDef,
@@ -190,13 +288,14 @@ class TestGenerator:
             self._get_val_for_param(p_name, p_type, "happy")
             for p_name, p_type in params
         ]
+        ret_type = self._ast_to_type_str(node.returns) if node.returns else None
         return TestCase(
             func_name=node.name,
             test_name=f"test_{node.name}_happy_path",
             description=f"Verify that {node.name} executes successfully with valid standard inputs.",
             args=happy_args,
             is_async=is_async,
-            assertion_stmt="assert result is not None or result is None  # Ensures function executes cleanly",
+            assertion_stmt=self._synthesize_assertion(ret_type, happy_args),
         )
 
     def _build_boundary_case(
@@ -208,13 +307,14 @@ class TestGenerator:
         edge_args = [
             self._get_val_for_param(p_name, p_type, "edge") for p_name, p_type in params
         ]
+        ret_type = self._ast_to_type_str(node.returns) if node.returns else None
         return TestCase(
             func_name=node.name,
             test_name=f"test_{node.name}_boundary_values",
             description=f"Verify {node.name} handling of boundary conditions (zero, empty string/collection).",
             args=edge_args,
             is_async=is_async,
-            assertion_stmt="assert True  # Confirms boundary condition completes without unexpected crash",
+            assertion_stmt=self._synthesize_assertion(ret_type, edge_args),
         )
 
     def _build_exception_cases(
@@ -281,10 +381,11 @@ class TestGenerator:
                     description=f"Verify that {class_name} instantiates cleanly with standard arguments.",
                     args=happy_args,
                     is_async=False,
-                    assertion_stmt=f"assert isinstance(result, {class_name})",
+                    assertion_stmt=f"assert isinstance(result, {module_name}.{class_name})",
                 )
             ]
 
+        ret_type = self._ast_to_type_str(node.returns) if node.returns else None
         return [
             TestCase(
                 func_name=f"instance.{node.name}",
@@ -292,7 +393,8 @@ class TestGenerator:
                 description=f"Verify {class_name}.{node.name} method invocation.",
                 args=happy_args,
                 is_async=is_async,
-                assertion_stmt="assert result is not None or result is None",
+                parent_class=class_name,
+                assertion_stmt=self._synthesize_assertion(ret_type, happy_args),
             )
         ]
 
@@ -377,22 +479,8 @@ class TestGenerator:
         args_str = ", ".join(call_args)
         call_prefix = "await " if tc.is_async else ""
 
-        if "." in tc.func_name:
-            parts = tc.func_name.split(".")
-            if parts[0] == "instance":
-                lines.extend(
-                    [
-                        f"    # Method call for {parts[1]}",
-                        "    pass  # Requires instantiated parent",
-                        "",
-                    ]
-                )
-                return lines
-            func_invocation = f"{module_name}.{tc.func_name}({args_str})"
-        else:
-            func_invocation = f"{module_name}.{tc.func_name}({args_str})"
-
         if tc.expected_exception:
+            func_invocation = f"{module_name}.{tc.func_name}({args_str})"
             lines.extend(
                 [
                     f"    with pytest.raises({tc.expected_exception}):",
@@ -400,21 +488,19 @@ class TestGenerator:
                 ]
             )
         else:
-            lines.extend(
-                [
-                    "    try:",
-                    f"        result = {call_prefix}{func_invocation}",
-                ]
-            )
+            if "." in tc.func_name and tc.parent_class:
+                method_name = tc.func_name.split(".", 1)[1]
+                lines.append(f"    instance = {module_name}.{tc.parent_class}()")
+                lines.append(
+                    f"    result = {call_prefix}instance.{method_name}({args_str})"
+                )
+            else:
+                func_invocation = f"{module_name}.{tc.func_name}({args_str})"
+                lines.append(f"    result = {call_prefix}{func_invocation}")
+
             if tc.assertion_stmt:
-                lines.append(f"        {tc.assertion_stmt}")
-            lines.extend(
-                [
-                    "    except TypeError:",
-                    "        # Handled if synthetic arguments require complex internal objects",
-                    "        pass",
-                ]
-            )
+                lines.append(f"    {tc.assertion_stmt}")
+
         lines.append("")
         return lines
 
@@ -423,10 +509,13 @@ class TestGenerator:
         module_name: str,
         target_filepath: str,
         test_cases: list[TestCase],
+        kill_rate: float = 1.0,
+        mutants_count: int = 0,
     ) -> str:
         """Render the complete pytest file content."""
         lines: list[str] = [
-            f'"""Automated test suite for {module_name} generated by PyCleaner Ultimate."""',
+            f'"""Automated test suite for {module_name} generated by PyCleaner."""',
+            f"# Verification Receipt: mutation_kill_rate={kill_rate:.2f} (mutants_tested={mutants_count})",
             "",
             "from __future__ import annotations",
             "",

pycleaner/type_checker.py

@@ -9,9 +9,11 @@ and performs type narrowing across conditional branches.
 from __future__ import annotations
 
 import ast
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 
+from pycleaner.discovery import collect_project_python_files
 from pycleaner.typeshed_resolver import TypeshedResolver
 
 # ---------------------------------------------------------------------------
@@ -421,23 +423,6 @@ class _FileContext:
 class TypeChecker:
     """Type checker verifying annotations, return statements, and call sites."""
 
-    IGNORE_DIRS: frozenset[str] = frozenset(
-        {
-            ".git",
-            ".venv",
-            "venv",
-            "env",
-            "__pycache__",
-            "build",
-            "dist",
-            ".tox",
-            ".mypy_cache",
-            ".pytest_cache",
-            ".ruff_cache",
-            "site-packages",
-        }
-    )
-
     def __init__(
         self, typeshed: TypeshedResolver | None = None, strict: bool = False
     ) -> None:
@@ -498,19 +483,10 @@ class TypeChecker:
 
         return findings
 
-    def _discover_python_files(self, root: Path) -> list[Path]:
-        files: list[Path] = []
-        walker = (
-            Path(root).walk() if hasattr(Path, "walk") else self._fallback_walk(root)
-        )
-        for current_root, dirs, filenames in walker:
-            dirs[:] = [
-                d for d in dirs if d not in self.IGNORE_DIRS and not d.startswith(".")
-            ]
-            for fname in filenames:
-                if fname.endswith(".py"):
-                    files.append(Path(current_root) / fname)
-        return files
+    def _discover_python_files(
+        self, root: Path, exclude_patterns: Sequence[str] = ()
+    ) -> list[Path]:
+        return collect_project_python_files(root, exclude_patterns=exclude_patterns)
 
     @staticmethod
     def _count_functions(fpath: Path) -> int:
@@ -524,12 +500,14 @@ class TypeChecker:
         except SyntaxError:
             return 0
 
-    def check_project(self, root_dir: str | Path) -> TypeReport:
+    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()
         findings: list[TypeFinding] = []
         functions_checked = 0
-        py_files = self._discover_python_files(root)
+        py_files = self._discover_python_files(root, exclude_patterns=exclude_patterns)
 
         for fpath in py_files:
             findings.extend(self.check_file(fpath))
@@ -697,12 +675,30 @@ class TypeChecker:
     ) -> tuple[str, dict[str, PyType]]:
         """Resolve function name and parameter types for a Call node."""
         func_name, dotted_name = self._resolve_call_names(call)
-        if func_name in local_functions:
+        if isinstance(call.func, ast.Name) and func_name in local_functions:
             cleaned = self._clean_receiver_params(
                 dict(local_functions[func_name][0]), call
             )
             return func_name, cleaned
 
+        if isinstance(call.func, ast.Attribute):
+            if (
+                isinstance(call.func.value, ast.Call)
+                and getattr(call.func.value.func, "id", None) == "super"
+            ):
+                return func_name, {}
+            if isinstance(call.func.value, ast.Name) and call.func.value.id in (
+                "self",
+                "cls",
+            ):
+                if func_name in local_functions:
+                    params = dict(local_functions[func_name][0])
+                    first_p = next(iter(params), None)
+                    if first_p in ("self", "cls"):
+                        cleaned = self._clean_receiver_params(params, call)
+                        return func_name, cleaned
+                return func_name, {}
+
         target_lookup = dotted_name or func_name
         if not target_lookup:
             return func_name, {}