| |
| """Remove opted-out repositories from your local copy of The Stack. |
| |
| usage: filter_stack.py --input PATH --output DIR [--edition optouts.csv] [--repo-column NAME] |
| [--include-withdrawn] |
| |
| PATH is a .parquet or .jsonl (optionally .gz) file, or a folder of them. Parquet needs pyarrow |
| (only imported if you have Parquet input). Your input is never modified: filtered copies are |
| written to DIR (which must not be the input folder) together with removal_report.csv. |
| Whole-account rows match every repository of that owner; repository rows match owner/repo exactly. |
| Names are compared ignoring case. |
| """ |
| import argparse, csv, gzip, json, os, sys |
|
|
| CANDIDATE_COLUMNS = ("repo_path", "repo_name", "repository_name", "full_name", "repo") |
|
|
|
|
| def load_rules(path, include_withdrawn=False): |
| owners, repos = {}, {} |
| with open(path, newline="", encoding="utf-8") as f: |
| for r in csv.DictReader(f): |
| if r["withdrawn"] == "yes" and not include_withdrawn: |
| continue |
| n = int(r["issue_number"]) |
| if r["request_type"] == "whole_account": |
| k = r["owner"].lower() |
| if k not in owners or n < owners[k]: |
| owners[k] = n |
| else: |
| k = (r["owner"] + "/" + r["repository"]).lower() |
| if k not in repos or n < repos[k]: |
| repos[k] = n |
| return owners, repos |
|
|
|
|
| def match(slug, owners, repos): |
| """Issue number of the earliest matching request, or None.""" |
| if not isinstance(slug, str) or not slug: |
| return None |
| s = slug.strip().lower() |
| hits = [] |
| if s in repos: |
| hits.append(repos[s]) |
| o = s.split("/", 1)[0] |
| if o in owners: |
| hits.append(owners[o]) |
| return min(hits) if hits else None |
|
|
|
|
| def pick_column(names, wanted): |
| if wanted: |
| if wanted not in names: |
| sys.exit(f"column {wanted!r} not found; columns are: {sorted(names)}") |
| return wanted |
| for c in CANDIDATE_COLUMNS: |
| if c in names: |
| return c |
| sys.exit("no repository column found; pass --repo-column. Columns: " + ", ".join(sorted(names))) |
|
|
|
|
| def _open(path, mode): |
| return gzip.open(path, mode + "t", encoding="utf-8") if path.endswith(".gz") else open(path, mode, encoding="utf-8") |
|
|
|
|
| def filter_jsonl(src, dst, owners, repos, col, counts): |
| scanned = removed = 0 |
| with _open(src, "r") as fi, _open(dst, "w") as fo: |
| for line in fi: |
| if not line.strip(): |
| continue |
| row = json.loads(line) |
| if col is None: |
| col = pick_column(set(row), None) |
| scanned += 1 |
| hit = match(row.get(col), owners, repos) |
| if hit is None: |
| fo.write(line if line.endswith("\n") else line + "\n") |
| else: |
| removed += 1 |
| counts[hit] = counts.get(hit, 0) + 1 |
| return scanned, removed |
|
|
|
|
| def filter_parquet(src, dst, owners, repos, wanted, counts): |
| try: |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| except ImportError: |
| sys.exit("pyarrow is needed for Parquet input (pip install pyarrow), or convert to JSONL") |
| pf = pq.ParquetFile(src) |
| col = pick_column(set(pf.schema_arrow.names), wanted) |
| scanned = removed = 0 |
| writer = pq.ParquetWriter(dst, pf.schema_arrow) |
| try: |
| for batch in pf.iter_batches(batch_size=1000): |
| slugs = batch.column(col).to_pylist() |
| keep = [] |
| for i, s in enumerate(slugs): |
| hit = match(s, owners, repos) |
| if hit is None: |
| keep.append(i) |
| else: |
| removed += 1 |
| counts[hit] = counts.get(hit, 0) + 1 |
| scanned += len(slugs) |
| if keep: |
| writer.write_table(pa.Table.from_batches([batch]).take(keep)) |
| finally: |
| writer.close() |
| return scanned, removed |
|
|
|
|
| def inputs(path): |
| if os.path.isdir(path): |
| for n in sorted(os.listdir(path)): |
| if n.endswith((".parquet", ".jsonl", ".jsonl.gz")): |
| yield os.path.join(path, n) |
| else: |
| yield path |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--input", required=True) |
| ap.add_argument("--output", required=True) |
| ap.add_argument("--edition", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "optouts.csv")) |
| ap.add_argument("--repo-column") |
| ap.add_argument("--include-withdrawn", action="store_true") |
| a = ap.parse_args(argv) |
| in_abs = os.path.abspath(a.input) |
| out_abs = os.path.abspath(a.output) |
| in_dir = in_abs if os.path.isdir(in_abs) else os.path.dirname(in_abs) |
| if out_abs == in_dir: |
| sys.exit("refusing: output folder is the input folder (inputs are never modified in place)") |
| os.makedirs(out_abs, exist_ok=True) |
| owners, repos = load_rules(a.edition, a.include_withdrawn) |
| meta = {} |
| with open(a.edition, newline="", encoding="utf-8") as f: |
| for r in csv.DictReader(f): |
| meta[int(r["issue_number"])] = r |
| counts, total_scanned, total_removed, files = {}, 0, 0, 0 |
| for src in inputs(a.input): |
| dst = os.path.join(out_abs, os.path.basename(src)) |
| if os.path.abspath(dst) == os.path.abspath(src): |
| sys.exit("refusing to overwrite input") |
| if src.endswith(".parquet"): |
| s, r = filter_parquet(src, dst, owners, repos, a.repo_column, counts) |
| else: |
| s, r = filter_jsonl(src, dst, owners, repos, a.repo_column, counts) |
| total_scanned += s |
| total_removed += r |
| files += 1 |
| with open(os.path.join(out_abs, "removal_report.csv"), "w", newline="", encoding="utf-8") as f: |
| w = csv.writer(f) |
| w.writerow(["issue_number", "request_type", "owner", "repository", "rows_removed", "source_url"]) |
| for n in sorted(counts): |
| m = meta.get(n, {}) |
| w.writerow([n, m.get("request_type", ""), m.get("owner", ""), m.get("repository", ""), counts[n], |
| m.get("source_url", "")]) |
| print(json.dumps({"files": files, "rows_scanned": total_scanned, "rows_removed": total_removed, |
| "rows_kept": total_scanned - total_removed, "requests_matched": len(counts)})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
