#!/usr/bin/env python3 """ fetch_gh_meta.py Pipeline step to fetch repository metadata from GitHub using GraphQL and save it as Parquet. This script is separate from docs scraping so you can pre-filter repos before downloading docs. Inputs (configured via YAML file next to this script: fetch_gh_meta_config.yaml): - input_parquet: list of parquet files, each with a column 'link' containing GitHub repo URLs - out_parquet: where to write the output metadata parquet (default: ../output/repometa.parquet) - batch_size: number of repositories to fetch per GraphQL request (default: 20) - quiet: reduce logging verbosity Usage: uv run data_collection_utils/fetch_gh_meta.py """ from __future__ import annotations import os import sys from pathlib import Path from urllib.parse import urlparse from typing import List, Dict, Any, Optional, Tuple import pandas as pd import yaml from tqdm import tqdm import logging from datetime import datetime from github_api_utils import fetch_repos_metadata_graphql, find_readme_file class TqdmLoggingHandler(logging.Handler): def emit(self, record): try: msg = self.format(record) tqdm.write(msg) except Exception: sys.stderr.write(str(record.getMessage()) + "\n") logger = logging.getLogger("fetch_gh_meta") def setup_logging(quiet: bool = False): logger.setLevel(logging.DEBUG) logger.propagate = False logger.handlers.clear() handler = TqdmLoggingHandler() handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s")) handler.setLevel(logging.WARNING if quiet else logging.INFO) logger.addHandler(handler) def ensure_github_token() -> str: tok = os.getenv("GITHUB_TOKEN") assert tok is not None and tok.strip() != "", ( "GITHUB_TOKEN is required. Export it in your environment or put it in a .env file." ) return tok def _parse_owner_repo(s: str) -> Optional[Tuple[str, str]]: s = s.strip() if not s: return None if s.startswith("http://") or s.startswith("https://"): p = urlparse(s) if p.netloc != "github.com": return None parts = [part for part in p.path.split("/") if part] if len(parts) < 2: return None owner, repo = parts[0], parts[1] if repo.endswith(".git"): repo = repo[:-4] return owner, repo if "/" in s: owner, repo = s.split("/", 1) return owner, repo return None def main(): # No CLI args; configuration is via YAML next to this script # Load YAML config next to this script if present cfg: Dict[str, Any] = {} cfg_path = Path(__file__).with_name("fetch_gh_meta_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[str]: if val is None: return None p = Path(val) if not p.is_absolute(): p = (cfg_path.parent / p).resolve() return str(p) def _resolve_cfg_paths(val) -> List[str]: 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(val)] input_parquet_values = _resolve_cfg_paths(cfg.get("input_parquet")) out_parquet_value = _resolve_cfg_path( cfg.get("out_parquet", "../output/repometa.parquet") ) resume = bool(cfg.get("resume", True)) batch_size = int(cfg.get("batch_size", 20)) quiet = bool(cfg.get("quiet", False)) setup_logging(quiet=quiet) ensure_github_token() assert input_parquet_values, ( "input_parquet must be configured in fetch_gh_meta_config.yaml" ) pairs: List[Tuple[str, str]] = [] seen: set[str] = set() for pth in input_parquet_values: df = pd.read_parquet(pth) assert "link" in df.columns, f"Parquet {pth} must contain 'link' column" for u in df["link"].tolist(): s = str(u).strip() if not s: continue parsed = _parse_owner_repo(s) if not parsed: continue owner, repo = parsed key = f"{owner}/{repo}" if key in seen: continue seen.add(key) pairs.append((owner, repo)) # Resume: if output exists and resume=true, skip already-present repos existing_map = {} out_path = Path(out_parquet_value) if resume and out_path.exists(): try: existing_df = pd.read_parquet(out_path) if {"owner", "repo"}.issubset(existing_df.columns): existing_map = { f"{o}/{r}": True for o, r in zip(existing_df["owner"], existing_df["repo"]) } except Exception: existing_map = {} if existing_map: pairs = [(o, r) for (o, r) in pairs if f"{o}/{r}" not in existing_map] logger.info( f"Total unique repos to fetch: {len(pairs)} (resume={'on' if resume else 'off'})" ) # Fetch in batches via GraphQL records: List[Dict[str, Any]] = [] run_ts = datetime.utcnow().isoformat() for i in tqdm(range(0, len(pairs), batch_size), desc="GraphQL batches"): batch = pairs[i : i + batch_size] meta = fetch_repos_metadata_graphql(batch) for owner, repo in batch: key = f"{owner}/{repo}" m = meta.get(key) or {} # Detect README file at repo root to store filename ri = find_readme_file(owner, repo, ref=m.get("default_branch")) records.append( { "owner": owner, "repo": repo, "link": f"https://github.com/{owner}/{repo}", "name": m.get("name"), "description": m.get("description"), "stars": m.get("stars"), "default_branch": m.get("default_branch"), "last_commit_date": m.get("last_commit_date"), "language": m.get("language"), # store topics as JSON string for portability in parquet, can be parsed downstream "topics": ( ",".join(m.get("topics", [])) if isinstance(m.get("topics"), list) else None ), "is_fork": m.get("is_fork"), "parent_url": m.get("parent_url"), "updated_at": run_ts, "readme_found": bool(ri), "readme_filename": (ri.get("name") if ri else None), } ) df_out = pd.DataFrame(records) out_path = Path(out_parquet_value) out_path.parent.mkdir(parents=True, exist_ok=True) if resume and out_path.exists(): try: existing_df = pd.read_parquet(out_path) # Ensure updated_at exists on existing_df as well if "updated_at" not in existing_df.columns: existing_df["updated_at"] = None combined = pd.concat([existing_df, df_out], ignore_index=True) # Drop duplicates by owner/repo keeping last (newest fetch) combined = combined.drop_duplicates(subset=["owner", "repo"], keep="last") combined.to_parquet(out_path, index=False) logger.info( f"Appended {len(df_out)} new repos (resume) to {out_path} (total {len(combined)})" ) return except Exception: # If any issue, fall back to overwrite with new pass df_out.to_parquet(out_path, index=False) logger.info(f"Wrote metadata for {len(df_out)} repos to {out_path}") if __name__ == "__main__": main()