feat: add DuckDB persistence and optimize GraphQL batching for repo scraping

.windsurf/rules/executing-python-files.md

@@ -2,4 +2,4 @@
 trigger: always_on
 ---
 
-When executing python files, use python3 instead of python because that adheres to project's venv. Additionally, if you haven't activated venv yet, you have to activate it or else the execution will fail with module not found exception. For this project, it's venv is in another project's, so activate it by running "source ../documentation-qa/.venv/bin/activate" - do NOT modify this command if you are willing to activate. Using bash -lc won't work, use the exact command.
+When executing python files, use python3 instead of python because that adheres to project's venv. Additionally, if you haven't activated venv yet, you have to activate it or else the execution will fail with module not found exception. For this project, it's venv is in another project's, so activate it by running `source ../../doc-venv/bin/activate` - do NOT modify this command if you are willing to activate. Using bash -lc won't work, use the exact command.

data_collection_utils/github_api_utils.py

@@ -27,6 +27,7 @@ _thread_local = threading.local()
 
 def github_headers() -> Dict[str, str]:
     token = os.getenv("GITHUB_TOKEN")
+    assert token is not None, "Set the Github token to run this script!"
     h = {"Accept": "application/vnd.github.v3+json", "User-Agent": "docs-scraper/1.0"}
     if token:
         h["Authorization"] = f"token {token}"
