diffgenome 0.1.0__py3-none-any.whl

diffgenome/collect/py_runtime.py

@@ -0,0 +1,116 @@
+"""Python/pytest runtime adapter: the CPython collector as a `RuntimeAdapter`."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from diffgenome.collect.py_symbols import PythonSymbolIndex
+from diffgenome.model import Execution, Stimulus
+from diffgenome.probe import copy_probe_traces
+from diffgenome.runtime import SymbolIndex
+from diffgenome.sandbox import Workspace
+from diffgenome.serialize import execution_from_json
+
+DIFFGENOME_SRC = Path(__file__).resolve().parents[2]
+
+
+class PytestRuntime:
+    name = "python/pytest"
+
+    def __init__(
+        self,
+        repo: Path,
+        python: Path,
+        source_root: str,
+        test_root: str,
+        tests: str,
+        pytest_args: list[str],
+        pythonpath: list[str] | None = None,
+        test_env: dict[str, str] | None = None,
+        allow_loopback: bool = False,
+    ) -> None:
+        self.repo = repo
+        self.python = python
+        self.source_root = source_root
+        self.test_root = test_root
+        self.tests = tests
+        self.pytest_args = pytest_args
+        # Generic target-environment options (experiment 10, Baserow): repo-relative import
+        # roots resolved inside the disposable workspace; allow-listed, non-secret test
+        # variables (e.g. a local disposable database); loopback-only networking for local
+        # services. Target code still runs under the OS sandbox with no other network.
+        self.pythonpath = list(pythonpath or [])
+        self.test_env = dict(test_env or {})
+        self.allow_loopback = allow_loopback
+
+    def prepare(self, ws: Workspace) -> SymbolIndex:
+        # Index the workspace copy, i.e. the analyzed revision (`--rev` archives it there), not
+        # the checkout: the checkout may sit at another revision, and the index maps the
+        # change's diff lines and the executed code's locations onto symbols.
+        return PythonSymbolIndex(ws.repo, [ws.repo / self.source_root], [ws.repo / self.test_root])
+
+    def trace(
+        self, ws: Workspace, out_dir: Path, stimulus: Stimulus, only: list[str] | None
+    ) -> tuple[list[Execution], str, str]:
+        tag = "existing" if stimulus is Stimulus.EXISTING_TEST else "probe"
+        traces_ws = ws.root / f"traces-{tag}-{len(list(ws.root.glob('traces-*')))}"
+        traces_ws.mkdir(parents=True, exist_ok=True)
+        argv = [
+            str(self.python), "-m", "pytest", "-q", "-p", "no:cacheprovider",
+            "-p", "diffgenome.collect.pytest_plugin",
+            "--diffgenome-out", str(traces_ws),
+            "--diffgenome-repo-root", ".",
+            "--diffgenome-source-root", self.source_root,
+            "--diffgenome-test-root", self.test_root,
+            "--diffgenome-stimulus", stimulus.value,
+            "--diffgenome-egress-guard",
+            *self.pytest_args,
+            *(only if only else [self.tests]),
+        ]  # fmt: skip
+        roots = [str(ws.repo / p) for p in self.pythonpath]
+        env = {**self.test_env, "PYTHONPATH": ":".join([*roots, str(DIFFGENOME_SRC)])}
+        result = ws.run(argv, env=env, timeout=1800, allow_loopback=self.allow_loopback)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        copy_probe_traces(traces_ws, out_dir)
+        executions = [execution_from_json(f.read_text()) for f in sorted(out_dir.glob("*.json"))]
+        return executions, result.stdout, result.stderr
+
+    def probe_relpath(self, tag: str) -> str:
+        return f"{self.test_root}/test_diffgenome_probe_{tag}.py"
+
+    def conventions(self, index: SymbolIndex) -> str:
+        parts = ["Runtime: Python, pytest. The probe is a pytest test file."]
+        for root in index.test_roots:
+            f = root / "conftest.py"
+            if f.is_file():
+                lines: list[str] = []
+                try:
+                    tree = ast.parse(f.read_text(encoding="utf-8"))
+                except SyntaxError:
+                    tree = None
+                for node in tree.body if tree else []:
+                    if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and any(
+                        "fixture" in ast.unparse(d) for d in node.decorator_list
+                    ):
+                        doc = ast.get_docstring(node) or ""
+                        params = ", ".join(a.arg for a in node.args.args)
+                        lines.append(
+                            f"- {node.name}({params}): {doc.splitlines()[0] if doc else ''}"
+                        )
+                if lines:
+                    parts.append("conftest fixtures available:\n" + "\n".join(lines[:30]))
+        ini = index.repo_root / "pytest.ini"
+        if ini.is_file():
+            parts.append(
+                "pytest.ini:\n" + "\n".join(ini.read_text(encoding="utf-8").splitlines()[:20])
+            )
+        pyproject = index.repo_root / "pyproject.toml"
+        if pyproject.is_file():
+            text = pyproject.read_text(encoding="utf-8")
+            if "[tool.pytest" in text:
+                parts.append(
+                    "pyproject pytest section:\n"
+                    + "\n".join(text[text.index("[tool.pytest") :].splitlines()[:15])
+                )
+        return "\n\n".join(parts)

diffgenome/collect/py_symbols.py

@@ -0,0 +1,238 @@
+"""Python source adapter: static symbol index over a repository's files.
+
+Maps source lines to `SymbolId`s with the *same naming scheme the tracer uses* (module from
+path under the roots, dotted qualname), extracts a symbol's source text for probe context,
+and lists test files that import a module. Language-specific by nature; it lives beside
+the collector and is used through `diffgenome.change.SymbolIndex`.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+from diffgenome.model import SymbolId
+
+_EXCLUDED = {"site-packages", "dist-packages", "node_modules", "__pycache__"}
+
+
+@dataclass(frozen=True)
+class Definition:
+    symbol: SymbolId
+    path: str  # repository-relative
+    start: int
+    end: int
+    kind: str  # "function" | "class"
+    is_async: bool = False
+
+
+class PythonSymbolIndex:
+    def __init__(self, repo_root: Path, source_roots: list[Path], test_roots: list[Path]) -> None:
+        self.repo_root = repo_root.resolve()
+        self.source_roots = [p.resolve() for p in source_roots]
+        self.test_roots = [p.resolve() for p in test_roots]
+        self._defs: dict[str, list[Definition]] = {}
+
+    # ------------------------------------------------------------------ naming (mirrors tracer)
+
+    def module_for(self, path: Path) -> str | None:
+        path = path.resolve()
+        if any(p in _EXCLUDED or p.startswith(".") for p in path.parts[1:]):
+            return None
+        for roots, is_test in ((self.test_roots, True), (self.source_roots, False)):
+            for root in roots:
+                try:
+                    rel = path.relative_to(root)
+                except ValueError:
+                    continue
+                parts = list(rel.with_suffix("").parts)
+                if parts and parts[-1] == "__init__":
+                    parts.pop()
+                prefix = root.relative_to(self.repo_root).parts if is_test else ()
+                return ".".join((*prefix, *parts))
+        return None
+
+    # ------------------------------------------------------------------ definitions
+
+    def definitions(self, rel_path: str) -> list[Definition]:
+        if rel_path in self._defs:
+            return self._defs[rel_path]
+        file = self.repo_root / rel_path
+        module = self.module_for(file)
+        out: list[Definition] = []
+        if module is not None and file.suffix == ".py":
+            try:
+                tree = ast.parse(file.read_text(encoding="utf-8"))
+            except (SyntaxError, OSError, UnicodeDecodeError):
+                tree = None
+            if tree is not None:
+                self._collect(tree.body, module, [], rel_path, out)
+        self._defs[rel_path] = out
+        return out
+
+    def _collect(
+        self, body: list[ast.stmt], module: str, scope: list[str], rel: str, out: list[Definition]
+    ) -> None:
+        for node in body:
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+                qual = ".".join([*scope, node.name])
+                out.append(
+                    Definition(
+                        f"py:{module}.{qual}",
+                        rel,
+                        node.lineno,
+                        node.end_lineno or node.lineno,
+                        "function",
+                        isinstance(node, ast.AsyncFunctionDef),
+                    )
+                )
+                self._collect(node.body, module, [*scope, node.name, "<locals>"], rel, out)
+            elif isinstance(node, ast.ClassDef):
+                qual = ".".join([*scope, node.name])
+                out.append(
+                    Definition(
+                        f"py:{module}.{qual}",
+                        rel,
+                        node.lineno,
+                        node.end_lineno or node.lineno,
+                        "class",
+                    )
+                )
+                self._collect(node.body, module, [*scope, node.name], rel, out)
+
+    def symbols_at(self, rel_path: str, lines: set[int]) -> list[Definition]:
+        """Innermost function definitions covering any of the lines (classes only when a
+        changed line belongs to no function, e.g. a class attribute)."""
+        defs = self.definitions(rel_path)
+        hits: dict[SymbolId, Definition] = {}
+        for line in lines:
+            covering = [d for d in defs if d.start <= line <= d.end]
+            funcs = [d for d in covering if d.kind == "function"]
+            pick = (
+                max(funcs, key=lambda d: d.start)
+                if funcs
+                else (max(covering, key=lambda d: d.start) if covering else None)
+            )
+            if pick:
+                hits[pick.symbol] = pick
+        return sorted(hits.values(), key=lambda d: (d.path, d.start))
+
+    def find(self, symbol: SymbolId) -> Definition | None:
+        rel = self.path_for(symbol)
+        if rel is None:
+            return None
+        for d in self.definitions(rel):
+            if d.symbol == symbol:
+                return d
+        return None
+
+    def path_for(self, symbol: SymbolId) -> str | None:
+        """Best-effort inverse of the naming scheme: longest module prefix that is a file."""
+        name = symbol.split(":", 1)[1]
+        parts = name.split(".")
+        for i in range(len(parts), 0, -1):
+            candidate = "/".join(parts[:i])
+            for roots, is_test in ((self.test_roots, True), (self.source_roots, False)):
+                for root in roots:
+                    base = root
+                    rel_prefix = root.relative_to(self.repo_root).parts if is_test else ()
+                    cand_parts = parts[:i]
+                    if is_test:
+                        if tuple(cand_parts[: len(rel_prefix)]) != tuple(rel_prefix):
+                            continue
+                        cand_parts = cand_parts[len(rel_prefix) :]
+                        candidate = "/".join(cand_parts)
+                    for suffix in (".py", "/__init__.py"):
+                        file = base / (candidate + suffix)
+                        if file.is_file():
+                            return str(file.resolve().relative_to(self.repo_root))
+        return None
+
+    def source(self, symbol: SymbolId, context: int = 0) -> str | None:
+        d = self.find(symbol)
+        if d is None:
+            return None
+        lines = (self.repo_root / d.path).read_text(encoding="utf-8").splitlines()
+        lo, hi = max(0, d.start - 1 - context), min(len(lines), d.end + context)
+        return "\n".join(f"{i + 1:5d}  {lines[i]}" for i in range(lo, hi))
+
+    def enclosing_class(self, symbol: SymbolId) -> Definition | None:
+        d = self.find(symbol)
+        if d is None:
+            return None
+        classes = [
+            c for c in self.definitions(d.path)
+            if c.kind == "class" and c.start <= d.start and c.end >= d.end and c.symbol != d.symbol
+        ]  # fmt: skip
+        return max(classes, key=lambda c: c.start) if classes else None
+
+    def is_test(self, symbol: SymbolId) -> bool:
+        d = self.find(symbol)
+        if d is None:
+            return False
+        path = self.repo_root / d.path
+        return any(path.is_relative_to(r) for r in self.test_roots)
+
+    def return_type_of(self, symbol: SymbolId) -> SymbolId | None:
+        d = self.find(symbol)
+        if d is None or d.kind != "function":
+            return None
+        try:
+            tree = ast.parse((self.repo_root / d.path).read_text(encoding="utf-8"))
+        except (SyntaxError, OSError):
+            return None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and node.lineno == d.start:
+                ann = node.returns
+                if ann is None:
+                    return None
+                name = ast.unparse(ann)
+                if name.startswith("Optional[") and name.endswith("]"):
+                    name = name[len("Optional[") : -1]
+                if name.endswith(" | None"):
+                    name = name[: -len(" | None")]
+                cls = name.split(".")[-1]
+                if not cls.isidentifier():
+                    return None
+                candidates = [
+                    x
+                    for x in self.all_definitions()
+                    if x.kind == "class" and x.symbol.endswith("." + cls)
+                ]
+                return candidates[0].symbol if len(candidates) == 1 else None
+        return None
+
+    def all_definitions(self) -> list[Definition]:
+        if not getattr(self, "_all", None):
+            out: list[Definition] = []
+            for root in self.source_roots:
+                for f in sorted(root.rglob("*.py")):
+                    try:
+                        rel = str(f.resolve().relative_to(self.repo_root))
+                    except ValueError:
+                        continue
+                    out.extend(self.definitions(rel))
+            self._all = out
+        return self._all
+
+    def module_of(self, symbol: SymbolId) -> str | None:
+        """Dotted module of a symbol: the longest prefix of its qualified name that is a file."""
+        rel = self.path_for(symbol)
+        return self.module_for(self.repo_root / rel) if rel else None
+
+    def tests_importing(self, module: str, limit: int = 3) -> list[str]:
+        """Test files that import the module (or its package), by name. Shallow and cheap."""
+        hits: list[str] = []
+        needles = {module, module.rsplit(".", 1)[0]}
+        for root in self.test_roots:
+            for file in sorted(root.rglob("test_*.py")):
+                try:
+                    text = file.read_text(encoding="utf-8")
+                except (OSError, UnicodeDecodeError):
+                    continue
+                if any(f"from {n} import" in text or f"import {n}" in text for n in needles):
+                    hits.append(str(file.resolve().relative_to(self.repo_root)))
+                if len(hits) >= limit:
+                    return hits
+        return hits

