Update README

README.md

@@ -11,4 +11,115 @@ size_categories:
 - 100K<n<1M
 ---
 
+# GoodDocs-v0: High-quality code documentation texts
+
+GoodDocs-v0 is a text dataset scraped from high-quality documentation sources in the open-source ecosystem, in particular the top GitHub repositories by stars. It is designed to serve as a foundation for building reasoning systems grounded in software documentation, enabling tasks such as:
+
+- Code and API understanding
+- Documentation question answering and retrieval
+- 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.
+- `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).
+  - `top_1000_repos.py` — helper to refresh the top‑repositories list via the public site referenced in the code.
+
+
+## Schema
+
+Two main Parquet artifacts are produced by the pipeline.
+
+1) results.parquet — one row per repository (see `process_repo_entry()` in `data_collection_utils/scrape_gh_docs.py`):
+   - `owner` — repository owner
+   - `repo` — repository name
+   - `default_branch` — branch used when scraping
+   - `method` — strategy used (e.g., `docs_folder_in_repo`, `sparse_docs`, `zip_whole_repo`, `no_fetch`)
+   - `docs_found` — boolean
+   - `docs_folder` — relative path (under outdir) used to count docs
+   - `md_count` — number of Markdown files discovered
+   - `status` — `ok`, `low-md-count`, `docs-not-found`, etc.
+   - `note` — optional message
+
+2) 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`, `lang_prob` — language prediction fields (via `langid.py` when language filtering is enabled)
+   - `content` — raw Markdown text
+
+
+## Quickstart
+
+Load the dataset with pandas:
+
+```python
+import pandas as pd
+df = pd.read_parquet("texts.parquet")
+print(len(df), "rows")
+print(df.columns.tolist())
+```
+
+Typical uses:
+
+- Retrieval corpora for doc QA and RAG pipelines
+- 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`.
+
+1) Prerequisites
+   - System tools: `git`
+   - Python 3.11+ packages: `pandas`, `pyarrow`, `requests`, `tqdm`, `PyYAML`, `langid`
+   - For refreshing top repositories (optional): `playwright` (and `playwright install` for a browser)
+   - A GitHub API token in the environment (`GITHUB_TOKEN`) or a file referenced by the config (`token_file`)
+
+2) Inputs
+   - `data_collection_utils/github_links.txt` — list of repositories to process (either `owner/repo` or full URLs)
+   - You can refresh this list with `data_collection_utils/top_1000_repos.py` if desired.
+
+3) Run
+
+```bash
+python3 data_collection_utils/scrape_gh_docs.py --config data_collection_utils/parse_gh_docs_config.yaml
+```
+
+Key configuration knobs (see the YAML file):
+
+- `outdir` — where raw files and interim results are stored
+- `prefer_sparse` — attempt `git sparse-checkout` of documentation folders first
+- `prefer_zip` — fall back to downloading the whole repo zip and extracting Markdown
+- `only_md` — restrict extracted files to Markdown
+- `no_fetch` — do not call the network; rebuild Parquet(s) from existing `outdir`
+- `lang_filter`, `min_lang_prob`, `min_text_chars` — control language gating in `texts.parquet`
+
+Outputs are written to `<outdir>/results.parquet` and, when enabled, `<outdir>/texts.parquet`. In this repository, `texts.parquet` is provided at the root for convenience.
+
+
+## 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`) with a minimum probability threshold.
+
+
+## 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

data_collection_utils/scrape_gh_docs.py

@@ -49,7 +49,7 @@ import subprocess
 import yaml
 from datetime import datetime, timezone
 import logging
-import gcld3
+import langid  # https://github.com/saffsd/langid.py
 
 
 GITHUB_API = "https://api.github.com"
@@ -867,7 +867,7 @@ def main():
         "--min-lang-prob",
         type=float,
         default=0.7,
-        help="Minimum language probability from detector to accept a file (0..1)",
+        help="Minimum language probability from langid to accept a file (0..1)",
     )
     parser.add_argument(
         "--min-text-chars",
@@ -976,13 +976,7 @@ def main():
         # Build from existing directories in outdir
         results: List[Dict[str, Any]] = []
         md_rows: List[Dict[str, Any]] = []
-        # Initialize language detector once if filtering is requested
-        lang_identifier = None
-        if lang_filter_value is not None and str(lang_filter_value).strip() != "":
-            lang_identifier = gcld3.NNetLanguageIdentifier(
-                min_num_bytes=int(min_text_chars_value),
-                max_num_bytes=1000000,
-            )
+        # langid does not require explicit initialization
         repo_dirs = [
             d for d in outdir.iterdir() if d.is_dir() and "__" in d.name and not d.name.startswith("tmp_")
         ]
@@ -1033,24 +1027,17 @@ def main():
                     text = md_file.read_text(encoding="utf-8", errors="replace")
                     lang_code = None
                     lang_prob = None
-                    is_reliable = None
                     include = True
-                    if lang_identifier is not None:
-                        # Apply detection and filter
-                        if len(text) < min_text_chars_value:
+                    # Apply langid-based detection and optional filter
+                    if len(text) >= min_text_chars_value:
+                        lid_code, lid_prob = langid.classify(text)
+                        lang_code = lid_code
+                        lang_prob = float(lid_prob)
+                        if lang_filter_value is not None and str(lang_filter_value).strip() != "":
+                            include = (lang_code == lang_filter_value) and (lang_prob >= min_lang_prob_value)
+                    else:
+                        if lang_filter_value is not None and str(lang_filter_value).strip() != "":
                             include = False
-                        else:
-                            pred = lang_identifier.FindLanguage(text)
-                            if pred is None:
-                                include = False
-                            else:
-                                lang_code = pred.language
-                                lang_prob = float(getattr(pred, "probability", 0.0))
-                                is_reliable = bool(getattr(pred, "is_reliable", False))
-                                include = (
-                                    (lang_code == lang_filter_value)
-                                    and (lang_prob is None or lang_prob >= min_lang_prob_value)
-                                )
                     if include:
                         row = {
                             "owner": owner,
@@ -1060,9 +1047,8 @@ def main():
                             "file_rel_outdir": str(md_file.relative_to(outdir)),
                             "size": md_file.stat().st_size,
                             "mtime": int(md_file.stat().st_mtime),
-                            "lang": lang_code if lang_code is not None else None,
-                            "lang_prob": lang_prob if lang_prob is not None else None,
-                            "lang_reliable": is_reliable if is_reliable is not None else None,
+                            "lang": lang_code,
+                            "lang_prob": lang_prob,
                             "content": text,
                         }
                         md_rows.append(row)