feat: config to yaml

data_collection_utils/github_api_utils.py

@@ -323,6 +323,7 @@ def _graphql_headers() -> Dict[str, str]:
 
 def fetch_repos_metadata_graphql(
     pairs: List[tuple[str, str]],
+    topics_limit: int = 20,
 ) -> Dict[str, Dict[str, Any]]:
     """
     Batch-fetch repository metadata via GitHub GraphQL for a list of (owner, repo) pairs.
@@ -367,7 +368,9 @@ def fetch_repos_metadata_graphql(
             "  isFork\n"
             "  parent { url nameWithOwner }\n"
             "  primaryLanguage { name }\n"
-            "  repositoryTopics(first: 20) { nodes { topic { name } } }\n"
+            "  repositoryTopics(first: "
+            + str(topics_limit)
+            + ") { nodes { topic { name } } }\n"
             "  defaultBranchRef {\n"
             "    name\n"
             "    target {\n"

data_collection_utils/parse_gh_docs_config.yaml

@@ -7,23 +7,35 @@
 #  - data_collection_utils/awesome_final_repos.py -> awesome-repos.parquet
 #  - data_collection_utils/top_1000_repos.py -> top-1000-repos.parquet
 input_parquet:
-  - ./awesome-repos.parquet
   - ./top-1000-repos.parquet
 
 # Output directories/files
 outdir: ../output
 md_failed: ../md-failed.txt
 texts_parquet: ../output/texts.parquet
+# Optional: path to write repository-level metadata parquet
+repometa_parquet: ../output/repometa.parquet
 
 # Concurrency and behavior
-workers: 16
+workers: 1
 dry_run: false
-no_fetch: true
+no_fetch: false
 quiet: false
+# How often to checkpoint partial outputs (in processed repos)
+checkpoint_every: 50
+
+# GraphQL batching and metadata
+# Max repos per GraphQL request; keep modest to avoid cost limits
+graphql_batch_size: 50
+# Number of topics to fetch per repository via GraphQL
+topics_limit: 20
 
 # Auth
-# Path to a file that contains your GitHub token (no quotes, single line)
-token_file: ./gh_token.secret
+# Secrets are NOT configured here. Put your GitHub token in a .env file (recommended)
+# or export it in your shell environment. Required env var:
+#   GITHUB_TOKEN
+# Example .env:
+#   GITHUB_TOKEN=ghp_your_token_here
 
 # Strategies
 # Use git sparse-checkout to try to download only documentation folders first.
@@ -34,10 +46,12 @@ prefer_zip: false
 # Content selection
 # Download only Markdown files from any chosen strategy
 only_md: true
+# Minimum number of .md files for a repo to be considered useful (otherwise marked low-md-count)
+min_docs_md_count: 10
 
 # Filtering
 # Skip repos younger than this many years
-min_repo_age_years: 3
+min_repo_age_years: 0
 
 # Language filtering for texts parquet
 lang_filter: en

data_collection_utils/scrape_gh_docs.py

@@ -49,7 +49,6 @@ import yaml
 from datetime import datetime, timezone
 import logging
 import langid  # https://github.com/saffsd/langid.py
-from dotenv import load_dotenv
 
 
 from github_api_utils import (
@@ -62,7 +61,6 @@ from github_api_utils import (
     search_repos,
     get_repo_tree_paths,
     get_repo_tree_md_paths,
-    fetch_repos_metadata_graphql,
 )
 from repo_tree import (
     build_tree_from_local_dir,
@@ -235,6 +233,7 @@ def compute_md_failed_for_existing(outdir: Path, md_failed_path: Path):
                 append_line_threadsafe(
                     md_failed_path, f"{owner}/{repo}  # md-count={md_count}\n"
                 )
+            pbar.update(1)
 
 
 # === Main logic for a single repo ===
@@ -692,7 +691,6 @@ def process_repo_entry(
             )
             result["status"] = "docs-not-found"
             return result
-
     if not got_any:
         # API-driven path (only if neither prefer_sparse nor prefer_zip succeeded)
         repo_json = get_repo_info(owner, repo)
@@ -841,124 +839,6 @@ def process_repo_entry(
     return result
 
 
-def _checkpoint_persist(
-    outdir: Path,
-    md_failed_path: Path,
-    results_snapshot: List[Dict[str, Any]],
-    workers_value: int,
-    lang_filter_value: Optional[str],
-    min_text_chars_value: int,
-    texts_parquet_value: Optional[str],
-    repometa_parquet_value: Optional[str],
-):
-    """Persist partial outputs to Parquet files as a checkpoint.
-
-    - texts.parquet: rescanned from current outdir contents
-    - repometa.parquet: built from current results with GraphQL metadata; docs structures are
-      derived from local files when available to avoid heavy API usage during checkpoints.
-    """
-    # 1) Re-scan outdir for .md files and write texts parquet
-    repo_dirs = [
-        d for d in outdir.iterdir() if d.is_dir() and "__" in d.name and not d.name.startswith("tmp_")
-    ]
-    md_rows: List[Dict[str, Any]] = []
-    with concurrent.futures.ThreadPoolExecutor(max_workers=workers_value) as executor:
-        futures = [
-            executor.submit(
-                collect_md_rows_for_repo_dir,
-                d,
-                outdir,
-                lang_filter_value,
-                min_text_chars_value,
-            )
-            for d in repo_dirs
-        ]
-        for fut in concurrent.futures.as_completed(futures):
-            try:
-                rows = fut.result()
-            except Exception:
-                rows = []
-            if rows:
-                md_rows.extend(rows)
-
-    texts_parquet_path = (
-        Path(texts_parquet_value) if texts_parquet_value else (outdir / "texts.parquet")
-    )
-    df_txt = pd.DataFrame(md_rows)
-    texts_parquet_path.parent.mkdir(parents=True, exist_ok=True)
-    df_txt.to_parquet(texts_parquet_path, index=False)
-
-    # 2) Build repometa (metadata via GraphQL; structures from local if possible)
-    repometa_rows: List[Dict[str, Any]] = []
-    # Batch GraphQL metadata
-    pairs: List[tuple[str, str]] = []
-    for r in results_snapshot:
-        o = r.get("owner")
-        n = r.get("repo")
-        if not o or not n:
-            continue
-        pairs.append((o, n))
-    meta_map: Dict[str, Dict[str, Any]] = {}
-    batch_size = 30
-    for i in range(0, len(pairs), batch_size):
-        chunk = pairs[i : i + batch_size]
-        mm = fetch_repos_metadata_graphql(chunk)
-        if mm:
-            meta_map.update(mm)
-
-    for res in results_snapshot:
-        owner = res.get("owner")
-        repo = res.get("repo")
-        if not owner or not repo:
-            continue
-        meta = meta_map.get(f"{owner}/{repo}") or {}
-        latest_commit_date = meta.get("last_commit_date")
-        stars = meta.get("stars")
-        link = f"https://github.com/{owner}/{repo}"
-        language = meta.get("language")
-        topics = meta.get("topics")
-        docs_found_in = res.get("docs_found_in")
-
-        # Attempt to build structures from local files only (avoid remote API during checkpoint)
-        docs_tree_json = None
-        docs_folder_rel = res.get("docs_folder")
-        if docs_folder_rel:
-            docs_dir = outdir / docs_folder_rel
-            if docs_dir.exists() and docs_dir.is_dir():
-                docs_tree = build_tree_from_local_dir(docs_dir, only_md=True)
-                docs_tree_json = json.dumps(docs_tree, ensure_ascii=False)
-
-        full_tree_json = None
-        saved_root = outdir / safe_name(f"{owner}__{repo}")
-        if saved_root.exists():
-            full_tree = build_tree_from_local_dir(saved_root, only_md=False)
-            full_tree_json = json.dumps(full_tree, ensure_ascii=False)
-
-        repometa_rows.append(
-            {
-                "latest_commit_date": latest_commit_date,
-                "name": repo,
-                "parent_org": owner,
-                "stars": stars,
-                "link": link,
-                "language": language,
-                "topics": topics,
-                "docs_found_in": docs_found_in,
-                "docs_repo_structure": docs_tree_json,
-                "repo_structure_all_files": full_tree_json,
-            }
-        )
-
-    repometa_parquet_path = (
-        Path(repometa_parquet_value)
-        if repometa_parquet_value
-        else (outdir / "repometa.parquet")
-    )
-    df_meta = pd.DataFrame(repometa_rows)
-    repometa_parquet_path.parent.mkdir(parents=True, exist_ok=True)
-    df_meta.to_parquet(repometa_parquet_path, index=False)
-
-
 # === CLI ===
 
 
@@ -1009,7 +889,11 @@ 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"))
@@ -1019,8 +903,6 @@ def main():
 
     # Ensure we have a GitHub token before making any requests (unless no-fetch)
     if not no_fetch_value:
-        # Load secrets from .env as per CLI tooling rules
-        load_dotenv()
         ensure_github_token(token_file_value)
 
     outdir = Path(outdir_value)
@@ -1035,9 +917,7 @@ 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()
@@ -1101,30 +981,8 @@ def main():
             max_workers=workers_value
         ) as executor:
             futures = [executor.submit(_run, lr) for lr in lines]
-            processed = 0
             for _ in concurrent.futures.as_completed(futures):
                 pbar.update(1)
-                processed += 1
-                # Periodic checkpoint every 300 processed repos
-                if processed % 300 == 0:
-                    try:
-                        # Snapshot results safely
-                        with results_lock:
-                            results_snapshot = list(results)
-                        # Persist current outputs (texts + repometa)
-                        _checkpoint_persist(
-                            outdir,
-                            md_failed_path,
-                            results_snapshot,
-                            workers_value,
-                            lang_filter_value,
-                            min_text_chars_value,
-                            texts_parquet_value,
-                            repometa_parquet_value,
-                        )
-                        logger.info(f"Checkpoint persisted after {processed} repos")
-                    except Exception as e:
-                        logger.warning(f"Checkpoint failed after {processed} repos: {e}")
 
     # In no-fetch mode, compute md-failed from existing directories after (skipped) fetch
     if no_fetch_value:
@@ -1217,49 +1075,22 @@ def main():
                 }
             )
     else:
-        # Pre-fetch repo metadata via GraphQL in batches to reduce REST calls
-        meta_map: Dict[str, Dict[str, Any]] = {}
-        pairs_unique: List[tuple[str, str]] = []
-        seen_pairs = set()
-        for r in results:
-            o = r.get("owner")
-            n = r.get("repo")
-            if not o or not n:
-                continue
-            key = f"{o}/{n}"
-            if key in seen_pairs:
-                continue
-            seen_pairs.add(key)
-            pairs_unique.append((o, n))
-
-        if pairs_unique:
-            batch_size = 30
-            for i in range(0, len(pairs_unique), batch_size):
-                chunk = pairs_unique[i : i + batch_size]
-                try:
-                    mm = fetch_repos_metadata_graphql(chunk)
-                except Exception as e:
-                    logger.warning(f"GraphQL metadata fetch failed for chunk starting {i}: {e}")
-                    mm = {}
-                if mm:
-                    meta_map.update(mm)
-
         for res in results:
             owner = res.get("owner")
             repo = res.get("repo")
             if not owner or not repo:
                 continue
             try:
-                meta = meta_map.get(f"{owner}/{repo}") or {}
-                default_branch = (
-                    res.get("default_branch")
-                    or meta.get("default_branch")
-                    or "main"
+                repo_json = get_repo_info(owner, repo) or {}
+                default_branch = res.get("default_branch") or repo_json.get(
+                    "default_branch", "main"
                 )
-                latest_commit_date = meta.get("last_commit_date")
-                stars = meta.get("stars")
-                language = meta.get("language")
-                topics = meta.get("topics")
+                # 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")
 
@@ -1348,8 +1179,6 @@ def main():
                         "parent_org": owner,
                         "stars": stars,
                         "link": link,
-                        "language": language,
-                        "topics": topics,
                         "docs_found_in": docs_found_in,
                         "docs_repo_structure": docs_tree_json,
                         "repo_structure_all_files": full_tree_json,

data_collection_utils/top_1000_repos.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from playwright.sync_api import sync_playwright
 from urllib.parse import urlparse
 from typing import List, Optional, Dict, Any
-import argparse
+import yaml
 import pandas as pd
 from github_api_utils import fetch_repos_metadata_graphql
 from dotenv import load_dotenv
@@ -94,26 +94,45 @@ def map_to_original_repos_graphql(urls: List[str]) -> List[str]:
 
 
 def main() -> None:
-    ap = argparse.ArgumentParser(
-        description="Fetch Top 1000 repos and enrich via GitHub API"
-    )
-    ap.add_argument(
-        "--workers", type=int, default=16, help="Concurrency for GitHub API requests"
-    )
-    args = ap.parse_args()
-
     # Load token from .env for GraphQL
     load_dotenv()
 
+    # Load YAML config next to this script if present
+    cfg: Dict[str, Any] = {}
+    cfg_path = Path(__file__).with_name("top_1000_repos_config.yaml")
+    if cfg_path.exists():
+        cfg = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
+
+    def _resolve_cfg_path(val: Optional[str]) -> Optional[Path]:
+        if val is None:
+            return None
+        p = Path(val)
+        if not p.is_absolute():
+            p = (cfg_path.parent / p).resolve()
+        return p
+
     project_root = Path(__file__).resolve().parents[1]
-    out_html = Path(__file__).with_name(
+    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 = project_root / "github_links.txt"
-    out_parquet = Path(__file__).with_name("top-1000-repos.parquet")
+    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"
+    )
+
+    headless = bool(cfg.get("headless", True))
+    # Scrolling config
+    scroll_max_iters = int(cfg.get("scroll_max_iters", 200))
+    scroll_pause_ms = int(cfg.get("scroll_pause_ms", 300))
+    stable_threshold = int(cfg.get("stable_threshold", 10))
+    min_anchors = int(cfg.get("min_anchors", 1500))
+    # GraphQL config
+    graphql_batch_size = int(cfg.get("graphql_batch_size", 30))
+    topics_limit = int(cfg.get("topics_limit", 20))
+    fork_resolution = bool(cfg.get("fork_resolution", True))
 
     with sync_playwright() as p:
-        browser = p.chromium.launch(headless=True)
+        browser = p.chromium.launch(headless=headless)
         context = browser.new_context()
         page = context.new_page()
         page.goto(URL, wait_until="networkidle")
@@ -121,7 +140,7 @@ 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 = 200, pause_ms: int = 300) -> 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):
@@ -136,7 +155,7 @@ def main() -> None:
                     stable = 0
                     prev_count = count
                 # Stop after several iterations without growth or when clearly above 1000 anchors
-                if stable >= 10 or prev_count >= 1500:
+                if stable >= stable_threshold or prev_count >= min_anchors:
                     break
 
         _scroll_all()
@@ -153,7 +172,8 @@ 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_graphql(repo_links)
+        if fork_resolution:
+            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:
@@ -166,11 +186,11 @@ def main() -> None:
             if pr is not None:
                 pairs.append(pr)
         meta_map: Dict[str, Dict[str, Any]] = {}
-        batch_size = args.workers
+        batch_size = graphql_batch_size
         for i in range(0, len(pairs), batch_size):
             chunk = pairs[i : i + batch_size]
             try:
-                mm = fetch_repos_metadata_graphql(chunk)
+                mm = fetch_repos_metadata_graphql(chunk, topics_limit=topics_limit)
             except Exception:
                 mm = {}
             if mm:

data_collection_utils/top_1000_repos_config.yaml

@@ -0,0 +1,21 @@
+# Configuration for top_1000_repos.py (YAML-driven)
+# Secrets are not stored here. Put GITHUB_TOKEN in a .env file or export it in the shell.
+
+# Outputs (paths can be absolute or relative to this file)
+out_html: ./Top 1000 GitHub repositories, updated daily, all on one page..html
+out_links: ../github_links.txt
+out_parquet: ./top-1000-repos.parquet
+
+# Browser
+headless: true
+
+# Scrolling behavior to load all repo links
+scroll_max_iters: 200
+scroll_pause_ms: 300
+stable_threshold: 10
+min_anchors: 1500
+
+# GraphQL
+graphql_batch_size: 50
+topics_limit: 20
+fork_resolution: true