Stars and source for filtering

.gitignore

@@ -2,6 +2,7 @@
 output/
 md-failed.txt
 github_links.txt
+awesome-repos.txt
 
 
 # Byte-compiled / optimized / DLL files

README.md

@@ -20,28 +20,29 @@ GoodDocs-v0 is a text dataset scraped from high-quality documentation sources in
 - Planning and tool-use grounded in docs
 - Long-context reasoning over multi-file documentation
 
-
 ## What's in this repository
 
 - `texts.parquet` — per-file Markdown documents and metadata extracted from documentation trees.
+- `awesome-repos.parquet` — structured links extracted from Awesome lists-of-lists (`name`, `link`, `description`, `source_repo`, optional `stars`).
 - `data_collection_utils/` — utilities to regenerate the dataset:
   - `scrape_gh_docs.py` — main scraper/collector for documentation from GitHub repositories.
   - `parse_gh_docs_config.yaml` — reproducible configuration (inputs, outputs, filters, strategies).
   - `github_links.txt` — the seed list of GitHub repositories (e.g., top repositories by stars).
+  - `awesome_final_repos.py` — extractor for non-"awesome" repositories referenced by Awesome lists.
+  - `awesome_scrap_config.yaml` — configuration for `awesome_final_repos.py` (root, depth, output, cache, workers, optional `fetch_stars`).
   - `top_1000_repos.py` — helper to refresh the top‑repositories list via the public site referenced in the code.
 
-
 ## Schema
 
 texts.parquet — one row per Markdown file (see `md_rows` assembly in `main()`):
-   - `owner`, `repo`, `repo_dir`
-   - `file_rel_repo` — path relative to the saved repo root
-   - `file_rel_outdir` — path relative to `outdir`
-   - `size` — file size in bytes
-   - `mtime` — file modification time (epoch seconds)
-   - `lang` — language prediction field (via `langid.py` when language filtering is enabled)
-   - `content` — raw Markdown text
 
+- `owner`, `repo`, `repo_dir`
+- `file_rel_repo` — path relative to the saved repo root
+- `file_rel_outdir` — path relative to `outdir`
+- `size` — file size in bytes
+- `mtime` — file modification time (epoch seconds)
+- `lang` — language prediction field (via `langid.py` when language filtering is enabled)
+- `content` — raw Markdown text
 
 ## Quickstart
 
@@ -60,7 +61,6 @@ Typical uses:
 - Supervision for instruction tuning grounded in docs
 - Long-context model evaluation with real project documentation
 
-
 ## Reproducing the dataset
 
 The scraper is configurable and designed to be reproducible via `data_collection_utils/parse_gh_docs_config.yaml`.
