| """Build SWE-DockerLess.jsonl from the repos/ fixed/ newtests/ trees. |
| |
| For every instance this script really does the work: |
| |
| 1. git-init the base repo and record the commit sha (base_commit); |
| 2. overlay the gold fix, capture ``git diff`` as the patch, restore; |
| 3. overlay the new tests, capture ``git diff --cached`` as the test_patch; |
| 4. materialise a clean checkout, apply test_patch, run pytest -> "before"; |
| 5. apply patch, run pytest -> "after"; |
| 6. derive FAIL_TO_PASS (fail before, pass after) and PASS_TO_PASS |
| (pass before, pass after) from the observed outcomes, not from guesses. |
| |
| Run with: python build_dataset.py |
| """ |
|
|
| import json |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent |
| REPOS = ROOT / "repos" |
| FIXED = ROOT / "fixed" |
| NEWTESTS = ROOT / "newtests" |
| OUT = ROOT / "SWE-DockerLess.jsonl" |
|
|
| STAMP = "2026-10-30T12:00:00+0000" |
| GIT_ENV = { |
| "GIT_AUTHOR_NAME": "swedl", |
| "GIT_AUTHOR_EMAIL": "swedl@example.invalid", |
| "GIT_COMMITTER_NAME": "swedl", |
| "GIT_COMMITTER_EMAIL": "swedl@example.invalid", |
| "GIT_AUTHOR_DATE": STAMP, |
| "GIT_COMMITTER_DATE": STAMP, |
| "GIT_CONFIG_NOSYSTEM": "1", |
| } |
| GIT_FLAGS = [ |
| "-c", "core.autocrlf=false", |
| "-c", "core.safecrlf=false", |
| "-c", "user.name=swedl", |
| "-c", "user.email=swedl@example.invalid", |
| "-c", "commit.gpgsign=false", |
| ] |
|
|
| PYTEST_CMD = "python -m pytest -v --tb=no -p no:cacheprovider" |
| RESULT_RE = re.compile( |
| r"^(tests/[^\s:]+::[^\s]+)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)" |
| ) |
|
|
| INSTANCES = [ |
| { |
| "instance_id": "swedl__miniconf-1", |
| "repo": "swedl/miniconf", |
| "name": "miniconf", |
| "problem_statement": ( |
| "Config interpolation blows up on reference cycles and expands escaped text.\n\n" |
| "We use miniconf for service configs that are layered from a shared file plus a\n" |
| "per-environment overlay. Two problems, both reproducible on main:\n\n" |
| "1. A cycle anywhere in the mapping crashes with `RecursionError` instead of the\n" |
| " documented error. `Config({'a': '${b}', 'b': '${a}'})['a']` recurses until the\n" |
| " interpreter gives up, and the traceback is a thousand frames of `_interpolate`.\n" |
| " The README says this must raise `CircularReferenceError` with a message naming\n" |
| " the chain, and we rely on that message in our error reporting.\n\n" |
| "2. `$$` does not escape. Our TLS config has `cert_subject: \"$${cluster}\"`, meaning\n" |
| " the literal text `${cluster}` to be handed to a downstream templating tool, but\n" |
| " miniconf substitutes the cluster name into it. The README's escape rule is not\n" |
| " implemented at all.\n\n" |
| "Both bugs live in `Config._resolve` / `Config._interpolate` in\n" |
| "`miniconf/config.py`. `README.md` section \"Interpolation contract\" is the spec we\n" |
| "want honoured, including the exact wording of the cycle message and the rule that\n" |
| "substituted text is never rescanned for references. A cycle that is unrelated to\n" |
| "the key being read must not affect that read, and `as_dict()` must surface cycles\n" |
| "like any other read.\n\n" |
| "The existing suite passes; the escape and cycle behaviour was never covered." |
| ), |
| }, |
| { |
| "instance_id": "swedl__ttlcache-1", |
| "name": "ttlcache", |
| "repo": "swedl/ttlcache", |
| "problem_statement": ( |
| "LRU eviction ignores reads, and len() counts entries that already expired.\n\n" |
| "Our request cache is a `TTLCache(maxsize=N, ttl=...)` and it is evicting the wrong\n" |
| "keys under load:\n\n" |
| "1. Reading a key does not protect it. With `maxsize=2`, writing `a`, `b`, reading\n" |
| " `a`, then writing `c` drops `a` and keeps `b` -- the exact opposite of LRU. The\n" |
| " same happens when a key is overwritten: the new write keeps the old position\n" |
| " instead of becoming the most recently used entry.\n\n" |
| "2. `len(cache)` returns the number of stored rows, including rows whose TTL already\n" |
| " elapsed. Our metrics dashboard reports a cache that never shrinks even though\n" |
| " every read says the key is gone.\n\n" |
| "3. `items()` order does not reflect access order for the same reason.\n\n" |
| "`README.md` documents the intended contract (sections 2-5): reads and overwrites\n" |
| "mark an entry most-recently-used, expired entries are purged before eviction\n" |
| "happens, and `len()` counts live entries only. `ttlcache/cache.py` is the file to\n" |
| "fix; `ttlcache/clock.py` already gives you a deterministic `FakeClock`.\n\n" |
| "Be careful that expiry still deletes the entry on read and that `get()` keeps\n" |
| "returning its default for missing keys." |
| ), |
| }, |
| { |
| "instance_id": "swedl__cronlite-1", |
| "name": "cronlite", |
| "repo": "swedl/cronlite", |
| "problem_statement": ( |
| "`5/15` in the minute field only fires once an hour, and day-of-week 7 is rejected.\n\n" |
| "Two field-parsing bugs, both in `cronlite/fields.py`:\n\n" |
| "1. A single value followed by a step is treated as a one-element set. `5/15`\n" |
| " parses to `{5}` instead of `{5, 20, 35, 50}`, so a job scheduled at\n" |
| " `5/20 * * * *` runs at 00:05, 01:05, 02:05 instead of every twenty minutes\n" |
| " starting at :05. `*/20` and `1-10/3` are correct -- only the `<value>/<step>`\n" |
| " form is wrong, because the upper bound collapses to the start value.\n\n" |
| "2. Sunday cannot be written as 7. `0 12 * * 7` raises\n" |
| " `ValueError: day_of_week value out of range: 7` at construction time, and so do\n" |
| " `7`, `1,7` and `6-7`. Standard cron accepts 0-7 for that field with both 0 and 7\n" |
| " meaning Sunday. The README's \"Day of week\" section asks for the 7 alias to be\n" |
| " accepted everywhere a value is accepted and collapsed onto 0, so that a parsed\n" |
| " day-of-week set is always expressed on the 0-6 scale (`6-7` -> `{6, 0}`).\n\n" |
| "Everything else about the field syntax must keep working, including the existing\n" |
| "range checks and the descending-range rejection." |
| ), |
| }, |
| { |
| "instance_id": "swedl__semverlite-1", |
| "name": "semverlite", |
| "repo": "swedl/semverlite", |
| "problem_statement": ( |
| "Prerelease ordering is lexicographic, and prereleases leak into release ranges.\n\n" |
| "Two spec violations against semver 2.0.0:\n\n" |
| "1. Prerelease identifiers are compared as strings. `1.0.0-alpha.2` sorts *after*\n" |
| " `1.0.0-alpha.10` because `\"2\" > \"1\"`, and `1.0.0-beta.2` sorts after\n" |
| " `1.0.0-beta.11`. Sorting a release train produces a wrong order. Numeric\n" |
| " identifiers must compare numerically, a numeric identifier must sort below an\n" |
| " alphanumeric one, and a shorter prerelease must sort below a longer one that\n" |
| " shares its prefix.\n\n" |
| "2. A prerelease satisfies ranges that never opted into prereleases.\n" |
| " `VersionRange('>=1.0.0').allows(Version.parse('1.0.1-alpha'))` returns True, and\n" |
| " so does `~1.2.3` with `1.2.4-rc.1`. That makes our upgrade tool offer release\n" |
| " candidates as if they were final releases. A prerelease may only satisfy a range\n" |
| " when some clause names a prerelease on the same `major.minor.patch` triple, so\n" |
| " `>=1.0.0-alpha` does allow `1.0.0-beta` but not `1.0.1-beta`.\n\n" |
| "`semverlite/version.py` holds precedence, `semverlite/range.py` holds range\n" |
| "matching; `README.md` states both rules precisely. Build metadata must stay\n" |
| "ignored for precedence, and equality/hashing must stay consistent with the new\n" |
| "ordering." |
| ), |
| }, |
| ] |
|
|
|
|
| def run(cmd, cwd, check=True): |
| env = os.environ.copy() |
| env.update(GIT_ENV) |
| proc = subprocess.run( |
| cmd, cwd=str(cwd), capture_output=True, text=True, encoding="utf-8", env=env |
| ) |
| if check and proc.returncode != 0: |
| raise RuntimeError( |
| "command failed (%d): %s\n--- stdout ---\n%s\n--- stderr ---\n%s" |
| % (proc.returncode, " ".join(cmd), proc.stdout, proc.stderr) |
| ) |
| return proc |
|
|
|
|
| def git(args, cwd, check=True): |
| return run(["git"] + GIT_FLAGS + args, cwd, check=check) |
|
|
|
|
| def overlay(src_root, dst_root): |
| """Copy every file under src_root into dst_root, preserving relative paths.""" |
| for path in sorted(src_root.rglob("*")): |
| if path.is_dir() or ".git" in path.parts: |
| continue |
| target = dst_root / path.relative_to(src_root) |
| target.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(path, target) |
|
|
|
|
| def read_tree(root): |
| files = {} |
| for path in sorted(root.rglob("*")): |
| if path.is_dir() or ".git" in path.parts: |
| continue |
| rel = path.relative_to(root).as_posix() |
| files[rel] = path.read_text(encoding="utf-8") |
| return files |
|
|
|
|
| def write_tree(files, dest): |
| for rel, content in files.items(): |
| path = dest / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with open(path, "w", encoding="utf-8", newline="\n") as handle: |
| handle.write(content) |
|
|
|
|
| def parse_outcomes(stdout): |
| outcomes = {} |
| for raw in stdout.splitlines(): |
| match = RESULT_RE.match(raw.strip()) |
| if match: |
| outcomes[match.group(1)] = match.group(2) |
| return outcomes |
|
|
|
|
| def run_tests(dest, test_files): |
| proc = run( |
| [sys.executable, "-m", "pytest", "-v", "--tb=no", "-p", "no:cacheprovider"] |
| + list(test_files), |
| dest, |
| check=False, |
| ) |
| return parse_outcomes(proc.stdout), proc |
|
|
|
|
| def build_instance(spec): |
| name = spec["name"] |
| repo_dir = REPOS / name |
|
|
| git_dir = repo_dir / ".git" |
| if git_dir.exists(): |
| shutil.rmtree(git_dir) |
| git(["init", "-q", "-b", "main"], repo_dir) |
| git(["add", "-A"], repo_dir) |
| git(["commit", "-q", "-m", "initial import"], repo_dir) |
| base_commit = git(["rev-parse", "HEAD"], repo_dir).stdout.strip() |
|
|
| |
| overlay(FIXED / name, repo_dir) |
| patch = git(["diff", "--no-color", "--no-ext-diff"], repo_dir).stdout |
| git(["checkout", "--", "."], repo_dir) |
| if not patch.strip(): |
| raise RuntimeError("%s: gold patch is empty" % name) |
|
|
| |
| overlay(NEWTESTS / name, repo_dir) |
| git(["add", "-A"], repo_dir) |
| test_patch = git(["diff", "--cached", "--no-color", "--no-ext-diff"], repo_dir).stdout |
| git(["reset", "-q", "--hard", "HEAD"], repo_dir) |
| git(["clean", "-qfd"], repo_dir) |
| if not test_patch.strip(): |
| raise RuntimeError("%s: test patch is empty" % name) |
|
|
| base_files = read_tree(repo_dir) |
| test_files = sorted( |
| rel for rel in base_files if rel.startswith("tests/") and rel.endswith(".py") |
| ) |
| test_files += sorted( |
| rel |
| for rel in read_tree(NEWTESTS / name) |
| if rel.startswith("tests/") and rel.endswith(".py") |
| ) |
| test_files = sorted(set(test_files)) |
|
|
| |
| with tempfile.TemporaryDirectory(prefix="swedl-") as tmp: |
| work = Path(tmp) / "work" |
| work.mkdir() |
| write_tree(base_files, work) |
| git(["init", "-q", "-b", "main"], work) |
| git(["add", "-A"], work) |
| git(["commit", "-q", "-m", "base"], work) |
|
|
| test_patch_file = Path(tmp) / "test.patch" |
| test_patch_file.write_text(test_patch, encoding="utf-8", newline="\n") |
| git(["apply", "--check", str(test_patch_file)], work) |
| git(["apply", str(test_patch_file)], work) |
|
|
| before, before_proc = run_tests(work, test_files) |
|
|
| patch_file = Path(tmp) / "gold.patch" |
| patch_file.write_text(patch, encoding="utf-8", newline="\n") |
| git(["apply", str(patch_file)], work) |
| after, after_proc = run_tests(work, test_files) |
|
|
| if not before: |
| raise RuntimeError( |
| "%s: no test outcomes collected\n%s\n%s" |
| % (name, before_proc.stdout[-3000:], before_proc.stderr[-2000:]) |
| ) |
| missing = set(before) - set(after) |
| if missing: |
| raise RuntimeError("%s: tests disappeared after patch: %s" % (name, sorted(missing))) |
|
|
| f2p = sorted( |
| test |
| for test, outcome in before.items() |
| if outcome in ("FAILED", "ERROR") and after.get(test) == "PASSED" |
| ) |
| p2p = sorted( |
| test |
| for test, outcome in before.items() |
| if outcome == "PASSED" and after.get(test) == "PASSED" |
| ) |
| broken = sorted(test for test, outcome in after.items() if outcome != "PASSED") |
| if broken: |
| raise RuntimeError("%s: gold patch leaves failures: %s" % (name, broken)) |
| if not f2p: |
| raise RuntimeError("%s: no FAIL_TO_PASS tests" % name) |
| if not p2p: |
| raise RuntimeError("%s: no PASS_TO_PASS tests" % name) |
|
|
| row = { |
| "instance_id": spec["instance_id"], |
| "repo": spec["repo"], |
| "base_commit": base_commit, |
| "patch": patch, |
| "test_patch": test_patch, |
| "problem_statement": spec["problem_statement"], |
| "hints_text": "", |
| "created_at": "2026-10-30", |
| "version": "1.0", |
| "environment_setup_commit": base_commit, |
| "FAIL_TO_PASS": json.dumps(f2p), |
| "PASS_TO_PASS": json.dumps(p2p), |
| "dockerless": { |
| "language": "python", |
| "python_requires": ">=3.9", |
| "install": [], |
| "run_from": ".", |
| "test_cmd": PYTEST_CMD + " {tests}", |
| "test_files": test_files, |
| "files": base_files, |
| }, |
| } |
| return row, f2p, p2p, len(patch.splitlines()) |
|
|
|
|
| def main(): |
| rows = [] |
| print("%-22s %5s %5s %7s %8s" % ("instance", "F2P", "P2P", "patch", "tests")) |
| for spec in INSTANCES: |
| row, f2p, p2p, patch_lines = build_instance(spec) |
| rows.append(row) |
| print( |
| "%-22s %5d %5d %7d %8d" |
| % (row["instance_id"], len(f2p), len(p2p), patch_lines, len(row["dockerless"]["test_files"])) |
| ) |
| for test in f2p: |
| print(" F2P %s" % test) |
|
|
| with open(OUT, "w", encoding="utf-8", newline="\n") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
| size = OUT.stat().st_size |
| print("\nwrote %s (%d rows, %.1f KiB)" % (OUT.name, len(rows), size / 1024.0)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
