Datasets:

ExpertCrowd
/

ec-swe

#!/usr/bin/env python3
"""Mutation probe runner — grades a tree with the SHIPPED grader.
Deliberately a sibling of calibrate.py rather than a flag on it: an in-flight
calibration owns .calib/calibration.json, and a mutation matrix must not write
into the file a verdict cites. Same weights (read out of tasks.py), same flat
blocker cap, same run_grading.sh, own state dirs, own logs, own JSON.
    python3 mutprobe.py mut-arity [mut-...]
    python3 mutprobe.py mut-lua --criteria B3_no_fabricated_record_on_status_change
"""

from __future__ import annotations

import argparse
import ast
import json
import os
import shutil
import subprocess
import sys
import time
from pathlib import Path

HERE = Path(__file__).resolve().parent
GRADER = Path(os.environ.get("CALIB_GRADER_DIR") or (HERE / "grader"))
CALIB = HERE / ".calib"
BASE_TREE = CALIB / "base"
OUT = CALIB / "mutation-probe.json"
# Nothing in this repository is regenerated in place by its own suite, so
# there is nothing to snapshot and put back after a grading.
MUTABLE: tuple[str, ...] = ()


def load_table():
    tree = ast.parse((HERE / "tasks.py").read_text())
    graders = cap = None
    for node in tree.body:
        if not isinstance(node, ast.Assign):
            continue
        for target in node.targets:
            if not isinstance(target, ast.Name):
                continue
            if target.id == "GRADERS":
                graders = [(t[0], t[1], t[2]) for t in ast.literal_eval(node.value)]
            elif target.id == "BLOCKER_CAP":
                cap = ast.literal_eval(node.value)
    assert graders and cap is not None
    total = sum(w for _n, w, _b in graders)
    if abs(total - 1.0) > 1e-9:
        raise SystemExit(f"weights sum to {total}, not 1.0")
    return graders, cap


def _cargo_env() -> dict[str, str]:
    """The host's cargo directories, for a calibration that runs outside the image.
    run_grading.sh defaults to the image's paths (/cargo, /hud/repotarget);
    on a developer machine those do not exist and every criterion would come
    back a GRADER FAULT — correctly, but uselessly. Asking the toolchain where
    its registry is is the one place this differs from the image, and it changes
    nothing about what is graded.
    """
    out = {}
    if not os.environ.get("CARGO_HOME"):
        home = Path.home() / ".cargo"
        if home.is_dir():
            out["GRADER_CARGO_HOME"] = str(home)
    return out


CARGO_ENV = _cargo_env()


def reward(results, graders, cap, faults=()):
    """The same arithmetic tasks.py does, faults included.
    A criterion the grader could not judge is STRUCK FROM THE BLOCKER SET — the
    grader broke, so it cannot cap the run; scoring a fault as a failed
    criterion is what turned mut-timer's 0.860 into a 0.600 with a blocker
    failure it never had. It does not earn its weight either: paying for an
    unjudged criterion is a channel, and it paid run 8d578573 a free 0.12 (see
    faultprobe.py for the arithmetic over this whole matrix).
    """
    # G-5-prime: та же арифметика, что в tasks.py. results НЕ переписывается
    # (гейт на base измерен зелёным и остаётся зелёным в отчёте) — он просто
    # не зарабатывает, когда ни одна другая клетка не зелёная.
    # G-5" (11.09): the rule of the ticket (law W-1) is green on an untouched
    # checkout for the same reason the gate is, so it is paid on the same
    # terms — only next to a green cell of the core.
    _G5P_CONDITIONAL = tuple(n for n, _w, _b in graders
                             if n.startswith(("gate_", "rule_")))
    _g5p_cells = [n for n, _w, _b in graders if n not in _G5P_CONDITIONAL and n in results]
    if _g5p_cells and not any(results.get(n) for n in _g5p_cells):
        results = dict(results, **{g: False for g in _G5P_CONDITIONAL})
    faults = set(faults)
    uncapped = sum(w for n, w, _b in graders if n not in faults and results.get(n))
    failed = [n for n, _w, b in graders
              if b and n not in faults and not results.get(n)]
    # A blocker that was not measured is not a blocker that was passed. It is
    # not reported as failed — that would be a phantom failure — but the ceiling
    # stays on, because lifting it is worth up to the whole gap between the cap
    # and 1.00 to a tree that would have failed the gate. Measured over every
    # possible outcome vector in faultprobe.py: without this, breaking a gate
    # fixture is worth +0.40.
    unproven = [n for n, _w, b in graders if b and n in faults]
    if not failed and not unproven:
        return uncapped, uncapped, []
    return max(0.0, min(uncapped, cap)), uncapped, failed