@@ -94,21 +94,56 @@ Configuration (YAML-driven; see `data_collection_utils/parse_gh_docs_config.yaml
 
 Output is written to `<outdir>/texts.parquet`.
 
+## Awesome list extraction
+
+`data_collection_utils/awesome_final_repos.py` crawls the Awesome list-of-lists and extracts final repositories (those whose repo names do not include "awesome"). For each bullet entry like:
+
+```
+* [Fuse](https://github.com/owner/repo) - Mobile development tools.
+```
+
+It records:
+
+- `name`: the markdown link text (e.g., `Fuse`).
+- `link`: canonical GitHub repository URL (e.g., `https://github.com/owner/repo`).
+- `description`: text after the ` - ` dash, or the rest of the line (with the link and bullet removed) if no dash.
+- `stars` (optional): repository stargazers count when enabled.
+
+Configuration is YAML-first via `data_collection_utils/awesome_scrap_config.yaml`:
+
+- `root`: root Awesome repository URL, e.g., `https://github.com/sindresorhus/awesome`.
+- `depth`: recursion depth for nested Awesome lists (0 = only root).
+- `output_dir`: directory for `awesome-repos.parquet`.
+- `cache_dir`: directory for README fetch caches.
+- `workers`: concurrency for network requests.
+- `fetch_stars`: when `true`, also fetch stargazers for each parsed repo (makes extra API calls) and include a `stars` column.
+
+Run:
+
+```bash
+python3 data_collection_utils/awesome_final_repos.py
+# or adjust via YAML first, then run without flags
+```
+
+Schema of `awesome-repos.parquet`:
+
+- `name` — link text from the Awesome entry.
+- `link` — canonical GitHub URL (<https://github.com/owner/repo>).
+- `description` — description text without the leading ` - ` and without repeating the name.
+- `source_repo` — the Awesome list repository where the entry was found, formatted as `owner/repo`.
+- `stars` — integer, optional; only present when `fetch_stars: true`.
 
 ## Language filtering
 
 Language detection is performed with `langid.py` (see imports in `data_collection_utils/scrape_gh_docs.py`). The default configuration keeps English-only files (`lang_filter: en`). There is no probability/confidence threshold; we gate by the predicted language label and a minimum text length (`min_text_chars`).
 
-
 ## Licensing
 
 - Code and dataset scaffolding in this repository are under the MIT license (see frontmatter).
 - The original documentation content belongs to the respective upstream projects and remains governed by their licenses. Please consult each repository’s license before redistribution or commercial use.
 
-
 ## Acknowledgements
 
 This dataset draws from the open-source community’s documentation efforts. The seed list targets highly-starred repositories to bias toward quality, breadth, and maturity.
 
-  
-Note to self: `size` distribution: 20th percentile - 363 symbols, 50p - 701, 95p - 17392
+Note to self: `size` distribution: 20th percentile - 363 symbols, 50p - 701, 95p - 17392

data_collection_utils/awesome_final_repos.py

@@ -38,6 +38,7 @@ import yaml
 from dotenv import load_dotenv
 from github_api_utils import fetch_repo_readme_markdown
 import pandas as pd
+from github_api_utils import github_headers
 
 load_dotenv()
 
@@ -134,7 +135,9 @@ def extract_github_links_from_markdown(md: str) -> List[str]:
     return sorted(urls)
 
 
-def _extract_entries_from_markdown_lines(md: str, current_owner: str, current_repo: str) -> List[Dict[str, str]]:
+def _extract_entries_from_markdown_lines(
+    md: str, current_owner: str, current_repo: str
+) -> List[Dict[str, str]]:
     """
     Extract entries of the form: bullet + [name](url) optionally followed by " - description".
     If there's no " - ", use the entire line as description but remove the [name](url) part.
@@ -199,7 +202,7 @@ async def crawl_awesome_final_entries(
     visited_awesome.add(root_cu)
     queue.append((root_owner, root_repo, 0))
 
-    # map canonical link -> {name, link, description}
+    # map canonical link -> {name, link, description, source_repo}
     results: Dict[str, Dict[str, str]] = {}
 
     while queue:
@@ -224,7 +227,12 @@ async def crawl_awesome_final_entries(
                     queue.append((o, r, depth + 1))
             else:
                 if cu not in results:
-                    results[cu] = {"name": e["name"], "link": cu, "description": e["description"]}
+                    results[cu] = {
+                        "name": e["name"],
+                        "link": cu,
+                        "description": e["description"],
+                        "source_repo": f"{owner}/{repo}",
+                    }
                 else:
                     # Prefer keeping the first occurrence; if existing description is empty and new is not, update
                     if not results[cu]["description"] and e["description"]:
@@ -233,6 +241,35 @@ async def crawl_awesome_final_entries(
     return list(results.values())
 
 
+async def fetch_repo_stars(
+    session: aiohttp.ClientSession, owner: str, repo: str
+) -> Optional[int]:
+    url = f"https://api.github.com/repos/{owner}/{repo}"
+    try:
+        async with session.get(url, headers=github_headers()) as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                if isinstance(data, dict) and "stargazers_count" in data:
+                    return data["stargazers_count"]
+    except Exception:
+        return None
+    return None
+
+
+async def enrich_with_stars(
+    session: aiohttp.ClientSession, rows: List[Dict[str, str]], concurrency: int
+) -> None:
+    sem = asyncio.Semaphore(concurrency if concurrency and concurrency > 0 else 10)
+
+    async def one(row: Dict[str, str]):
+        async with sem:
+            owner, repo = parse_owner_repo(row["link"])  # link is canonical
+            stars = await fetch_repo_stars(session, owner, repo)
+            row["stars"] = stars if stars is not None else None
+
+    await asyncio.gather(*(one(r) for r in rows))
+
+
 def main() -> None:
     cfg_dir = Path(__file__).resolve().parent
     cfg_path = cfg_dir / "awesome_scrap_config.yaml"
@@ -271,6 +308,8 @@ def main() -> None:
         default=cfg.get("cache_dir", "output/awesome_parse_cache"),
         help="Cache directory for README content",
     )
+    # YAML-configurable flag to fetch stars for each parsed repo
+    fetch_stars_value = bool(cfg.get("fetch_stars", False))
     args = ap.parse_args()
 
     # Resolve paths relative to cfg_dir
@@ -287,9 +326,28 @@ def main() -> None:
             rows = await crawl_awesome_final_entries(
                 session, cache, cache_file, args.root, args.depth
             )
+            if fetch_stars_value and rows:
+                print(
+                    f"Fetching stargazers_count for {len(rows)} repos (concurrency={args.workers})..."
+                )
+                await enrich_with_stars(session, rows, args.workers)
             out_parquet = output_dir / "awesome-repos.parquet"
             output_dir.mkdir(parents=True, exist_ok=True)
-            df = pd.DataFrame(rows, columns=["name", "link", "description"])
+            # include stars column if present
+            df = pd.DataFrame(rows)
+            # Ensure column order when possible
+            cols = [
+                c
+                for c in [
+                    "name",
+                    "link",
+                    "description",
+                    "source_repo",
+                    "stars",
+                ]
+                if c in df.columns
+            ]
+            df = df[cols]
             df.to_parquet(out_parquet, index=False)
             print(f"Collected {len(rows)} final repositories with descriptions")
             print(f"Wrote to {out_parquet}")

data_collection_utils/awesome_scrap_config.yaml

@@ -8,11 +8,15 @@ 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 directory for awesome-repos.parquet (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
+workers: 16
+
+# Optionally fetch stargazers_count for each parsed repo (extra API requests)
+# Set to true to include a 'stars' column in awesome-repos.parquet
+fetch_stars: false