| """Batch queue for the teacher run: hands out batches and checks output format. Never sees answers. |
| |
| Run from the pack root (the folder holding tasks/ and outputs/): |
| python3 tasks/queue.py next N [--first A --last B] claim up to N unstarted batches, print their names |
| python3 tasks/queue.py check NAME check outputs/NAME.json; if bad, delete it and requeue |
| python3 tasks/queue.py status [--first A --last B] counts |
| python3 tasks/queue.py release requeue claimed batches with no valid output |
| (only when no worker is running, e.g. after a restart) |
| A batch that fails the check 3 times is given up (listed in progress/failed.txt). |
| """ |
|
|
| import argparse |
| import fcntl |
| import json |
| from pathlib import Path |
|
|
| BATCHES, OUTPUTS, PROGRESS = Path("tasks/batches"), Path("outputs"), Path("progress") |
| CLAIMED, BAD, FAILED = PROGRESS / "claimed.txt", PROGRESS / "bad.txt", PROGRESS / "failed.txt" |
| MAX_TRIES = 3 |
|
|
|
|
| def names(path): |
| return path.read_text().split() if path.is_file() else [] |
|
|
|
|
| def append(path, name): |
| with path.open("a") as stream: |
| stream.write(name + "\n") |
|
|
|
|
| def problem(name): |
| """None if outputs/NAME.json answers batch NAME in the right format, else the reason.""" |
| items = [json.loads(line) for line in (BATCHES / f"{name}.jsonl").read_text(encoding="utf-8").splitlines()] |
| path = OUTPUTS / f"{name}.json" |
| if not path.is_file(): |
| return "no output file" |
| try: |
| rows = json.loads(path.read_text(encoding="utf-8")) |
| except (json.JSONDecodeError, UnicodeDecodeError) as error: |
| return f"not valid JSON ({error})" |
| if not isinstance(rows, list) or not all(isinstance(row, dict) for row in rows): |
| return "not a JSON array of objects" |
| by_id = {row.get("id"): row for row in rows} |
| if len(rows) != len(items) or set(by_id) != {item["id"] for item in items}: |
| return f"ids differ from the batch (need each of its {len(items)} ids once)" |
| for item in items: |
| row = by_id[item["id"]] |
| if not isinstance(row.get("reasoning"), str) or not row["reasoning"].strip(): |
| return f"empty reasoning for {item['id']}" |
| if row.get("answer") not in item["options"]: |
| return f"answer for {item['id']} is not one of its option keys" |
| if len({row["reasoning"].strip() for row in rows}) < len(rows): |
| return "same reasoning text for different items" |
| return None |
|
|
|
|
| def in_range(first, last): |
| found = sorted(path.stem for path in BATCHES.glob("batch-*.jsonl")) |
| return [name for name in found if first <= int(name.split("-")[1]) <= last] |
|
|
|
|
| def run(args): |
| claimed, failed = names(CLAIMED), set(names(FAILED)) |
| if args.command == "next": |
| taken = set(claimed) |
| picked = [name for name in in_range(args.first, args.last) |
| if name not in taken and not (OUTPUTS / f"{name}.json").is_file()][:int(args.name)] |
| for name in picked: |
| append(CLAIMED, name) |
| print("\n".join(picked) if picked else "none left") |
| elif args.command == "check": |
| reason = problem(args.name) |
| if reason is None: |
| print(f"ok {args.name}") |
| return |
| (OUTPUTS / f"{args.name}.json").unlink(missing_ok=True) |
| append(BAD, args.name) |
| if names(BAD).count(args.name) >= MAX_TRIES: |
| append(FAILED, args.name) |
| print(f"bad {args.name}: {reason}; given up after {MAX_TRIES} tries") |
| else: |
| CLAIMED.write_text("".join(name + "\n" for name in claimed if name != args.name)) |
| print(f"bad {args.name}: {reason}; requeued") |
| elif args.command == "status": |
| batches, taken = in_range(args.first, args.last), set(claimed) |
| done = {name for name in batches if (OUTPUTS / f"{name}.json").is_file()} |
| print(json.dumps({"batches": len(batches), "done": len(done), |
| "failed": sum(name in failed for name in batches), |
| "running": sum(name in taken and name not in failed | done for name in batches), |
| "not_started": sum(name not in taken | done for name in batches)})) |
| elif args.command == "release": |
| keep = [] |
| for name in claimed: |
| if name in failed or problem(name) is None: |
| keep.append(name) |
| else: |
| (OUTPUTS / f"{name}.json").unlink(missing_ok=True) |
| CLAIMED.write_text("".join(name + "\n" for name in keep)) |
| print(f"released {len(claimed) - len(keep)}") |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("command", choices=["next", "check", "status", "release"]) |
| parser.add_argument("name", nargs="?", help="N for next, batch name for check") |
| parser.add_argument("--first", type=int, default=0) |
| parser.add_argument("--last", type=int, default=10**9) |
| args = parser.parse_args() |
| PROGRESS.mkdir(exist_ok=True) |
| OUTPUTS.mkdir(exist_ok=True) |
| with open(PROGRESS / ".lock", "w") as lock: |
| fcntl.flock(lock, fcntl.LOCK_EX) |
| run(args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
