| |
| """Read one cell's episode parquet: list it, unpack an episode, verify the hashes. |
| |
| python3 scripts/read_episodes.py <cell>.parquet # what is in here |
| python3 scripts/read_episodes.py <cell>.parquet --extract <entry_id> --out DIR |
| python3 scripts/read_episodes.py <cell>.parquet --verify # recompute every sha256 |
| |
| Needs pyarrow; nothing else beyond the standard library. |
| |
| Layout: one row per EPISODE. The artefacts live in the `files` column as |
| ``list<struct<name, kind, size_bytes, sha256, bytes>>`` -- `name` is the path the |
| file had inside the episode directory, so --extract restores the original tree. |
| |
| `sha256` is taken over the PUBLISHED bytes (after absolute paths and box names |
| were scrubbed out of the text payloads), so --verify passes on this file as it |
| stands; it does not check against anything outside the repository. |
| """ |
| import argparse, collections, hashlib, os, sys |
|
|
| import pyarrow.parquet as pq |
|
|
|
|
| def rows_of(path, columns=None): |
| for batch in pq.ParquetFile(path).iter_batches(batch_size=1, columns=columns): |
| for row in batch.to_pylist(): |
| yield row |
|
|
|
|
| def listing(path): |
| meta = pq.ParquetFile(path).metadata |
| light = ["entry_id", "task_name", "source_model", "condition", "cell_id", |
| "is_successful", "score", "file_count", "payload_size_bytes"] |
| rows = list(rows_of(path, columns=light)) |
| print("%s %.1f MB · %d row(s) · %d row group(s)" |
| % (os.path.basename(path), os.path.getsize(path) / 1e6, |
| meta.num_rows, meta.num_row_groups)) |
| if rows: |
| print("cell: %s" % rows[0]["cell_id"]) |
| print() |
| print("%-58s %-9s %6s %9s" % ("entry_id", "verdict", "files", "payload")) |
| for r in rows: |
| print("%-58s %-9s %6d %8.1fM" |
| % (r["entry_id"], |
| "-" if r["is_successful"] is None else |
| ("success" if r["is_successful"] >= 1 else "fail"), |
| r["file_count"], r["payload_size_bytes"] / 1e6)) |
| kinds = collections.Counter() |
| for r in rows_of(path, columns=["files"]): |
| for f in r["files"]: |
| kinds[f["kind"]] += 1 |
| print("\nfile kinds: %s" % ", ".join("%s %d" % (k, n) for k, n in kinds.most_common())) |
|
|
|
|
| def extract(path, entry_id, out_dir): |
| for r in rows_of(path): |
| if r["entry_id"] != entry_id: |
| continue |
| for f in r["files"]: |
| dst = os.path.join(out_dir, entry_id, f["name"]) |
| os.makedirs(os.path.dirname(dst), exist_ok=True) |
| with open(dst, "wb") as fh: |
| fh.write(f["bytes"]) |
| print("%d file(s) -> %s" % (len(r["files"]), os.path.join(out_dir, entry_id))) |
| return 0 |
| print("no episode with entry_id %r (use the listing to see them)" % entry_id, file=sys.stderr) |
| return 1 |
|
|
|
|
| def verify(path): |
| |
| |
| n = bad = 0 |
| for r in rows_of(path, columns=["entry_id", "files"]): |
| for f in r["files"]: |
| n += 1 |
| if hashlib.sha256(f["bytes"]).hexdigest() != f["sha256"]: |
| bad += 1 |
| print("MISMATCH %s/%s" % (r["entry_id"], f["name"])) |
| if n == 0: |
| print("no payload files found in %s -- nothing was verified" % path, file=sys.stderr) |
| return 2 |
| print("%d/%d file(s) match their stored sha256" % (n - bad, n)) |
| return 1 if bad else 0 |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("parquet") |
| ap.add_argument("--extract", metavar="ENTRY_ID") |
| ap.add_argument("--out", default=".") |
| ap.add_argument("--verify", action="store_true") |
| a = ap.parse_args() |
| if a.extract: |
| return extract(a.parquet, a.extract, a.out) |
| if a.verify: |
| return verify(a.parquet) |
| listing(a.parquet) |
| return 0 |
|
|
|
|
| sys.exit(main()) |
|
|
