gh scraping improved and split to utils.

.gitignore

@@ -1,4 +1,176 @@
 *.secret
 output/
 md-failed.txt
-github_links.txt
+github_links.txt
+
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json

data_collection_utils/awesome_final_repos.py

@@ -29,13 +29,14 @@ from urllib.parse import urlparse
 import asyncio
 import aiohttp
 import json
-import os
+import os  # noqa: F401
 
 import argparse
 import re
 import sys
 import yaml
 from dotenv import load_dotenv
+from github_api_utils import fetch_repo_readme_markdown
 
 load_dotenv()
 
@@ -55,51 +56,17 @@ def save_cache(cache_file: Path, cache: Dict[str, Any]) -> None:
         json.dump(cache, f, ensure_ascii=False, indent=2)
 
 
-async def fetch_readme_async(
-    session: aiohttp.ClientSession, owner: str, repo: str, headers: Dict[str, str]
-) -> Optional[str]:
-    # Try README.md and readme.md
-    for name in ["README.md", "readme.md"]:
-        url = f"https://api.github.com/repos/{owner}/{repo}/contents/{name}"
-        try:
-            async with session.get(url, headers=headers) as resp:
-                if resp.status == 200:
-                    data = await resp.json()
-                    if isinstance(data, dict) and "download_url" in data:
-                        download_url = data["download_url"]
-                        async with session.get(
-                            download_url, headers=headers
-                        ) as download_resp:
-                            if download_resp.status == 200:
-                                return await download_resp.text()
-        except Exception:
-            continue
-    return None
-
-
-def get_aiohttp_headers() -> Dict[str, str]:
-    token = os.getenv("GITHUB_TOKEN")
-    headers = {
-        "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "awesome-final-repos/1.0",
-    }
-    if token:
-        headers["Authorization"] = f"token {token}"
-    return headers
-
-
 async def fetch_readme_with_cache(
     session: aiohttp.ClientSession,
     cache: Dict[str, Any],
     cache_file: Path,
     owner: str,
     repo: str,
-    headers: Dict[str, str],
 ) -> Optional[str]:
     key = f"{owner}/{repo}"
     if key in cache:
         return cache[key]
-    md = await fetch_readme_async(session, owner, repo, headers)
+    md = await fetch_repo_readme_markdown(session, owner, repo)
     if md is not None:
         cache[key] = md
         save_cache(cache_file, cache)
@@ -170,7 +137,6 @@ async def crawl_awesome_final_repos(
     session: aiohttp.ClientSession,
     cache: Dict[str, Any],
     cache_file: Path,
-    headers: Dict[str, str],
     root_repo_url: str,
     max_depth: int,
 ) -> List[str]:
@@ -189,9 +155,7 @@ async def crawl_awesome_final_repos(
     while queue:
         owner, repo, depth = queue.popleft()
         print(f"[depth={depth}] awesome: {owner}/{repo}")
-        md = await fetch_readme_with_cache(
-            session, cache, cache_file, owner, repo, headers
-        )
+        md = await fetch_readme_with_cache(session, cache, cache_file, owner, repo)
         if md is None:
             print(f"  README not found for {owner}/{repo}", file=sys.stderr)
             continue
@@ -262,14 +226,11 @@ def main() -> None:
     # Load cache
     cache = load_cache(cache_file)
 
-    # Get headers
-    headers = get_aiohttp_headers()
-
     # Run async crawl
     async def run():
         async with aiohttp.ClientSession() as session:
             finals = await crawl_awesome_final_repos(
-                session, cache, cache_file, headers, args.root, args.depth
+                session, cache, cache_file, args.root, args.depth
             )
             out_links = output_dir / "github_links.txt"
             out_links.write_text("\n".join(finals) + "\n", encoding="utf-8")

data_collection_utils/awesome_scrap_config.yaml

@@ -0,0 +1,18 @@
+# Awesome Scraper Config
+# Configuration for awesome_final_repos.py
+# All settings can be overridden via CLI args.
+
+# Root Awesome repository (full GitHub URL)
+root: "https://github.com/sindresorhus/awesome"
+
+# Maximum recursion depth for Awesome sublists
+depth: 2
+
+# Output directory for github_links.txt (relative to script dir)
+output_dir: "."
+
+# Cache directory for README content (relative to script dir)
+cache_dir: "output/awesome_parse_cache"
+
+# Number of concurrent workers for fetching
+workers: 16

data_collection_utils/github_api_utils.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+GitHub API utilities for scraping and metadata collection.
+Separated from scrape_gh_docs.py to keep the main script slimmer.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import logging
+import threading
+from urllib.parse import quote_plus
+from typing import Optional, Dict, Any, List
+
+import requests
+import aiohttp
+
+GITHUB_API = "https://api.github.com"
+
+# Use the same logger name as the main script so logs route through its handler
+logger = logging.getLogger("scrape_gh_docs")
+
+_thread_local = threading.local()
+
+
+def github_headers() -> Dict[str, str]:
+    token = os.getenv("GITHUB_TOKEN")
+    h = {"Accept": "application/vnd.github.v3+json", "User-Agent": "docs-scraper/1.0"}
+    if token:
+        h["Authorization"] = f"token {token}"
+    return h
+
+
+def get_session() -> requests.Session:
+    sess = getattr(_thread_local, "session", None)
+    if sess is None:
+        sess = requests.Session()
+        _thread_local.session = sess
+    return sess
+
+
+def request_json(
+    url: str, params: Optional[dict] = None, accept_status=(200,), max_retries: int = 3
+):
+    for attempt in range(max_retries):
+        resp = get_session().get(
+            url, headers=github_headers(), params=params, timeout=30
+        )
+        if resp.status_code in accept_status:
+            # Some endpoints return empty responses on success (e.g. 204). Handle json errors defensively.
+            try:
+                return resp.json()
+            except Exception:
+                return None
+        if resp.status_code == 403:
+            # rate limit or blocked - try to get reset and sleep
+            reset = resp.headers.get("X-RateLimit-Reset")
+            ra = resp.headers.get("Retry-After")
+            if ra:
+                wait = int(ra)
+            elif reset:
+                wait = max(5, int(reset) - int(time.time()))
+            else:
+                wait = 30
+            logger.warning(
+                f"403 from {url}. Sleeping {wait}s (attempt {attempt + 1}/{max_retries})"
+            )
+            time.sleep(wait)
+            continue
+        if 500 <= resp.status_code < 600:
+            backoff = (attempt + 1) * 5
+            logger.warning(f"{resp.status_code} from {url}. Backing off {backoff}s")
+            time.sleep(backoff)
+            continue
+        logger.error(f"Request to {url} returned {resp.status_code}: {resp.text}")
+        return None
+    logger.error(f"Exhausted retries for {url}")
+    return None
+
+
+def download_file(url: str, dest_path):
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    with get_session().get(url, headers=github_headers(), stream=True, timeout=60) as r:
+        r.raise_for_status()
+        with open(dest_path, "wb") as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+
+# === High-level GitHub API helpers ===
+
+
+def get_repo_info(owner: str, repo: str) -> Optional[Dict[str, Any]]:
+    url = f"{GITHUB_API}/repos/{owner}/{repo}"
+    return request_json(url)
+
+
+def get_default_branch(
+    owner: str, repo: str, repo_json: Optional[Dict[str, Any]] = None
+) -> Optional[str]:
+    if repo_json and "default_branch" in repo_json:
+        return repo_json["default_branch"]
+    info = get_repo_info(owner, repo)
+    if not info:
+        return None
+    return info.get("default_branch")
+
+
+def get_latest_commit_date(
+    owner: str,
+    repo: str,
+    ref: Optional[str],
+    repo_json: Optional[Dict[str, Any]] = None,
+) -> Optional[str]:
+    """
+    Return ISO8601 date string of the latest commit on the given ref (branch or SHA).
+    Falls back to repo's pushed_at if commits endpoint returns nothing.
+    """
+    branch = ref or (repo_json.get("default_branch") if repo_json else None) or "main"
+    commits = request_json(
+        f"{GITHUB_API}/repos/{owner}/{repo}/commits",
+        params={"sha": branch, "per_page": 1},
+        accept_status=(200,),
+    )
+    if isinstance(commits, list) and commits:
+        try:
+            return commits[0]["commit"]["author"]["date"]
+        except Exception:
+            pass
+    if repo_json is None:
+        repo_json = get_repo_info(owner, repo) or {}
+    return repo_json.get("pushed_at")
+
+
+def get_contents(owner: str, repo: str, path: str, ref: Optional[str] = None):
+    url = f"{GITHUB_API}/repos/{owner}/{repo}/contents/{quote_plus(path)}"
+    params = {"ref": ref} if ref else None
+    return request_json(url, params=params, accept_status=(200, 404))
+
+
+def get_owner_type(owner: str) -> Optional[str]:
+    info = request_json(f"{GITHUB_API}/users/{owner}", accept_status=(200, 404))
+    if not info:
+        return None
+    return info.get("type")
+
+
+def get_org_repos(owner: str, per_page: int = 100) -> List[Dict[str, Any]]:
+    owner_type = get_owner_type(owner)
+    base = "orgs" if owner_type == "Organization" else "users"
+    repos: List[Dict[str, Any]] = []
+    page = 1
+    while True:
+        url = f"{GITHUB_API}/{base}/{owner}/repos"
+        params = {"per_page": per_page, "page": page}
+        data = request_json(url, params=params)
+        if not data:
+            if page == 1 and base == "orgs":
+                base = "users"
+                continue
+            break
+        repos.extend(data)
+        if len(data) < per_page:
+            break
+        page += 1
+    return repos
+
+
+def search_repos(query: str, per_page: int = 5) -> List[Dict[str, Any]]:
+    url = f"{GITHUB_API}/search/repositories"
+    params = {"q": query, "per_page": per_page}
+    res = request_json(url, params=params, accept_status=(200,))
+    if not res:
+        return []
+    return res.get("items", [])
+
+
+def get_repo_tree_paths(owner: str, repo: str, ref: Optional[str]) -> List[str]:
+    ref = ref or "main"
+    url = f"{GITHUB_API}/repos/{owner}/{repo}/git/trees/{quote_plus(ref)}"
+    params = {"recursive": 1}
+    data = request_json(url, params=params, accept_status=(200,))
+    if not data or "tree" not in data:
+        return []
+    paths: List[str] = []
+    for entry in data["tree"]:
+        if entry.get("type") == "blob" and "path" in entry:
+            paths.append(entry["path"])
+    return paths
+
+
+def get_repo_tree_md_paths(owner: str, repo: str, ref: Optional[str]) -> List[str]:
+    """
+    Return only Markdown file paths from the repository tree on the given ref
+    using the Git Trees API (recursive=1).
+
+    This is a convenience wrapper over get_repo_tree_paths() that filters to
+    .md files, case-insensitive.
+    """
+    all_paths = get_repo_tree_paths(owner, repo, ref)
+    return [p for p in all_paths if p.lower().endswith(".md")]
+
+
+async def fetch_repo_readme_markdown(
+    session: aiohttp.ClientSession, owner: str, repo: str
+) -> Optional[str]:
+    """
+    Fetch README markdown using the contents API, trying README.md and readme.md.
+    Returns the markdown text or None if not found.
+    """
+    headers = github_headers()
+    for name in ("README.md", "readme.md"):
+        url = f"{GITHUB_API}/repos/{owner}/{repo}/contents/{name}"
+        try:
+            async with session.get(url, headers=headers) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    if isinstance(data, dict) and "download_url" in data:
+                        download_url = data["download_url"]
+                        async with session.get(download_url, headers=headers) as d:
+                            if d.status == 200:
+                                return await d.text()
+        except Exception:
+            continue
+    return None

data_collection_utils/repo_tree.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Repository tree utilities: build nested structures from local directories or flat path lists.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Any, List
+
+
+def _tree_node(name: str, node_type: str) -> Dict[str, Any]:
+    assert node_type in ("dir", "file")
+    if node_type == "dir":
+        return {"name": name, "type": node_type, "children": []}
+    return {"name": name, "type": node_type}
+
+
+def _insert_path_into_tree(root: Dict[str, Any], parts: List[str]):
+    node = root
+    for i, part in enumerate(parts):
+        is_last = i == len(parts) - 1
+        if not is_last:
+            # find or create directory child
+            found = None
+            for ch in node["children"]:
+                if ch["type"] == "dir" and ch["name"] == part:
+                    found = ch
+                    break
+            if found is None:
+                found = _tree_node(part, "dir")
+                node["children"].append(found)
+            node = found
+        else:
+            # file leaf
+            node["children"].append(_tree_node(part, "file"))
+
+
+def build_tree_from_local_dir(base: Path, only_md: bool) -> Dict[str, Any]:
+    root = _tree_node(base.name, "dir")
+    for p in base.rglob("*"):
+        if not p.is_file():
+            continue
+        if only_md and not p.name.lower().endswith(".md"):
+            continue
+        rel = p.relative_to(base)
+        parts = list(rel.parts)
+        if parts:
+            _insert_path_into_tree(root, parts)
+    return root
+
+
+def build_tree_from_paths(paths: List[str], root_name: str = "repo") -> Dict[str, Any]:
+    root = _tree_node(root_name, "dir")
+    for path in paths:
+        parts = [p for p in Path(path).parts if p]
+        if parts:
+            _insert_path_into_tree(root, parts)
+    return root
+
+
+def filter_paths_by_directories(paths: List[str], dir_names: List[str]) -> List[str]:
+    """
+    Keep only those paths that are under any of the given directory names.
+    A match occurs when a path starts with "<dir>/" or contains "/<dir>/".
+    """
+    if not dir_names:
+        return paths
+    name_set = set(dir_names)
+    out: List[str] = []
+    for p in paths:
+        for dn in name_set:
+            if p.startswith(f"{dn}/") or f"/{dn}/" in p:
+                out.append(p)
+                break
+    return out

data_collection_utils/scrape_gh_docs.py

@@ -30,19 +30,18 @@ Outputs:
 
 import os
 import sys
-import time
 import zipfile
 import shutil
 import re
 import argparse
-from urllib.parse import quote_plus, urlparse
+from urllib.parse import urlparse
 from pathlib import Path
-import requests
 from tqdm import tqdm
 import concurrent.futures
 import threading
 from typing import Optional
 from typing import Dict, Any, List
+import json
 
 import pandas as pd
 import subprocess
@@ -52,52 +51,29 @@ import logging
 import langid  # https://github.com/saffsd/langid.py
 
 
-GITHUB_API = "https://api.github.com"
+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,
+)
 
