| """Reproduce the pinned pymethods2test TaskTrove source with reviewed repairs. |
| |
| R1 (stage 1): pin pytest in environment/Dockerfile and tests/test.sh, and drop |
| the `2>/dev/null` that makes check-pip-pinning.sh report the package as unpinned. |
| The version is the one the unpinned install resolved in the pilot stage-5 logs. |
| |
| R2 (stage 4): add solution/solve.sh, which copies the existing solution/solution.py |
| to /app/solution.py. |
| |
| Tests and reward logic are never edited. |
| |
| R3: replace the ignored verifier.restart_environment=false field with the |
| supported environment_mode="shared" setting. |
| |
| R4: repair the missing cmp_to_key import in reference 1059 and install the |
| missing numpy==2.2.6 dependency during verifier preparation for task 3412. |
| |
| R5: bake numpy==2.2.6 into the task image for 18 further verified NumPy failures. |
| The pinned upstream image installs pytest only; no NumPy dependency was removed. |
| |
| R6: add missing standard-library imports to 37 audited reference solutions. |
| |
| R7: replace `solution.py` with `/app/solution.py` in 15 instructions, at the |
| positions the validation path resolver observed and applied. |
| """ |
|
|
| |
| import sys |
| from pathlib import Path |
| sys.path.insert(0, str(Path(__file__).resolve().parents[2])) |
|
|
|
|
| import argparse |
| import copy |
| import gzip |
| import hashlib |
| import io |
| import json |
| import re |
| import tarfile |
| import tomllib |
| from pathlib import Path |
|
|
| REVISION = '946884702046be1a7dcea2638186ad6b0d2ea103' |
| PATCH_VERSION = 'pymethods2test-numpy18-import37-paths15-v7' |
| REPAIRED_PYTEST_VERSION = '9.0.2' |
| EXPECTED_TASK_COUNT = 4990 |
|
|
| DOCKER_LINE = 'RUN pip install --no-cache-dir pytest' |
| DOCKER_LINE_FIXED = 'RUN pip install --no-cache-dir pytest==9.1.1' |
| TEST_LINE = 'pip3 install --quiet pytest 2>/dev/null || true' |
| TEST_LINE_FIXED = 'pip3 install --quiet pytest==9.1.1 || true' |
| SOLVE_SH = b'#!/bin/bash\nset -euo pipefail\ncp /solution/solution.py /app/solution.py\n' |
|
|
| from data.utils.task_archive import read_members |
| from data.utils.patch_reporting import write_patch_report |
|
|
| REFERENCE_HASHES = { |
| 'pymethods2test-1059': '487e92ef39067b0649af5f61a1435fdcb5e6ddde4693c076977a5c169d14bde8', |
| 'pymethods2test-3412': 'e76b0b9ba081cda01d4eef0ccaee180c951c9ea66c433ed96401307b1e593f34', |
| } |
| REPAIR_REASONS = { |
| 'pymethods2test-1059': 'Added the missing functools.cmp_to_key import to the supplied reference solution; its seven unchanged tests pass locally.', |
| 'pymethods2test-3412': 'Added numpy==2.2.6 to tests/setup.sh because the supplied reference imports NumPy; its six unchanged tests pass locally. The shared Dockerfile is unchanged by this repair.', |
| } |
| NUMPY_REFERENCE_HASHES = json.loads((Path(__file__).parent / 'repairs' / 'numpy_repairs.json').read_text()) |
| IMPORT_REPAIRS = json.loads((Path(__file__).parent / 'repairs' / 'import_repairs.json').read_text()) |
| PATH_REPAIRS = json.loads((Path(__file__).parent / 'repairs' / 'path_repairs.json').read_text()) |
| REPAIR_REASONS.update({task: 'Baked numpy==2.2.6 into the task image to repair an undeclared upstream dependency; reference, tests and reward logic unchanged.' |
| for task in NUMPY_REFERENCE_HASHES}) |
| REPAIR_REASONS.update({task: 'Added missing standard-library imports to the supplied reference: ' |
| + '; '.join(repair['imports']) + '. Function bodies, instructions, tests and reward logic unchanged.' |
| for task, repair in IMPORT_REPAIRS.items()}) |
| for task in NUMPY_REFERENCE_HASHES.keys() | IMPORT_REPAIRS.keys(): |
| REPAIR_REASONS[task] += ' Pinned pytest to 9.0.2, the version used for local verification, before image preparation.' |
|
|
|
|
| def pin_repaired_pytest(task_id, files): |
| """Freeze the verified pytest version before cache verification and validation.""" |
| if task_id not in NUMPY_REFERENCE_HASHES and task_id not in IMPORT_REPAIRS: |
| return {} |
| edits = {} |
| for name in ('environment/Dockerfile', 'tests/test.sh', 'tests/setup.sh'): |
| if name not in files: |
| continue |
| lines = files[name].decode().splitlines(keepends=True) |
| for index, line in enumerate(lines): |
| if re.search(r'\bpip[0-9]*\s+install\b', line): |
| lines[index] = re.sub(r'\bpytest(?:==9\.1\.1)?(?=\s|$)', |
| 'pytest==' + REPAIRED_PYTEST_VERSION, line) |
| |
| if 'pytest==' + REPAIRED_PYTEST_VERSION in lines[index]: |
| lines[index] = lines[index].replace(' 2>/dev/null', '') |
| updated = ''.join(lines).encode() |
| if updated != files[name]: |
| edits[name] = updated |
| return edits |
|
|
|
|
| def repair_numpy_environment(task_id, files): |
| """Repair only audited reference payloads; keep existing image instructions.""" |
| if task_id not in NUMPY_REFERENCE_HASHES: |
| return {} |
| if hashlib.sha256(files['solution/solution.py']).hexdigest() != NUMPY_REFERENCE_HASHES[task_id]: |
| raise ValueError(f'{task_id}: unexpected NumPy reference solution') |
| dockerfile = files['environment/Dockerfile'] |
| if b'numpy' in dockerfile.lower(): |
| raise ValueError(f'{task_id}: unexpected existing NumPy image declaration') |
| return {'environment/Dockerfile': dockerfile.rstrip(b'\n') + b'\nRUN python -m pip install --no-cache-dir numpy==2.2.6\n'} |
|
|
|
|
| def repair_reference(task_id, files): |
| """Return targeted edits and additions, rejecting unexpected source payloads.""" |
| if task_id in IMPORT_REPAIRS: |
| repair = IMPORT_REPAIRS[task_id] |
| raw = files['solution/solution.py'] |
| if hashlib.sha256(raw).hexdigest() != repair['reference_sha256']: |
| raise ValueError(f'{task_id}: unexpected reference solution for import repair') |
| prefix = ('\n'.join(repair['imports']) + '\n\n').encode() |
| return {'solution/solution.py': prefix + raw}, {} |
| if task_id not in REFERENCE_HASHES: |
| return {}, {} |
| if hashlib.sha256(files['solution/solution.py']).hexdigest() != REFERENCE_HASHES[task_id]: |
| raise ValueError(f'{task_id}: unexpected reference solution') |
| if task_id == 'pymethods2test-1059': |
| return {'solution/solution.py': b'from functools import cmp_to_key\n\n' + files['solution/solution.py']}, {} |
| if 'tests/setup.sh' in files: |
| raise ValueError(f'{task_id}: unexpected existing verifier setup') |
| return {}, {'tests/setup.sh': b'#!/bin/bash\nset -euo pipefail\npython -m pip install --quiet numpy==2.2.6\n'} |
|
|
|
|
| def repair_instruction_paths(task_id, files): |
| """Apply the resolver's recorded absolute-path edits to the unchanged instruction.""" |
| if task_id not in PATH_REPAIRS: |
| return {} |
| repair = PATH_REPAIRS[task_id] |
| raw = files['instruction.md'] |
| if hashlib.sha256(raw).hexdigest() != repair['instruction_sha256']: |
| raise ValueError(f'{task_id}: unexpected instruction for path repair') |
| text = raw.decode() |
| for edit in sorted(repair['edits'], key=lambda e: e['start'], reverse=True): |
| if text[edit['start']:edit['end']] != edit['old']: |
| raise ValueError(f'{task_id}: path repair does not match the instruction') |
| text = text[:edit['start']] + edit['new'] + text[edit['end']:] |
| return {'instruction.md': text.encode()} |
|
|
|
|
| def replace_single_line(text, old, new, name): |
| lines = text.split('\n') |
| if lines.count(old) != 1: |
| raise ValueError(f'{name}: expected exactly one {old!r} line, got {lines.count(old)}') |
| return '\n'.join(new if line == old else line for line in lines) |
|
|
|
|
| def pin_pytest(files): |
| """R1. Raises unless each file has exactly one matching line and no other pip line.""" |
| for name, old, new in (('environment/Dockerfile', DOCKER_LINE, DOCKER_LINE_FIXED), |
| ('tests/test.sh', TEST_LINE, TEST_LINE_FIXED)): |
| text = files[name].decode() |
| others = [line for line in text.split('\n') if 'pip' in line and line != old] |
| if others: |
| raise ValueError(f'{name}: unexpected pip lines {others!r}') |
| files[name] = replace_single_line(text, old, new, name).encode() |
|
|
|
|
| def add_oracle_wrapper(files): |
| """R2. Raises if solve.sh already exists or solution.py is missing.""" |
| if 'solution/solve.sh' in files: |
| raise ValueError('solution/solve.sh already exists') |
| if 'solution/solution.py' not in files: |
| raise ValueError('solution/solution.py is missing') |
| return SOLVE_SH |
|
|
|
|
| def migrate_verifier_mode(content): |
| """Migrate only the upstream false flag, preserving shared verification.""" |
| verifier = tomllib.loads(content.decode())["verifier"] |
| if verifier.get("restart_environment") is not False: |
| raise ValueError("expected verifier.restart_environment = false") |
| if "environment_mode" in verifier or "environment" in verifier: |
| raise ValueError("unexpected existing verifier environment configuration") |
| updated, count = re.subn( |
| rb'(?m)^([ \t]*)restart_environment[ \t]*=[ \t]*false[ \t]*$', |
| rb'\1environment_mode = "shared"', content) |
| if count != 1: |
| raise ValueError("expected exactly one legacy verifier restart flag") |
| return updated |
|
|
|
|
| def repack(blob, edits, additions): |
| """Rewrite edited members in place, append each addition after solution/solution.py. |
| |
| Added members copy ownership from the anchor member, with mode 0755 and mtime 0. |
| """ |
| out = io.BytesIO() |
| compress = blob[:2] == b'\x1f\x8b' |
| stream = gzip.GzipFile(filename='', fileobj=out, mode='wb', compresslevel=9, mtime=0) if compress else out |
| anchor = 'solution/solution.py' |
| with tarfile.open(fileobj=io.BytesIO(blob), mode='r:*') as src, \ |
| tarfile.open(fileobj=stream, mode='w', format=src.format) as dst: |
| for member in src: |
| info = copy.copy(member) |
| info.mtime = 0 |
| info.pax_headers = {k: v for k, v in member.pax_headers.items() |
| if k not in ('mtime', 'atime', 'ctime')} |
| if info.name in edits: |
| info.size = len(edits[info.name]) |
| dst.addfile(info, io.BytesIO(edits[info.name])) |
| elif member.isfile(): |
| dst.addfile(info, src.extractfile(member)) |
| else: |
| dst.addfile(info) |
| if member.name == anchor: |
| for name, data in additions.items(): |
| new = tarfile.TarInfo(name) |
| new.size = len(data) |
| new.mode = 0o755 |
| new.mtime = 0 |
| new.uid, new.gid = member.uid, member.gid |
| new.uname, new.gname = member.uname, member.gname |
| dst.addfile(new, io.BytesIO(data)) |
| if compress: |
| stream.close() |
| return out.getvalue() |
|
|
|
|
| def patch_task(blob, task_id=None): |
| files = read_members(blob) |
| additions = {'solution/solve.sh': add_oracle_wrapper(files)} |
| pin_pytest(files) |
| edits = {name: files[name] for name in ('environment/Dockerfile', 'tests/test.sh')} |
| edits['task.toml'] = migrate_verifier_mode(files['task.toml']) |
| reference_edits, reference_additions = repair_reference(task_id, files) |
| edits.update(reference_edits) |
| additions.update(reference_additions) |
| edits.update(repair_numpy_environment(task_id, files)) |
| edits.update(pin_repaired_pytest(task_id, {**files, **edits, **additions})) |
| edits.update(repair_instruction_paths(task_id, files)) |
| return repack(blob, edits, additions) |
|
|
|
|
| def main(): |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--source", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args() |
| args.output.mkdir(parents=True, exist_ok=True) |
| source = pq.ParquetFile(args.source) |
| if source.metadata.num_rows != EXPECTED_TASK_COUNT: |
| raise ValueError(f'Expected {EXPECTED_TASK_COUNT} tasks, got {source.metadata.num_rows}') |
| patched = 0 |
| labels, reasons = {}, {} |
| with pq.ParquetWriter(args.output / "tasks.parquet", source.schema_arrow) as writer: |
| for batch in source.iter_batches(batch_size=32): |
| rows = batch.to_pylist() |
| for row in rows: |
| task_id = row['path'] |
| row['task_binary'] = patch_task(row['task_binary'], task_id) |
| labels[task_id] = ['pymethods-preparation-repairs'] |
| reasons[task_id] = ('Pinned pytest, added the reference entry point and migrated the shared verifier schema. ' |
| + REPAIR_REASONS.get(task_id, 'The supplied reference solution is unchanged.')) |
| patched += 1 |
| writer.write_table(pa.Table.from_pylist(rows, schema=source.schema_arrow)) |
| if patched != EXPECTED_TASK_COUNT: |
| raise ValueError(f'Patched {patched} tasks, expected {EXPECTED_TASK_COUNT}') |
| manifest = {'patch_version': PATCH_VERSION, 'revision': REVISION, |
| 'r1_pin_pytest_tasks': patched, 'r2_oracle_wrapper_tasks': patched, |
| 'r3_shared_verifier_schema_tasks': patched, |
| 'reference_repairs': {task: reason for task, reason in REPAIR_REASONS.items() if task in labels}} |
| (args.output / 'manifest.json').write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n') |
| write_patch_report(args.source, args.output / 'tasks.parquet', |
| source={'dataset': 'open-thoughts/TaskTrove', 'revision': REVISION, |
| 'url': 'https://huggingface.co/datasets/open-thoughts/TaskTrove/tree/' + REVISION + '/DCAgent__exp_rpt_pymethods2test-large-v2', |
| 'subset': 'DCAgent__exp_rpt_pymethods2test-large-v2'}, |
| dropped={}, change_labels=labels, change_reasons=reasons, |
| patcher=__file__) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
