vibecodedshit 0.0.0-stage → 0.3.0

package/python/tests_helper.py

@@ -0,0 +1,171 @@
+"""Import and test-case facts for Python files (1.4 and 1.5). Standard library only.
+
+Reads {"files": [relative paths]} as JSON on stdin and prints
+{path: {"ok": false}
+      | {"ok": true, "imports": [...], "defined": [...], "reexports": [...], "cases": [...]}}.
+
+imports:   every import statement at any nesting depth:
+           {"module": str | null, "level": int, "names": [{"name", "asname"}], "star": bool}
+           ("import a.b" has module "a.b", level 0 and no names; "from . import x" has module null and level 1).
+defined:   names defined at module level (functions, classes, assignments).
+reexports: module-level "from m import a as b" bindings (including inside top-level if/try/with):
+           {"name": bound name, "module", "level", "orig"}; used for __init__.py re-exports.
+cases:     test_* functions at module level or directly in a class body: {"name", "line", "asserts": bool}.
+"""
+
+import ast
+import json
+import sys
+
+NESTED = (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ClassDef)
+DEFS = (ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def read_tree(path):
+    with open(path, "rb") as handle:
+        return ast.parse(handle.read().decode("utf-8", errors="replace"), filename=path)
+
+
+def target_names(target):
+    if isinstance(target, ast.Name):
+        return [target.id]
+    if isinstance(target, (ast.Tuple, ast.List)):
+        return [n for t in target.elts for n in target_names(t)]
+    if isinstance(target, ast.Starred):
+        return target_names(target.value)
+    return []
+
+
+def top_level(nodes):
+    """Statements at module level, descending into if/try/with but not into definitions."""
+    for node in nodes:
+        yield node
+        if isinstance(node, ast.If):
+            yield from top_level(node.body + node.orelse)
+        elif isinstance(node, ast.Try):
+            yield from top_level(node.body + node.orelse + node.finalbody)
+            for handler in node.handlers:
+                yield from top_level(handler.body)
+        elif isinstance(node, (ast.With, ast.AsyncWith)):
+            yield from top_level(node.body)
+
+
+def pytest_names(tree):
+    modules, members = set(), set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "pytest":
+                    modules.add(alias.asname or "pytest")
+        elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module == "pytest":
+            for alias in node.names:
+                if alias.name in ("raises", "warns"):
+                    members.add(alias.asname or alias.name)
+    return modules, members
+
+
+def walk_body(nodes):
+    """Every node of a body, not descending into nested def, lambda or class bodies."""
+    stack = list(reversed(nodes))
+    while stack:
+        node = stack.pop()
+        yield node
+        if isinstance(node, NESTED):
+            continue
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+
+
+def is_assertion(node, pytest_modules, pytest_members):
+    if isinstance(node, ast.Assert):
+        return True
+    if not isinstance(node, ast.Call):
+        return False
+    func = node.func
+    if isinstance(func, ast.Attribute):
+        if isinstance(func.value, ast.Name) and func.value.id == "self" and func.attr.startswith("assert"):
+            return True
+        if func.attr in ("raises", "warns") and isinstance(func.value, ast.Name) and func.value.id in pytest_modules:
+            return True
+        if func.attr.startswith("assert_"):
+            return True
+    return isinstance(func, ast.Name) and func.id in pytest_members
+
+
+def direct_assertion(body, pm, pf):
+    return any(is_assertion(n, pm, pf) for n in walk_body(body))
+
+
+def case_asserts(func, class_methods, module_funcs, pm, pf):
+    nodes = list(walk_body(func.body))
+    if any(is_assertion(n, pm, pf) for n in nodes):
+        return True
+    inner = {n.name: n for n in nodes if isinstance(n, DEFS)}
+    for node in nodes:
+        if not isinstance(node, ast.Call):
+            continue
+        helper = None
+        if isinstance(node.func, ast.Name):
+            helper = inner.get(node.func.id) or module_funcs.get(node.func.id)
+        elif isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name) and node.func.value.id == "self":
+            helper = class_methods.get(node.func.attr)
+        if helper is not None and helper is not func and direct_assertion(helper.body, pm, pf):
+            return True
+    return False
+
+
+def analyze(path):
+    tree = read_tree(path)
+    pm, pf = pytest_names(tree)
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({"module": alias.name, "level": 0, "names": [], "star": False, "asname": alias.asname})
+        elif isinstance(node, ast.ImportFrom):
+            imports.append({
+                "module": node.module,
+                "level": node.level,
+                "names": [{"name": a.name, "asname": a.asname} for a in node.names if a.name != "*"],
+                "star": any(a.name == "*" for a in node.names),
+            })
+    defined, reexports = [], []
+    module_funcs = {}
+    for node in top_level(tree.body):
+        if isinstance(node, DEFS):
+            defined.append(node.name)
+            module_funcs[node.name] = node
+        elif isinstance(node, ast.ClassDef):
+            defined.append(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                defined.extend(target_names(target))
+        elif isinstance(node, (ast.AnnAssign, ast.AugAssign)):
+            defined.extend(target_names(node.target))
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                if alias.name != "*":
+                    reexports.append({"name": alias.asname or alias.name, "module": node.module, "level": node.level, "orig": alias.name})
+    cases = []
+    for node in tree.body:
+        if isinstance(node, DEFS) and node.name.startswith("test_"):
+            cases.append({"name": node.name, "line": node.lineno, "asserts": case_asserts(node, {}, module_funcs, pm, pf)})
+        elif isinstance(node, ast.ClassDef):
+            methods = {n.name: n for n in node.body if isinstance(n, DEFS)}
+            for method in methods.values():
+                if method.name.startswith("test_"):
+                    cases.append({"name": f"{node.name}.{method.name}", "line": method.lineno, "asserts": case_asserts(method, methods, module_funcs, pm, pf)})
+    return {"ok": True, "imports": imports, "defined": sorted(set(defined)), "reexports": reexports, "cases": cases}
+
+
+def main():
+    request = json.load(sys.stdin)
+    out = {}
+    for path in request["files"]:
+        try:
+            out[path] = analyze(path)
+        except (SyntaxError, ValueError, OSError, RecursionError):
+            out[path] = {"ok": False}
+    json.dump(out, sys.stdout)
+
+
+main()

package/python/typing_helper.py

@@ -0,0 +1,235 @@
+"""Typing facts for Python files. Standard library only.
+
+Reads {"files": [relative paths]} as JSON on stdin and prints
+{path: {"ok": false}
+      | {"ok": true, "points": {...}, "allNames": [...] | null, "defs": [...]}}
+as JSON on stdout. The helper only extracts facts; counting and publicness rules are applied by the caller.
+
+points: anyCount, castCount, typeIgnoreLine, typeIgnoreHeader, pyrightIgnore, mypyIgnoreErrors (bool).
+defs: public-surface candidates in source order, module level only (including inside top-level if,
+try and with blocks):
+  {"kind": "function", "name", "info": fn} or {"kind": "class", "name", "methods": [fn]}
+fn: {"name", "params": [{"name", "typed", "kind"}], "returns": bool, "decorators": [str]}
+"""
+
+import ast
+import io
+import json
+import re
+import sys
+import tokenize
+
+TYPE_IGNORE = re.compile(r"#\s*type:\s*ignore\b")
+PYRIGHT_IGNORE = re.compile(r"#\s*pyright:\s*ignore\b")
+MYPY_IGNORE_ERRORS = re.compile(r"^#\s*mypy:\s*ignore-errors\b")
+TYPING_MODULES = ("typing", "typing_extensions")
+
+
+def read_text(path):
+    with open(path, "rb") as handle:
+        raw = handle.read()
+    try:
+        encoding, _ = tokenize.detect_encoding(io.BytesIO(raw).readline)
+        text = raw.decode(encoding)
+    except (SyntaxError, UnicodeDecodeError, LookupError):
+        text = raw.decode("utf-8", errors="replace")
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+class Imports:
+    """Names that resolve to typing.Any, typing.cast and the typing modules themselves."""
+
+    def __init__(self, tree):
+        self.any_names = set()
+        self.cast_names = set()
+        self.modules = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom) and node.level == 0 and node.module in TYPING_MODULES:
+                for alias in node.names:
+                    bound = alias.asname or alias.name
+                    if alias.name == "Any":
+                        self.any_names.add(bound)
+                    elif alias.name == "cast":
+                        self.cast_names.add(bound)
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    if alias.name in TYPING_MODULES:
+                        self.modules.add(alias.asname or alias.name)
+
+    def is_member(self, node, member, names):
+        if isinstance(node, ast.Name):
+            return node.id in names
+        return (
+            isinstance(node, ast.Attribute)
+            and node.attr == member
+            and isinstance(node.value, ast.Name)
+            and node.value.id in self.modules
+        )
+
+
+def count_any(annotation, imports):
+    if annotation is None:
+        return 0
+    total = 0
+    for node in ast.walk(annotation):
+        if isinstance(node, (ast.Name, ast.Attribute)) and imports.is_member(node, "Any", imports.any_names):
+            total += 1
+        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+            try:
+                inner = ast.parse(node.value.strip(), mode="eval")
+            except SyntaxError:
+                continue
+            total += count_any(inner.body, imports)
+    return total
+
+
+def all_arguments(args):
+    return list(args.posonlyargs) + list(args.args) + ([args.vararg] if args.vararg else []) + list(args.kwonlyargs) + ([args.kwarg] if args.kwarg else [])
+
+
+def describe_function(node):
+    args = node.args
+    params = []
+    for kind, group in (
+        ("positional", list(args.posonlyargs) + list(args.args)),
+        ("vararg", [args.vararg] if args.vararg else []),
+        ("keyword", list(args.kwonlyargs)),
+        ("kwarg", [args.kwarg] if args.kwarg else []),
+    ):
+        for arg in group:
+            params.append({"name": arg.arg, "typed": arg.annotation is not None, "kind": kind})
+    decorators = []
+    for decorator in node.decorator_list:
+        try:
+            decorators.append(ast.unparse(decorator))
+        except Exception:
+            decorators.append("")
+    return {"name": node.name, "params": params, "returns": node.returns is not None, "decorators": decorators}
+
+
+FUNCTIONS = (ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def module_level(statements):
+    """Statements at module level, descending into if, try and with blocks but not into functions or classes."""
+    for statement in statements:
+        yield statement
+        if isinstance(statement, ast.If):
+            yield from module_level(statement.body)
+            yield from module_level(statement.orelse)
+        elif isinstance(statement, (ast.With, ast.AsyncWith)):
+            yield from module_level(statement.body)
+        elif isinstance(statement, (ast.Try, getattr(ast, "TryStar", ast.Try))):
+            yield from module_level(statement.body)
+            for handler in statement.handlers:
+                yield from module_level(handler.body)
+            yield from module_level(statement.orelse)
+            yield from module_level(statement.finalbody)
+
+
+def string_list(node):
+    if isinstance(node, (ast.List, ast.Tuple)):
+        return [e.value for e in node.elts if isinstance(e, ast.Constant) and isinstance(e.value, str)]
+    return None
+
+
+def find_all_names(tree):
+    names = None
+    for statement in tree.body:
+        if isinstance(statement, ast.Assign) and any(isinstance(t, ast.Name) and t.id == "__all__" for t in statement.targets):
+            listed = string_list(statement.value)
+            if listed is not None:
+                names = list(listed)
+        elif isinstance(statement, ast.AnnAssign) and isinstance(statement.target, ast.Name) and statement.target.id == "__all__" and statement.value is not None:
+            listed = string_list(statement.value)
+            if listed is not None:
+                names = list(listed)
+        elif isinstance(statement, ast.AugAssign) and isinstance(statement.target, ast.Name) and statement.target.id == "__all__" and isinstance(statement.op, ast.Add):
+            listed = string_list(statement.value)
+            if listed is not None:
+                names = (names or []) + listed
+        elif (
+            isinstance(statement, ast.Expr)
+            and isinstance(statement.value, ast.Call)
+            and isinstance(statement.value.func, ast.Attribute)
+            and isinstance(statement.value.func.value, ast.Name)
+            and statement.value.func.value.id == "__all__"
+            and statement.value.args
+        ):
+            method = statement.value.func.attr
+            argument = statement.value.args[0]
+            if method == "extend":
+                listed = string_list(argument)
+                if listed is not None:
+                    names = (names or []) + listed
+            elif method == "append" and isinstance(argument, ast.Constant) and isinstance(argument.value, str):
+                names = (names or []) + [argument.value]
+    return names
+
+
+def comment_points(text, first_statement_line):
+    points = {"typeIgnoreLine": 0, "typeIgnoreHeader": 0, "pyrightIgnore": 0, "mypyIgnoreErrors": False}
+    for token in tokenize.generate_tokens(io.StringIO(text).readline):
+        if token.type != tokenize.COMMENT:
+            continue
+        comment = token.string
+        if TYPE_IGNORE.search(comment):
+            if first_statement_line is None or token.start[0] < first_statement_line:
+                points["typeIgnoreHeader"] += 1
+            else:
+                points["typeIgnoreLine"] += 1
+        if PYRIGHT_IGNORE.search(comment):
+            points["pyrightIgnore"] += 1
+        if MYPY_IGNORE_ERRORS.match(comment):
+            points["mypyIgnoreErrors"] = True
+    return points
+
+
+def analyze(path):
+    text = read_text(path)
+    try:
+        tree = ast.parse(text)
+        first = tree.body[0].lineno if tree.body else None
+        points = comment_points(text, first)
+    except (SyntaxError, ValueError, tokenize.TokenError, RecursionError, MemoryError):
+        return {"ok": False}
+
+    imports = Imports(tree)
+    any_count = 0
+    cast_count = 0
+    for node in ast.walk(tree):
+        if isinstance(node, FUNCTIONS) or isinstance(node, ast.Lambda):
+            if isinstance(node, FUNCTIONS):
+                for arg in all_arguments(node.args):
+                    any_count += count_any(arg.annotation, imports)
+                any_count += count_any(node.returns, imports)
+        elif isinstance(node, ast.AnnAssign):
+            any_count += count_any(node.annotation, imports)
+        elif isinstance(node, ast.Call) and imports.is_member(node.func, "cast", imports.cast_names):
+            cast_count += 1
+    points["anyCount"] = any_count
+    points["castCount"] = cast_count
+
+    defs = []
+    for statement in module_level(tree.body):
+        if isinstance(statement, FUNCTIONS):
+            defs.append({"kind": "function", "name": statement.name, "info": describe_function(statement)})
+        elif isinstance(statement, ast.ClassDef):
+            methods = [describe_function(m) for m in statement.body if isinstance(m, FUNCTIONS)]
+            defs.append({"kind": "class", "name": statement.name, "methods": methods})
+    return {"ok": True, "points": points, "allNames": find_all_names(tree), "defs": defs}
+
+
+def main():
+    request = json.load(sys.stdin)
+    result = {}
+    for path in request["files"]:
+        try:
+            result[path] = analyze(path)
+        except OSError:
+            result[path] = {"ok": False}
+    json.dump(result, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()