File size: 3,365 Bytes
30ce80e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | """Parallel split of sorted index parquets into parts < 50 GB for HTTP upload to HF.
Windows Xet upload stalls on large files; the HTTP fallback caps at 50 GB/file.
Parts preserve sorted order (contiguous row-group ranges), so DuckDB zone-map
pruning still works across parts. Multiprocessing (N_WORKERS) since pyarrow's
writer is mostly single-threaded. Resumable: existing completed parts are skipped.
"""
import multiprocessing as mp
import os
import time
import pyarrow.parquet as pq
BASE = os.path.dirname(os.path.abspath(__file__))
# budget on UNCOMPRESSED size; SNAPPY output lands well under the 50 GB cap
TARGET_UNCOMPRESSED = 45 * 1024**3
N_WORKERS = 5
BATCH_GROUPS = 100 # row groups read per batch (~1-3 GiB in RAM)
JOBS = ["idx_phone.parquet", "idx_aadhar.parquet"]
def plan_partitions(sizes, target):
"""Split row-group size list into (start, end) buckets each ~target bytes."""
parts = []
acc = 0
start = 0
for i, s in enumerate(sizes):
acc += s
if acc >= target and i - start > 200: # at least 200 row groups per part
parts.append((start, i + 1))
start = i + 1
acc = 0
if start < len(sizes):
parts.append((start, len(sizes)))
return parts
def split_one(src, pi, a, b):
out = f"{os.path.splitext(src)[0]}.{pi}.parquet"
if os.path.exists(out) and os.path.getsize(out) > 0:
print(f" {out} exists, skip", flush=True)
return
tmp = out + ".tmp"
if os.path.exists(tmp):
os.remove(tmp)
t0 = time.time()
pf = pq.ParquetFile(src)
with pq.ParquetWriter(tmp, pf.schema_arrow, compression="snappy",
use_dictionary=True, data_page_version="2.0",
version="2.6") as w:
g = a
while g < b:
g2 = min(g + BATCH_GROUPS, b)
w.write_table(pf.read_row_groups(list(range(g, g2))))
g = g2
os.rename(tmp, out)
print(f" DONE {out} ({os.path.getsize(out)/1073741824:.1f} GiB) "
f"in {time.time()-t0:.0f}s", flush=True)
def worker(wid, tasklist):
for src, pi, a, b in tasklist:
print(f"[w{wid}] start {src} part {pi} (groups {a}-{b})", flush=True)
try:
split_one(src, pi, a, b)
except Exception as e:
print(f"[w{wid}] FAIL {src} part {pi}: {e}", flush=True)
def main():
jobs = [] # (src, [(a,b), ...])
for src in JOBS:
if not os.path.exists(src):
print(f"SKIP {src}: not found", flush=True)
continue
pf = pq.ParquetFile(src)
sizes = [pf.metadata.row_group(i).total_byte_size
for i in range(pf.num_row_groups)]
boundaries = plan_partitions(sizes, TARGET_UNCOMPRESSED)
print(f"{src}: {pf.num_row_groups} row groups, "
f"{sum(sizes)/1073741824:.1f} GiB uncompressed -> "
f"{len(boundaries)} parts", flush=True)
jobs.append((src, boundaries))
flat = [(src, i, a, b)
for src, bnd in jobs for i, (a, b) in enumerate(bnd)]
procs = []
for wi in range(N_WORKERS):
mine = flat[wi::N_WORKERS]
p = mp.Process(target=worker, args=(wi, mine))
p.start()
procs.append(p)
for p in procs:
p.join()
print("ALL DONE", flush=True)
if __name__ == "__main__":
main()
|