Publish PyMethods2Test v1: 4,990 kept tasks with verified images

pymethods2test_v1/README.md

@@ -0,0 +1,54 @@
+# [PyMethods2Test](https://huggingface.co/datasets/open-thoughts/TaskTrove/tree/946884702046be1a7dcea2638186ad6b0d2ea103/DCAgent__exp_rpt_pymethods2test-large-v2)
+
+## Dataset stats
+
+- **Original tasks:** 4,990
+- **Kept:** 4,990
+- **Changed:** 4,990
+- **Archived:** 0
+- **Images:** 1 image before, 3 images now.
+
+## Dataset characteristics
+
+PyMethods2Test turns Python methods and their unit tests into tasks: implement the described function in `/app/solution.py` so that the supplied pytest suite passes.
+
+<details><summary>Domains</summary>
+
+**Software Engineering:** Every sampled task asks the agent to write one self-contained Python function with a prescribed name and signature into /app/solution.py (e.g. GCD of a list, factorial mod 1e9+7, BFS over digit multiplications, additive-sequence check, triangular-number ranges). A pytest/unittest file derived from the original focal method's unit test is the verifier, and metadata marks each item as source 'pymethods2test' with the repo/path fields blank. The work is pure code implementation from a natural-language spec; there is no existing codebase, system state, data, or external service involved.
+
+</details>
+<details><summary>Capabilities</summary>
+
+**Specification Adherence:** Intended practice: the hidden tests import a specific function name from /app/solution.py and check exact return shapes (a dict keyed by natural numbers, the tuple ('YES', x, y, z) versus the bare string 'NO', a default argument of '', integer division for means, float tolerance for the Nim probability), so the agent must keep the stated file path, signature, and output contract rather than drift toward a more natural design. Several instructions also contain details the tests contradict or omit (e.g. the additive-sequence example claims '123' is False but the test asserts True; the Nim example output 0.2 does not match the test values), so reward depends on matching the original repository's behavior, not polishing the prose spec. No trajectories were supplied, so this is inferred from task structure, not observed behavior. **Mathematical Derivation:** A minority of sampled tasks require working out the formula before coding: the straw problem needs the insight that the best rectangle splits N into floor(N/4)^2 versus x*(x+1) side lengths, and the Nim problem requires recognizing an XOR-convolution raised to the n-th power by repeated squaring to pass the n=1e9 test within the timeout. Most tasks (string matching, GCD, factorial, scaling scores) need no derivation, so this is a secondary target observed only in the task contents, not in any trajectory. These are intended capabilities inferred from task examples, not measured agent behavior. Labels follow [CLI-Universe](https://arxiv.org/abs/2606.22883v1).
+
+</details>
+
+Intended benchmark transfer: **HumanEval+**, Same problem shape: implement a single Python function from a natural-language description with examples, graded by hidden functional tests that include edge cases (empty input, minimal values, large inputs). Practicing exact signature/return-type compliance against stricter-than-shown tests directly targets what EvalPlus's expanded tests catch; **MBPP+**, The tasks are short, mostly algorithmic Python functions (GCD, factorial modulo, triangular numbers, sequence checks) with a required function name and assert-style unit tests, which closely matches MBPP+ problems and their extended test suites. The 4,990 verifiable items provide execution-grounded reward for exactly this style of entry-level Python programming.
+
+## Per-stage breakdown
+
+- **1. Build and setup: 4,990 changed, 0 archived.** Changed all 4,990 tasks to pin pytest, which was installed unpinned, and to use the supported shared verifier environment setting. Changed 19 tasks to install NumPy, which their reference solutions import but their images never installed.
+- **2. Reference solution (reward 1): 4,990 changed, 0 archived.** Changed all 4,990 tasks to add an entry point that runs the supplied reference solution. Changed 38 reference solutions to add a missing standard-library import, such as `from collections import deque`; function bodies and tests are unchanged. All 4,990 reference solutions scored 1.
+- **3. No-op baseline (reward 0): 0 changed, 0 archived.** All 4,990 tasks scored 0 without a solution. Manually approved 176 false positives from the no-op checker, which could not confirm verifier execution; the corresponding reference solutions passed. In each, the tests stopped only because the missing solution module could not be imported.
+- **4. Rule-based checks: 4,990 changed, 0 archived.** Changed all 4,990 tasks so their instruction ends with the time limit and the request not to cheat. Flagged 88 tasks for relative paths. Automatic repair cleared warnings for 15 tasks. 73 tasks still have warnings. Inspected 50: all were fine, naming `solution.py` in the `/app` working directory where the verifier reads it. All other rule-based checks passed. Git-history and timestamp cleanup do not apply: the tasks contain no repository.
+
+The reference-solution leak check ran on 177 tasks, all passing; it did not run on the remaining 4,813.
+
+## Per-task resource requirements
+
+| CPUs | Memory | Agent timeout | Verifier timeout | Tasks |
+| ---: | ---: | ---: | ---: | ---: |
+| Unspecified | Unspecified | 900 s | 720 s | 4,990 |
+
+## Runtime and validation time
+
+- **Versions:** Python **3.12.14**, Harbor **0.8.1**, Apptainer backend; tasks run Python 3.10 with pytest 9.1.1, or 9.0.2 for the 55 repaired tasks.
+- **Implementation:** [Marin Harbor `7faf878c14b6`](https://github.com/marin-community/harbor/tree/7faf878c14b6d72737579ec936ebf5f74ba3194d) with [our runtime patches](https://github.com/MLI-lab/OT-next-data/tree/main/harbor_patches).
+- **Resources:** CLAIX jobs of **16 CPU cores, 64 GiB RAM** with trial concurrency 4; one repaired task ran on Helma with **8 CPU cores, 15 GiB RAM**; image building uses **4 CPU cores and 8 GiB RAM per image**. Includes the full validation run and reruns of repaired tasks.
+
+| Stage | Measured tasks | Summed task time | Mean per task | Median per task |
+| --- | --- | --- | --- | --- |
+| 1. Build and setup (container start and setup) | 4,990 (all kept) | 133.6 h | 96.4 s | 6.2 s |
+| 2. Reference solution | 4,990 (all kept) | 148.5 h | 107.2 s | 23.5 s |
+| 3. No-op baseline | 4,990 (all kept) | 121.6 h | 87.7 s | 23.1 s |
+| 4. Rule-based checks | 4,990 (all kept) | 0.4 h | 0.3 s | 0.3 s |

pymethods2test_v1/archive.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6fb5add101f55322d2bbccdc5cfaf9fb9fbff0cb808706b62358265b4fe5dec
+size 3758533

pymethods2test_v1/patch.py

@@ -0,0 +1,282 @@
+"""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.
+"""
+
+# Support both direct execution and python -m data.<source>.patch.
+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)
+                # Keep pip-check parsing unambiguous, as in the existing R1 fix.
+                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()

