Datasets:
File size: 9,216 Bytes
28adce7 2504377 28adce7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | 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")
|