Update hub-stats.py

hub-stats.py

@@ -22,6 +22,8 @@ import requests.utils
 from dotenv import load_dotenv
 from huggingface_hub import HfApi
 from tenacity import retry, stop_after_attempt, wait_exponential
+import pyarrow as pa
+import pyarrow.parquet as pq
 
 load_dotenv()
 
@@ -175,14 +177,91 @@ 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
+
+    # First pass: determine full column set after processing
+    all_columns = None
+    with open(jsonl_file, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            data = json.loads(line)
+            if endpoint == "posts":
+                items = data.get("socialPosts", [])
+            else:
+                items = data
+
+            if not items:
+                continue
+
+            df = pd.DataFrame(items)
+            df = process_dataframe(df, endpoint)
+            cols = list(df.columns)
+
+            if all_columns is None:
+                all_columns = cols
+            else:
+                new_cols = [c for c in cols if c not in all_columns]
+                all_columns.extend(new_cols)
+
+    if all_columns is None:
+        print(f"  No data found for {endpoint}")
+        return 0
+
+    # Second pass: write parquet in streaming fashion
+    if os.path.exists(output_file):
+        os.remove(output_file)
+
+    writer = None
+    total_rows = 0
+
+    with open(jsonl_file, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            data = json.loads(line)
+            if endpoint == "posts":
+                items = data.get("socialPosts", [])
+            else:
+                items = data
+
+            if not items:
+                continue
+
+            df = pd.DataFrame(items)
+            if df.empty:
+                continue
+
+            df = process_dataframe(df, endpoint)
+            df = df.reindex(columns=all_columns)
+
+            table = pa.Table.from_pandas(df, preserve_index=False)
+            if writer is None:
+                writer = pq.ParquetWriter(output_file, table.schema)
+
+            writer.write_table(table)
+            total_rows += len(df)
+
+    if writer is not None:
+        writer.close()
+
+    return total_rows
+
+
 async def create_parquet_files(skip_upload=False):
     start_time = time.time()
     endpoints = ["daily_papers", "models", "spaces", "datasets", "posts"]
     created_files = []
+    jsonl_files = {}
 
     async with aiohttp.ClientSession() as session:
         for endpoint in endpoints:
-            print(f"Processing {endpoint}...")
+            print(f"Fetching {endpoint}...")
 
             config = ENDPOINT_CONFIGS[endpoint]
             base_url = config.get("base_url", f"https://huggingface.co/api/{endpoint}")
@@ -190,15 +269,12 @@ async def create_parquet_files(skip_upload=False):
             params.update(config["params"])
 
             headers = {"Accept": "application/json"}
-            all_data = []
             url = base_url
             page = 0
 
-            jsonl_file = None
-            if skip_upload:
-                jsonl_file = os.path.join(CACHE_DIR, f"{endpoint}_raw.jsonl")
-                with open(jsonl_file, "w") as f:
-                    pass
+            jsonl_file = os.path.join(CACHE_DIR, f"{endpoint}_raw.jsonl")
+            with open(jsonl_file, "w") as f:
+                pass  # truncate
 
             while url:
                 if endpoint == "posts":
@@ -209,52 +285,48 @@ async def create_parquet_files(skip_upload=False):
                         session, url, params, headers
                     )
 
-                    if skip_upload and jsonl_file:
-                        with open(jsonl_file, "a") as f:
-                            f.write(json.dumps(data) + "\n")
+                    with open(jsonl_file, "a") as f:
+                        f.write(json.dumps(data) + "\n")
 
                     if endpoint == "posts":
-                        items = data["socialPosts"]
-                        total_items = data["numTotalItems"]
-                        all_data.extend(items)
-
-                        if (page + 1) * params["limit"] >= total_items:
+                        total_items = data.get("numTotalItems", 0)
+                        items_on_page = len(data.get("socialPosts", []))
+                        if (page + 1) * params["limit"] >= total_items or items_on_page == 0:
                             url = None
                         else:
                             url = base_url
                     else:
-                        all_data.extend(data)
                         url = parse_link_header(link_header)
                         if url:
                             params = {}
 
-                    if len(all_data) % 10000 == 0:
-                        print(f"  {len(all_data):,} records processed")
-
                     page += 1
 
                 except Exception as e:
-                    print(f"Error on page {page}: {e}")
+                    print(f"Error on page {page} for {endpoint}: {e}")
                     await asyncio.sleep(2)
                     if page > 0:
                         url = None
                     else:
                         raise
 
-            if skip_upload and jsonl_file and os.path.exists(jsonl_file):
-                print(f"  Raw data saved to {jsonl_file}")
+            print(f"  Raw data for {endpoint} saved to {jsonl_file}")
+            jsonl_files[endpoint] = jsonl_file
 
-            df = pd.DataFrame(all_data)
-            df = process_dataframe(df, endpoint)
-
-            output_file = os.path.join(CACHE_DIR, f"{endpoint}.parquet")
-            save_parquet(df, output_file)
-            created_files.append(output_file)
+    # Convert JSONL -> Parquet with streaming writer
+    for endpoint in endpoints:
+        jsonl_file = jsonl_files.get(endpoint)
+        if not jsonl_file or not os.path.exists(jsonl_file):
+            continue
 
-            print(f"✓ {endpoint}: {len(df):,} rows -> {output_file}")
+        print(f"Processing {endpoint} from JSONL...")
+        output_file = os.path.join(CACHE_DIR, f"{endpoint}.parquet")
+        total_rows = jsonl_to_parquet(endpoint, jsonl_file, output_file)
+        print(f"✓ {endpoint}: {total_rows:,} rows -> {output_file}")
+        created_files.append(output_file)
 
-            if not skip_upload:
-                upload_to_hub(output_file, REPO_ID)
+        if not skip_upload:
+            upload_to_hub(output_file, REPO_ID)
 
     elapsed = time.time() - start_time
     return created_files, elapsed
@@ -270,23 +342,9 @@ def recreate_from_jsonl():
             continue
 
         print(f"Recreating {endpoint} from {jsonl_file}...")
-
-        all_data = []
-        with open(jsonl_file, "r") as f:
-            for line in f:
-                data = json.loads(line.strip())
-                if endpoint == "posts":
-                    all_data.extend(data["socialPosts"])
-                else:
-                    all_data.extend(data)
-
-        df = pd.DataFrame(all_data)
-        df = process_dataframe(df, endpoint)
-
         output_file = os.path.join(CACHE_DIR, f"{endpoint}.parquet")
-        save_parquet(df, output_file)
-
-        print(f"✓ {endpoint}: {len(df):,} rows -> {output_file}")
+        total_rows = jsonl_to_parquet(endpoint, jsonl_file, output_file)
+        print(f"✓ {endpoint}: {total_rows:,} rows -> {output_file}")
 
 
 def upload_to_hub(file_path, repo_id):
@@ -312,7 +370,8 @@ def main(skip_upload=False):
 
     for file in created_files:
         size = os.path.getsize(file)
-        rows = len(pd.read_parquet(file))
+        pf = pq.ParquetFile(file)
+        rows = pf.metadata.num_rows
         print(f"  {os.path.basename(file)}: {rows:,} rows, {size:,} bytes")
 
     if skip_upload: