stream jsonl to parquet in chunks to fix oom

hub-stats.py

@@ -14,6 +14,7 @@
 import json
 import os
 import asyncio
+import sys
 import time
 
 import pandas as pd
@@ -202,13 +203,12 @@ async def fetch_data_page(session, url, params=None, headers=None):
         return await response.json(), response.headers.get("Link")
 
 
-def jsonl_to_parquet(endpoint, jsonl_file, output_file):
-    if not os.path.exists(jsonl_file):
-        print(f"✗ {jsonl_file} not found")
-        return 0
+ROWS_PER_CHUNK = 50_000
+
 
-    # Collect all dataframes first to get unified schema
-    all_dfs = []
+def iter_chunk_dfs(endpoint, jsonl_file, rows_per_chunk=ROWS_PER_CHUNK):
+    """Stream the raw JSONL as processed DataFrames of ~rows_per_chunk rows."""
+    items = []
     with open(jsonl_file, "r") as f:
         for line in f:
             line = line.strip()
@@ -216,41 +216,63 @@ def jsonl_to_parquet(endpoint, jsonl_file, output_file):
                 continue
             data = json.loads(line)
             if endpoint == "posts":
-                items = data.get("socialPosts", [])
+                page_items = data.get("socialPosts", [])
             else:
-                items = data
-
-            if not items:
+                page_items = data
+            if not page_items:
                 continue
 
-            df = pd.DataFrame(items)
-            if df.empty:
-                continue
+            items.extend(page_items)
+            if len(items) >= rows_per_chunk:
+                df = process_dataframe(pd.DataFrame(items), endpoint)
+                items = []
+                if not df.empty:
+                    yield df
+
+    if items:
+        df = process_dataframe(pd.DataFrame(items), endpoint)
+        if not df.empty:
+            yield df
 
-            df = process_dataframe(df, endpoint)
-            all_dfs.append(df)
 
-    if not all_dfs:
+def jsonl_to_parquet(endpoint, jsonl_file, output_file):
+    if not os.path.exists(jsonl_file):
+        print(f"✗ {jsonl_file} not found")
+        return 0
+
+    # Pass 1: infer a unified schema one chunk at a time, never holding all rows
+    schemas = []
+    for df in iter_chunk_dfs(endpoint, jsonl_file):
+        schemas.append(pa.Table.from_pandas(df, preserve_index=False).schema)
+
+    if not schemas:
         print(f"  No data found for {endpoint}")
         return 0
 
-    # Concatenate all dataframes - pandas will unify types
-    combined_df = pd.concat(all_dfs, ignore_index=True)
-    total_rows = len(combined_df)
+    unified_schema = pa.unify_schemas(schemas, promote_options="permissive")
 
-    # Write to parquet with controlled row group sizes
-    row_group_size = 50_000
-    table = pa.Table.from_pandas(combined_df, preserve_index=False)
-    writer = pq.ParquetWriter(output_file, table.schema)
-    for i in range(0, total_rows, row_group_size):
-        chunk = table.slice(i, min(row_group_size, total_rows - i))
-        writer.write_table(chunk)
-    writer.close()
+    # Pass 2: convert chunk-by-chunk and stream row groups straight to disk
+    total_rows = 0
+    writer = pq.ParquetWriter(output_file, unified_schema)
+    try:
+        for df in iter_chunk_dfs(endpoint, jsonl_file):
+            for name in unified_schema.names:
+                if name not in df.columns:
+                    df[name] = None
+            table = pa.Table.from_pandas(
+                df[list(unified_schema.names)],
+                schema=unified_schema,
+                preserve_index=False,
+            )
+            writer.write_table(table)
+            total_rows += len(df)
+    finally:
+        writer.close()
 
     return total_rows
 
 
-async def create_parquet_files(skip_upload=False):
+async def create_parquet_files(skip_upload=False, max_pages=None):
     start_time = time.time()
     endpoints = [
         "daily_papers",
@@ -307,6 +329,8 @@ async def create_parquet_files(skip_upload=False):
                             params = {}
 
                     page += 1
+                    if max_pages is not None and page >= max_pages:
+                        url = None
 
                 except Exception as e:
                     print(f"Error on page {page} for {endpoint}: {e}")
@@ -375,8 +399,22 @@ def upload_to_hub(file_path, repo_id):
         return False
 
 
-def main(skip_upload=False):
-    created_files, elapsed = asyncio.run(create_parquet_files(skip_upload=skip_upload))
+def print_peak_memory():
+    try:
+        import resource
+
+        peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+        # ru_maxrss is bytes on macOS, kilobytes on Linux
+        peak_mb = peak / (1024 * 1024) if sys.platform == "darwin" else peak / 1024
+        print(f"Peak memory: {peak_mb:,.0f} MB")
+    except Exception:
+        pass
+
+
+def main(skip_upload=False, max_pages=None):
+    created_files, elapsed = asyncio.run(
+        create_parquet_files(skip_upload=skip_upload, max_pages=max_pages)
+    )
 
     print(f"\nCompleted in {elapsed:.2f} seconds")
     print(f"Created {len(created_files)} parquet files:")
@@ -387,16 +425,20 @@ def main(skip_upload=False):
         rows = pf.metadata.num_rows
         print(f"  {os.path.basename(file)}: {rows:,} rows, {size:,} bytes")
 
+    print_peak_memory()
+
     if skip_upload:
         print(f"\nRaw JSONL files saved to {CACHE_DIR}/ for recreation")
         print("Use 'python app.py --recreate' to recreate parquet files from JSONL")
 
 
 if __name__ == "__main__":
-    import sys
-
     if "--recreate" in sys.argv:
         recreate_from_jsonl()
+        print_peak_memory()
     else:
         skip_upload = "--skip-upload" in sys.argv
-        main(skip_upload=skip_upload)
+        max_pages = None
+        if "--max-pages" in sys.argv:
+            max_pages = int(sys.argv[sys.argv.index("--max-pages") + 1])
+        main(skip_upload=skip_upload, max_pages=max_pages)