#!/usr/bin/env python3 """ Standalone validator for the Bash instruction-tuning dataset. This file is INTENTIONALLY DECOUPLED from generate.py -- generation never calls it. Run it by hand whenever you want to grade a dataset file. Checks (a) bash -n on every command -> syntax-failure rate (b) shellcheck (if available), warning-level -> finding rate, by SC code (c) real execution of a SAFE subset in a -> execution-error rate disposable fixture dir (opt-in: --execute) (d) summary of (a)/(b)/(c) broken down by category and utility Safety: the execution pass runs ONLY self-contained, non-destructive, non-network commands, inside a throwaway temp dir populated with dummy files/dirs named after what each command references. Anything matching rm/dd/mkfs/shutdown/reboot/fork-bomb, touching absolute/system paths, redirecting/writing outside the sandbox, or using the network is skipped -- never executed. Usage python validate.py # static checks (a,b) on the whole file python validate.py --data bash_dataset.jsonl python validate.py --shellcheck-n 4000 # cap the shellcheck sample (0 = all) python validate.py --execute --n 3000 # also run (c) on up to 3000 safe cmds """ import argparse, collections, json, os, re, shutil, subprocess, tempfile, random, sys HERE = os.path.dirname(os.path.abspath(__file__)) def find_bash(): return shutil.which("bash") or r"C:\Users\User\AppData\Local\Programs\Git\usr\bin\bash.exe" def find_shellcheck(): for c in (shutil.which("shellcheck"), os.path.join(HERE, ".venv", "Scripts", "shellcheck.exe"), os.path.join(HERE, ".venv", "bin", "shellcheck")): if c and os.path.exists(c): return c return None BASH = find_bash() SHELLCHECK = find_shellcheck() def row_nl_bash(o): if "messages" in o: nl = next(m["content"] for m in o["messages"] if m["role"] == "user") bash = next(m["content"] for m in o["messages"] if m["role"] == "assistant") return nl, bash return o.get("nl", ""), o.get("bash", "") def load(path): rows = [] with open(path, encoding="utf-8") as fh: for line in fh: line = line.strip() if not line: continue o = json.loads(line) nl, bash = row_nl_bash(o) rows.append({"nl": nl, "bash": bash, "category": o.get("category", "?"), "utility": o.get("utility", "?"), "variant_group": o.get("variant_group")}) return rows # ----------------------------------------------------------------- (a) bash -n def bash_n(snippets, chunk=400): """Return list[bool] valid? Wraps snippets as functions so multi-line scripts parse; falls back to per-snippet on a chunk failure to localize the culprit.""" d = tempfile.mkdtemp(prefix="bn_") out = [True] * len(snippets) try: for k in range(0, len(snippets), chunk): grp = list(range(k, min(k + chunk, len(snippets)))) combined = os.path.join(d, "c.sh") with open(combined, "w", encoding="utf-8", newline="\n") as fh: for i in grp: fh.write(f"__v{i}() {{\n{snippets[i]}\n}}\n") r = subprocess.run([BASH, "-n", combined], capture_output=True, text=True) if r.returncode == 0: continue for i in grp: # localize failures in this chunk p = os.path.join(d, "s.sh") with open(p, "w", encoding="utf-8", newline="\n") as fh: fh.write(f"__v() {{\n{snippets[i]}\n}}\n") rr = subprocess.run([BASH, "-n", p], capture_output=True, text=True) out[i] = rr.returncode == 0 finally: shutil.rmtree(d, ignore_errors=True) return out # ------------------------------------------------------------- (b) shellcheck def shellcheck(rows, cap): if not SHELLCHECK: return None sample = rows if (cap == 0 or cap >= len(rows)) else random.sample(rows, cap) d = tempfile.mkdtemp(prefix="sc_") files = [] try: for i, r in enumerate(sample): p = os.path.join(d, f"s{i}.sh") head = "" if r["bash"].startswith("#!") else "#!/usr/bin/env bash\n" with open(p, "w", encoding="utf-8", newline="\n") as fh: fh.write(head + r["bash"] + "\n") files.append((p, r)) path2row = dict(files) codes = collections.Counter() flagged = set() cat_flag = collections.Counter(); util_flag = collections.Counter() for k in range(0, len(files), 150): print(f" shellcheck {k}/{len(files)}", flush=True) chunk = files[k:k + 150] r = subprocess.run([SHELLCHECK, "-f", "json", "-S", "warning"] + [p for p, _ in chunk], capture_output=True, text=True) try: issues = json.loads(r.stdout or "[]") except json.JSONDecodeError: issues = [] for it in issues: f = it.get("file") if f in flagged: continue codes[f"SC{it['code']}"] += 1 flagged.add(f) row = path2row.get(f) if row: cat_flag[row["category"]] += 1 util_flag[row["utility"]] += 1 return {"n": len(sample), "flagged": len(flagged), "codes": codes, "cat_flag": cat_flag, "util_flag": util_flag} finally: shutil.rmtree(d, ignore_errors=True) # ------------------------------------------------------------- (c) execution SAFE_UTIL = {"grep", "awk", "sed", "sort", "uniq", "wc", "cut", "tr", "head", "tail", "cat", "ls", "find", "nl", "stat", "file", "date", "comm", "paste", "cp", "mkdir", "touch", "echo", "printf", "basename", "dirname", "seq", "tac", "rev", "fold", "column", "diff", "cmp"} DANGER = re.compile(r"(^|[\s;&|(])(sudo|rm|rmdir|dd|mkfs\w*|shred|kill|pkill|killall|" r"reboot|shutdown|halt|poweroff|mv|chmod|chown|chgrp|ln|truncate|" r"curl|wget|ssh|scp|rsync|ping|nc|telnet|systemctl|journalctl|service|" r"apt|apt-get|dnf|yum|pacman|brew|pip|npm|git|docker|mount|umount|" r"nice|renice|crontab|tee|gzip|gunzip|zip|unzip|tar|make|convert)([\s;&|)]|$)") ABSPATH = re.compile(r"(^|[\s'\"=<>(])/(etc|var|srv|opt|home|mnt|usr|dev|proc|sys|boot|root|" r"tmp|backup|data|lib|bin|sbin|run)\b|(^|\s)/\w") WRITEOUT = re.compile(r">>?\s*/|>\s*/dev/(?!null)") FORKBOMB = re.compile(r":\s*\(\s*\)\s*\{") # strip `sudo` only in COMMAND position (start, or after ; | && || `(`), never when # it's an argument -- e.g. `chgrp sudo file` (group named "sudo") must stay intact. SUDO = re.compile(r"(^|[;&|(]\s*)sudo\s+") _GREP_TAIL = re.compile(r"\|\s*(?:z|e|f)?grep\b[^|]*$") # pipeline ending in grep -> rc1 = no match # --- permissive mode (throwaway Linux, e.g. WSL) ---------------------------- # In permissive mode almost every single-line command is executed; only two # classes are withheld: HARD_BLOCK (could damage the host/VM with zero test # value) and HANG/NET (would block forever or reach the network). Everything # else runs in a sandbox dir with a timeout and stdin from /dev/null. _SYS = r"(?:etc|var|usr|boot|lib|lib64|bin|sbin|root|opt|srv|dev|proc|sys|run|mnt|media)" HARD_BLOCK = re.compile( r"(?:^|[\s;&|(])(?:dd|mkfs\w*|mkswap|fdisk|parted|sgdisk|wipefs|blkdiscard|hdparm|" r"shutdown|reboot|halt|poweroff|telinit|kexec|mount|umount|swapon|swapoff|" r"useradd|userdel|usermod|groupadd|groupdel|passwd|chpasswd|visudo|init|" r"kill|pkill|killall|skill|fuser|" # process-killers can kill the validator itself r"crontab)\b" # crontab installs persistent jobs r"|of=/dev/|/dev/(?:sd|nvme|vd|mapper)|--no-preserve-root") WRITE_SYS = re.compile( rf"\b(?:rm|rmdir|mv|cp|chmod|chown|chgrp|ln|truncate|shred|tee|install|rsync)\b[^|]*\s/{_SYS}\b" rf"|\bsed\s+-i\b[^|]*\s/{_SYS}\b|>>?\s*/{_SYS}\b|\bfind\b[^|]*\s/{_SYS}\b[^|]*-delete" rf"|>>?\s*~/|>>?\s*\$HOME|\b(?:rm|mv|shred)\b[^|]*\s~/") HANG = re.compile( r"\b(?:top|htop|watch|vi|vim|nvim|nano|emacs|less|more|man|tmux|screen|irb|ipython|" r"mysql|psql|sqlite3|python|python3|node|ssh|sftp|telnet|curl|wget|scp|nc|ncat|netcat)\b" r"|\btail\b[^|]*\s-f\b|\bjournalctl\b[^|]*(?:\s-f\b|--follow)|\bdmesg\b[^|]*\s-w\b" r"|\bping6?\b|\brsync\b[^|]*@|\byes\b|/dev/(?:zero|urandom|random)" r"|\b(?:vmstat|iostat|mpstat|pidstat|sar|dstat)\b\s+\d|\bfree\b[^|]*\s-s\b" r"|\b(?:apt|apt-get|dnf|yum|pacman|zypper|snap|flatpak|pip|pip3|npm|npx|yarn|gem|" r"cargo|go|brew|docker|make)\b[^|]*\b(?:install|reinstall|update|upgrade|add|pull|" r"run|build|-S|-Sy|-Syu)\b" r"|\bsleep\b\s+(?:[3-9]|\d\d+)") # Scripts (multi-line) run in permissive mode too, but infinite loops / sleeps / # follow-watches would hang. Interactive read/select are safe: with stdin from # /dev/null they hit EOF and exit fast under `set -e`. SCRIPT_HANG = re.compile( r"while\s+(?:true|:)\b|\bsleep\b" r"|\btail\b[^\n]*\s-f\b|\bjournalctl\b[^\n]*\s-f\b|\bdmesg\b[^\n]*\s-w\b|\bwatch\b", re.I) def exec_class(bash, util, permissive=False): """Return 'run' if the command should be executed, else a reason label.""" if "\n" in bash: if not permissive: return "multiline" if FORKBOMB.search(bash) or HARD_BLOCK.search(bash) or WRITE_SYS.search(bash): return "block" if HANG.search(bash) or SCRIPT_HANG.search(bash): return "skip" return "run" if permissive: if FORKBOMB.search(bash) or HARD_BLOCK.search(bash) or WRITE_SYS.search(bash): return "block" if HANG.search(bash): return "skip" return "run" # strict (default) mode if util not in SAFE_UTIL: return "util" if FORKBOMB.search(bash) or DANGER.search(bash): return "block" if ABSPATH.search(bash): return "abspath" if WRITEOUT.search(bash): return "writeout" if "$(" in bash or "`" in bash: return "cmdsub" return "run" REFED = re.compile(r"[\w./-]+\.\w+|\b(?:src|logs|backup|data|tmp|project|dist|build|config|" r"docs|reports|uploads|scripts|assets|public|cache|vendor|images|media|" r"tests|include|static|templates|fixtures|downloads|releases|artifacts)\b") SEED_LINES = "\n".join([ "alice,30,alice@example.com", "bob,25,bob@example.org", "carol,41,carol@example.net", "ERROR something failed", "WARNING low disk", "INFO ok", "DEBUG trace", "ERROR again", "192.168.1.10 GET /index 200", "10.0.0.5 POST /api 500", "apple", "banana", "apple", "1 2 3", "4 5 6", "7 8 9", "", ] * 4) def build_sandbox(cmds): sb = tempfile.mkdtemp(prefix="ds_sandbox_") def write_file(path): os.makedirs(os.path.dirname(path) or sb, exist_ok=True) if not os.path.exists(path): with open(path, "w", encoding="utf-8", newline="\n") as fh: fh.write(SEED_LINES) for bash in cmds: for tok in REFED.findall(bash): tok = tok.strip("'\"") if tok.startswith("/") or ".." in tok or tok.startswith("-"): continue path = os.path.join(sb, tok) try: if "." in os.path.basename(tok): write_file(path) else: os.makedirs(path, exist_ok=True) for fn in ("a.txt", "b.log", "c.csv"): write_file(os.path.join(path, fn)) except OSError: pass for fn in ("part1.txt", "part2.txt", "packages.txt", "checksums.txt", "data.csv", "access.log", "metrics.log", "inventory.csv", "users.txt", "emails.txt", "syslog", "messages", "app.log", "error.log", "cleanup.log", "output.log", "hosts.txt", "servers.txt", "urls.txt", "nodes.txt", "targets.txt", "config.yaml", "config.json", "clean.txt", "whole.txt", "emails.txt"): write_file(os.path.join(sb, fn)) return sb _ENV_UTIL = {"systemctl", "journalctl", "service", "timedatectl", "loginctl", "systemd-analyze", "hostnamectl", "dmesg", "renice", "nice"} _ENV_ERR = re.compile(r"System has not been booted with systemd|Failed to connect to bus|" r"Operation not permitted|must be run as root|are you root|" r"Permission denied|Read-only file system|not permitted", re.I) # a bad flag mid-pipeline can leave the pipeline exit 0 (a downstream stage # succeeds), so scan EVERY stage's stderr for these -- caught regardless of exit. _BADFLAG = re.compile(r"invalid option|unrecognized option|unknown option|illegal option|" r"invalid argument|invalid line count|option requires an argument|" r"not an option", re.I) # an upstream grep/find/cmp that matches nothing exits non-zero; under pipefail # that propagates to the pipeline with NO stderr -> not a real error. _NOMATCH_STAGE = re.compile(r"(?:^|[\s|(])(?:z|e|f)?grep\b|\bfind\b|\bcmp\b|\bcomm\b|" r"\bdiff\b|\bpgrep\b") def execute(rows, n, permissive=False, timeout=8): cls = collections.Counter(exec_class(r["bash"], r["utility"], permissive) for r in rows) cands = [r for r in rows if exec_class(r["bash"], r["utility"], permissive) == "run"] random.shuffle(cands) cands = cands[:n] print(f"mode: {'PERMISSIVE (throwaway Linux)' if permissive else 'strict/safe'} " f"| timeout {timeout}s | stdin=/dev/null | sudo stripped") print(f"eligible -> executed: {len(cands)} (n cap {n}) of {len(rows)} rows") notrun = ", ".join(f"{k}={v}" for k, v in cls.items() if k != "run") print(f"not executed: {notrun}") if not cands: return None sb = build_sandbox([r["bash"] for r in cands]) buckets = collections.Counter() cat_err = collections.Counter(); util_err = collections.Counter() cat_tot = collections.Counter(); util_tot = collections.Counter() fails = []; genuine = [] try: for i, r in enumerate(cands): if i % 500 == 0: print(f" exec {i}/{len(cands)}", flush=True) cat_tot[r["category"]] += 1; util_tot[r["utility"]] += 1 cmd = SUDO.sub(r"\1", r["bash"]) # strip sudo -> run as current user try: # stdout -> /dev/null: infinite-output cmds (yes, cat /dev/zero) must not # be buffered into memory (that OOM-killed an earlier run). stderr is # capped so a stderr-spamming command can't blow up memory either. # `set -o pipefail` so a failing mid-pipe stage isn't masked by a later 0. wrapped = "set -o pipefail\n" + cmd p = subprocess.run([BASH, "-c", wrapped], cwd=sb, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True, errors="replace", timeout=timeout, stdin=subprocess.DEVNULL) rc = p.returncode except subprocess.TimeoutExpired: buckets["timeout"] += 1 fails.append(("timeout", r["utility"], r["bash"], "")) continue except Exception as e: buckets["spawn-error"] += 1 fails.append(("spawn", r["utility"], r["bash"], str(e)[:80])) continue out = (p.stderr or "")[:4000] # classification uses stderr only errline = out.strip().splitlines()[-1] if out.strip() else "" low = out.lower() grep_nomatch = r["utility"] in {"grep", "egrep", "fgrep", "zgrep", "cmp", "comm", "diff", "pgrep"} or _GREP_TAIL.search(cmd) if _BADFLAG.search(out): buckets["err bad-flag"] += 1 # invalid/unknown flag, ANY exit code cat_err[r["category"]] += 1; util_err[r["utility"]] += 1 genuine.append({"nl": r["nl"], "bash": r["bash"], "category": r["category"], "utility": r["utility"], "variant_group": r.get("variant_group"), "rc": rc, "err": errline}) if len(fails) < 80: fails.append(("bad-flag", r["utility"], r["bash"], errline)) elif rc == 0: buckets["ok"] += 1 elif rc == 1 and grep_nomatch: buckets["ok(rc1 no-match)"] += 1 # grep/pgrep "no match" is fine elif rc != 0 and not out.strip() and _NOMATCH_STAGE.search(cmd): buckets["ok(rc1 no-match)"] += 1 # pipefail-propagated grep/find no-match (silent) elif rc == 127 or "command not found" in low: buckets["tool-missing"] += 1 # not installed in this env elif ("usage:" in low or "required environment variable" in low or "is not set" in low): buckets["by-design(needs args/env)"] += 1 # script exits when args/env absent elif re.search(r"no such file or directory|cannot open|cannot access|cannot stat|" r"not a directory|is a directory|file exists|already exists|" r"cannot create|cannot remove|read-only file system", low): buckets["fixture(missing/collision)"] += 1 # blank/shared sandbox artifact elif re.search(r"invalid user|unknown user|no such user|invalid group|" r"unknown group|no such group", low): buckets["env(missing user/group)"] += 1 elif re.search(r"must be root|must be run as root|permission denied|" r"operation not permitted|not permitted|inappropriate ioctl|" r"not a tty|not booted with systemd|failed to connect to bus|" r"not a git repository", low) or r["utility"] in _ENV_UTIL: buckets["env(needs-root/systemd)"] += 1 elif re.search(r"not running|is down|unreachable|does not exist|is missing|" r"cannot parse|could not resolve|name or service not known", low): buckets["env(target absent/unresolved)"] += 1 # script correctly signaled absence else: buckets[f"err rc{rc}"] += 1 # genuine: bad flag/option/logic cat_err[r["category"]] += 1; util_err[r["utility"]] += 1 genuine.append({"nl": r["nl"], "bash": r["bash"], "category": r["category"], "utility": r["utility"], "variant_group": r.get("variant_group"), "rc": rc, "err": errline}) if len(fails) < 80: fails.append((f"rc{rc}", r["utility"], r["bash"], errline)) finally: shutil.rmtree(sb, ignore_errors=True) total = sum(buckets.values()) ok = buckets["ok"] + buckets["ok(rc1 no-match)"] env_keys = ("tool-missing", "by-design(needs args/env)", "fixture(missing/collision)", "env(missing user/group)", "env(needs-root/systemd)", "env(target absent/unresolved)") env = sum(buckets[k] for k in env_keys) real_err = sum(v for k, v in buckets.items() if k.startswith("err ")) other = buckets["timeout"] + buckets["spawn-error"] return {"total": total, "ok": ok, "env": env, "real_err": real_err, "other": other, "buckets": buckets, "fails": fails, "genuine": genuine, "cat_err": cat_err, "util_err": util_err, "cat_tot": cat_tot, "util_tot": util_tot} # ----------------------------------------------------------------- deletion def delete_rows(path, genuine): """Remove rows whose (request, command) matches a genuine-error entry. Writes a .bak of the original first. Returns the number of rows removed.""" keyset = {(g["nl"], g["bash"]) for g in genuine} kept, removed = [], 0 with open(path, encoding="utf-8") as fh: for line in fh: s = line.strip() if not s: continue nl, bash = row_nl_bash(json.loads(s)) if (nl, bash) in keyset: removed += 1 else: kept.append(line if line.endswith("\n") else line + "\n") shutil.copyfile(path, path + ".bak") with open(path, "w", encoding="utf-8") as fh: fh.writelines(kept) return removed # ----------------------------------------------------------------- reporting def rate_table(title, err_by, tot_by, top=12): print(f"\n {title}") rows = [(k, err_by.get(k, 0), tot_by[k]) for k in tot_by] rows.sort(key=lambda x: (-(x[1] / x[2] if x[2] else 0), -x[2])) for k, e, t in rows[:top]: print(f" {k:14s} {e:6d}/{t:<6d} {e/t*100 if t else 0:5.1f}%") def main(): ap = argparse.ArgumentParser() ap.add_argument("--data", default=os.path.join(HERE, "bash_dataset.jsonl")) ap.add_argument("--execute", action="store_true", help="also run the sandbox execution pass") ap.add_argument("--n", type=int, default=3000, help="max commands to execute in (c)") ap.add_argument("--permissive", action="store_true", help="throwaway-Linux mode: execute nearly all single-line commands " "(system-info + fs-mutating), blocking only host-dangerous/hanging ones") ap.add_argument("--timeout", type=int, default=8, help="per-command execution timeout (s)") ap.add_argument("--dump-errors", default=None, help="write every genuine-error command (rc + stderr) to this JSONL file") ap.add_argument("--yes", action="store_true", help="delete genuine-error rows without prompting") ap.add_argument("--no", action="store_true", help="never delete; skip the prompt") ap.add_argument("--shellcheck-n", type=int, default=6000, help="shellcheck sample size (0=all)") ap.add_argument("--seed", type=int, default=1234) args = ap.parse_args() random.seed(args.seed) if not os.path.exists(args.data): print(f"no such file: {args.data}"); sys.exit(1) rows = load(args.data) cats = collections.Counter(r["category"] for r in rows) print(f"loaded {len(rows)} rows from {args.data}") print(f"categories: {dict(cats)}") ngroups = len({r['variant_group'] for r in rows if r['variant_group']}) if ngroups: print(f"variant_groups: {ngroups} (avg {len(rows)/ngroups:.2f} rows/request)") # ---- (a) bash -n print("\n" + "=" * 66); print("(a) bash -n (every command)"); print("=" * 66) valid = bash_n([r["bash"] for r in rows]) fails = [rows[i] for i, ok in enumerate(valid) if not ok] print(f"syntax failures: {len(fails)}/{len(rows)} ({len(fails)/len(rows)*100:.3f}%)") if fails: cat_fail = collections.Counter(r["category"] for r in fails) util_fail = collections.Counter(r["utility"] for r in fails) print(f" by category: {dict(cat_fail)}") print(f" top utilities: {util_fail.most_common(10)}") for r in fails[:10]: print(f" [{r['utility']}] {r['bash'][:90]}") # ---- (b) shellcheck print("\n" + "=" * 66); print("(b) shellcheck (warning level)"); print("=" * 66) sc = shellcheck(rows, args.shellcheck_n) if sc is None: print("shellcheck not found -> skipped (install shellcheck to enable)") else: clean = sc["n"] - sc["flagged"] print(f"clean (no warning+ findings): {clean}/{sc['n']} ({clean/sc['n']*100:.1f}%)") print(f"flagged: {sc['flagged']} ({sc['flagged']/sc['n']*100:.1f}%)") print("top SC codes:") for c, n in sc["codes"].most_common(12): print(f" {c}: {n}") rate_table("shellcheck-flagged rate by category:", sc["cat_flag"], collections.Counter(r["category"] for r in rows)) rate_table("shellcheck-flagged rate by utility (worst):", sc["util_flag"], collections.Counter(r["utility"] for r in rows)) # ---- (c) execution print("\n" + "=" * 66); print("(c) real execution in sandbox"); print("=" * 66) if not args.execute: print("skipped (pass --execute to enable; runs only safe, non-destructive commands)") else: ex = execute(rows, args.n, permissive=args.permissive, timeout=args.timeout) if ex: t = ex["total"] # "gradable" = commands whose failure would actually mean a bad command # (exclude environmental: missing files/users/env/args/root/systemd/tools). gradable = ex["ok"] + ex["real_err"] print(f"\nexecuted {t}") print(f" ran clean: {ex['ok']}") print(f" environmental (missing file/user/env/args, needs root/systemd, tool absent): " f"{ex['env']} <- not correctness failures") print(f" timeout/spawn: {ex['other']}") print(f" GENUINE errors (bad flag/option/logic): {ex['real_err']}") print(f" => correctness on gradable commands: " f"{ex['ok']}/{gradable} = {ex['ok']/max(1,gradable)*100:.1f}% clean, " f"{ex['real_err']/max(1,gradable)*100:.2f}% genuine errors") print(" buckets:") for k, v in ex["buckets"].most_common(): print(f" {k}: {v}") if args.dump_errors: with open(args.dump_errors, "w", encoding="utf-8") as fh: for g in ex["genuine"]: fh.write(json.dumps(g, ensure_ascii=False) + "\n") print(f" wrote {len(ex['genuine'])} genuine-error commands -> {args.dump_errors}") rate_table("real-error rate by category:", ex["cat_err"], ex["cat_tot"]) rate_table("real-error rate by utility (worst):", ex["util_err"], ex["util_tot"]) # ---- offer to delete the genuine-error rows gradable = ex["ok"] + ex["real_err"] pct = ex["real_err"] / max(1, gradable) * 100 if ex["genuine"]: print(f"\nverifications finished. {pct:.2f}% are genuine errors " f"({len(ex['genuine'])} rows).") if args.yes: ans = "y" elif args.no: ans = "n" else: try: ans = input("would you like to delete those rows? [y/N] ").strip().lower() except EOFError: ans = "" # non-interactive -> default No (safe) if ans in ("y", "yes"): removed = delete_rows(args.data, ex["genuine"]) print(f"deleted {removed} rows -> {args.data} (backup: {args.data}.bak)") else: print("kept all rows. (re-run with --yes to delete non-interactively)") else: print(f"\nverifications finished. {pct:.2f}% are genuine errors — nothing to delete.") if ex["fails"]: print("\n sample non-ok commands:") for tag, util, bash, err in ex["fails"][:15]: print(f" [{tag}/{util}] {bash[:90]}") if err: print(f" -> {err[:110]}") print("\ndone.") if __name__ == "__main__": main()