@@ -359,6 +360,13 @@ def fetch_repos_metadata_graphql(
         vars[f"name{i}"] = name
         alias = f"repo_{i}"
         header = f"{alias}: repository(owner: $owner{i}, name: $name{i}) "
+        topics_fragment = (
+            "  repositoryTopics(first: "
+            + str(topics_limit)
+            + ") { nodes { topic { name } } }\n"
+            if topics_limit and topics_limit > 0
+            else ""
+        )
         body = (
             "{\n"
             "  name\n"
@@ -368,9 +376,7 @@ def fetch_repos_metadata_graphql(
             "  isFork\n"
             "  parent { url nameWithOwner }\n"
             "  primaryLanguage { name }\n"
-            "  repositoryTopics(first: "
-            + str(topics_limit)
-            + ") { nodes { topic { name } } }\n"
+            + topics_fragment +
             "  defaultBranchRef {\n"
             "    name\n"
             "    target {\n"

data_collection_utils/parse_gh_docs_config.yaml

@@ -26,7 +26,7 @@ checkpoint_every: 50
 
 # GraphQL batching and metadata
 # Max repos per GraphQL request; keep modest to avoid cost limits
-graphql_batch_size: 50
+graphql_batch_size: 20
 # Number of topics to fetch per repository via GraphQL
 topics_limit: 20
 

data_collection_utils/scrape_gh_docs.py

@@ -46,6 +46,7 @@ import json
 import pandas as pd
 import subprocess
 import yaml
+import duckdb
 from datetime import datetime, timezone
 import logging
 import langid  # https://github.com/saffsd/langid.py
@@ -839,6 +840,40 @@ def process_repo_entry(
     return result
 
 
+def _init_duckdb(con):
+    con.execute(
+        """
+        CREATE TABLE IF NOT EXISTS texts (
+          owner TEXT,
+          repo TEXT,
+          repo_dir TEXT,
+          file_rel_repo TEXT,
+          file_rel_outdir TEXT,
+          size BIGINT,
+          mtime BIGINT,
+          lang TEXT,
+          content TEXT
+        );
+        """
+    )
+    con.execute(
+        """
+        CREATE TABLE IF NOT EXISTS repometa (
+          latest_commit_date TEXT,
+          name TEXT,
+          parent_org TEXT,
+          stars BIGINT,
+          link TEXT,
+          language TEXT,
+          topics TEXT,
+          docs_found_in TEXT,
+          docs_repo_structure TEXT,
+          repo_structure_all_files TEXT
+        );
+        """
+    )
+
+
 # === CLI ===
 
 
@@ -875,13 +910,15 @@ def main():
     workers_value = int(cfg.get("workers", 4))
     texts_parquet_value = _resolve_cfg_path(cfg.get("texts_parquet"))
     repometa_parquet_value = _resolve_cfg_path(cfg.get("repometa_parquet"))
+    duckdb_path_value = _resolve_cfg_path(cfg.get("duckdb_path"))
     token_file_value = _resolve_cfg_path(cfg.get("token_file"))
     prefer_zip_value = bool(cfg.get("prefer_zip", False))
     prefer_sparse_value = bool(cfg.get("prefer_sparse", False))
     only_md_value = bool(cfg.get("only_md", False))
     min_repo_age_years_value = int(cfg.get("min_repo_age_years", 0))
     quiet_value = bool(cfg.get("quiet", False))
-    no_fetch_value = bool(cfg.get("no_fetch", args.no_fetch))
+    # CLI should override YAML for convenience
+    no_fetch_value = bool(args.no_fetch or cfg.get("no_fetch", False))
     lang_filter_value = cfg.get("lang_filter", "en")
     min_text_chars_value = int(cfg.get("min_text_chars", 200))
 
@@ -889,11 +926,7 @@ def main():
         if val is None:
             return []
         if isinstance(val, (list, tuple)):
-            return [
-                _resolve_cfg_path(v)
-                for v in val
-                if v is not None
-            ]
+            return [_resolve_cfg_path(v) for v in val if v is not None]
         return [_resolve_cfg_path(val)]
 
     input_parquet_values = _resolve_cfg_paths(cfg.get("input_parquet"))
@@ -908,6 +941,13 @@ def main():
     outdir = Path(outdir_value)
     outdir.mkdir(parents=True, exist_ok=True)
 
+    # Initialize DuckDB connection (file-backed)
+    duckdb_path = (
+        Path(duckdb_path_value) if duckdb_path_value else (outdir / "gh_docs.duckdb")
+    )
+    con = duckdb.connect(str(duckdb_path))
+    _init_duckdb(con)
+
     md_failed_path = Path(md_failed_value)
     # create/empty md_failed file
     md_failed_path.write_text("")
@@ -917,7 +957,9 @@ def main():
     else:
         lines: List[str] = []
         if not input_parquet_values:
-            logger.error("'input_parquet' is required. Configure one or more Parquet files with a 'link' column in parse_gh_docs_config.yaml.")
+            logger.error(
+                "'input_parquet' is required. Configure one or more Parquet files with a 'link' column in parse_gh_docs_config.yaml."
+            )
             sys.exit(2)
         # Read repositories from one or more Parquet files; use 'link' column
         seen = set()
@@ -937,6 +979,7 @@ def main():
     md_failed_lock = threading.Lock()
     results_lock = threading.Lock()
     results: List[Dict[str, Any]] = []
+    duckdb_lock = threading.Lock()
 
     # Process repositories concurrently
     with tqdm(total=len(lines), desc="Repos") as pbar:
@@ -957,6 +1000,43 @@ def main():
                 if res is not None:
                     with results_lock:
                         results.append(res)
+                    # Incremental per-repo texts persistence into DuckDB
+                    owner = res.get("owner")
+                    repo = res.get("repo")
+                    if owner and repo and res.get("docs_found"):
+                        d = outdir / safe_name(f"{owner}__{repo}")
+                        if d.exists() and d.is_dir():
+                            rows_one = collect_md_rows_for_repo_dir(
+                                d,
+                                outdir,
+                                lang_filter_value,
+                                min_text_chars_value,
+                            )
+                            if rows_one:
+                                cols = [
+                                    "owner",
+                                    "repo",
+                                    "repo_dir",
+                                    "file_rel_repo",
+                                    "file_rel_outdir",
+                                    "size",
+                                    "mtime",
+                                    "lang",
+                                    "content",
+                                ]
+                                df_one = pd.DataFrame(rows_one, columns=cols)
+                                with duckdb_lock:
+                                    con.execute("BEGIN")
+                                    con.execute(
+                                        "DELETE FROM texts WHERE owner = ? AND repo = ?",
+                                        [owner, repo],
+                                    )
+                                    con.register("df_txt_one", df_one)
+                                    con.execute(
+                                        "INSERT INTO texts SELECT * FROM df_txt_one"
+                                    )
+                                    con.unregister("df_txt_one")
+                                    con.execute("COMMIT")
             except Exception as e:
                 logger.error(f"Exception while processing {lr}: {e}")
                 append_line_threadsafe(
@@ -1019,19 +1099,40 @@ def main():
                     md_rows.extend(rows)
                 pbar.update(1)
 
-    # Save per-file dataset (texts only)
+    # Save per-file dataset (texts) into DuckDB and export Parquet
     texts_parquet_path = (
         Path(texts_parquet_value) if texts_parquet_value else (outdir / "texts.parquet")
     )
     try:
-        df_txt = pd.DataFrame(md_rows)
+        cols = [
+            "owner",
+            "repo",
+            "repo_dir",
+            "file_rel_repo",
+            "file_rel_outdir",
+            "size",
+            "mtime",
+            "lang",
+            "content",
+        ]
+        df_txt = pd.DataFrame(md_rows, columns=cols)
+        with duckdb_lock:
+            con.execute("BEGIN")
+            con.execute("DELETE FROM texts")
+            con.register("df_txt_all", df_txt)
+            con.execute("INSERT INTO texts SELECT * FROM df_txt_all")
+            con.unregister("df_txt_all")
+            con.execute("COMMIT")
         texts_parquet_path.parent.mkdir(parents=True, exist_ok=True)
-        df_txt.to_parquet(texts_parquet_path, index=False)
+        con.execute(
+            "COPY (SELECT * FROM texts) TO ? (FORMAT PARQUET)",
+            [str(texts_parquet_path)],
+        )
         logger.info(
             f"Wrote per-file dataset to {texts_parquet_path} (rows={len(md_rows)})"
         )
     except Exception as e:
-        logger.error(f"Failed to write per-file Parquet to {texts_parquet_path}: {e}")
+        logger.error(f"Failed to persist/export texts: {e}")
 
     # Build and save repo metadata dataset
     repometa_rows: List[Dict[str, Any]] = []
@@ -1064,11 +1165,13 @@ def main():
 
             repometa_rows.append(
                 {
-                    "latest_commit_date": None,  # unknown without network
+                    "latest_commit_date": None,
                     "name": repo,
                     "parent_org": owner,
-                    "stars": None,  # unknown without network
+                    "stars": None,
                     "link": link,
+                    "language": None,
+                    "topics": None,
                     "docs_found_in": None,
                     "docs_repo_structure": docs_tree_json,
                     "repo_structure_all_files": full_tree_json,
@@ -1085,29 +1188,23 @@ def main():
                 default_branch = res.get("default_branch") or repo_json.get(
                     "default_branch", "main"
                 )
-                # latest commit date via utility (fallback to pushed_at handled inside)
                 latest_commit_date = get_latest_commit_date(
                     owner, repo, default_branch, repo_json
                 )
-
                 stars = repo_json.get("stargazers_count")
                 link = f"https://github.com/{owner}/{repo}"
                 docs_found_in = res.get("docs_found_in")
 
-                # docs repo structure (only .md) via Git Trees API; scope it to the actual container that held the docs
-                # Examples:
-                #  - docker: use repo 'docker/docs' (entire repo)
-                #  - flutter: use 'flutter/flutter' restricted to the 'docs/' folder
+                # Build docs tree
                 method = res.get("method")
                 docs_tree_json = None
                 try:
                     docs_src_owner = owner
                     docs_src_repo = repo
                     docs_src_ref = default_branch
-                    path_filters: List[str] | None = None  # prefix filters
+                    path_filters: List[str] | None = None
 
                     if method in ("org_docs_repo_zip", "search_repo_zip"):
-                        # docs are in a separate repository; parse from docs_found_in URL
                         dfi = res.get("docs_found_in")
                         if isinstance(dfi, str) and dfi.startswith("http"):
                             u = urlparse(dfi)
@@ -1118,14 +1215,10 @@ def main():
                                     get_repo_info(docs_src_owner, docs_src_repo) or {}
                                 )
                                 docs_src_ref = info.get("default_branch", "main")
-                            # else: fallback to original owner/repo
-                        # For full separate docs repos, include all .md files (no path filter)
                         path_filters = None
                     elif method in ("docs_folder_in_repo", "docs_file_in_repo"):
-                        # Restrict to top-level docs/ folder
                         path_filters = ["docs"]
                     elif method in ("sparse_docs", "zip_whole_repo"):
-                        # Include common doc directory names anywhere in the tree
                         path_filters = ["docs", "doc", "documentation"]
 
                     md_paths_all = get_repo_tree_md_paths(
@@ -1145,7 +1238,6 @@ def main():
                 except Exception:
                     pass
                 if docs_tree_json is None:
-                    # Fallback to local docs dir if available
                     docs_folder_rel = res.get("docs_folder")
                     if docs_folder_rel:
                         docs_dir = outdir / docs_folder_rel
@@ -1155,7 +1247,7 @@ def main():
                             )
                             docs_tree_json = json.dumps(docs_tree, ensure_ascii=False)
 
-                # full repo structure via GitHub Tree API; fallback to local saved root if API fails
+                # Build full tree
                 full_tree_json = None
                 try:
                     paths = get_repo_tree_paths(owner, repo, default_branch)
@@ -1179,6 +1271,12 @@ def main():
                         "parent_org": owner,
                         "stars": stars,
                         "link": link,
+                        "language": repo_json.get("language"),
+                        "topics": json.dumps(
+                            repo_json.get("topics"), ensure_ascii=False
+                        )
+                        if repo_json.get("topics") is not None
+                        else None,
                         "docs_found_in": docs_found_in,
                         "docs_repo_structure": docs_tree_json,
                         "repo_structure_all_files": full_tree_json,
@@ -1187,22 +1285,49 @@ def main():
             except Exception as e:
                 logger.warning(f"Failed to build repometa for {owner}/{repo}: {e}")
 
+    # Persist repo metadata to DuckDB and export Parquet
     repometa_parquet_path = (
         Path(repometa_parquet_value)
         if repometa_parquet_value
         else (outdir / "repometa.parquet")
     )
     try:
-        df_meta = pd.DataFrame(repometa_rows)
+        cols_meta = [
+            "latest_commit_date",
+            "name",
+            "parent_org",
+            "stars",
+            "link",
+            "language",
+            "topics",
+            "docs_found_in",
+            "docs_repo_structure",
+            "repo_structure_all_files",
+        ]
+        df_meta = pd.DataFrame(repometa_rows, columns=cols_meta)
+        with duckdb_lock:
+            con.execute("BEGIN")
+            con.execute("DELETE FROM repometa")
+            con.register("df_meta_all", df_meta)
+            con.execute("INSERT INTO repometa SELECT * FROM df_meta_all")
+            con.unregister("df_meta_all")
+            con.execute("COMMIT")
         repometa_parquet_path.parent.mkdir(parents=True, exist_ok=True)
-        df_meta.to_parquet(repometa_parquet_path, index=False)
+        con.execute(
+            "COPY (SELECT * FROM repometa) TO ? (FORMAT PARQUET)",
+            [str(repometa_parquet_path)],
+        )
         logger.info(
             f"Wrote repo metadata dataset to {repometa_parquet_path} (rows={len(repometa_rows)})"
         )
     except Exception as e:
-        logger.error(
-            f"Failed to write repo metadata Parquet to {repometa_parquet_path}: {e}"
-        )
+        logger.error(f"Failed to persist/export repo metadata: {e}")
+
+    # Close DB connection
+    try:
+        con.close()
+    except Exception:
+        pass
 
     logger.info("Done. Check output directory and md-failed.txt")
 

data_collection_utils/top_1000_repos.py

@@ -65,11 +65,14 @@ def parse_owner_repo(url: str) -> Optional[tuple[str, str]]:
     return parts[0], parts[1]
 
 
-def map_to_original_repos_graphql(urls: List[str]) -> List[str]:
-    """Resolve forks to their parent repos using a single round of GraphQL metadata.
+def map_to_original_repos_graphql(
+    urls: List[str], *, batch_size: int = 30, topics_limit: int = 0
+) -> List[str]:
+    """Resolve forks to their parent repos using batched GraphQL metadata requests.
 
     - 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.
+    - Queries are sent in chunks of ``batch_size`` to avoid oversized GraphQL payloads.
     """
     pairs: List[tuple[str, str]] = []
     for u in urls:
@@ -77,10 +80,15 @@ def map_to_original_repos_graphql(urls: List[str]) -> List[str]:
         if pr is None:
             continue
         pairs.append(pr)
-    # Batch query
-    meta = fetch_repos_metadata_graphql(pairs)
+    # Batch query to avoid 502s on oversized GraphQL requests
+    meta: Dict[str, Dict[str, Any]] = {}
+    for i in range(0, len(pairs), batch_size):
+        chunk = pairs[i : i + batch_size]
+        mm = fetch_repos_metadata_graphql(chunk, topics_limit=topics_limit)
+        if mm:
+            meta.update(mm)
     out: set[str] = set()
-    for (owner, repo) in pairs:
+    for owner, repo in pairs:
         key = f"{owner}/{repo}"
         m = meta.get(key) or {}
         parent_url = m.get("parent_url")
@@ -96,6 +104,7 @@ def map_to_original_repos_graphql(urls: List[str]) -> List[str]:
 def main() -> None:
     # Load token from .env for GraphQL
     load_dotenv()
+    print("[top_1000_repos] Starting script execution. This may take a minute or so...")
 
     # Load YAML config next to this script if present
     cfg: Dict[str, Any] = {}
@@ -115,7 +124,9 @@ def main() -> None:
     out_html = _resolve_cfg_path(cfg.get("out_html")) or Path(__file__).with_name(
         "Top 1000 GitHub repositories, updated daily, all on one page..html"
     )
-    out_links = _resolve_cfg_path(cfg.get("out_links")) or (project_root / "github_links.txt")
+    out_links = _resolve_cfg_path(cfg.get("out_links")) or (
+        project_root / "github_links.txt"
+    )
     out_parquet = _resolve_cfg_path(cfg.get("out_parquet")) or Path(__file__).with_name(
         "top-1000-repos.parquet"
     )
@@ -131,6 +142,7 @@ def main() -> None:
     topics_limit = int(cfg.get("topics_limit", 20))
     fork_resolution = bool(cfg.get("fork_resolution", True))
 
+    print("[top_1000_repos] Launching Playwright browser...")
     with sync_playwright() as p:
         browser = p.chromium.launch(headless=headless)
         context = browser.new_context()
@@ -140,7 +152,9 @@ def main() -> None:
         page.wait_for_selector('a[href*="https://github.com/"]', timeout=30000)
 
         # Auto-scroll to force lazy loading/virtualized list to render all items
-        def _scroll_all(max_iters: int = scroll_max_iters, pause_ms: int = scroll_pause_ms) -> None:
+        def _scroll_all(
+            max_iters: int = scroll_max_iters, pause_ms: int = scroll_pause_ms
+        ) -> None:
             prev_count = 0
             stable = 0
             for _ in range(max_iters):
@@ -159,10 +173,12 @@ def main() -> None:
                     break
 
         _scroll_all()
+        print("[top_1000_repos] Scrolling completed. Extracting links...")
 
         # Save rendered HTML
         html = page.content()
         out_html.write_text(html, encoding="utf-8")
+        print(f"[top_1000_repos] Saved rendered HTML to {out_html}")
 
         # Extract canonical GitHub repo URLs from the DOM after full scroll
         links = page.eval_on_selector_all(
@@ -173,9 +189,14 @@ def main() -> None:
 
         # Optionally map any fork links to their original repositories and deduplicate
         if fork_resolution:
-            repo_links = map_to_original_repos_graphql(repo_links)
+            repo_links = map_to_original_repos_graphql(
+                repo_links, batch_size=graphql_batch_size, topics_limit=0
+            )
 
         # Persist github_links.txt for visibility/debug (even if not used downstream)
+        print(
+            f"[top_1000_repos] Writing {len(repo_links)} repository links to {out_links}"
+        )
         with out_links.open("w", encoding="utf-8") as f:
             f.write("\n".join(repo_links) + "\n")
 
@@ -215,6 +236,9 @@ def main() -> None:
                 }
             )
 
+        print(
+            f"[top_1000_repos] Enriching repository metadata via GraphQL (batch size {graphql_batch_size})..."
+        )
         df = pd.DataFrame(rows)
         df.to_parquet(out_parquet, index=False)
         print(f"Wrote HTML to {out_html}")