Extract awesome repos to parquet

data_collection_utils/awesome_final_repos.py

@@ -7,14 +7,14 @@ Build a list of "final" GitHub repositories starting from the Awesome list-of-li
 (case-insensitive). We recursively traverse linked Awesome lists to collect end repositories.
 
 We fetch README markdown via the GitHub API (contents) instead of parsing HTML. From the README
-markdown we extract only absolute GitHub links, ignore anchors and non-repo links, canonicalize
-to owner/repo URLs, and exclude any repos whose name contains "awesome".
+markdown we parse bullet entries like:
+  * [Fuse](https://github.com/owner/repo) - Mobile development tools.
+and extract: name (link text), canonical GitHub link, and description (text after " - ").
+If there is no " - ", we capture the entire line (with the markdown link removed) as description.
+We exclude any repos whose name contains "awesome" and recursively traverse those as Awesome lists.
 
-Output: one canonical GitHub URL per line:
-  https://github.com/owner/repo
-
-This file mirrors the output expected by data_collection_utils/parse_gh_docs_config.yaml
-as the input for scrape_gh_docs.py, and writes to data_collection_utils/github_links.txt.
+Output: a Parquet file with columns: name, link, description
+  awesome-repos.parquet
 
 Usage:
   python3 data_collection_utils/awesome_final_repos.py \
@@ -37,6 +37,7 @@ import sys
 import yaml
 from dotenv import load_dotenv
 from github_api_utils import fetch_repo_readme_markdown
+import pandas as pd
 
 load_dotenv()
 
@@ -133,13 +134,61 @@ def extract_github_links_from_markdown(md: str) -> List[str]:
     return sorted(urls)
 
 
-async def crawl_awesome_final_repos(
+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.
+    Returns a list of dicts with keys: name, url, description (raw url before canonicalization).
+    """
+    entries: List[Dict[str, str]] = []
+    lines = md.splitlines()
+    # Regex to find markdown links in a line
+    link_re = re.compile(r"\[([^\]]+)\]\((https?://[^)\s]+)\)")
+    bullet_re = re.compile(r"^\s*[-*+]\s+")
+    for line in lines:
+        # pick the first link on the line that canonicalizes to a GitHub repo
+        chosen = None
+        for m in link_re.finditer(line):
+            url_candidate = m.group(2).strip()
+            cu = canonical_repo_url(url_candidate)
+            if cu is None:
+                continue
+            o, r = parse_owner_repo(cu)
+            # Skip self-referential links (including anchors to the current README/file)
+            if o == current_owner and r == current_repo:
+                continue
+            chosen = m
+            break
+        if not chosen:
+            continue
+        name = chosen.group(1).strip()
+        url = chosen.group(2).strip()
+        # Determine description
+        right = line[chosen.end() :]
+        desc: str
+        # If right side starts with optional spaces, then dash + space, we take after it
+        m_dash = re.match(r"^\s*-\s+(.*)$", right)
+        if m_dash is not None:
+            desc = m_dash.group(1).strip()
+        else:
+            # Use entire line without the bullet marker and without the [name](url) segment
+            without_link = (line[: chosen.start()] + line[chosen.end() :]).strip()
+            # Strip a leading bullet marker if present
+            if bullet_re.match(without_link):
+                # remove the first bullet marker occurrence
+                without_link = bullet_re.sub("", without_link, count=1).strip()
+            desc = without_link
+        entries.append({"name": name, "url": url, "description": desc})
+    return entries
+
+
+async def crawl_awesome_final_entries(
     session: aiohttp.ClientSession,
     cache: Dict[str, Any],
     cache_file: Path,
     root_repo_url: str,
     max_depth: int,
-) -> List[str]:
+) -> List[Dict[str, str]]:
     root_cu = canonical_repo_url(root_repo_url)
     assert root_cu is not None, f"Not a canonical GitHub repo URL: {root_repo_url}"
     root_owner, root_repo = parse_owner_repo(root_cu)
@@ -150,7 +199,8 @@ async def crawl_awesome_final_repos(
     visited_awesome.add(root_cu)
     queue.append((root_owner, root_repo, 0))
 
-    final_repos: Set[str] = set()
+    # map canonical link -> {name, link, description}
+    results: Dict[str, Dict[str, str]] = {}
 
     while queue:
         owner, repo, depth = queue.popleft()
@@ -159,13 +209,13 @@ async def crawl_awesome_final_repos(
         if md is None:
             print(f"  README not found for {owner}/{repo}", file=sys.stderr)
             continue
-        links = extract_github_links_from_markdown(md)
-        for link in links:
-            cu = canonical_repo_url(link)
+        entries = _extract_entries_from_markdown_lines(md, owner, repo)
+        for e in entries:
+            cu = canonical_repo_url(e["url"])
             if cu is None:
                 continue
             o, r = parse_owner_repo(cu)
-            # Skip self-references (TOC linking back to the same repo)
+            # Skip self-references
             if o == owner and r == repo:
                 continue
             if is_awesome_repo_name(r):
@@ -173,9 +223,14 @@ async def crawl_awesome_final_repos(
                     visited_awesome.add(cu)
                     queue.append((o, r, depth + 1))
             else:
-                final_repos.add(cu)
+                if cu not in results:
+                    results[cu] = {"name": e["name"], "link": cu, "description": e["description"]}
+                else:
+                    # Prefer keeping the first occurrence; if existing description is empty and new is not, update
+                    if not results[cu]["description"] and e["description"]:
+                        results[cu]["description"] = e["description"]
 
-    return sorted(final_repos)
+    return list(results.values())
 
 
 def main() -> None:
@@ -209,7 +264,7 @@ def main() -> None:
     ap.add_argument(
         "--output-dir",
         default=cfg.get("output_dir", "."),
-        help="Output directory for github_links.txt",
+        help="Output directory for awesome-repos.parquet",
     )
     ap.add_argument(
         "--cache-dir",
@@ -229,13 +284,15 @@ def main() -> None:
     # Run async crawl
     async def run():
         async with aiohttp.ClientSession() as session:
-            finals = await crawl_awesome_final_repos(
+            rows = await crawl_awesome_final_entries(
                 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")
-            print(f"Collected {len(finals)} final repositories")
-            print(f"Wrote to {out_links}")
+            out_parquet = output_dir / "awesome-repos.parquet"
+            output_dir.mkdir(parents=True, exist_ok=True)
+            df = pd.DataFrame(rows, columns=["name", "link", "description"])
+            df.to_parquet(out_parquet, index=False)
+            print(f"Collected {len(rows)} final repositories with descriptions")
+            print(f"Wrote to {out_parquet}")
 
     asyncio.run(run())