Use streaming ParquetWriter for single-file output

reshard_parquet.py

@@ -14,7 +14,6 @@ Usage:
 """
 
 import argparse
-import math
 import os
 from pathlib import Path
 
@@ -29,59 +28,37 @@ def collect_shards(directory: Path, prefix: str) -> list[Path]:
     return sorted(p for p in directory.glob(f"{prefix}-*.parquet"))
 
 
-def reshard(shards: list[Path], split: str, rows_per_shard: int, out_dir: Path) -> int:
-    """Read input shards and write larger output shards. Returns number of output shards."""
-    # Count total rows
+def reshard(shards: list[Path], split: str, out_dir: Path) -> None:
+    """Stream input shards into a single output file using ParquetWriter (low memory)."""
     total_rows = sum(pq.read_metadata(s).num_rows for s in shards)
-    num_out = math.ceil(total_rows / rows_per_shard)
-    print(f"  {split}: {total_rows:,} rows across {len(shards)} shards -> {num_out} output shards")
-
-    buf_rows = []
-    out_idx = 0
-    rows_in_buf = 0
-
+    print(f"  {split}: {total_rows:,} rows across {len(shards)} shards -> 1 output file")
+
+    name = f"{split}-00000-of-00001.parquet"
+    out_path = out_dir / name
+    schema = pq.read_schema(shards[0])
+    writer = pq.ParquetWriter(
+        out_path, schema,
+        compression="zstd",
+        write_page_index=True,
+        use_content_defined_chunking=True,
+    )
+
+    rows_written = 0
     for shard_path in shards:
         table = pq.read_table(shard_path)
-        buf_rows.append(table)
-        rows_in_buf += table.num_rows
-
-        if rows_in_buf >= rows_per_shard:
-            import pyarrow as pa
-            merged = pa.concat_tables(buf_rows)
-
-            # Write exactly rows_per_shard, keep remainder
-            to_write = merged.slice(0, rows_per_shard)
-            remainder = merged.slice(rows_per_shard)
-
-            name = f"{split}-{out_idx:05d}-of-{num_out:05d}.parquet"
-            pq.write_table(to_write, out_dir / name, compression="zstd", row_group_size=200_000, write_page_index=True, use_content_defined_chunking=True)
-            out_idx += 1
-            print(f"    wrote {name} ({to_write.num_rows:,} rows)")
-
-            if remainder.num_rows > 0:
-                buf_rows = [remainder]
-                rows_in_buf = remainder.num_rows
-            else:
-                buf_rows = []
-                rows_in_buf = 0
-
-    # Flush remaining
-    if buf_rows:
-        import pyarrow as pa
-        merged = pa.concat_tables(buf_rows)
-        name = f"{split}-{out_idx:05d}-of-{num_out:05d}.parquet"
-        pq.write_table(merged, out_dir / name, compression="zstd", row_group_size=200_000, write_page_index=True, use_content_defined_chunking=True)
-        out_idx += 1
-        print(f"    wrote {name} ({merged.num_rows:,} rows)")
+        writer.write_table(table, row_group_size=200_000)
+        rows_written += table.num_rows
+        print(f"    appended {shard_path.name} ({rows_written:,}/{total_rows:,} rows)")
+        del table
 
-    return out_idx
+    writer.close()
+    print(f"    wrote {name}")
 
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="Re-shard Parquet files into fewer, larger shards")
     parser.add_argument("--input-dir", default=DEFAULT_DIR, help="Directory with existing shards")
     parser.add_argument("--output-dir", default=None, help="Output directory (default: input-dir + '_resharded')")
-    parser.add_argument("--rows-per-shard", type=int, default=1_000_000, help="Rows per output shard")
     args = parser.parse_args()
 
     in_dir = Path(args.input_dir)
@@ -90,13 +67,12 @@ def main() -> None:
 
     print(f"Input:  {in_dir}")
     print(f"Output: {out_dir}")
-    print(f"Rows per shard: {args.rows_per_shard:,}")
     print()
 
     for split in ("validation", "train"):
         shards = collect_shards(in_dir, split)
         if shards:
-            reshard(shards, split, args.rows_per_shard, out_dir)
+            reshard(shards, split, out_dir)
 
     print(f"\nDone! Output in {out_dir}")