"""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 `/`\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() # --- gold patch ------------------------------------------------------- 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) # --- test patch ------------------------------------------------------- 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)) # --- verify by really running pytest ---------------------------------- 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()