Upload view_row_licenses.py with huggingface_hub

view_row_licenses.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""View per-row upstream dataset licenses for single-record-v1.
+
+single-record-v1/train.jsonl is a projection of threemix-v1/train.jsonl with
+origin metadata removed. Row order is 1:1 (row i == parent row i, verified by
+lockstep payload comparison). Each parent row keeps `source.{dataset, config,
+license, license_use}`, which we resolve against the upstream-license tables:
+
+  - tasksource rows:  config -> tasksource_sources.tsv  -> real HF dataset_id
+  - direct roots:     dataset -> direct_source_roots.tsv -> dataset-level terms
+
+license_use is a best-effort classification: commercial, non-commercial or
+unspecified; it is not legal clearance. The per-row embedded value wins when
+present; the dataset-level table is the fallback; conflicts are retained in
+the audit columns, never silently reconciled.
+
+Usage:
+  python3 view_row_licenses.py                     # full pass, all outputs
+  python3 view_row_licenses.py --row 123456        # one row's upstream evidence
+  python3 view_row_licenses.py --list-rows 100      # first N rows, table view
+  python3 view_row_licenses.py --filter commercial # count rows by license_use
+"""
+
+import argparse
+import csv
+import json
+import os
+import sys
+from collections import Counter, defaultdict
+
+DATA_ROOT_DEFAULT = "/upfs_mnt/secbasemodel/dev_up/111649/experiments/jev/20261018-threemix-recipe-initbio4b-v1/data"
+SOURCES_DIR_DEFAULT = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "..",
+    "analysis-single-record-v1-upstream-licenses-20261103-v1")
+TASKSOURCE_DATASET = "tasksource/tasksource-jev-typed-decisions"
+VALID_USE = {"commercial", "non-commercial", "unspecified"}
+
+
+def load_tables(sources_dir):
+    ts = {}
+    ts_path = os.path.join(sources_dir, "tasksource_sources.tsv")
+    with open(ts_path) as f:
+        for r in csv.DictReader(f, delimiter="\t"):
+            ts[r["config"]] = {
+                "dataset_id": r["dataset_id"],
+                "license": r["license"],
+                "license_use": r["license_use"].strip(),
+                "hf_url": r["hf_url"],
+                "table_rows": int(r["rows"]),
+            }
+    dr = {}
+    dr_path = os.path.join(sources_dir, "direct_source_roots.tsv")
+    with open(dr_path) as f:
+        for r in csv.DictReader(f, delimiter="\t"):
+            dr[r["root_name"]] = {
+                "license": r["license"],
+                "license_use": r["license_use"].strip(),
+                "url": r["canonical_url"],
+                "table_rows": int(r["rows"]),
+            }
+    return ts, dr
+
+
+def norm_use(use):
+    use = (use or "").strip().lower()
+    return use if use in VALID_USE else "unspecified"
+
+
+def resolve(source, ts, dr):
+    """Row source dict -> (upstream_id, config, license, license_use, url, notes)."""
+    dataset = source.get("dataset", "")
+    config = source.get("config") or ""
+    row_lic = source.get("license") or ""
+    row_use = norm_use(source.get("license_use"))
+
+    notes = []
+    if dataset == TASKSOURCE_DATASET:
+        t = ts.get(config)
+        if t is None:
+            notes.append("tasksource_config_not_in_table")
+            return dataset, config, row_lic, row_use, "", notes
+        upstream = t["dataset_id"]
+        lic = t["license"] or row_lic
+        table_use = norm_use(t["license_use"])
+        url = t["hf_url"]
+    else:
+        t = dr.get(dataset)
+        if t is None:
+            notes.append("direct_root_not_in_table")
+            return dataset, config, row_lic, row_use, "", notes
+        upstream = dataset
+        lic = t["license"] or row_lic
+        table_use = norm_use(t["license_use"])
+        url = t["url"]
+
+    use = row_use
+    if not (source.get("license_use") or "").strip():
+        # no embedded classification: fall back to dataset-level table
+        use = table_use
+        notes.append("license_use_from_table")
+    elif table_use not in (row_use, "") and table_use != row_use:
+        # embedded and table disagree: keep the (stricter) classification,
+        # retain the disagreement as explicit evidence
+        worse = sorted([row_use, table_use], key=["commercial", "unspecified",
+                                                  "non-commercial"].index)[-1]
+        use = worse
+        notes.append(f"embedded={row_use},table={table_use},kept_stricter={worse}")
+    if row_lic and lic and row_lic.lower() != lic.lower():
+        notes.append(f"embedded_license={row_lic},table_license={lic}")
+    return upstream, config, lic, use, url, notes
+
+
+def idl(f):
+    """Iterate (rowno, parsed) over a jsonl, 1-based."""
+    for i, line in enumerate(f, 1):
+        yield i, json.loads(line)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data-root", default=DATA_ROOT_DEFAULT)
+    ap.add_argument("--sources-dir", default=SOURCES_DIR_DEFAULT)
+    ap.add_argument("--out-dir", default=None, help="default: this script's dir")
+    ap.add_argument("--row", type=int, default=None,
+                    help="show upstream evidence for one 1-based row and exit")
+    ap.add_argument("--list-rows", type=int, default=None,
+                    help="show a table of the first N rows and exit")
+    ap.add_argument("--filter", choices=sorted(VALID_USE), default=None,
+                    help="full pass, print row counts per license_use")
+    args = ap.parse_args()
+
+    parent = os.path.join(args.data_root, "threemix-v1", "train.jsonl")
+    single = os.path.join(args.data_root, "single-record-v1", "train.jsonl")
+    out_dir = args.out_dir or os.path.dirname(os.path.abspath(__file__))
+    ts, dr = load_tables(args.sources_dir)
+
+    if args.row:
+        i, p = next(itertools_idl(parent, args.row))
+        s = read_single_row(single, args.row)
+        check_pair(i, p, s)
+        show_row(i, p, s, ts, dr)
+        return
+
+    if args.list_rows:
+        with open(parent) as fp, open(single) as fs:
+            print(f"{'row':>7} {'upstream':45.45} {'license_use':13} {'license':22.22} config")
+            for (i, p), (_, s) in zip(idl(fp), idl(fs)):
+                if i > args.list_rows:
+                    break
+                check_pair(i, p, s)
+                up, cfg, lic, use, url, notes = resolve(p["source"], ts, dr)
+                print(f"{i:>7} {up:45.45} {use:13} {lic:22.22} {cfg}")
+        return
+
+    # full pass ------------------------------------------------------------
+    mismatches = 0
+    use_counter = Counter()
+    ds_counter = Counter()                 # upstream -> rows
+    ds_use = defaultdict(Counter)          # upstream -> use -> rows
+    ds_license = {}                        # upstream -> license string(s)
+    noted = Counter()
+    cleaned_rows = 0
+    with open(parent) as fp, open(single) as fs, \
+            open(os.path.join(out_dir, "row_licenses.jsonl"), "w") as fout:
+        for (i, p), (_, s) in zip(idl(fp), idl(fs)):
+            mismatches += check_pair(i, p, s)
+            up, cfg, lic, use, url, notes = resolve(p["source"], ts, dr)
+            for n in notes:
+                noted[n] += 1
+            use_counter[use] += 1
+            ds_counter[up] += 1
+            ds_use[up][use] += 1
+            ds_license.setdefault(up, set()).add(lic)
+            fout.write(json.dumps({
+                "row": i, "id": s["id"],
+                "upstream_dataset": up, "config": cfg,
+                "license": lic, "license_use": use,
+                "url": url,
+                **({"notes": notes} if notes else {}),
+            }, ensure_ascii=False) + "\n")
+            cleaned_rows += 1
+
+    summary = {
+        "rows": cleaned_rows,
+        "payload_mismatches_vs_threemix": mismatches,
+        "rows_by_license_use": dict(use_counter),
+        "upstream_dataset_count": len(ds_counter),
+        "note_counts": dict(noted),
+    }
+    with open(os.path.join(out_dir, "summary.json"), "w") as f:
+        json.dump(summary, f, indent=2, ensure_ascii=False)
+
+    with open(os.path.join(out_dir, "upstream_aggregate.tsv"), "w", newline="") as f:
+        w = csv.writer(f, delimiter="\t", lineterminator="\n")
+        w.writerow(["upstream_dataset", "rows", "license", "license_use_rows",
+                    "url"])
+        for up in sorted(ds_counter, key=lambda u: -ds_counter[u]):
+            use_mix = ", ".join(f"{k}:{v}" for k, v in sorted(ds_use[up].items()))
+            w.writerow([up, ds_counter[up], " | ".join(sorted(ds_license[up])),
+                        use_mix,
+                        next(iter(ds_license[up])) and ""])
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+    if args.filter:
+        print(f"\nfilter('{args.filter}') would keep "
+              f"{use_counter[args.filter]} of {cleaned_rows} rows")
+
+
+def check_pair(i, p, s):
+    """Return 1 if parent row i and single row i disagree on payload, else 0."""
+    same = (p.get("state") == s.get("state")
+            and p.get("question") == s.get("question")
+            and p.get("target") == s.get("target")
+            and p.get("label") == s.get("label"))
+    if not same:
+        print(f"WARN: payload mismatch at parent/single row {i}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def show_row(i, p, s, ts, dr):
+    up, cfg, lic, use, url, notes = resolve(p["source"], ts, dr)
+    print(f"row {i} ({s['id']})")
+    print(f"  upstream_dataset : {up}")
+    print(f"  config           : {cfg}")
+    print(f"  license          : {lic}")
+    print(f"  license_use      : {use}")
+    print(f"  url              : {url}")
+    if notes:
+        print(f"  notes            : {'; '.join(notes)}")
+    print(f"  state[:120]      : {str(s.get('state'))[:120]!r}")
+
+
+def read_single_row(path, rowno):
+    with open(path) as f:
+        for i, line in enumerate(f, 1):
+            if i == rowno:
+                return json.loads(line)
+    raise SystemExit(f"row {rowno} out of range")
+
+
+def itertools_idl(path, rowno):
+    with open(path) as f:
+        for i, line in enumerate(f, 1):
+            if i == rowno:
+                yield i, json.loads(line)
+                return
+
+
+if __name__ == "__main__":
+    main()