diffgenome/collect/pytest_plugin.py

@@ -0,0 +1,130 @@
+"""pytest adapter for the CPython collector: traces the call phase of every test and writes
+one `Execution` JSON per test.
+
+    python -m pytest -p diffgenome.collect.pytest_plugin \\
+        --diffgenome-out OUT --diffgenome-source-root . --diffgenome-test-root tests
+
+The target repository is never written to: pass `-p no:cacheprovider` and set
+PYTHONDONTWRITEBYTECODE=1 when the target is mounted read-only.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import subprocess
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+from diffgenome.collect.py_monitoring import COLLECTOR, EGRESS_GUARD, Tracer
+from diffgenome.model import Collector, Execution, Stimulus
+from diffgenome.serialize import execution_to_json
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("diffgenome")
+    group.addoption("--diffgenome-out", required=True, help="directory for Execution JSON")
+    group.addoption(
+        "--diffgenome-source-root",
+        action="append",
+        default=[],
+        help="repository source root (repeatable); the first is the repository root",
+    )
+    group.addoption(
+        "--diffgenome-test-root", action="append", default=[], help="test root (repeatable)"
+    )
+    group.addoption(
+        "--diffgenome-repo-root",
+        default=None,
+        help="repository root that site ids and paths are relative to (default: first source root)",
+    )
+    group.addoption(
+        "--diffgenome-stimulus",
+        default="existing_test",
+        choices=[s.value for s in Stimulus],
+        help="how these executions were caused (generated probes must say so)",
+    )
+    group.addoption(
+        "--diffgenome-egress-guard",
+        action="store_true",
+        help="refuse socket connects and record attempts as OS-plane evidence",
+    )
+
+
+def _revision(cwd: Path) -> str | None:
+    try:
+        out = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=cwd, capture_output=True, text=True, timeout=5
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return out.stdout.strip() or None
+
+
+class _Plugin:
+    def __init__(self, config: pytest.Config) -> None:
+        self.out = Path(config.getoption("--diffgenome-out")).resolve()
+        self.out.mkdir(parents=True, exist_ok=True)
+        roots = [Path(p).resolve() for p in config.getoption("--diffgenome-source-root")]
+        if not roots:
+            roots = [Path(config.rootpath).resolve()]
+        tests = [Path(p).resolve() for p in config.getoption("--diffgenome-test-root")]
+        # Site ids hash the repository-relative path (sites.py); a source root below the
+        # repository root (Baserow: backend/src) must not become the base. Experiment 10, F2.
+        repo_opt = config.getoption("--diffgenome-repo-root")
+        repo_root = Path(repo_opt).resolve() if repo_opt else roots[0]
+        self.tracer = Tracer(
+            repo_root=repo_root, source_roots=tuple(roots), test_roots=tuple(tests)
+        )
+        self.tracer.install_patch_hook()
+        self.stimulus = Stimulus(config.getoption("--diffgenome-stimulus"))
+        self.collectors: tuple[Collector, ...] = (COLLECTOR,)
+        if config.getoption("--diffgenome-egress-guard"):
+            self.tracer.install_egress_guard()
+            self.collectors = (COLLECTOR, EGRESS_GUARD)
+        self.revision = _revision(roots[0])
+
+    @pytest.hookimpl(wrapper=True)
+    def pytest_runtest_call(self, item: pytest.Item) -> Generator[None, None, None]:
+        function = getattr(item, "function", None)
+        code = getattr(function, "__code__", None)
+        root_symbol = (code and self.tracer.symbol_for_code(code)) or f"py:{item.nodeid}"
+        self.tracer.start(root_symbol, code)
+        outcome = "passed"
+        try:
+            return (yield)
+        except BaseException:
+            outcome = "failed"
+            raise
+        finally:
+            result = self.tracer.stop()
+            execution = Execution(
+                id=f"{item.nodeid}@{self.revision or 'unknown'}",
+                stimulus=self.stimulus,
+                stimulus_ref=item.nodeid,
+                outcome=outcome,
+                revision=self.revision,
+                collectors=self.collectors,
+                symbols=result.symbols,
+                nodes=result.nodes,
+                branches=result.branches,
+                diagnostics=(
+                    ("stack_repairs", str(result.stack_repairs)),
+                    ("attribution_disagreements", str(result.attribution_disagreements)),
+                ),
+            )
+            # Sanitized ids can collide (parametrized ids differing only in punctuation)
+            # and can exceed filesystem limits; the digest keeps every execution distinct.
+            digest = hashlib.sha256(item.nodeid.encode()).hexdigest()[:12]
+            name = re.sub(r"[^A-Za-z0-9_.-]+", "_", item.nodeid)[:100]
+            (self.out / f"{name}-{digest}.json").write_text(execution_to_json(execution))
+            if result.stack_repairs:
+                item.add_report_section(
+                    "call", "diffgenome", f"stack repairs: {result.stack_repairs}"
+                )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.pluginmanager.register(_Plugin(config), "diffgenome-collector")