-# === Helpers ===
+# Note: core Github helpers and repo tree builders are defined in the modules above
 
-
-def github_headers():
-    token = os.getenv("GITHUB_TOKEN")
-    h = {"Accept": "application/vnd.github.v3+json", "User-Agent": "docs-scraper/1.0"}
-    if token:
-        h["Authorization"] = f"token {token}"
-    return h
+# === Helpers (local only) ===
 
 
-def request_json(url, params=None, accept_status=(200,), max_retries=3):
-    for attempt in range(max_retries):
-        resp = get_session().get(
-            url, headers=github_headers(), params=params, timeout=30
-        )
-        if resp.status_code in accept_status:
-            return resp.json()
-        if resp.status_code == 403:
-            # rate limit or blocked - try to get reset and sleep
-            reset = resp.headers.get("X-RateLimit-Reset")
-            ra = resp.headers.get("Retry-After")
-            if ra:
-                wait = int(ra)
-            elif reset:
-                wait = max(5, int(reset) - int(time.time()))
-            else:
-                wait = 30
-            logger.warning(
-                f"403 from {url}. Sleeping {wait}s (attempt {attempt + 1}/{max_retries})"
-            )
-            time.sleep(wait)
-            continue
-        if 500 <= resp.status_code < 600:
-            # server error - backoff
-            backoff = (attempt + 1) * 5
-            logger.warning(f"{resp.status_code} from {url}. Backing off {backoff}s")
-            time.sleep(backoff)
-            continue
-        # other errors - return None
-        logger.error(f"Request to {url} returned {resp.status_code}: {resp.text}")
-        return None
-    logger.error(f"Exhausted retries for {url}")
-    return None
+# moved: request_json -> github_api_utils.request_json
 
 
 def write_text(path, data):