def measured_scale(results, graders, cap, faults=()):
    """(weight measured, reward over that weight) — reported, never the reward.
    §5.3 of SOLVER-FORENSICS asks for this number, and it is the right number to
    show a human re-reading a faulted trace. It is not the reward, because
    renormalising pays for a broken fixture exactly when the unmeasured
    criterion would have scored below the run's average — which is the criterion
    an agent would pick. faultprobe.py measures how much, on every tree in the
    matrix.
    """
    faults = set(faults)
    measured = sum(w for n, w, _b in graders if n not in faults)
    if measured <= 0:
        return 0.0, 0.0
    final, _uncapped, _failed = reward(results, graders, cap, faults)
    return measured, final / measured


def load_timeouts():
    """Per-criterion timeout from the same GRADERS table, handed to the grader.
    The ladder is fitted to this budget, so grading locally against a different
    one is grading a different ladder.
    """
    tree = ast.parse((HERE / "tasks.py").read_text())
    for node in tree.body:
        if isinstance(node, ast.Assign) and any(
                getattr(t, "id", None) == "GRADERS" for t in node.targets):
            return {t[0]: t[4] for t in ast.literal_eval(node.value)}
    raise SystemExit("could not read GRADERS out of tasks.py")


TIMEOUTS = load_timeouts()


def run_criterion(tree: Path, name: str, state: Path, log_dir: Path):
    env = dict(os.environ)
    env.update({
        "REPO_DIR": str(tree),
        "HARNESS_DIR": str(GRADER),
        "GRADER_STATE_DIR": str(state),
        "BASE_SRC": os.environ.get("BASE_SRC") or str(BASE_TREE),
        "PYTHON_BIN": sys.executable,
        **CARGO_ENV,
    })
    budget = TIMEOUTS.get(name, GATE_TIMEOUT)
    started = time.time()
    proc = subprocess.run(["bash", str(GRADER / "run_grading.sh"), name, str(budget)],
                          env=env, capture_output=True, text=True, timeout=budget + 300)
    elapsed = time.time() - started
    (log_dir / f"{name}.log").write_text(proc.stdout + "\n--- stderr ---\n" + proc.stderr)
    if proc.returncode == 3:
        return None, elapsed, proc.stdout          # grader fault
    return proc.returncode == 0, elapsed, proc.stdout


def load_gate() -> tuple[str, int]:
    tree = ast.parse((HERE / "tasks.py").read_text())
    name = budget = None
    for node in tree.body:
        if isinstance(node, ast.Assign):
            for t in node.targets:
                if getattr(t, "id", None) == "GATE":
                    name = ast.literal_eval(node.value)
                elif getattr(t, "id", None) == "GATE_TIMEOUT":
                    budget = ast.literal_eval(node.value)
    if not name or not budget:
        raise SystemExit("could not read GATE/GATE_TIMEOUT out of tasks.py")
    return name, budget


GATE, GATE_TIMEOUT = load_gate()


def grade(which: str, graders, cap, criteria, keep):
    tree = CALIB / which
    if not (tree / "Cargo.toml").exists():
        raise SystemExit(f"no tree at {tree}")
    state = CALIB / f"state-{which}"
    if not keep:
        shutil.rmtree(state, ignore_errors=True)
    state.mkdir(parents=True, exist_ok=True)
    log_dir = CALIB / f"logs-{which}"
    log_dir.mkdir(parents=True, exist_ok=True)

    snap = {r: (tree / r).read_bytes() for r in MUTABLE if (tree / r).exists()}
    print(f"\n=== {which} ===", flush=True)
    results, timings, faults = {}, {}, []
    for name, weight, blocker in graders:
        if criteria and name not in criteria:
            continue
        ok, elapsed, out = run_criterion(tree, name, state, log_dir)
        verdict = "PASS" if ok else "FAIL"
        if ok is None:
            faults.append(name)
            ok, verdict = False, "FAULT"
        results[name] = ok
        timings[name] = elapsed
        print(f"  {verdict:<5} {name:<46} w={weight:.2f} "
              f"{'blocker' if blocker else '       '} {elapsed:6.1f}s", flush=True)
        for line in out.splitlines():
            stripped = line.strip()
            if stripped.startswith(("PASS:", "FAIL:", "GRADER FAULT")):
                print(f"        {stripped[:200]}", flush=True)
    # Law G-5: the gate is the last row of GRADERS and was graded in the loop
    # above with everything else; there is no separate, weightless gate run.
    gate_ok = results.get(GATE, True) if not criteria else True

    for rel, data in snap.items():
        f = tree / rel
        if f.exists() and f.read_bytes() != data:
            f.write_bytes(data)

    final, uncapped, failed = reward(results, graders, cap, faults)
    if not gate_ok:
        print("  -> A GATE FAILED: the repository's own tests were rewritten or "
              "left red; the total is capped and the gate's own weight is not earned",
              flush=True)
    print(f"  -> uncapped {uncapped:.3f}, failed blockers {failed or 'none'}, "
          f"gate {'PASS' if gate_ok else 'FAIL'}, "
          f"reward {final:.3f}"
          + (f"  ⚠ NOT A MEASUREMENT — grader faults: {faults} "
             f"(counted as met, struck from the blockers)" if faults else ""), flush=True)
    return {"tree": which, "results": results, "timings": timings, "uncapped": uncapped,
            "reward": final, "failed_blockers": failed, "grader_faults": faults,
            "gate": gate_ok, "partial": bool(criteria)}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("trees", nargs="+")
    ap.add_argument("--criteria", default="")
    ap.add_argument("--keep-state", action="store_true")
    args = ap.parse_args()
    graders, cap = load_table()
    criteria = [c for c in args.criteria.split(",") if c]
    report = [grade(t, graders, cap, criteria, args.keep_state) for t in args.trees]

    previous = []
    if OUT.exists():
        try:
            previous = json.loads(OUT.read_text())
        except (ValueError, OSError):
            previous = []
    merged = {e["tree"]: e for e in previous if isinstance(e, dict) and "tree" in e}
    for e in report:
        if e["partial"] and e["tree"] in merged and not merged[e["tree"]]["partial"]:
            merged[e["tree"]]["results"].update(e["results"])
            continue
        merged[e["tree"]] = e
    OUT.write_text(json.dumps(sorted(merged.values(), key=lambda e: e["tree"]), indent=2) + "\n")
    print(f"\nwritten to {OUT}")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Mutation probe runner — grades a tree with the SHIPPED grader.

	Deliberately a sibling of calibrate.py rather than a flag on it: an in-flight
	calibration owns .calib/calibration.json, and a mutation matrix must not write
	into the file a verdict cites. Same weights (read out of tasks.py), same flat
	blocker cap, same run_grading.sh, own state dirs, own logs, own JSON.

	python3 mutprobe.py mut-arity [mut-...]
	python3 mutprobe.py mut-lua --criteria B3_no_fabricated_record_on_status_change
	"""

	from __future__ import annotations

	import argparse
	import ast
	import json
	import os
	import shutil
	import subprocess
	import sys
	import time
	from pathlib import Path

	HERE = Path(__file__).resolve().parent
	GRADER = Path(os.environ.get("CALIB_GRADER_DIR") or (HERE / "grader"))
	CALIB = HERE / ".calib"
	BASE_TREE = CALIB / "base"
	OUT = CALIB / "mutation-probe.json"
	# Nothing in this repository is regenerated in place by its own suite, so
	# there is nothing to snapshot and put back after a grading.
	MUTABLE: tuple[str, ...] = ()


	def load_table():
	tree = ast.parse((HERE / "tasks.py").read_text())
	graders = cap = None
	for node in tree.body:
	if not isinstance(node, ast.Assign):
	continue
	for target in node.targets:
	if not isinstance(target, ast.Name):
	continue
	if target.id == "GRADERS":
	graders = [(t[0], t[1], t[2]) for t in ast.literal_eval(node.value)]
	elif target.id == "BLOCKER_CAP":
	cap = ast.literal_eval(node.value)
	assert graders and cap is not None
	total = sum(w for _n, w, _b in graders)
	if abs(total - 1.0) > 1e-9:
	raise SystemExit(f"weights sum to {total}, not 1.0")
	return graders, cap


	def _cargo_env() -> dict[str, str]:
	"""The host's cargo directories, for a calibration that runs outside the image.

	run_grading.sh defaults to the image's paths (/cargo, /hud/repotarget);
	on a developer machine those do not exist and every criterion would come
	back a GRADER FAULT — correctly, but uselessly. Asking the toolchain where
	its registry is is the one place this differs from the image, and it changes
	nothing about what is graded.
	"""
	out = {}
	if not os.environ.get("CARGO_HOME"):
	home = Path.home() / ".cargo"
	if home.is_dir():
	out["GRADER_CARGO_HOME"] = str(home)
	return out


	CARGO_ENV = _cargo_env()


	def reward(results, graders, cap, faults=()):
	"""The same arithmetic tasks.py does, faults included.

	A criterion the grader could not judge is STRUCK FROM THE BLOCKER SET — the
	grader broke, so it cannot cap the run; scoring a fault as a failed
	criterion is what turned mut-timer's 0.860 into a 0.600 with a blocker
	failure it never had. It does not earn its weight either: paying for an
	unjudged criterion is a channel, and it paid run 8d578573 a free 0.12 (see
	faultprobe.py for the arithmetic over this whole matrix).
	"""
	# G-5-prime: та же арифметика, что в tasks.py. results НЕ переписывается
	# (гейт на base измерен зелёным и остаётся зелёным в отчёте) — он просто
	# не зарабатывает, когда ни одна другая клетка не зелёная.
	# G-5" (11.09): the rule of the ticket (law W-1) is green on an untouched
	# checkout for the same reason the gate is, so it is paid on the same
	# terms — only next to a green cell of the core.
	_G5P_CONDITIONAL = tuple(n for n, _w, _b in graders
	if n.startswith(("gate_", "rule_")))
	_g5p_cells = [n for n, _w, _b in graders if n not in _G5P_CONDITIONAL and n in results]
	if _g5p_cells and not any(results.get(n) for n in _g5p_cells):
	results = dict(results, **{g: False for g in _G5P_CONDITIONAL})
	faults = set(faults)
	uncapped = sum(w for n, w, _b in graders if n not in faults and results.get(n))
	failed = [n for n, _w, b in graders
	if b and n not in faults and not results.get(n)]
	# A blocker that was not measured is not a blocker that was passed. It is
	# not reported as failed — that would be a phantom failure — but the ceiling
	# stays on, because lifting it is worth up to the whole gap between the cap
	# and 1.00 to a tree that would have failed the gate. Measured over every
	# possible outcome vector in faultprobe.py: without this, breaking a gate
	# fixture is worth +0.40.
	unproven = [n for n, _w, b in graders if b and n in faults]
	if not failed and not unproven:
	return uncapped, uncapped, []
	return max(0.0, min(uncapped, cap)), uncapped, failed


	def measured_scale(results, graders, cap, faults=()):
	"""(weight measured, reward over that weight) — reported, never the reward.

	§5.3 of SOLVER-FORENSICS asks for this number, and it is the right number to
	show a human re-reading a faulted trace. It is not the reward, because
	renormalising pays for a broken fixture exactly when the unmeasured
	criterion would have scored below the run's average — which is the criterion
	an agent would pick. faultprobe.py measures how much, on every tree in the
	matrix.
	"""
	faults = set(faults)
	measured = sum(w for n, w, _b in graders if n not in faults)
	if measured <= 0:
	return 0.0, 0.0
	final, _uncapped, _failed = reward(results, graders, cap, faults)
	return measured, final / measured


	def load_timeouts():
	"""Per-criterion timeout from the same GRADERS table, handed to the grader.

	The ladder is fitted to this budget, so grading locally against a different
	one is grading a different ladder.
	"""
	tree = ast.parse((HERE / "tasks.py").read_text())
	for node in tree.body:
	if isinstance(node, ast.Assign) and any(
	getattr(t, "id", None) == "GRADERS" for t in node.targets):
	return {t[0]: t[4] for t in ast.literal_eval(node.value)}
	raise SystemExit("could not read GRADERS out of tasks.py")


	TIMEOUTS = load_timeouts()


	def run_criterion(tree: Path, name: str, state: Path, log_dir: Path):
	env = dict(os.environ)
	env.update({
	"REPO_DIR": str(tree),
	"HARNESS_DIR": str(GRADER),
	"GRADER_STATE_DIR": str(state),
	"BASE_SRC": os.environ.get("BASE_SRC") or str(BASE_TREE),
	"PYTHON_BIN": sys.executable,
	**CARGO_ENV,
	})
	budget = TIMEOUTS.get(name, GATE_TIMEOUT)
	started = time.time()
	proc = subprocess.run(["bash", str(GRADER / "run_grading.sh"), name, str(budget)],
	env=env, capture_output=True, text=True, timeout=budget + 300)
	elapsed = time.time() - started
	(log_dir / f"{name}.log").write_text(proc.stdout + "\n--- stderr ---\n" + proc.stderr)
	if proc.returncode == 3:
	return None, elapsed, proc.stdout # grader fault
	return proc.returncode == 0, elapsed, proc.stdout


	def load_gate() -> tuple[str, int]:
	tree = ast.parse((HERE / "tasks.py").read_text())
	name = budget = None
	for node in tree.body:
	if isinstance(node, ast.Assign):
	for t in node.targets:
	if getattr(t, "id", None) == "GATE":
	name = ast.literal_eval(node.value)
	elif getattr(t, "id", None) == "GATE_TIMEOUT":
	budget = ast.literal_eval(node.value)
	if not name or not budget:
	raise SystemExit("could not read GATE/GATE_TIMEOUT out of tasks.py")
	return name, budget


	GATE, GATE_TIMEOUT = load_gate()


	def grade(which: str, graders, cap, criteria, keep):
	tree = CALIB / which
	if not (tree / "Cargo.toml").exists():
	raise SystemExit(f"no tree at {tree}")
	state = CALIB / f"state-{which}"
	if not keep:
	shutil.rmtree(state, ignore_errors=True)
	state.mkdir(parents=True, exist_ok=True)
	log_dir = CALIB / f"logs-{which}"
	log_dir.mkdir(parents=True, exist_ok=True)

	snap = {r: (tree / r).read_bytes() for r in MUTABLE if (tree / r).exists()}
	print(f"\n=== {which} ===", flush=True)
	results, timings, faults = {}, {}, []
	for name, weight, blocker in graders:
	if criteria and name not in criteria:
	continue
	ok, elapsed, out = run_criterion(tree, name, state, log_dir)
	verdict = "PASS" if ok else "FAIL"
	if ok is None:
	faults.append(name)
	ok, verdict = False, "FAULT"
	results[name] = ok
	timings[name] = elapsed
	print(f" {verdict:<5} {name:<46} w={weight:.2f} "
	f"{'blocker' if blocker else ' '} {elapsed:6.1f}s", flush=True)
	for line in out.splitlines():
	stripped = line.strip()
	if stripped.startswith(("PASS:", "FAIL:", "GRADER FAULT")):
	print(f" {stripped[:200]}", flush=True)
	# Law G-5: the gate is the last row of GRADERS and was graded in the loop
	# above with everything else; there is no separate, weightless gate run.
	gate_ok = results.get(GATE, True) if not criteria else True

	for rel, data in snap.items():
	f = tree / rel
	if f.exists() and f.read_bytes() != data:
	f.write_bytes(data)

	final, uncapped, failed = reward(results, graders, cap, faults)
	if not gate_ok:
	print(" -> A GATE FAILED: the repository's own tests were rewritten or "
	"left red; the total is capped and the gate's own weight is not earned",
	flush=True)
	print(f" -> uncapped {uncapped:.3f}, failed blockers {failed or 'none'}, "
	f"gate {'PASS' if gate_ok else 'FAIL'}, "
	f"reward {final:.3f}"
	+ (f" ⚠ NOT A MEASUREMENT — grader faults: {faults} "
	f"(counted as met, struck from the blockers)" if faults else ""), flush=True)
	return {"tree": which, "results": results, "timings": timings, "uncapped": uncapped,
	"reward": final, "failed_blockers": failed, "grader_faults": faults,
	"gate": gate_ok, "partial": bool(criteria)}


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("trees", nargs="+")
	ap.add_argument("--criteria", default="")
	ap.add_argument("--keep-state", action="store_true")
	args = ap.parse_args()
	graders, cap = load_table()
	criteria = [c for c in args.criteria.split(",") if c]
	report = [grade(t, graders, cap, criteria, args.keep_state) for t in args.trees]

	previous = []
	if OUT.exists():
	try:
	previous = json.loads(OUT.read_text())
	except (ValueError, OSError):
	previous = []
	merged = {e["tree"]: e for e in previous if isinstance(e, dict) and "tree" in e}
	for e in report:
	if e["partial"] and e["tree"] in merged and not merged[e["tree"]]["partial"]:
	merged[e["tree"]]["results"].update(e["results"])
	continue
	merged[e["tree"]] = e
	OUT.write_text(json.dumps(sorted(merged.values(), key=lambda e: e["tree"]), indent=2) + "\n")
	print(f"\nwritten to {OUT}")


	if __name__ == "__main__":
	main()