pymethods2test_v1/repairs/import_repairs.json

@@ -0,0 +1,228 @@
+{
+  "pymethods2test-0213": {
+    "reference_sha256": "90e6f4101a630eab04ac70bcc01071780a1bd32e043eff446e75f780a477cc14",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-0310": {
+    "reference_sha256": "45b626f9c41bf9fad10611d5eee9ff72bb2664e2edd1d82358d92099ef0698fe",
+    "imports": [
+      "from collections import defaultdict"
+    ]
+  },
+  "pymethods2test-0475": {
+    "reference_sha256": "2799b0234bb6e0cebca9032bb295f892a3e5d820fbe1f810f57ccfd70b20ab79",
+    "imports": [
+      "from heapq import heappop",
+      "from heapq import heappush"
+    ]
+  },
+  "pymethods2test-0610": {
+    "reference_sha256": "37ddef14c395e4f849dc22f291fd95a8e74a7563f557d929db99a4b70cd6fdc5",
+    "imports": [
+      "from itertools import product"
+    ]
+  },
+  "pymethods2test-0739": {
+    "reference_sha256": "2bf7ea4619663c05cc1b53aa3473ba1a1b30095d5955b3d2ca4c2f1a0c22d387",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-0979": {
+    "reference_sha256": "2240cbc6e122635bb769518ba3868f774d79d8427e91cf6f0ca9a273bcb30cdb",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-1055": {
+    "reference_sha256": "758dc3eb631976dfda68ffcff3e7f9138148bb2be5ed43f978bcd6b197b8cfca",
+    "imports": [
+      "from collections import defaultdict"
+    ]
+  },
+  "pymethods2test-1191": {
+    "reference_sha256": "03afa57d35b88b93d10294c4dd3c7640aae8c55d22a6776fe05bb2ee75f6562a",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-1327": {
+    "reference_sha256": "52a8ba2800ec5497d61dabc2d29f01facb400177ec00ddf94b20ac103e1b1068",
+    "imports": [
+      "from collections import Counter"
+    ]
+  },
+  "pymethods2test-1332": {
+    "reference_sha256": "4cc1604cc28af09661e23840a8a60c0dd675843291247b87aa643e53ebbd640a",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-1576": {
+    "reference_sha256": "c16acea1bcb3f842615424b50ef667471cee063fb55622e0845597cc692540f6",
+    "imports": [
+      "import collections"
+    ]
+  },
+  "pymethods2test-1763": {
+    "reference_sha256": "a76717a7329e2edc84d264dc1bf57d9abefc312082f2e16fed7f7c0f2071bcc1",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-1823": {
+    "reference_sha256": "c02e3113ddb1b3967ed2e4ca5fdc55fb6e65f4643918c9498a806ec4be181e6e",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-1970": {
+    "reference_sha256": "f1abb9ae7576a90e47c7c3d7fe61ac77ac47bf3b58aeddab7a2973a876cdcb53",
+    "imports": [
+      "from bisect import bisect_left"
+    ]
+  },
+  "pymethods2test-1998": {
+    "reference_sha256": "94d0af479b841e8e91ed0a7f7897d42bccd62525461d60b4edc68c3d41154125",
+    "imports": [
+      "from collections import defaultdict"
+    ]
+  },
+  "pymethods2test-2107": {
+    "reference_sha256": "c0988b6034adf295c4ee320fabc983c78cd35d6cf2c1d45bd91368f346ac8e53",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-2284": {
+    "reference_sha256": "9be6dc2902e2bb9605aa6d7c07c2d5b9693b86876826338917d0bfa97f2df336",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-2386": {
+    "reference_sha256": "6549e17d3aac2b4a76fb9593add19d207214344f31caf4e0133673b0e87ae88e",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-2503": {
+    "reference_sha256": "7dfe8313e9ddaaecf18b8289030cf0fce5d91060eee24c2a949e1880dcd0748c",
+    "imports": [
+      "from itertools import islice"
+    ]
+  },
+  "pymethods2test-2675": {
+    "reference_sha256": "5c97fc172dcb17c5ad8baa7ced6c0ce85dd00b7dff977b4907318fe0caa9545e",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-2874": {
+    "reference_sha256": "26c9bb73f8658a061718182ba8290290692566d80de1b498b9572b1f1ea708d9",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-2927": {
+    "reference_sha256": "650c9d2b892abaed155c5f48b4db7c09234f5b628e86f2abb2499c16523bdb22",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-3052": {
+    "reference_sha256": "4d94a46d89740695b0acc6f69932320493647ea7c6eadbce9fcb295804570333",
+    "imports": [
+      "from itertools import zip_longest"
+    ]
+  },
+  "pymethods2test-3319": {
+    "reference_sha256": "a94ab983968017fafce2bbfc18d1f25b3782699685c6b6f57e724ccdc3b379ae",
+    "imports": [
+      "from itertools import product"
+    ]
+  },
+  "pymethods2test-3355": {
+    "reference_sha256": "07887d3d71c08538e19d5740cc8c9abb1a81242a01c29726fcff51bbfc8574cc",
+    "imports": [
+      "from math import gcd"
+    ]
+  },
+  "pymethods2test-3456": {
+    "reference_sha256": "134469f84149611d9704737fd861d57406727ca5d761817bd506e9463b39e948",
+    "imports": [
+      "import math"
+    ]
+  },
+  "pymethods2test-3593": {
+    "reference_sha256": "2489ac877421296dffd7ea68b4ba1e93b6020bd0ebcbfcd38652a7cc4a857824",
+    "imports": [
+      "from collections import Counter"
+    ]
+  },
+  "pymethods2test-3779": {
+    "reference_sha256": "1088e8c80b904bbb2ea80cf79892ff172ee567c88a9f69b6881186109b748c44",
+    "imports": [
+      "import re"
+    ]
+  },
+  "pymethods2test-3851": {
+    "reference_sha256": "598ad36ad3363980898f3e76d6ffd750164db2633f1a6193d62f1d1dc767bfc3",
+    "imports": [
+      "from itertools import product"
+    ]
+  },
+  "pymethods2test-3892": {
+    "reference_sha256": "08fb1a081330a38cc41fe29ae7c4162e26d275799f521a17780e4c63cc7a3b14",
+    "imports": [
+      "import sys"
+    ]
+  },
+  "pymethods2test-4188": {
+    "reference_sha256": "f2dbe5036c1a63846f1a36c5cd8c19e8c466586b5f9aea5ae2a7012043e0c3fe",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-4209": {
+    "reference_sha256": "6cbd02638341c8988437375081eb1e1b7c512c1bc1076c755402a5cb5e6e1aa7",
+    "imports": [
+      "from math import ceil",
+      "from math import floor",
+      "from math import sqrt"
+    ]
+  },
+  "pymethods2test-4281": {
+    "reference_sha256": "ecc7b2fbec7317b6f7bfa3b5d4899ddcf5d9b2dc66512292deef5639ca121746",
+    "imports": [
+      "import heapq"
+    ]
+  },
+  "pymethods2test-4350": {
+    "reference_sha256": "8f9ca76f3923ec7c7b4fb2fc0461bc6b373c00bfcf277581260a6ecf3605be90",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-4514": {
+    "reference_sha256": "0df73c75dc4a025d9493390757243d480af7dfee6cad55c3a2064315fd0a84a9",
+    "imports": [
+      "from collections import defaultdict"
+    ]
+  },
+  "pymethods2test-4526": {
+    "reference_sha256": "8f8422c8e053e0bd4a758fe05c8a2f55b63f9d497b1b2d77f3928aca6146c057",
+    "imports": [
+      "from collections import deque"
+    ]
+  },
+  "pymethods2test-4569": {
+    "reference_sha256": "a2e1c82eb7fb84b0b80f3daefea36f909ea49afcfeab4d550e1e7b5c924e3317",
+    "imports": [
+      "from collections import Counter",
+      "from collections import defaultdict"
+    ]
+  }
+}