@@ -105,15 +81,7 @@ def write_text(path, data):
     path.write_text(data, encoding="utf-8")
 
 
-thread_local = threading.local()
-
-
-def get_session() -> requests.Session:
-    sess = getattr(thread_local, "session", None)
-    if sess is None:
-        sess = requests.Session()
-        thread_local.session = sess
-    return sess
+# moved: session management -> github_api_utils.get_session
 
 
 def ensure_github_token(token_file: Optional[str]) -> str:
@@ -156,14 +124,7 @@ def append_line_threadsafe(
             lock.release()
 
 
-def download_file(url, dest_path):
-    dest_path.parent.mkdir(parents=True, exist_ok=True)
-    with get_session().get(url, headers=github_headers(), stream=True, timeout=60) as r:
-        r.raise_for_status()
-        with open(dest_path, "wb") as f:
-            for chunk in r.iter_content(chunk_size=8192):
-                if chunk:
-                    f.write(chunk)
+# moved: download_file -> github_api_utils.download_file
 
 
 def count_md_files(root_dir: Path):
@@ -278,68 +239,22 @@ def compute_md_failed_for_existing(outdir: Path, md_failed_path: Path):
 # === Main logic for a single repo ===
 
 
-def get_repo_info(owner, repo):
-    url = f"{GITHUB_API}/repos/{owner}/{repo}"
-    return request_json(url)
+# moved: get_repo_info -> github_api_utils.get_repo_info
 
 
-def get_default_branch(owner, repo, repo_json=None):
-    if repo_json and "default_branch" in repo_json:
-        return repo_json["default_branch"]
-    info = get_repo_info(owner, repo)
-    if not info:
-        return None
-    return info.get("default_branch")
+# moved: get_default_branch -> github_api_utils.get_default_branch
 
 
-def get_contents(owner, repo, path, ref=None):
-    # GET /repos/{owner}/{repo}/contents/{path}
-    url = f"{GITHUB_API}/repos/{owner}/{repo}/contents/{quote_plus(path)}"
-    params = {"ref": ref} if ref else None
-    return request_json(url, params=params, accept_status=(200, 404))
+# moved: get_contents -> github_api_utils.get_contents
 
 
-def get_owner_type(owner: str) -> Optional[str]:
-    """Return 'Organization' or 'User' (or None if unknown)."""
-    info = request_json(f"{GITHUB_API}/users/{owner}", accept_status=(200, 404))
-    if not info:
-        return None
-    return info.get("type")
+# moved: get_owner_type -> github_api_utils.get_owner_type
 
 
-def get_org_repos(owner, per_page=100):
-    """List repositories for the owner whether it's an organization or a user.
+# moved: get_org_repos -> github_api_utils.get_org_repos
 
-    Tries to detect owner type via /users/{owner}. Falls back appropriately.
-    """
-    owner_type = get_owner_type(owner)
-    base = "orgs" if owner_type == "Organization" else "users"
-    repos = []
-    page = 1
-    while True:
-        url = f"{GITHUB_API}/{base}/{owner}/repos"
-        params = {"per_page": per_page, "page": page}
-        data = request_json(url, params=params)
-        if not data:
-            # If org endpoint 404'd earlier and we misdetected, try the other once
-            if page == 1 and base == "orgs":
-                base = "users"
-                continue
-            break
-        repos.extend(data)
-        if len(data) < per_page:
-            break
-        page += 1
-    return repos
-
-
-def search_repos(query, per_page=5):
-    url = f"{GITHUB_API}/search/repositories"
-    params = {"q": query, "per_page": per_page}
-    res = request_json(url, params=params, accept_status=(200,))
-    if not res:
-        return []
-    return res.get("items", [])
+
+# moved: search_repos -> github_api_utils.search_repos
 
 
 def download_docs_folder(
@@ -450,6 +365,9 @@ def download_repo_zip(owner, repo, ref, outdir, only_md: bool = False):
     return extract_to
 
 
+# === Repo structure helpers moved to data_collection_utils.repo_tree ===
+
+
 def sparse_checkout_docs(
     owner: str,
     repo: str,
@@ -643,6 +561,7 @@ def process_repo_entry(
         "md_count": None,
         "status": "ok",
         "note": None,
+        "docs_found_in": None,
     }
     got_any = False
     default_branch = None
@@ -725,6 +644,9 @@ def process_repo_entry(
                     default_branch = branch_guess
                     result["default_branch"] = branch_guess
                     result["method"] = "sparse_docs"
+                    result["docs_found_in"] = (
+                        f"https://github.com/{owner}/{repo}/tree/{branch_guess}/docs"
+                    )
                     got_any = True
                     break
             except FileNotFoundError:
@@ -753,6 +675,7 @@ def process_repo_entry(
                 default_branch = branch_guess
                 result["default_branch"] = branch_guess
                 result["method"] = "zip_whole_repo"
+                result["docs_found_in"] = f"https://github.com/{owner}/{repo}"
                 got_any = True
                 break
             except Exception as e:
@@ -810,6 +733,9 @@ def process_repo_entry(
                 )
             got_any = True
             result["method"] = "docs_folder_in_repo"
+            result["docs_found_in"] = (
+                f"https://github.com/{owner}/{repo}/tree/{default_branch}/{docs_path}"
+            )
         elif isinstance(contents, dict) and contents.get("type") == "file":
             logger.info(f"Found file at docs (single-file). Downloading...")
             if not dry_run:
@@ -818,6 +744,9 @@ def process_repo_entry(
                 )
             got_any = True
             result["method"] = "docs_file_in_repo"
+            result["docs_found_in"] = (
+                f"https://github.com/{owner}/{repo}/blob/{default_branch}/{docs_path}"
+            )
         else:
             # contents returned but unknown structure: skip to next steps
             pass
@@ -840,6 +769,7 @@ def process_repo_entry(
                 )
             got_any = True
             result["method"] = "org_docs_repo_zip"
+            result["docs_found_in"] = f"https://github.com/{owner}/{cand_name}"
         else:
             # Step 3 fallback: use search API for repos in owner scope with '{repo} docs' in name
             owner_type = get_owner_type(owner)
@@ -861,6 +791,10 @@ def process_repo_entry(
                     )
                 got_any = True
                 result["method"] = "search_repo_zip"
+                result["docs_found_in"] = first.get(
+                    "html_url",
+                    f"https://github.com/{first['owner']['login']}/{first['name']}",
+                )
 
     if not got_any:
         logger.warning(
@@ -915,7 +849,7 @@ def main():
     parser.add_argument(
         "--no-fetch",
         action="store_true",
-        help="Do not perform any network downloads; scan existing outdir to build Parquet and md-failed",
+        help="Do not perform any network downloads; only scan existing outdir to build Parquet and md-failed",
     )
     args = parser.parse_args()
 
@@ -941,6 +875,7 @@ 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"))
     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))
@@ -1078,6 +1013,177 @@ def main():
     except Exception as e:
         logger.error(f"Failed to write per-file Parquet to {texts_parquet_path}: {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,  # unknown without network
+                    "name": repo,
+                    "parent_org": owner,
+                    "stars": None,  # unknown without network
+                    "link": link,
+                    "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 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
+                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
+
+                    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)
+                            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")
+                            # 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(
+                        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:
+                    # Fallback to local docs dir if available
+                    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 repo structure via GitHub Tree API; fallback to local saved root if API fails
+                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,
+                        "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}")
+
+    repometa_parquet_path = (
+        Path(repometa_parquet_value)
+        if repometa_parquet_value
+        else (outdir / "repometa.parquet")
+    )
+    try:
+        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)
+        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.info("Done. Check output directory and md-failed.txt")
 
 

data_collection_utils/top_1000_repos.py

@@ -115,7 +115,9 @@ def main() -> None:
             f.write("\n".join(repo_links) + "\n")
 
         print(f"Wrote HTML to {out_html}")
-        print(f"Found {len(repo_links)} original GitHub repositories and saved to {out_links}")
+        print(
+            f"Found {len(repo_links)} original GitHub repositories and saved to {out_links}"
+        )
 
         context.close()
         browser.close()