Upload folder using huggingface_hub

README.md

@@ -0,0 +1,171 @@
+# Awesome Final Repos Dataset
+
+Collect a curated dataset of “final” GitHub repositories starting from an Awesome list-of-lists. This tool crawls Awesome lists recursively and extracts end repositories whose names do not contain “awesome” (case-insensitive). It optionally enriches entries with GitHub stars and README previews.
+
+- Script: `data_collection_utils/awesome_final_repos.py`
+- Config: `data_collection_utils/awesome_scrap_config.yaml`
+- Output dataset: `awesome-repos.parquet`
+
+## Key Features
+
+- Crawl Awesome lists to a configurable depth and collect “final” repos only at the edge depth (`depth == max_depth`).
+- Extract name, canonical GitHub link, and description from Awesome README bullet entries.
+- Optional enrichment:
+  - GitHub stars (`stargazers_count`)
+  - README preview text (first N characters)
+- Caching of fetched READMEs for faster repeated runs.
+- Progress bars for enrichment phases with `tqdm`.
+
+## How It Works
+
+1. Start from a root Awesome repo (e.g., `sindresorhus/awesome`).
+2. Fetch the README markdown via GitHub API (not HTML).
+3. Parse bullet entries of the form:
+   - `[Name](https://github.com/owner/repo) - Short description`
+   - If there is no “ - ” separator, the remainder of the line becomes the description (with the link removed).
+4. Recurse through linked Awesome lists until `max_depth` is reached.
+5. Only at `depth == max_depth`, collect non-awesome repos as “final” repos.
+6. Optionally enrich with stars and README previews.
+
+## Installation
+
+Use Python 3.11+. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+Core dependencies include: `aiohttp`, `pandas`, `pyarrow`, `tqdm`, `pyyaml`, `python-dotenv`, `numpy`, `requests`, `duckdb`, `langid`, `playwright`, `huggingface_hub`.
+
+## Configuration
+
+Edit `data_collection_utils/awesome_scrap_config.yaml` to control defaults. Important keys:
+
+- `root`: Root Awesome repo URL, e.g. `https://github.com/sindresorhus/awesome`
+- `depth`: Max recursion depth. Only repos discovered at this depth are collected.
+- `workers`: Concurrency for async requests.
+- `output_dir`: Where to write `awesome-repos.parquet`.
+- `cache_dir`: JSON cache for retrieved READMEs.
+- `fetch_stars`: true/false to enrich with `stargazers_count`.
+- `fetch_readme_preview`: true/false to enrich with `readme_preview`.
+- `readme_preview_chars`: Max characters for the preview.
+
+Example:
+
+```yaml
+root: https://github.com/sindresorhus/awesome
+depth: 2
+workers: 20
+
+output_dir: .
+cache_dir: output/awesome_parse_cache
+
+# Enrichments
+fetch_stars: false
+fetch_readme_preview: false
+readme_preview_chars: 1000
+```
+
+All of the above can be overridden via CLI flags.
+
+## Usage
+
+From the repo root:
+
+```bash
+python3 data_collection_utils/awesome_final_repos.py \
+  --root https://github.com/sindresorhus/awesome \
+  --depth 2 \
+  --workers 20
+```
+
+Flags:
+
+- `--root`: Root Awesome repo URL
+- `--depth`: Maximum recursion depth (0 = only root)
+- `--workers`: Concurrency for async fetching (default from config)
+- `--output-dir`: Output directory for `awesome-repos.parquet`
+- `--cache-dir`: Cache directory for README content
+- `--fetch-readme-preview`: Include a `readme_preview` column
+- `--readme-preview-chars`: Number of chars to include in `readme_preview`
+
+Run flow:
+
+- Crawl Awesome lists and log progress as `[depth=X] awesome: owner/repo`.
+- After crawling completes, enrichment steps run with progress bars:
+  - “Description enrichment” for missing descriptions
+  - “README enrichment” for preview extraction (if enabled)
+- Write `awesome-repos.parquet` to the `--output-dir`.
+
+## Authentication and Rate Limits
+
+Set a GitHub token to increase API limits and reduce throttling:
+
+```bash
+export GITHUB_TOKEN=ghp_your_token_here
+```
+
+The script reads `GITHUB_TOKEN` from environment (via `python-dotenv` or directly exported).
+
+## Output Schema
+
+`awesome-repos.parquet` columns (presence depends on config):
+
+- `name`: Repo name extracted from the Awesome bullet link text.
+- `link`: Canonical GitHub repo URL, e.g., `https://github.com/owner/repo`.
+- `description`: Short description (from Awesome bullet or enriched via GitHub repo API if missing).
+- `source_repo`: The Awesome list repo that referenced this entry at the deepest traversal level.
+- `stars` (optional): GitHub `stargazers_count`.
+- `readme_preview` (optional): First N characters of README markdown.
+
+Notes:
+
+- Only “final” repos (non-awesome) discovered at `depth == max_depth` are included.
+- Internal traversal bookkeeping is not written to the final dataset.
+
+## Caching
+
+Fetched README markdown is cached at:
+
+```
+<cache_dir>/readme_cache.json
+```
+
+Caching dramatically speeds up iterative development and re-runs.
+
+## Performance Tips
+
+- Provide a `GITHUB_TOKEN` for higher rate limits.
+- Tune `--workers` based on your network and rate limits (e.g., 20–50).
+- Keep `fetch_readme_preview: false` to reduce requests if you only need core fields.
+- Reuse the cache between runs.
+
+## Example: Publish the Dataset
+
+To publish the dataset to the Hugging Face Hub (dataset repo):
+
+```bash
+# Create or upload to your dataset repo
+hf upload your-username/awesome-repo-descriptions . --repo-type dataset
+```
+
+Example public dataset: `MRiabov/awesome-repo-descriptions`
+
+```
+https://huggingface.co/datasets/MRiabov/awesome-repo-descriptions
+```
+
+## Project Structure
+
+```
+.
+├── data_collection_utils/
+│   ├── awesome_final_repos.py
+│   └── awesome_scrap_config.yaml
+├── awesome-repos.parquet
+└── requirements.txt
+```
+
+## License
+
+This project is provided as-is. Please verify the licenses of any third-party repositories included in the dataset before redistribution or downstream use.

