refactor: reorganize repository filtering into separate clean/ module with metadata and content filters

filter.py → clean/clean_docs_using_content.py

@@ -31,13 +31,13 @@ if __name__ == "__main__":
     ),
     -- Step 2: Rank by mtime within each (owner, repo, filename) group to identify latest versions
     ranked_mtime AS (
-        SELECT *, ROW_NUMBER() OVER (PARTITION BY owner, repo, filename ORDER BY mtime DESC) as rn_mtime
+        SELECT *, ROW_NUMBER() OVER (PARTITION BY owner, repo, file_rel_repo ORDER BY mtime DESC) as rn_mtime
         FROM filtered
     ),
     -- Step 3: Keep only the latest version for duplicates, but preserve all README.md files
     filtered_dup AS (
         SELECT * FROM ranked_mtime
-        WHERE rn_mtime = 1 OR filename LIKE 'README.md'
+        WHERE rn_mtime = 1 OR file_rel_repo LIKE 'README.md'
     ),
     -- Step 4: Rank by content to remove duplicate content, keeping the first occurrence
     ranked AS (
@@ -45,7 +45,7 @@ if __name__ == "__main__":
         FROM filtered_dup
     )
     -- Final selection: unique content after filename deduplication
-    SELECT owner, repo, repo_dir, file_rel_repo, file_rel_outdir, size, mtime, lang, content, filename
+    SELECT owner, repo, repo_dir, file_rel_repo, file_rel_outdir, size, mtime, lang, content
     FROM ranked
     WHERE rn = 1
     """

clean/clean_meta.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+clean_meta.py
+
+Filter repository-level metadata (repometa.parquet) using declarative predicates
+so you can decide which repos to pass to the docs scraper.
+
+Configuration is read from clean_meta.yaml next to this script.
+Outputs a filtered metadata parquet and a links parquet with a single 'link' column.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import sys
+import logging
+
+import pandas as pd
+import yaml
+from tqdm import tqdm
+
+
+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("clean_meta")
+
+
+def setup_logging():
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    logger.handlers.clear()
+    handler = TqdmLoggingHandler()
+    handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+    handler.setLevel(logging.INFO)
+    logger.addHandler(handler)
+
+
+def main():
+    setup_logging()
+
+    cfg_path = Path(__file__).with_name("clean_meta.yaml")
+    assert cfg_path.exists(), f"Missing config: {cfg_path}"
+    cfg: Dict[str, Any] = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
+
+    def _resolve(p: Optional[str]) -> str:
+        if p is None:
+            return ""
+        q = Path(p)
+        if not q.is_absolute():
+            q = (cfg_path.parent / q).resolve()
+        return str(q)
+
+    in_meta = _resolve(cfg.get("repometa_parquet", "../output/repometa.parquet"))
+    out_meta = _resolve(
+        cfg.get("out_repometa_parquet", "../output/repometa.filtered.parquet")
+    )
+    out_links = _resolve(
+        cfg.get("out_links_parquet", "../output/links.filtered.parquet")
+    )
+    out_filtered_reasons_csv = _resolve(
+        cfg.get("out_filtered_reasons_csv", "../output/repometa.filtered_out.csv")
+    )
+
+    include_languages: List[str] = cfg.get("include_languages", [])
+    exclude_languages: List[str] = cfg.get("exclude_languages", [])
+    include_topic_substrings: List[str] = cfg.get("include_topic_substrings", [])
+    exclude_topic_substrings: List[str] = cfg.get("exclude_topic_substrings", [])
+    min_stars: int = int(cfg.get("min_stars", 0))
+    exclude_forks: bool = bool(cfg.get("exclude_forks", True))
+    updated_after: Optional[str] = cfg.get("updated_after")  # ISO date string
+    include_owners: List[str] = cfg.get("include_owners", [])
+    exclude_owners: List[str] = cfg.get("exclude_owners", [])
+
+    df0 = pd.read_parquet(in_meta)
+    total = len(df0)
+    df = df0.copy()
+    # Track filtered-out reasons per repo_name
+    # repo_name := "owner/repo"
+    filtered_reasons: Dict[str, List[str]] = {}
+    reason_counts: Dict[str, int] = {}
+
+    def _note_excluded(mask: pd.Series, reason: str):
+        nonlocal filtered_reasons, reason_counts
+        if mask.any():
+            excluded = df[mask]
+            for _, row in excluded.iterrows():
+                repo_name = f"{row['owner']}/{row['repo']}"
+                lst = filtered_reasons.get(repo_name)
+                if lst is None:
+                    filtered_reasons[repo_name] = [reason]
+                else:
+                    lst.append(reason)
+            reason_counts[reason] = reason_counts.get(reason, 0) + int(mask.sum())
+
+    # Normalize columns we expect from fetch_gh_meta.py
+    assert {"owner", "repo", "link"}.issubset(df.columns)
+
+    if include_languages:
+        mask_keep = df["language"].isin(include_languages)
+        _note_excluded(~mask_keep, "include_languages")
+        df = df[mask_keep]
+    if exclude_languages:
+        mask_excl = df["language"].isin(exclude_languages)
+        _note_excluded(mask_excl, "exclude_languages")
+        df = df[~mask_excl]
+    if min_stars > 0 and "stars" in df.columns:
+        mask_keep = df["stars"] >= min_stars
+        _note_excluded(~mask_keep, "min_stars")
+        df = df[mask_keep]
+    if exclude_forks and "is_fork" in df.columns:
+        mask_excl = df["is_fork"].fillna(False)
+        _note_excluded(mask_excl, "exclude_forks")
+        df = df[~mask_excl]
+    if updated_after and "last_commit_date" in df.columns:
+        mask_keep = df["last_commit_date"] >= updated_after
+        _note_excluded(~mask_keep, "updated_after")
+        df = df[mask_keep]
+    if include_owners:
+        mask_keep = df["owner"].isin(include_owners)
+        _note_excluded(~mask_keep, "include_owners")
+        df = df[mask_keep]
+    if exclude_owners:
+        mask_excl = df["owner"].isin(exclude_owners)
+        _note_excluded(mask_excl, "exclude_owners")
+        df = df[~mask_excl]
+
+    # Topic filters. Topics are stored as comma-joined string in fetch_gh_meta.
+    if include_topic_substrings:
+        mask_any = False
+        for sub in include_topic_substrings:
+            mask_any = mask_any | df["topics"].fillna("").str.contains(sub, case=False)
+        _note_excluded(~mask_any, "include_topic_substrings")
+        df = df[mask_any]
+    if exclude_topic_substrings:
+        mask_excl = False
+        for sub in exclude_topic_substrings:
+            mask_excl = mask_excl | df["topics"].fillna("").str.contains(
+                sub, case=False
+            )
+        _note_excluded(mask_excl, "exclude_topic_substrings")
+        df = df[~mask_excl]
+
+    # Summary logging
+    kept = len(df)
+    filtered_total = total - kept
+    logger.info(f"Kept {kept} from total {total} (filtered out {filtered_total})")
+    if reason_counts:
+        for reason, cnt in reason_counts.items():
+            logger.info(f"  - {reason}: {cnt}")
+
+    # Write filtered-out reasons CSV
+    if filtered_reasons:
+        rows = [
+            {"repo_name": rn, "reasons": ",".join(sorted(set(rs)))}
+            for rn, rs in filtered_reasons.items()
+        ]
+        pd.DataFrame(rows, columns=["repo_name", "reasons"]).to_csv(
+            out_filtered_reasons_csv, index=False
+        )
+
+    out_meta_path = Path(out_meta)
+    out_meta_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_parquet(out_meta_path)
+
+    # Export links parquet for the scraper
+    out_links_path = Path(out_links)
+    out_links_path.parent.mkdir(parents=True, exist_ok=True)
+    df[["link"]].drop_duplicates().to_parquet(out_links_path)
+
+    logger.info(
+        f"Filtered metadata saved to {out_meta_path} (rows={len(df)}); links written to {out_links_path}"
+    )
+
+
+if __name__ == "__main__":
+    main()

clean/clean_meta.yaml

@@ -0,0 +1,28 @@
+# Configuration for clean_meta.py
+
+# Input metadata parquet produced by fetch_gh_meta.py
+repometa_parquet: ../output/repometa.parquet
+
+# Outputs
+out_repometa_parquet: ../output/repometa.filtered.parquet
+out_links_parquet: ../output/links.filtered.parquet
+out_filtered_reasons_csv: ../output/repometa.filtered_out.csv
+
+# Predicates
+# Keep only repos whose primaryLanguage is in this list (empty means no include filter)
+include_languages: []
+# Exclude repos whose primaryLanguage is in this list
+exclude_languages: [null] # filter empty here.
+# Minimum number of stars
+min_stars: 300
+# Exclude forks
+exclude_forks: true
+# Keep only repos whose last commit date is on/after this ISO8601 date, e.g., "2022-01-01"
+updated_after: null
+# Restrict to specific owners (orgs/users); empty means no include filter
+include_owners: []
+# Exclude these owners
+exclude_owners: []
+# Topic filters (substring match, case-insensitive) over comma-joined topics field
+include_topic_substrings: []
+exclude_topic_substrings: ["interview","interview-prep","learn"]

data_collection_utils/fetch_gh_meta.py

@@ -0,0 +1,182 @@
+#!/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 github_api_utils import fetch_repos_metadata_graphql
+
+
+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")
+    )
+    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))
+
+    logger.info(f"Total unique repos to fetch: {len(pairs)}")
+
+    # Fetch in batches via GraphQL
+    records: List[Dict[str, Any]] = []
+    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 {}
+            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"),
+                }
+            )
+
+    df_out = pd.DataFrame(records)
+    out_path = Path(out_parquet_value)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    df_out.to_parquet(out_path)
+    logger.info(f"Wrote metadata for {len(df_out)} repos to {out_path}")
+
+
+if __name__ == "__main__":
+    main()

data_collection_utils/fetch_gh_meta_config.yaml

@@ -0,0 +1,14 @@
+# Configuration for fetch_gh_meta.py
+
+# Inputs: one or more Parquet files with a 'link' column pointing to GitHub repos
+input_parquet:
+  - ./top-1000-repos.parquet
+
+# Output metadata parquet
+out_parquet: ../output/repometa.parquet
+
+# GraphQL batching
+batch_size: 20
+
+# Logging
+quiet: false

data_collection_utils/github_api_utils.py

@@ -375,9 +375,7 @@ def fetch_repos_metadata_graphql(
             "  pushedAt\n"
             "  isFork\n"
             "  parent { url nameWithOwner }\n"
-            "  primaryLanguage { name }\n"
-            + topics_fragment +
-            "  defaultBranchRef {\n"
+            "  primaryLanguage { name }\n" + topics_fragment + "  defaultBranchRef {\n"
             "    name\n"
             "    target {\n"
             "      ... on Commit {\n"
@@ -393,7 +391,9 @@ def fetch_repos_metadata_graphql(
         )
         fields.append(header + body)
     # Assemble query
-    var_decls = " ".join([f"$owner{i}: String!, $name{i}: String!" for i in range(len(pairs))])
+    var_decls = " ".join(
+        [f"$owner{i}: String!, $name{i}: String!" for i in range(len(pairs))]
+    )
     query = "query(" + var_decls + ") {\n" + "\n".join(fields) + "\n}"
 
     payload = {"query": query, "variables": vars}

data_collection_utils/parse_gh_docs_config.yaml

@@ -7,14 +7,12 @@
 #  - data_collection_utils/awesome_final_repos.py -> awesome-repos.parquet
 #  - data_collection_utils/top_1000_repos.py -> top-1000-repos.parquet
 input_parquet:
-  - ./top-1000-repos.parquet
+  - ../output/links_filtered.parquet
 
 # Output directories/files
-outdir: ../output
+outdir: ../output/raw_docs
 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: 1
@@ -24,12 +22,6 @@ 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: 20
-# Number of topics to fetch per repository via GraphQL
-topics_limit: 20
-
 # Auth
 # Secrets are NOT configured here. Put your GitHub token in a .env file (recommended)
 # or export it in your shell environment. Required env var:
@@ -49,9 +41,7 @@ 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: 0
+# Filtering (note: age filtering moved to metadata stage)
 
 # Language filtering for texts parquet
 lang_filter: en

data_collection_utils/scrape_gh_docs.py

@@ -14,8 +14,9 @@ Key features:
     3) Zip fallback (optional): `--prefer-zip` to download a codeload zip (no REST usage) and extract only .md.
     4) Org heuristics and search fallback via GitHub API if direct docs folder not found.
  - Content selection: `--only-md` limits downloads/extractions to Markdown files.
- - Filtering: `--min-repo-age-years` skips repos younger than N years (uses repo metadata, requires token).
  - Central config: reads YAML from `parse_gh_docs_config.yaml` to control inputs/outputs and strategies.
+ - Note: Repository metadata fetching and filtering (e.g., by age/language/topics) has been split
+   into a separate pipeline step (see `data_collection_utils/fetch_gh_meta.py` and `clean/clean_meta.py`).
  - Quiet mode: `--quiet` or YAML `quiet: true` switches logging to warnings+ so tqdm progress stays visible.
  - No-fetch mode: `--no-fetch` rebuilds Parquet(s) from existing outdir without any network calls. You can also emit a per-file texts Parquet via `--texts-parquet` or YAML `texts_parquet`.
 
@@ -41,13 +42,11 @@ import concurrent.futures
 import threading
 from typing import Optional
 from typing import Dict, Any, List
-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
 
@@ -55,18 +54,10 @@ import langid  # https://github.com/saffsd/langid.py
 from github_api_utils import (
     download_file,
     get_repo_info,
-    get_latest_commit_date,
     get_contents,
     get_owner_type,
     get_org_repos,
     search_repos,
-    get_repo_tree_paths,
-    get_repo_tree_md_paths,
-)
-from repo_tree import (
-    build_tree_from_local_dir,
-    build_tree_from_paths,
-    filter_paths_by_directories,
 )
 
 # Note: core Github helpers and repo tree builders are defined in the modules above
@@ -538,7 +529,6 @@ def process_repo_entry(
     prefer_zip: bool = False,
     prefer_sparse: bool = False,
     only_md: bool = False,
-    min_repo_age_years: int = 0,
 ):
     owner_repo = owner_repo.strip()
     if not owner_repo or owner_repo.startswith("#"):
@@ -567,67 +557,6 @@ def process_repo_entry(
     got_any = False
     default_branch = None
 
-    # Age filter: ensure repo existed for at least the configured number of years
-    if min_repo_age_years and min_repo_age_years > 0:
-        repo_json_age = get_repo_info(owner, repo)
-        if not repo_json_age:
-            logger.error(f"Cannot fetch repo metadata for age check: {owner}/{repo}")
-            append_line_threadsafe(
-                md_failed_path, f"{owner}/{repo}  # metadata-failed\n", lock
-            )
-            return {
-                "owner": owner,
-                "repo": repo,
-                "default_branch": None,
-                "method": None,
-                "docs_found": False,
-                "docs_folder": None,
-                "md_count": None,
-                "status": "metadata-failed",
-                "note": "failed to fetch repo metadata (age)",
-            }
-        created_at = repo_json_age.get("created_at")
-        if not created_at:
-            logger.warning(
-                f"Missing created_at for {owner}/{repo}; cannot evaluate age. Skipping repo."
-            )
-            append_line_threadsafe(
-                md_failed_path, f"{owner}/{repo}  # created_at-missing\n", lock
-            )
-            return {
-                "owner": owner,
-                "repo": repo,
-                "default_branch": repo_json_age.get("default_branch"),
-                "method": None,
-                "docs_found": False,
-                "docs_folder": None,
-                "md_count": None,
-                "status": "age-unknown",
-                "note": "created_at missing",
-            }
-        # Normalize ISO8601 (Z -> +00:00)
-        created_dt = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
-        now = datetime.now(timezone.utc)
-        age_years = (now - created_dt).days / 365.25
-        if age_years < min_repo_age_years:
-            logger.info(
-                f"Skipping {owner}/{repo}: age {age_years:.2f}y < {min_repo_age_years}y"
-            )
-            append_line_threadsafe(
-                md_failed_path, f"{owner}/{repo}  # too-young\n", lock
-            )
-            return {
-                "owner": owner,
-                "repo": repo,
-                "default_branch": repo_json_age.get("default_branch"),
-                "method": None,
-                "docs_found": False,
-                "docs_folder": None,
-                "md_count": None,
-                "status": "too-young",
-                "note": f"age_years={age_years:.2f}",
-            }
-
     if prefer_sparse:
         # Try to fetch only docs/ folder via git sparse-checkout without REST API
         for branch_guess in ("main", "master"):
@@ -856,22 +785,6 @@ def _init_duckdb(con):
         );
         """
     )
