| """Re-pack a Pass A store into the sharded Zarr layout. |
| |
| Shards written before the 2026-09-04 fix hold one file per chunk (1.5 to 4.7 files per |
| calculation); the fixed writer groups 256 chunks per file. This copies every shard group of a |
| store array by array, keeping dtype, chunk shape and codecs and adding the sharding codec, and |
| verifies each copy element for element before marking it done. Groups already in the sharded |
| layout are copied unchanged. Safe to re-run: a destination group carrying the `repack_verified` |
| attribute is skipped. |
| |
| python repack_store.py --src $PSCRATCH/omol_store_100k --dst $PSCRATCH/omol_100k --workers 64 |
| """ |
| from __future__ import annotations |
| import argparse, glob, os, shutil, sys, time, traceback |
| import multiprocessing as mp |
| import numpy as np |
| import zarr |
|
|
| |
| |
| zarr.config.set({"threading.max_workers": 1, "async.concurrency": 2}) |
| try: |
| import numcodecs.blosc |
| numcodecs.blosc.set_nthreads(1) |
| numcodecs.blosc.use_threads = False |
| except Exception: |
| pass |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from omol_store import CHUNKS_PER_SHARD |
|
|
|
|
| def shard_paths(root): |
| out = [] |
| for side in ("p1", "p2"): |
| for depth in ("*", "*/*/*"): |
| out += glob.glob(os.path.join(root, side, depth, "*.zarr")) |
| return sorted(set(out)) |
|
|
|
|
| def count_files(path): |
| return sum(len(fs) for _, _, fs in os.walk(path)) |
|
|
|
|
| def equal(a, b): |
| if a.shape != b.shape or a.dtype != b.dtype: |
| return False |
| if a.dtype.kind == "f": |
| return bool(np.array_equal(a, b, equal_nan=True)) |
| return bool(np.array_equal(a, b)) |
|
|
|
|
| def repack_group(args): |
| src, dst = args |
| t0 = time.time() |
| try: |
| if os.path.isdir(dst): |
| if zarr.open_group(dst, mode="r").attrs.get("repack_verified"): |
| return dst, "skip", 0, 0, 0.0, "" |
| shutil.rmtree(dst) |
| gs = zarr.open_group(src, mode="r") |
| attrs = dict(gs.attrs) |
| gd = zarr.open_group(dst, mode="w") |
| gd.attrs.update(attrs) |
| for name in sorted(gs.array_keys()): |
| zs = gs[name] |
| data = np.asarray(zs[...]) |
| chunks = tuple(int(c) for c in zs.chunks) |
| n_chunks = max(1, -(-zs.shape[0] // chunks[0])) |
| shards = zs.shards or ((chunks[0] * min(CHUNKS_PER_SHARD, n_chunks),) |
| + tuple(zs.shape[1:])) |
| zd = gd.create_array(name=name, shape=zs.shape, chunks=chunks, shards=shards, |
| dtype=zs.dtype, compressors=zs.compressors) |
| if data.size: |
| zd[...] = data |
| if not equal(data, np.asarray(zd[...])): |
| raise RuntimeError(f"read-back mismatch in {name}") |
| gd = zarr.open_group(dst, mode="r+") |
| if dict(gd.attrs) != attrs or sorted(gd.array_keys()) != sorted(gs.array_keys()): |
| raise RuntimeError("attrs or array list differ after copy") |
| gd.attrs["repack_verified"] = True |
| return dst, "ok", count_files(src), count_files(dst), time.time() - t0, "" |
| except Exception: |
| return dst, "fail", 0, 0, time.time() - t0, traceback.format_exc(limit=3) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--src", required=True) |
| ap.add_argument("--dst", required=True) |
| ap.add_argument("--workers", type=int, default=64) |
| ap.add_argument("--limit", type=int, default=0) |
| ap.add_argument("--pattern", default="", help="only shards whose basename contains this") |
| args = ap.parse_args() |
| src = os.path.abspath(args.src) |
| dst = os.path.abspath(args.dst) |
| shards = shard_paths(src) |
| if args.pattern: |
| shards = [s for s in shards if args.pattern in os.path.basename(s)] |
| if args.limit: |
| shards = shards[:args.limit] |
| jobs = [(s, os.path.join(dst, os.path.relpath(s, src))) for s in shards] |
| print(f"repack {len(jobs)} shard groups: {src} -> {dst}", flush=True) |
| os.makedirs(dst, exist_ok=True) |
| for f in glob.glob(os.path.join(src, "*.tsv")): |
| shutil.copy2(f, dst) |
| t0 = time.time() |
| n_ok = n_skip = n_fail = 0 |
| files_in = files_out = 0 |
| with mp.Pool(min(args.workers, len(jobs))) as pool: |
| for k, (path, status, fi, fo, dt, err) in enumerate(pool.imap_unordered(repack_group, jobs), 1): |
| if status == "ok": |
| n_ok += 1 |
| files_in += fi |
| files_out += fo |
| elif status == "skip": |
| n_skip += 1 |
| else: |
| n_fail += 1 |
| print(f"FAIL {path}\n{err}", flush=True) |
| if k % 100 == 0 or k == len(jobs): |
| el = time.time() - t0 |
| print(f" {k}/{len(jobs)} ok={n_ok} skip={n_skip} fail={n_fail} " |
| f"files {files_in:,} -> {files_out:,} {el/60:.1f} min", flush=True) |
| print(f"\ndone: ok {n_ok}, skipped {n_skip}, failed {n_fail}, " |
| f"files {files_in:,} -> {files_out:,}, wall {(time.time()-t0)/60:.1f} min") |
|
|
|
|
| if __name__ == "__main__": |
| mp.set_start_method("fork", force=True) |
| main() |
|
|
