| |
| from pathlib import Path |
| import argparse |
| import json |
| import shutil |
|
|
|
|
| def fail(msg): |
| raise SystemExit(msg) |
|
|
|
|
| def import_arrow(): |
| try: |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import pyarrow.compute as pc |
| return pa, pq, pc |
| except Exception as e: |
| fail(f"pyarrow is required for safe subset creation: {e}") |
|
|
|
|
| def auto_col(cols, candidates): |
| lower = {c.lower(): c for c in cols} |
| for cand in candidates: |
| if cand.lower() in lower: |
| return lower[cand.lower()] |
| return None |
|
|
|
|
| def is_lfs_pointer(path): |
| try: |
| return path.read_bytes()[:120].startswith(b"version https://git-lfs.github.com/spec/v1") |
| except OSError: |
| return False |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--root", default=".") |
| parser.add_argument("--out", default="safe_public_subset") |
| parser.add_argument("--risk-column", default=None) |
| parser.add_argument("--id-column", default=None) |
| parser.add_argument("--exclude-risk-values", default="high", help="Comma-separated risk values to exclude") |
| parser.add_argument("--overwrite", action="store_true") |
| args = parser.parse_args() |
|
|
| pa, pq, pc = import_arrow() |
|
|
| root = Path(args.root) |
| out = Path(args.out) |
|
|
| persona_path = root / "persona_core.parquet" |
| if not persona_path.exists(): |
| fail("persona_core.parquet not found") |
| if is_lfs_pointer(persona_path): |
| fail("persona_core.parquet is a Git LFS pointer. Pull the real Parquet payload before creating a safe subset.") |
|
|
| table = pq.read_table(persona_path) |
| cols = table.column_names |
|
|
| if out.exists(): |
| if not args.overwrite: |
| fail(f"Output directory exists: {out}. Use --overwrite to replace it.") |
| shutil.rmtree(out) |
| out.mkdir(parents=True) |
|
|
| risk_col = args.risk_column or auto_col(cols, [ |
| "disclosure_risk_level", |
| "disclosure_risk", |
| "privacy_risk_level", |
| "risk_level", |
| ]) |
| if not risk_col: |
| fail(f"Could not auto-detect disclosure risk column. Columns: {cols}") |
|
|
| id_col = args.id_column or auto_col(cols, [ |
| "synthetic_person_id", |
| "persona_id", |
| "person_id", |
| "synthetic_person_id", |
| "id", |
| ]) |
| if not id_col: |
| fail(f"Could not auto-detect persona id column. Columns: {cols}") |
|
|
| exclude_values = [x.strip().lower() for x in args.exclude_risk_values.split(",") if x.strip()] |
| risk_lower = pc.utf8_lower(table[risk_col].cast(pa.string())) |
| excluded_mask = pc.is_in(risk_lower, value_set=pa.array(exclude_values)) |
| keep_mask = pc.invert(excluded_mask) |
| safe_persona = table.filter(keep_mask) |
| high_persona = table.filter(excluded_mask) |
|
|
| removed_ids = set(high_persona[id_col].to_pylist()) |
| pq.write_table(safe_persona, out / "persona_core_safe.parquet") |
|
|
| report = { |
| "risk_column": risk_col, |
| "id_column": id_col, |
| "exclude_risk_values": exclude_values, |
| "persona_core_rows_before": table.num_rows, |
| "persona_core_rows_after": safe_persona.num_rows, |
| "removed_persona_rows": len(removed_ids), |
| "artifacts": { |
| "persona_core": { |
| "input": "persona_core.parquet", |
| "output": "persona_core_safe.parquet", |
| "rows_before": table.num_rows, |
| "rows_after": safe_persona.num_rows, |
| } |
| }, |
| } |
|
|
| for name in ["persona_views", "actor_state_init"]: |
| p = root / f"{name}.parquet" |
| if not p.exists(): |
| continue |
| if is_lfs_pointer(p): |
| report["artifacts"][name] = {"input": p.name, "skipped": "Git LFS pointer; real Parquet payload not present"} |
| continue |
| t = pq.read_table(p) |
| if id_col not in t.column_names: |
| report["artifacts"][name] = {"input": p.name, "skipped": f"missing id column {id_col}"} |
| continue |
| remove_mask = pc.is_in(t[id_col], value_set=pa.array(list(removed_ids), type=t[id_col].type)) |
| keep = pc.invert(remove_mask) |
| safe_t = t.filter(keep) |
| out_name = f"{name}_safe.parquet" |
| pq.write_table(safe_t, out / out_name) |
| report["artifacts"][name] = { |
| "input": p.name, |
| "output": out_name, |
| "rows_before": t.num_rows, |
| "rows_after": safe_t.num_rows, |
| } |
|
|
| (out / "safe_subset_report.json").write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8") |
| print(json.dumps(report, indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