-    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 ===
@@ -909,13 +822,11 @@ def main():
     dry_run_value = bool(cfg.get("dry_run", False))
     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))
     # CLI should override YAML for convenience
     no_fetch_value = bool(args.no_fetch or cfg.get("no_fetch", False))
@@ -995,7 +906,6 @@ def main():
                     prefer_zip=prefer_zip_value,
                     prefer_sparse=prefer_sparse_value,
                     only_md=only_md_value,
-                    min_repo_age_years=min_repo_age_years_value,
                 )
                 if res is not None:
                     with results_lock:
@@ -1074,7 +984,21 @@ def main():
         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]] = []
+    # Rebuild texts table from filesystem by streaming per-repo inserts into DuckDB
+    cols = [
+        "owner",
+        "repo",
+        "repo_dir",
+        "file_rel_repo",
+        "file_rel_outdir",
+        "size",
+        "mtime",
+        "lang",
+        "content",
+    ]
+    total_inserted = 0
+    with duckdb_lock:
+        con.execute("DELETE FROM texts")
     with tqdm(total=len(repo_dirs), desc="Collecting per-file rows (repos)") as pbar:
         with concurrent.futures.ThreadPoolExecutor(
             max_workers=workers_value
@@ -1096,232 +1020,29 @@ def main():
                     logger.error(f"Error while scanning repo dir: {e}")
                     rows = []
                 if rows:
-                    md_rows.extend(rows)
+                    df_chunk = pd.DataFrame(rows, columns=cols)
+                    with duckdb_lock:
+                        con.register("df_txt_chunk", df_chunk)
+                        con.execute("INSERT INTO texts SELECT * FROM df_txt_chunk")
+                        con.unregister("df_txt_chunk")
+                    total_inserted += len(rows)
                 pbar.update(1)
 
-    # Save per-file dataset (texts) into DuckDB and export Parquet
+    # Export texts from DuckDB to Parquet
     texts_parquet_path = (
         Path(texts_parquet_value) if texts_parquet_value else (outdir / "texts.parquet")
     )
     try:
-        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)
         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 persist/export texts: {e}")