github_api_utils.py

@@ -0,0 +1,302 @@
+#!/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
+    # Fallback: list the repo tree at depth=0 (root only) and select any file starting with README*
+    try:
+        # Get default branch to address the tree head
+        repo_url = f"{GITHUB_API}/repos/{owner}/{repo}"
+        default_branch = "main"
+        async with session.get(repo_url, headers=headers) as rinfo:
+            if rinfo.status == 200:
+                info = await rinfo.json()
+                if isinstance(info, dict) and info.get("default_branch"):
+                    default_branch = info["default_branch"]
+
+        # Depth=0 tree (root only). Omitting recursive parameter implies non-recursive.
+        tree_url = f"{GITHUB_API}/repos/{owner}/{repo}/git/trees/{quote_plus(default_branch)}"
+        async with session.get(tree_url, headers=headers) as rtree:
+            if rtree.status != 200:
+                return None
+            tree = await rtree.json()
+            if not isinstance(tree, dict) or "tree" not in tree:
+                return None
+
+            entries = tree["tree"]
+            # Find candidates that start with README (case-insensitive) and are files (blobs)
+            candidates = []
+            for e in entries:
+                if e.get("type") != "blob":
+                    continue
+                path = e.get("path")
+                if not path:
+                    continue
+                name_lower = path.lower()
+                if name_lower.startswith("readme"):
+                    # Priority: .md < .rst < .org < others; shorter names first
+                    prio_map = {".md": 0, ".rst": 1, ".org": 2}
+                    ext = ""
+                    if "." in path:
+                        ext = path[path.rfind(".") :].lower()
+                    prio = (prio_map.get(ext, 3), len(path))
+                    candidates.append((prio, path))
+
+            if not candidates:
+                return None
+            candidates.sort()
+            chosen_path = candidates[0][1]
+
+            # Fetch the chosen README variant via contents API to get a direct download URL
+            contents_url = f"{GITHUB_API}/repos/{owner}/{repo}/contents/{quote_plus(chosen_path)}"
+            async with session.get(contents_url, headers=headers) as rc:
+                if rc.status != 200:
+                    return None
+                cdata = await rc.json()
+                if isinstance(cdata, dict) and "download_url" in cdata:
+                    download_url = cdata["download_url"]
+                    async with session.get(download_url, headers=headers) as rd:
+                        if rd.status == 200:
+                            return await rd.text()
+    except Exception:
+        return None
+
+    return None
+
+
+async def fetch_repo_description(
+    session: aiohttp.ClientSession, owner: str, repo: str
+) -> Optional[str]:
+    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 "description" in data:
+                    desc = data["description"]
+                    if isinstance(desc, str):
+                        return desc
+    except Exception:
+        return None
+    return None

requirements.txt

@@ -0,0 +1,2 @@
+requests
+dotenv