Create hub-stats.py

hub-stats.py

@@ -0,0 +1,319 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "pandas==2.2.2",
+#     "aiohttp",
+#     "python-dotenv==1.0.1",
+#     "huggingface-hub==0.24.3",
+#     "tenacity==9.0.0",
+#     "pyarrow==17.0.0",
+#     "requests",
+# ]
+# ///
+
+import json
+import os
+import asyncio
+import time
+
+import pandas as pd
+import aiohttp
+import requests.utils
+from dotenv import load_dotenv
+from huggingface_hub import HfApi
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+load_dotenv()
+
+CACHE_DIR = ".hf_cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+ENDPOINT_CONFIGS = {
+    "models": {
+        "limit": 1000,
+        "params": {
+            "full": "true",
+            "config": "true",
+            "expand[]": [
+                "gguf",
+                "downloadsAllTime",
+                "transformersInfo",
+                "cardData",
+                "safetensors",
+                "author",
+                "likes",
+                "inferenceProviderMapping",
+                "downloads",
+                "siblings",
+                "tags",
+                "pipeline_tag",
+                "lastModified",
+                "createdAt",
+                "config",
+                "library_name",
+            ],
+        },
+    },
+    "datasets": {
+        "limit": 1000,
+        "params": {
+            "full": "true",
+            "expand[]": [
+                "author",
+                "cardData",
+                "citation",
+                "createdAt",
+                "disabled",
+                "description",
+                "downloads",
+                "downloadsAllTime",
+                "gated",
+                "lastModified",
+                "likes",
+                "paperswithcode_id",
+                "private",
+                "siblings",
+                "sha",
+                "tags",
+                "trendingScore",
+            ],
+        },
+    },
+    "spaces": {"limit": 1000, "params": {"full": "true"}},
+    "posts": {"limit": 50, "params": {"skip": 0}},
+    "daily_papers": {
+        "limit": 1000,
+        "params": {},
+        "base_url": "https://huggingface.co/api/daily_papers",
+    },
+}
+
+
+def parse_link_header(link_header):
+    if not link_header:
+        return None
+    links = requests.utils.parse_header_links(link_header)
+    for link in links:
+        if link.get("rel") == "next":
+            return link.get("url")
+    return None
+
+
+def to_json_string(x):
+    return (
+        json.dumps(x)
+        if isinstance(x, (dict, list))
+        else str(x) if x is not None else None
+    )
+
+
+def process_dataframe(df, endpoint):
+    if len(df) == 0:
+        return df
+
+    if endpoint == "posts":
+        if "author" in df.columns:
+            author_df = pd.json_normalize(df["author"])
+            author_cols = ["avatarUrl", "followerCount", "fullname", "name"]
+            for col in author_cols:
+                if col in author_df.columns:
+                    df[col] = author_df[col]
+            df = df.drop("author", axis=1)
+
+        for ts_col in ["publishedAt", "updatedAt"]:
+            if ts_col in df.columns:
+                df[ts_col] = pd.to_datetime(df[ts_col]).dt.tz_localize(None)
+
+    elif endpoint == "daily_papers":
+        if "paper" in df.columns:
+            paper_df = pd.json_normalize(df["paper"], errors="ignore").add_prefix(
+                "paper_"
+            )
+            df = pd.concat([df.drop("paper", axis=1), paper_df], axis=1)
+
+        for ts_col in ["publishedAt", "paper_publishedAt"]:
+            if ts_col in df.columns:
+                df[ts_col] = pd.to_datetime(df[ts_col], errors="coerce").dt.tz_localize(
+                    None
+                )
+
+    else:
+        for field in ["createdAt", "lastModified"]:
+            if field in df.columns:
+                df[field] = pd.to_datetime(df[field], errors="coerce").dt.tz_localize(
+                    None
+                )
+
+    for col in ["cardData", "config", "gguf"]:
+        if col in df.columns:
+            df[col] = df[col].apply(to_json_string)
+
+    return df
+
+
+def save_parquet(df, output_file):
+    df.to_parquet(output_file, index=False, engine="pyarrow")
+
+
+@retry(stop=stop_after_attempt(5), wait=wait_exponential(multiplier=1, min=4, max=60))
+async def fetch_data_page(session, url, params=None, headers=None):
+    async with session.get(url, params=params, headers=headers) as response:
+        response.raise_for_status()
+        return await response.json(), response.headers.get("Link")
+
+
+async def create_parquet_files(skip_upload=False):
+    start_time = time.time()
+    endpoints = ["models", "daily_papers", "spaces", "datasets", "posts"]
+    created_files = []
+
+    async with aiohttp.ClientSession() as session:
+        for endpoint in endpoints:
+            print(f"Processing {endpoint}...")
+
+            config = ENDPOINT_CONFIGS[endpoint]
+            base_url = config.get("base_url", f"https://huggingface.co/api/{endpoint}")
+            params = {"limit": config["limit"]}
+            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
+
+            while url:
+                if endpoint == "posts":
+                    params["skip"] = page * params["limit"]
+
+                try:
+                    data, link_header = await fetch_data_page(
+                        session, url, params, headers
+                    )
+
+                    if skip_upload and jsonl_file:
+                        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:
+                            url = None
+                        else:
+                            url = base_url
+                    else:
+                        all_data.extend(data)
+                        url = parse_link_header(link_header)
+                        if url:
+                            params = {}
+
+                    if len(all_data) % 1000000 == 0:
+                        print(f"  {len(all_data):,} records processed")
+
+                    page += 1
+
+                except Exception as e:
+                    print(f"Error on page {page}: {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}")
+
+            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)
+
+            print(f"✓ {endpoint}: {len(df):,} rows -> {output_file}")
+
+    elapsed = time.time() - start_time
+    return created_files, elapsed
+
+
+def recreate_from_jsonl():
+    endpoints = ["models", "daily_papers", "spaces", "datasets", "posts"]
+
+    for endpoint in endpoints:
+        jsonl_file = os.path.join(CACHE_DIR, f"{endpoint}_raw.jsonl")
+        if not os.path.exists(jsonl_file):
+            print(f"✗ {jsonl_file} not found")
+            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}")
+
+
+def upload_to_hub(created_files):
+    api = HfApi()
+    repo_id = "cfahlgren1/hub-stats"
+
+    for file in created_files:
+        try:
+            api.upload_file(
+                path_or_fileobj=file,
+                path_in_repo=os.path.basename(file),
+                repo_id=repo_id,
+                repo_type="dataset",
+            )
+            print(f"✓ Uploaded {os.path.basename(file)} to {repo_id}")
+        except Exception as e:
+            print(f"✗ Failed to upload {os.path.basename(file)}: {e}")
+
+
+def main(skip_upload=False):
+    created_files, elapsed = asyncio.run(create_parquet_files(skip_upload=skip_upload))
+
+    print(f"\nCompleted in {elapsed:.2f} seconds")
+    print(f"Created {len(created_files)} parquet files:")
+
+    for file in created_files:
+        size = os.path.getsize(file)
+        rows = len(pd.read_parquet(file))
+        print(f"  {os.path.basename(file)}: {rows:,} rows, {size:,} bytes")
+
+    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")
+    else:
+        print("\nUploading to HuggingFace...")
+        upload_to_hub(created_files)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if "--recreate" in sys.argv:
+        recreate_from_jsonl()
+    else:
+        skip_upload = "--skip-upload" in sys.argv
+        main(skip_upload=skip_upload)