-
-    # Build and save repo metadata dataset
-    repometa_rows: List[Dict[str, Any]] = []
-    if no_fetch_value:
-        # Derive metadata purely from local folders (no network calls)
-        for d in repo_dirs:
-            try:
-                owner, repo = d.name.split("__", 1)
-            except ValueError:
-                continue
-            link = f"https://github.com/{owner}/{repo}"
-            # Determine docs folder similar to compute_md_failed_for_existing()
-            if (d / "docs").exists():
-                docs_folder = d / "docs"
-            else:
-                found = None
-                for p in d.rglob("docs"):
-                    if p.is_dir():
-                        found = p
-                        break
-                docs_folder = found if found else d
-
-            docs_tree_json = None
-            if docs_folder.exists() and docs_folder.is_dir():
-                docs_tree = build_tree_from_local_dir(docs_folder, only_md=True)
-                docs_tree_json = json.dumps(docs_tree, ensure_ascii=False)
-
-            full_tree = build_tree_from_local_dir(d, only_md=False)
-            full_tree_json = json.dumps(full_tree, ensure_ascii=False)
-
-            repometa_rows.append(
-                {
-                    "latest_commit_date": None,
-                    "name": repo,
-                    "parent_org": owner,
-                    "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,
-                }
-            )
-    else:
-        for res in results:
-            owner = res.get("owner")
-            repo = res.get("repo")
-            if not owner or not repo:
-                continue
-            try:
-                repo_json = get_repo_info(owner, repo) or {}
-                default_branch = res.get("default_branch") or repo_json.get(
-                    "default_branch", "main"
-                )
-                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")
-
-                # 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
-
-                    if method in ("org_docs_repo_zip", "search_repo_zip"):
-                        dfi = res.get("docs_found_in")
-                        if isinstance(dfi, str) and dfi.startswith("http"):
-                            u = urlparse(dfi)
-                            parts = [p for p in u.path.split("/") if p]
-                            if len(parts) >= 2:
-                                docs_src_owner, docs_src_repo = parts[0], parts[1]
-                                info = (
-                                    get_repo_info(docs_src_owner, docs_src_repo) or {}
-                                )
-                                docs_src_ref = info.get("default_branch", "main")
-                        path_filters = None
-                    elif method in ("docs_folder_in_repo", "docs_file_in_repo"):
-                        path_filters = ["docs"]
-                    elif method in ("sparse_docs", "zip_whole_repo"):
-                        path_filters = ["docs", "doc", "documentation"]
-
-                    md_paths_all = get_repo_tree_md_paths(
-                        docs_src_owner, docs_src_repo, docs_src_ref
-                    )
-                    if path_filters is not None:
-                        md_paths = filter_paths_by_directories(
-                            md_paths_all, path_filters
-                        )
-                    else:
-                        md_paths = md_paths_all
-
-                    if md_paths:
-                        root_name = f"{docs_src_owner}__{docs_src_repo}"
-                        docs_tree = build_tree_from_paths(md_paths, root_name=root_name)
-                        docs_tree_json = json.dumps(docs_tree, ensure_ascii=False)
-                except Exception:
-                    pass
-                if docs_tree_json is 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)
-
-                # Build full tree
-                full_tree_json = None
-                try:
-                    paths = get_repo_tree_paths(owner, repo, default_branch)
-                    if paths:
-                        full_tree = build_tree_from_paths(
-                            paths, root_name=f"{owner}__{repo}"
-                        )
-                        full_tree_json = json.dumps(full_tree, ensure_ascii=False)
-                except Exception:
-                    pass
-                if full_tree_json is 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": 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,
-                    }
-                )
-            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:
-        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)
-        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)})"
+            f"Wrote per-file dataset to {texts_parquet_path} (rows={total_inserted})"
         )
     except Exception as e:
-        logger.error(f"Failed to persist/export repo metadata: {e}")
+        logger.error(f"Failed to export texts to Parquet: {e}")
 
     # Close DB connection
     try:
@@ -1332,7 +1053,6 @@ def main():
     logger.info("Done. Check output directory and md-failed.txt")
 
 
-# ... (rest of the code remains the same)
 class TqdmLoggingHandler(logging.Handler):
     def emit(self, record):
         try:

data_collection_utils/top-1000-repos.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cd4d9bdf975cf71b2a68fa7e4e525911c9a46b77b95f5e6c85f3306527cb239c
-size 22108
+oid sha256:4fa7b4ed3bbeca1048ed6fbe9e2ccb212043c211785fff53564230b4c5cad876
+size 90891

data_collection_utils/top_1000_repos_config.yaml

@@ -9,13 +9,14 @@ out_parquet: ./top-1000-repos.parquet
 # Browser
 headless: true
 
-# Scrolling behavior to load all repo links
-scroll_max_iters: 200
+# Scrolling behavior to load all repo links (more generous)
+scroll_max_iters: 500
 scroll_pause_ms: 300
-stable_threshold: 10
-min_anchors: 1500
+stable_threshold: 25
+min_anchors: 4000
 
 # GraphQL
 graphql_batch_size: 50
 topics_limit: 20
+# Keep forks as separate entries to avoid collapsing many entries to parents
 fork_resolution: true

texts.parquet → filtered_texts.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3a065276d3cd17cbecdf20a62d6e7610ecf7d9be6415b5e3648a2f1ac63fb080
-size 381801625
+oid sha256:b506a8cc9cd928f237b367cf8c975c3280f512a7d85925fdf97ce9feed1d5c7c
+size 50065296

gooddocs.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3cf9e395f5191efec809e9be1c3a647a0bc7a12030dd003b839280c4fbbae5e2
-size 250675101
+oid sha256:016c90924a61528cc8eae7f75ebea250bc9bdc63be22655be6f9a31e7411d5c3
+size 91294381