Datasets:
Download experiments/common/tests/test_task.py from PV-SJTU/PV-Bench: direct link, hf CLI and curl.
- Browser
- Download file 9.22 kB
-
https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/common/tests/test_task.py
- Command line
-
hf download hf://datasets/PV-SJTU/PV-Bench/experiments/common/tests/test_task.py
-
curl -L -o test_task.py https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/common/tests/test_task.py
9.22 kB
| import dataclasses | |
| import sys | |
| import tempfile | |
| import unittest | |
| from pathlib import Path | |
| COMMON = Path(__file__).resolve().parents[1] | |
| sys.path.insert(0, str(COMMON)) | |
| from pvbench_common.task import Limits, TaskError, docker_limit_args, fingerprint, load # noqa: E402 | |
| EXPERIMENTS = COMMON.parent | |
| GOOD = """\ | |
| [task] | |
| name = "t3" | |
| agent_cwd = "/work" | |
| prompt_file = "PROMPT.md" | |
| tools_in_container = [] | |
| eval_recipe = "t3" | |
| eval_set_version = "v1" | |
| runners = ["codex", "claude"] | |
| egress_allow = ["api.openai.com", "chatgpt.com", "auth.openai.com", "api.anthropic.com"] | |
| [limits] | |
| memory = "8g" | |
| cpus = 2 | |
| pids = 512 | |
| agent_timeout_s = 3600 | |
| eval_timeout_s = 1200 | |
| [mounts] | |
| problem = { at = "/work/problem", mode = "ro" } | |
| examples = { at = "/work/examples", mode = "ro" } | |
| knowledge = { at = "/work/knowledge", mode = "ro" } | |
| lib = { at = "/work/lib", mode = "ro" } | |
| src = { at = "/work/src", mode = "ro" } | |
| answer = { at = "/work/answer", mode = "rw" } | |
| """ | |
| def replace_line(text: str, prefix: str, new: str) -> str: | |
| """Replace the single line starting with ``prefix`` (``new`` = "" deletes it).""" | |
| lines = text.splitlines(keepends=True) | |
| hits = [i for i, line in enumerate(lines) if line.startswith(prefix)] | |
| assert len(hits) == 1, (prefix, hits) | |
| lines[hits[0]] = new + "\n" if new else "" | |
| return "".join(lines) | |
| class TaskTests(unittest.TestCase): | |
| def setUp(self): | |
| self._tmp = tempfile.TemporaryDirectory() | |
| self.addCleanup(self._tmp.cleanup) | |
| self._n = 0 | |
| def write(self, text: str) -> Path: | |
| self._n += 1 | |
| path = Path(self._tmp.name) / f"task{self._n}.toml" | |
| path.write_text(text, encoding="utf-8") | |
| return path | |
| def load_text(self, text: str): | |
| return load(self.write(text)) | |
| def assert_rejected(self, text: str, key_path: str | None = None): | |
| with self.assertRaises(TaskError) as cm: | |
| self.load_text(text) | |
| if key_path is not None: | |
| self.assertIn(key_path, str(cm.exception)) | |
| return cm.exception | |
| def test_load_good_returns_frozen_task(self): | |
| task = self.load_text(GOOD) | |
| self.assertEqual(task.limits, Limits("8g", 2, 512, 3600, 1200)) | |
| self.assertEqual(sum(m.mode == "ro" for m in task.mounts), 5) | |
| self.assertEqual([m.name for m in task.mounts if m.mode == "rw"], ["answer"]) | |
| self.assertEqual(task.runners, ("codex", "claude")) | |
| self.assertIsNone(task.judge) | |
| with self.assertRaises(dataclasses.FrozenInstanceError): | |
| task.name = "t1" | |
| with self.assertRaises(dataclasses.FrozenInstanceError): | |
| task.limits.cpus = 4 | |
| def test_missing_limit_is_an_error(self): | |
| # Breaks: deletes one mandatory limit key at a time. | |
| for key in ("memory", "cpus", "pids", "agent_timeout_s", "eval_timeout_s"): | |
| with self.subTest(key=key): | |
| self.assert_rejected(replace_line(GOOD, f"{key} =", ""), f"limits.{key}") | |
| def test_check_timeout_is_optional_and_positive(self): | |
| self.assertIsNone(load(self.write(GOOD)).limits.check_timeout_s) | |
| self.assertEqual(load(self.write(GOOD.replace("[limits]\n", "[limits]\ncheck_timeout_s = 300\n"))).limits.check_timeout_s, 300) | |
| self.assert_rejected(GOOD.replace("[limits]\n", "[limits]\ncheck_timeout_s = 0\n"), "limits.check_timeout_s") | |
| def test_non_positive_limit_is_an_error(self): | |
| # Breaks: a limit value that is zero or negative. | |
| self.assert_rejected(replace_line(GOOD, "cpus =", "cpus = 0"), "limits.cpus") | |
| self.assert_rejected(replace_line(GOOD, "pids =", "pids = -1"), "limits.pids") | |
| self.assert_rejected(replace_line(GOOD, "memory =", 'memory = "0g"'), "limits.memory") | |
| def test_memory_format(self): | |
| # Breaks (for rejected cases): memory unit/casing/suffix. | |
| for ok in ("4g", "512m"): | |
| with self.subTest(ok=ok): | |
| task = self.load_text(replace_line(GOOD, "memory =", f'memory = "{ok}"')) | |
| self.assertEqual(task.limits.memory, ok) | |
| for bad in ("4G", "4gb", "4"): | |
| with self.subTest(bad=bad): | |
| self.assert_rejected(replace_line(GOOD, "memory =", f'memory = "{bad}"'), "limits.memory") | |
| def test_exactly_one_rw_mount_named_answer(self): | |
| # Breaks: zero rw mounts. | |
| zero = replace_line(GOOD, "answer ", 'answer = { at = "/work/answer", mode = "ro" }') | |
| self.assert_rejected(zero, "mounts") | |
| # Breaks: two rw mounts. | |
| two = replace_line(GOOD, "src ", 'src = { at = "/work/src", mode = "rw" }') | |
| self.assert_rejected(two, "mounts") | |
| # Breaks: the single rw mount is named "problem", not "answer". | |
| wrong = replace_line(zero, "problem ", 'problem = { at = "/work/problem", mode = "rw" }') | |
| self.assert_rejected(wrong, "mounts") | |
| def test_mount_paths(self): | |
| cases = { | |
| "relative path": 'lib = { at = "work/lib", mode = "ro" }', | |
| "duplicate at": 'lib = { at = "/work/src", mode = "ro" }', | |
| "outside /work": 'lib = { at = "/opt/lib", mode = "ro" }', | |
| "/work itself": 'lib = { at = "/work", mode = "ro" }', | |
| } | |
| for why, line in cases.items(): | |
| with self.subTest(why=why): | |
| self.assert_rejected(replace_line(GOOD, "lib ", line), "mounts.") | |
| def test_tools_in_container_are_bare_names(self): | |
| ok = self.load_text(replace_line(GOOD, "tools_in_container", 'tools_in_container = ["symexec.sh"]')) | |
| self.assertEqual(ok.tools_in_container, ("symexec.sh",)) | |
| # Breaks: tool entry with a directory component, absolute, or empty. | |
| for bad in ("bin/symexec.sh", "/usr/bin/x", ""): | |
| with self.subTest(bad=bad): | |
| text = replace_line(GOOD, "tools_in_container", f'tools_in_container = ["{bad}"]') | |
| self.assert_rejected(text, "task.tools_in_container") | |
| def test_eval_set_version_format(self): | |
| self.assertEqual(self.load_text(GOOD).eval_set_version, "v1") | |
| # Breaks: eval_set_version not of the form v<digits>. | |
| for bad in ("1", "v1.2", "latest"): | |
| with self.subTest(bad=bad): | |
| text = replace_line(GOOD, "eval_set_version", f'eval_set_version = "{bad}"') | |
| self.assert_rejected(text, "task.eval_set_version") | |
| def test_unknown_key_is_an_error(self): | |
| # Breaks: a typo'd limit key next to the real one. | |
| self.assert_rejected(GOOD.replace('memory = "8g"\n', 'memory = "8g"\nmemroy = "4g"\n'), "limits.memroy") | |
| # Breaks: an unknown top-level table. | |
| self.assert_rejected(GOOD + "\n[extras]\nfoo = 1\n", "extras") | |
| def test_fingerprint_is_stable_under_formatting(self): | |
| task_part, rest = GOOD.split("[limits]") | |
| limits_part, mounts_part = rest.split("[mounts]") | |
| # Same definition: tables and keys reordered, whitespace and quoting changed. | |
| reordered = ( | |
| "[mounts]" + mounts_part.replace(" ", " ") | |
| + "\n[limits]\neval_timeout_s=1200\nagent_timeout_s=3600\npids=512\ncpus=2\nmemory='8g'\n\n" | |
| + "\n".join(reversed(task_part.strip().splitlines()[1:])).join(["[task]\n", "\n"]) | |
| ) | |
| base = fingerprint(self.write(GOOD)) | |
| self.assertEqual(load(self.write(reordered)), load(self.write(GOOD))) | |
| self.assertEqual(fingerprint(self.write(reordered)), base) | |
| # Breaks: a changed value. | |
| changed = replace_line(GOOD, "cpus =", "cpus = 3") | |
| self.assertNotEqual(fingerprint(self.write(changed)), base) | |
| def test_docker_limit_args(self): | |
| self.assertEqual(docker_limit_args(Limits("4g", 2, 512, 3600, 1200)), | |
| ["--memory", "4g", "--cpus", "2", "--pids-limit", "512"]) | |
| self.assertEqual(docker_limit_args(Limits("4g", 1.5, 512, 3600, 1200))[3], "1.5") | |
| def test_real_task_files_load(self): | |
| tasks = {n: load(EXPERIMENTS / n / "task.toml") for n in ("t1", "t2", "t3")} | |
| for name, task in tasks.items(): | |
| self.assertEqual((task.name, task.eval_recipe), (name, name)) | |
| self.assertEqual(tasks["t2"].tools_in_container, ("symexec.sh",)) | |
| self.assertIsNone(tasks["t3"].judge) | |
| self.assertIn("gold", [m.name for m in tasks["t1"].judge.mounts]) | |
| if __name__ == "__main__": | |
| unittest.main() | |
| class JudgeMountsReadOnly(TaskTests): | |
| def test_judge_mounts_are_a_complete_set(self): | |
| good = GOOD + '\n[judge]\nmounts = { src = { at = "/work/src", mode = "rw" }, gold = { at = "/work/gold", mode = "ro" } }\n' | |
| task = self.load_text(good) | |
| self.assertEqual([m.name for m in task.judge.mounts], ["src", "gold"]) | |
| # gold must be present and read-only; exactly one rw mount | |
| self.assert_rejected(GOOD + '\n[judge]\nmounts = { gold = { at = "/work/gold", mode = "rw" } }\n', "judge.mounts") | |
| self.assert_rejected(GOOD + '\n[judge]\nmounts = { src = { at = "/work/src", mode = "rw" } }\n', "judge.mounts.gold") | |
| self.assert_rejected(GOOD + '\n[judge]\nmounts = { a = { at = "/work/a", mode = "rw" }, b = { at = "/work/b", mode = "rw" }, gold = { at = "/work/gold", mode = "ro" } }\n', "judge.mounts") | |