GraphQL for top1000 repos scraping

.windsurf/rules/creating-cli-tooling.md

@@ -3,4 +3,4 @@ trigger: model_decision
 description: When creating CLI tooling
 ---
 
-CLI tooling is good, but I prefer configuring through YAML. When creating CLI tooling, create a "config.yaml" or "[name_of_the_code_function]_config.yaml", and put all config there. Secrets should be put in a `.env` file, and loaded with `dotenv.load_dotenv()`. 
+I prefer configuring scripts through YAML. When creating CLI tooling, "[module_name]_config.yaml", and put all config there. Secrets should be put in a `.env` file, and loaded with `dotenv.load_dotenv()`.

data_collection_utils/github_api_utils.py

@@ -328,10 +328,15 @@ def fetch_repos_metadata_graphql(
     Batch-fetch repository metadata via GitHub GraphQL for a list of (owner, repo) pairs.
 
     Returns a mapping from "owner/repo" -> {
+        "name": str | None,
         "description": str | None,
         "stars": int | None,
         "default_branch": str | None,
         "last_commit_date": str | None,
+        "language": str | None,
+        "topics": List[str],
+        "is_fork": bool | None,
+        "parent_url": str | None,
     }
 
     Notes:
@@ -347,35 +352,40 @@ def fetch_repos_metadata_graphql(
     #   repo_0: repository(owner: $owner0, name: $name0) { ...fields }
     # }
     vars: Dict[str, Any] = {}
-    fields = []
+    fields: List[str] = []
     for i, (owner, name) in enumerate(pairs):
         vars[f"owner{i}"] = owner
         vars[f"name{i}"] = name
         alias = f"repo_{i}"
-        fields.append(
-            f"""
-{alias}: repository(owner: $owner{i}, name: $name{i}) {{
-  description
-  stargazerCount
-  pushedAt
-  defaultBranchRef {{
-    name
-    target {{
-      ... on Commit {{
-        history(first: 1) {{
-          nodes {{
-            committedDate
-          }}
-        }}
-      }}
-    }}
-  }}
-}}
-""".strip().format(alias=alias)
+        header = f"{alias}: repository(owner: $owner{i}, name: $name{i}) "
+        body = (
+            "{\n"
+            "  name\n"
+            "  description\n"
+            "  stargazerCount\n"
+            "  pushedAt\n"
+            "  isFork\n"
+            "  parent { url nameWithOwner }\n"
+            "  primaryLanguage { name }\n"
+            "  repositoryTopics(first: 20) { nodes { topic { name } } }\n"
+            "  defaultBranchRef {\n"
+            "    name\n"
+            "    target {\n"
+            "      ... on Commit {\n"
+            "        history(first: 1) {\n"
+            "          nodes {\n"
+            "            committedDate\n"
+            "          }\n"
+            "        }\n"
+            "      }\n"
+            "    }\n"
+            "  }\n"
+            "}\n"
         )
+        fields.append(header + body)
     # Assemble query
     var_decls = " ".join([f"$owner{i}: String!, $name{i}: String!" for i in range(len(pairs))])
-    query = f"query({var_decls}) {{\n" + "\n".join(fields) + "\n}"
+    query = "query(" + var_decls + ") {\n" + "\n".join(fields) + "\n}"
 
     payload = {"query": query, "variables": vars}
     max_retries = 3
@@ -428,11 +438,39 @@ def fetch_repos_metadata_graphql(
         r = repos.get(alias)
         key = f"{owner}/{name}"
         if not isinstance(r, dict):
-            out[key] = {"description": None, "stars": None, "default_branch": None, "last_commit_date": None}
+            out[key] = {
+                "name": None,
+                "description": None,
+                "stars": None,
+                "default_branch": None,
+                "last_commit_date": None,
+                "language": None,
+                "topics": [],
+                "is_fork": None,
+                "parent_url": None,
+            }
             continue
+        repo_name = r.get("name")
         desc = r.get("description")
         stars = r.get("stargazerCount")
         pushed_at = r.get("pushedAt")
+        is_fork = r.get("isFork")
+        parent = r.get("parent") or {}
+        parent_url = parent.get("url") if isinstance(parent, dict) else None
+        lang_obj = r.get("primaryLanguage") or {}
+        language = lang_obj.get("name") if isinstance(lang_obj, dict) else None
+        topics_list: List[str] = []
+        rt = r.get("repositoryTopics") or {}
+        nodes = rt.get("nodes") if isinstance(rt, dict) else None
+        if isinstance(nodes, list):
+            for node in nodes:
+                t = None
+                if isinstance(node, dict):
+                    topic = node.get("topic")
+                    if isinstance(topic, dict):
+                        t = topic.get("name")
+                if isinstance(t, str):
+                    topics_list.append(t)
         dbr = r.get("defaultBranchRef") or {}
         default_branch = dbr.get("name") if isinstance(dbr, dict) else None
         last_commit_date = pushed_at
@@ -445,9 +483,14 @@ def fetch_repos_metadata_graphql(
                 if isinstance(lcd, str):
                     last_commit_date = lcd
         out[key] = {
+            "name": repo_name if isinstance(repo_name, str) else None,
             "description": desc if isinstance(desc, str) else None,
             "stars": stars,
             "default_branch": default_branch,
             "last_commit_date": last_commit_date,
+            "language": language if isinstance(language, str) else None,
+            "topics": topics_list,
+            "is_fork": is_fork if isinstance(is_fork, bool) else None,
+            "parent_url": parent_url if isinstance(parent_url, str) else None,
         }
     return out

data_collection_utils/top_1000_repos.py

@@ -2,10 +2,10 @@ from pathlib import Path
 from playwright.sync_api import sync_playwright
 from urllib.parse import urlparse
 from typing import List, Optional, Dict, Any
-from concurrent.futures import ThreadPoolExecutor, as_completed
 import argparse
 import pandas as pd
-from github_api_utils import get_repo_info
+from github_api_utils import fetch_repos_metadata_graphql
+from dotenv import load_dotenv
 
 URL = "https://top1000repos.com/"
 
@@ -54,40 +54,43 @@ def normalize_github_repo_links(links: List[str]) -> List[str]:
     return sorted(repos)
 
 
-def resolve_to_original_repo(url: str) -> Optional[str]:
-    """Return the canonical URL of the original (non-fork) repository.
+# removed: resolve_to_original_repo (replaced by GraphQL-based mapping)
 
-    If the input URL points to a fork, map it to its parent/original repository.
-    If the repository metadata cannot be retrieved, return None.
-    """
+
+def parse_owner_repo(url: str) -> Optional[tuple[str, str]]:
     p = urlparse(url)
     parts = [part for part in p.path.split("/") if part]
     if len(parts) < 2:
         return None
-    owner, repo = parts[0], parts[1]
-    info = get_repo_info(owner, repo)
-    if not info:
-        return None
-    if info.get("fork"):
-        parent = info.get("parent") or {}
-        html_url = parent.get("html_url")
-        if not html_url:
-            return None
-        return canonical_repo_url(html_url)
-    return canonical_repo_url(url)
+    return parts[0], parts[1]
 
 
-def map_to_original_repos(urls: List[str]) -> List[str]:
-    originals = set()
+def map_to_original_repos_graphql(urls: List[str]) -> List[str]:
+    """Resolve forks to their parent repos using a single round of GraphQL metadata.
+
+    - For each input repo URL, if it's a fork and parent_url is available, map to parent.
+    - Returns the sorted unique list of canonical GitHub URLs.
+    """
+    pairs: List[tuple[str, str]] = []
     for u in urls:
-        o = resolve_to_original_repo(u)
-        if o is not None:
-            originals.add(o)
-        else:
-            # keep the canonical URL if we couldn't resolve
-            cu = canonical_repo_url(u) or u
-            originals.add(cu)
-    return sorted(originals)
+        pr = parse_owner_repo(u)
+        if pr is None:
+            continue
+        pairs.append(pr)
+    # Batch query
+    meta = fetch_repos_metadata_graphql(pairs)
+    out: set[str] = set()
+    for (owner, repo) in pairs:
+        key = f"{owner}/{repo}"
+        m = meta.get(key) or {}
+        parent_url = m.get("parent_url")
+        if m.get("is_fork") and isinstance(parent_url, str):
+            cu = canonical_repo_url(parent_url)
+            if cu is not None:
+                out.add(cu)
+                continue
+        out.add(f"https://github.com/{owner}/{repo}")
+    return sorted(out)
 
 
 def main() -> None:
@@ -99,6 +102,9 @@ def main() -> None:
     )
     args = ap.parse_args()
 
+    # Load token from .env for GraphQL
+    load_dotenv()
+
     project_root = Path(__file__).resolve().parents[1]
     out_html = Path(__file__).with_name(
         "Top 1000 GitHub repositories, updated daily, all on one page..html"
@@ -147,36 +153,47 @@ def main() -> None:
         repo_links = normalize_github_repo_links(links)
 
         # Optionally map any fork links to their original repositories and deduplicate
-        repo_links = map_to_original_repos(repo_links)
+        repo_links = map_to_original_repos_graphql(repo_links)
 
         # Persist github_links.txt for visibility/debug (even if not used downstream)
         with out_links.open("w", encoding="utf-8") as f:
             f.write("\n".join(repo_links) + "\n")
 
-        # Enrich via GitHub API concurrently
-        def _one(url: str) -> Dict[str, Any]:
-            owner_repo = urlparse(url).path.strip("/").split("/")[:2]
-            owner, repo = owner_repo[0], owner_repo[1]
-            info = get_repo_info(owner, repo) or {}
-            name = info.get("name") or repo
-            desc = info.get("description") or None
-            stars = info.get("stargazers_count")
-            return {
-                "name": name,
-                "link": f"https://github.com/{owner}/{repo}",
-                "description": desc,
-                "stars": int(stars) if isinstance(stars, int) else None,
-            }
+        # Enrich via GraphQL in batches
+        pairs: List[tuple[str, str]] = []
+        for u in repo_links:
+            pr = parse_owner_repo(u)
+            if pr is not None:
+                pairs.append(pr)
+        meta_map: Dict[str, Dict[str, Any]] = {}
+        batch_size = args.workers
+        for i in range(0, len(pairs), batch_size):
+            chunk = pairs[i : i + batch_size]
+            try:
+                mm = fetch_repos_metadata_graphql(chunk)
+            except Exception:
+                mm = {}
+            if mm:
+                meta_map.update(mm)
 
         rows: List[Dict[str, Any]] = []
-        with ThreadPoolExecutor(max_workers=args.workers) as ex:
-            futs = [ex.submit(_one, u) for u in repo_links]
-            for fut in as_completed(futs):
-                try:
-                    rows.append(fut.result())
-                except Exception:
-                    # Skip on error; we aim for stability over strict completeness
-                    continue
+        for owner, repo in pairs:
+            m = meta_map.get(f"{owner}/{repo}") or {}
+            name = m.get("name") or repo
+            desc = m.get("description")
+            stars = m.get("stars")
+            language = m.get("language")
+            topics = m.get("topics")
+            rows.append(
+                {
+                    "name": name,
+                    "link": f"https://github.com/{owner}/{repo}",
+                    "description": desc if isinstance(desc, str) else None,
+                    "stars": stars if isinstance(stars, int) else None,
+                    "language": language if isinstance(language, str) else None,
+                    "topics": topics if isinstance(topics, list) else [],
+                }
+            )
 
         df = pd.DataFrame(rows)
         df.to_parquet(out_parquet, index=False)