pymethods2test_v1/repairs/numpy_repairs.json

@@ -0,0 +1,20 @@
+{
+  "pymethods2test-0457": "2509961835f09b99321d9be863e28df053a7f1fc4bcb761775585c5b3f4ec8d2",
+  "pymethods2test-0469": "a691b1f4248bd5cf09f40accf3a654bdf9741c2c50bbe163a504cdfc0da5f0a4",
+  "pymethods2test-0732": "7addc2c7918145a0146221bf19c71da21cf2d004f63aa2b33499058364eff5b7",
+  "pymethods2test-0907": "2ab239603b14b8e7cfb86eff4b5de6e6b4ad4b78902eba9e8904ca53ca0bf1b2",
+  "pymethods2test-2208": "135154b90c774ded69ce3bec4e4eb76de0aff5fd8d3668a7f0963d54e0b836db",
+  "pymethods2test-2331": "2cd77e1bb8f0fc8df80919b9db09ea876ca883b6b823965e872b7c5e68fa40be",
+  "pymethods2test-2354": "6bdab6cadeabadaf7f3976847b5a014c2d9058c23ed8944a44147779161f32bc",
+  "pymethods2test-2680": "227c22136cd8e5e8930b25aa3675e968cafbd096c0d003a83f7dd141c26de11b",
+  "pymethods2test-2995": "fc434955063469f33bb80a4084f74f8f7132c56599bed51618ff5237ea528786",
+  "pymethods2test-3005": "02b537187f6a75cd46e1efd82b5248ea9d7d58cb6322cce6e5bc2fbaa7eae29c",
+  "pymethods2test-3148": "0355c12c3adb012635af0caa195df4b2825641326bf174aeda160924b550dd46",
+  "pymethods2test-3525": "e5bd901e1b5fc80dfb179ab48f9c7c5e608037276b6209e7e6f904e28bb59947",
+  "pymethods2test-3701": "e1ee3a3886e9b48c823be78b865a47c5033ef361309af5b27f93e07649d7a9f4",
+  "pymethods2test-3772": "0d879b3d91e595ddf9d35dd98054451200f02fc814d9f20cc3bb5beafae7bbe3",
+  "pymethods2test-4306": "d46e3d1b7f73f7b37862bd9bd9c7b87e65f6129e1b974b2f3d64a8342334b094",
+  "pymethods2test-4434": "59e6bea4cbafc2be216e8482950097dc8440007a79c5d66d8fe7657f03a6520e",
+  "pymethods2test-4752": "51f5ec0152261e968ffeb020f1c62b97bcf97a2c268286bf2c3e6df551ba441a",
+  "pymethods2test-4921": "b452a65cb0e5bee4006b2351306a2e2c693847f154e87d8754d0db8856446d5c"
+}

pymethods2test_v1/repairs/path_repairs.json

@@ -0,0 +1,185 @@
+{
+  "pymethods2test-0099": {
+    "instruction_sha256": "efdaa9040be74fde8a5945799281d6c64a9d0c6410d80754dbf0e3a4c19a453a",
+    "edits": [
+      {
+        "start": 1522,
+        "end": 1533,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-0406": {
+    "instruction_sha256": "85361801600625eaf5ef96025dddcc151643bff63f0a56b564c1e62f464718bd",
+    "edits": [
+      {
+        "start": 787,
+        "end": 798,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-0456": {
+    "instruction_sha256": "2b6ece08bb8fcea3e72eb923967a59dec2bcc648fed5dca484619565f37c1b57",
+    "edits": [
+      {
+        "start": 1309,
+        "end": 1320,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-0605": {
+    "instruction_sha256": "4dee057eb87ec7390c2fd6a9ee879f83ff06971f1d782e73f80bcaa6a88a50ec",
+    "edits": [
+      {
+        "start": 1063,
+        "end": 1074,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-1056": {
+    "instruction_sha256": "89e6942a19331437337b1a2847a27ac84af9ecb71d305da304ecdb315ec28e0c",
+    "edits": [
+      {
+        "start": 926,
+        "end": 937,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      },
+      {
+        "start": 984,
+        "end": 995,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-1204": {
+    "instruction_sha256": "5ddf376bd699a86106cf33000fcf73db80647d804f96959a94c68a7201afd650",
+    "edits": [
+      {
+        "start": 874,
+        "end": 885,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-1205": {
+    "instruction_sha256": "93460b2371ab9b99651d0c6b389891806fdf4309f77b8195c47144ee73a5a0af",
+    "edits": [
+      {
+        "start": 1393,
+        "end": 1404,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-1285": {
+    "instruction_sha256": "5f51df5578011f3797e776d9daf655f302c74cc3fe8701237a7695a0e13549ef",
+    "edits": [
+      {
+        "start": 922,
+        "end": 933,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-2255": {
+    "instruction_sha256": "1c233e6d2e5e0c2df1078e7354e27166749b9c5029be2096426d4127f3c54f6f",
+    "edits": [
+      {
+        "start": 755,
+        "end": 766,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-2708": {
+    "instruction_sha256": "a7566ba2dc34a197884274695ac6849cf743b7a8882bcaf4f5d25cd5b45ec49e",
+    "edits": [
+      {
+        "start": 1207,
+        "end": 1218,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-3059": {
+    "instruction_sha256": "f0e0a024dc111c47073cde867392b8722d2d0ca4f67e2a47fb2a9b13ad3f17b1",
+    "edits": [
+      {
+        "start": 1289,
+        "end": 1300,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      },
+      {
+        "start": 1368,
+        "end": 1379,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-3255": {
+    "instruction_sha256": "aeca764d345685d5b864026166b2eba942d13add5ef63f5a6eb2b7a80487db48",
+    "edits": [
+      {
+        "start": 823,
+        "end": 834,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-3422": {
+    "instruction_sha256": "a4a3d42e35303410f895f656820ed3fedc12654542127178c622d0490ece9dd8",
+    "edits": [
+      {
+        "start": 739,
+        "end": 750,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-3659": {
+    "instruction_sha256": "76adbb52a28552741d555d8ea433eaaa6bfd2a4f4c448029d3d0bc5d19e0da91",
+    "edits": [
+      {
+        "start": 715,
+        "end": 726,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      },
+      {
+        "start": 771,
+        "end": 782,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  },
+  "pymethods2test-4209": {
+    "instruction_sha256": "576b3f1cb2b009767869e5ce2d5ed554e5b40273e492f17d67cd25ac801b04e4",
+    "edits": [
+      {
+        "start": 1188,
+        "end": 1199,
+        "old": "solution.py",
+        "new": "/app/solution.py"
+      }
+    ]
+  }
+}

pymethods2test_v1/tasks.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbf2edf6a4870f8503914d974832693f01fd1977ae5f98744d5dc56c1c60f0dd
+size 17153849