Index the parts and say so on the card

README.md

@@ -5,6 +5,8 @@ language:
 license: other
 license_name: per-document-restricted
 license_link: https://github.com/tamnd/gao/blob/main/law/posture.go
+size_categories:
+  - 1K<n<10K
 multilinguality:
   - monolingual
 language_creators:
@@ -20,11 +22,20 @@ tags:
   - web
   - corpus
   - metadata-only
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/*/*.parquet
+  - config_name: web
+    data_files:
+      - split: train
+        path: data/web/*.parquet
 ---
 
 # ViTweb
 
-> Vietnamese text under one schema, nothing sealed here yet
+> 3,260 Vietnamese documents, metadata only from one public corpus, 970.5 kB of Parquet, one schema
 
 This dataset is one row per page gao's own crawler fetched and kept: the address, the host, the fetch time, the robots decision that allowed it, and every measurement the page was judged on, with the text withheld because a crawled page carries no grant to pass it on.
 
@@ -32,8 +43,10 @@ This dataset is one row per page gao's own crawler fetched and kept: the address
 
 - [What is it](#what-is-it)
 - [What is in it](#what-is-in-it)
+- [Where the text came from](#where-the-text-came-from)
 - [How it is laid out](#how-it-is-laid-out)
 - [Reading it](#reading-it)
+- [What you can build with it](#what-you-can-build-with-it)
 - [The columns](#the-columns)
 - [What this repo is](#what-this-repo-is)
 - [What ships and what does not](#what-ships-and-what-does-not)
@@ -54,18 +67,42 @@ Every page that was not kept is in `open-index/vitweb-rejects` with the stage an
 
 ## What is in it
 
-Nothing yet. The repo was created ahead of the first ingest, and this section fills in from the parts index once there are parts to index.
+| source | documents | parts | input files | size | pinned at |
+| --- | ---: | ---: | ---: | ---: | --- |
+| `web` | 3,260 | 16 | 3 | 970.5 kB | `web-20260819` |
+| **total** | **3,260** | **16** | | **970.5 kB** | |
+
+Every count here is the row count in a part's own Parquet footer, added up. None of it is what a run reported writing, because a run that died between pushing a part and writing down that it had is exactly the case a count has to be right about.
+
+The per part version of this table is `parts.csv` at the root of the repo, which is one row per file with its source, its snapshot, the input file it came from, its document count and its size. It is a CSV so that it can be read without a Parquet reader, and it is small enough to open in anything.
+
+The repo grows while ingests run, so these numbers are the ones from the last time `gao store index` was run against it rather than a sealed total. The counts in `parts.csv` and the counts here always agree, because they are generated together.
+
+## Where the text came from
+
+Four public corpora, pinned at a revision, read once, and written out under the schema below. Nothing here was crawled by us. Every one of them has its own card, its own paper in most cases, and its own terms, and the links are the place to read them.
+
+### `web`
+
+3,260 documents.
+
+Two more are pinned in the ingest manifest and are not here. CulturaX is gated on the Hub and the terms were never granted to anybody on this project, so not one byte of it has been read and it is dropped rather than pending. It is mC4 and OSCAR, both built out of Common Crawl, so it went over the same pages the sources above went over, though that is worth less than it sounds: identity here is a hash of the extracted text, and two Common Crawl derivatives in this repo share under one percent of the smaller of them, because two extractors rarely agree on every byte of a page. MADLAD-400 ships as gzipped JSONL rather than Parquet, so it costs a rewrite that the Parquet sources do not, and it is queued behind them.
+
+The manifest with every pinned revision, every input file and its byte count is at https://github.com/tamnd/gao/blob/main/harvest/manifest.json.
 
 ## How it is laid out
 
 ```
 README.md
 parts.csv
+data/web/
+  web-20260819-00000-00000.parquet
+  ... and 15 more
 ```
 
 One directory per source, and the file name is the snapshot, the input file of the source the part came out of, and the part. The snapshot is the source and the revision it was pinned at, so re-pinning a source puts its new parts beside the old ones in the same directory under a different name rather than moving the directory. That is deliberate: the directory is the config name somebody writes in a `load_dataset` call, and a name that moves every time a source is re-pinned is a name nobody can write down.
 
-The directories are named plainly rather than Hive style. A Hive path spells the directory `snapshot=gao-v1.0`, and then every reader who globs the repo gets a `snapshot` column in their result set that is in no file, sitting next to a `source` column that is, so the first thing the layout teaches them is a distinction they did not ask for.
+The directories are named plainly rather than Hive style. A Hive path spells the directory `snapshot=web-20260819`, and then every reader who globs the repo gets a `snapshot` column in their result set that is in no file, sitting next to a `source` column that is, so the first thing the layout teaches them is a distinction they did not ask for.
 
 ## Reading it
 
@@ -80,19 +117,46 @@ INSTALL httpfs;
 LOAD httpfs;
 ```
 
+**What is in the repo, without opening a single Parquet file.** `parts.csv` is a CSV of one row per part, so this is a few tens of kilobytes of reading.
+
+```sql
+SELECT source, count(*) AS parts, sum(documents) AS documents,
+       round(sum(bytes) / 1e9, 1) AS gb
+FROM 'hf://datasets/open-index/vitweb/parts.csv'
+GROUP BY source ORDER BY documents DESC;
+```
+
+```
+┌─────────┬───────┬───────────┬────────┐
+│ source  │ parts │ documents │   gb   │
+│ varchar │ int64 │  int128   │ double │
+├─────────┼───────┼───────────┼────────┤
+│ web     │    16 │      3260 │    0.0 │
+└─────────┴───────┴───────────┴────────┘
+```
+
 **Count one source.** A count reads the row counts out of each file's footer rather than the file, so this is a few hundred kilobytes whatever the source weighs.
 
 ```sql
 SELECT count(*) AS documents
-FROM read_parquet('hf://datasets/open-index/vitweb/data/SOURCE/*.parquet');
+FROM read_parquet('hf://datasets/open-index/vitweb/data/web/*.parquet');
 ```
 
-**Group by a column.** Parquet is columnar, so a query over two columns reads two columns. This one touches only the columns it names.
+```
+┌───────────┐
+│ documents │
+│   int64   │
+├───────────┤
+│      3260 │
+└───────────┘
+```
+
+**Group by a column.** Parquet is columnar, so a query over two columns reads two columns. This one touches 3,260 documents across 16 files.
 
 ```sql
 SELECT license_class, count(*) AS documents,
        round(avg(n_syllables)) AS mean_syllables
-FROM read_parquet('hf://datasets/open-index/vitweb/data/SOURCE/*.parquet')
+FROM read_parquet('hf://datasets/open-index/vitweb/data/web/*.parquet')
 GROUP BY license_class ORDER BY documents DESC;
 ```
 
@@ -100,7 +164,7 @@ GROUP BY license_class ORDER BY documents DESC;
 
 ```sql
 SELECT url, lang, n_syllables, substr(text, 1, 60) AS opening
-FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
+FROM read_parquet('hf://datasets/open-index/vitweb/data/web/web-20260819-00001-00004.parquet')
 WHERE lang = 'vie' AND n_syllables BETWEEN 200 AND 400
 LIMIT 5;
 ```
@@ -110,7 +174,7 @@ The `lang` column is ISO 639-3, so the value to filter on is `vie` rather than t
 **Every column and its type.**
 
 ```sql
-DESCRIBE SELECT * FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet');
+DESCRIBE SELECT * FROM read_parquet('hf://datasets/open-index/vitweb/data/web/web-20260819-00001-00004.parquet');
 ```
 
 ### Python
@@ -120,10 +184,91 @@ The configs in this card's front matter are what `datasets` reads, so a source i
 ```python
 from datasets import load_dataset
 
-ds = load_dataset("open-index/vitweb", split="train", streaming=True)
+# One source, streamed rather than downloaded.
+ds = load_dataset("open-index/vitweb", "web", split="train", streaming=True)
 print(next(iter(ds))["url"])
 ```
 
+Streaming is the right default here. The whole repo does not fit on most disks and one source of it does not fit on many, so a run that reads once should read over the network rather than land the corpus first.
+
+When it does need to be on disk, take a source or a single part rather than the repo.
+
+```python
+from huggingface_hub import snapshot_download
+
+# One source on disk, which for the smallest of these is 970.5 kB.
+snapshot_download(
+    "open-index/vitweb",
+    repo_type="dataset",
+    allow_patterns="data/web/*",
+)
+```
+
+```python
+import pyarrow.parquet as pq
+from huggingface_hub import hf_hub_download
+
+# One part, for looking rather than training. Read the columns you want:
+# text is most of the bytes and a row group of it is a couple of hundred MB.
+path = hf_hub_download("open-index/vitweb", "data/web/web-20260819-00001-00004.parquet", repo_type="dataset")
+table = pq.read_table(path, columns=["url", "host", "lang", "n_syllables"])
+print(table.num_rows, table.schema.names)
+```
+
+## What you can build with it
+
+The repo is addresses and measurements, so what it is good for is deciding which pages are worth fetching, and measuring a crawl while it runs. Both are column scans.
+
+### A fetch list somebody else can act on
+
+The rows are pages that were fetched once and passed every gate, so the URLs are a list of Vietnamese prose pages that are known to exist, known to be allowed by robots.txt, and known to be long enough to be worth a request.
+
+```sql
+SELECT url, host, n_syllables, lang_score
+FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
+WHERE n_syllables >= 400 AND lang_score >= 0.9 AND diacritics = 'present'
+ORDER BY n_syllables DESC;
+```
+
+Fetching them yourself is what makes the text yours to use. `fetched_at` says how old our reading of each page is, and `robots_decision` says which rule allowed it at that time rather than now.
+
+### Which Vietnamese sites are worth crawling
+
+A host's yield is the thing every crawler wants and nobody publishes: how many pages of real prose come back per site, and how long they are.
+
+```sql
+SELECT host, count(*) AS pages, round(avg(n_syllables)) AS syllables
+FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
+GROUP BY host ORDER BY pages DESC LIMIT 5;
+```
+
+```
+┌──────────────────┬───────┬───────────┐
+│       host       │ pages │ syllables │
+│     varchar      │ int64 │  double   │
+├──────────────────┼───────┼───────────┤
+│ baoquangninh.vn  │    82 │    1153.0 │
+│ baolamdong.vn    │    21 │    1364.0 │
+│ tuoitre.vn       │     7 │    1147.0 │
+│ vtv.vn           │     6 │     660.0 │
+│ radio.nhandan.vn │     5 │     206.0 │
+└──────────────────┴───────┴───────────┘
+```
+
+Two provincial papers ahead of the national ones, on a seed list that had both. That is the gap this crawl exists to fill, and it shows up in the first four hundred pages.
+
+### Measuring a crawl rather than describing one
+
+Joining this repo to `open-index/vitweb-rejects` on `url` gives the whole outcome of every request, which is what a yield curve is made of.
+
+```sql
+SELECT date_trunc('day', fetched_at) AS day, count(*) AS kept
+FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
+GROUP BY day ORDER BY day;
+```
+
+`url_template` is the URL with its variable parts replaced, which is what the crawl budgets against. Grouping by it rather than by host is how a calendar trap or a faceted catalog shows up as one template with thousands of rows.
+
 ## The columns
 
 42 columns, in file order. Every part in this repo has all of them, and a column a stage has not run yet is null rather than absent, so a query written against one source works against the next.
@@ -207,7 +352,7 @@ Every row carries its own class in the `license_class` column, so a reader who n
 
 **The measurements are gao's own and they are not a quality judgment.** `lang_score` is the share of tokens that are Vietnamese syllables, `heuristics` is the full map the sift produced, and `gao_qual` and `gao_edu` are zero because the classifier behind them is trained against a reference set that does not exist yet. A page is here because it is Vietnamese prose of some length, not because it is good.
 
-**The extractor keeps some of what a template puts around an article.** On the first run a third of the repetition rejections were article pages rather than listings, which is what a related-articles rail at the bottom of a CMS template looks like to an eight syllable gram counter. Those pages are in the rejects repo with their measured rate, so the size of the problem is a query rather than a guess, and it is being worked on in the extractor rather than by moving the threshold.
+**The repetition filter removes party and government prose, and that is a known fault rather than a finding about the writing.** On the first run a third of the repetition rejections were article pages rather than listing pages. Two of them were pulled out and read: the extraction was clean, with no navigation and no related stories in it, and what pushed them over the threshold was the register. An official is named in full every time they are mentioned, so `đồng chí Vũ Quyết Tiến, Phó Bí thư Tỉnh ủy, Chủ tịch Ủy ban MTTQ tỉnh` is three occurrences of the same eight syllable gram in a nine hundred word article, and the body doing the meeting is named in full in every paragraph about it. The threshold those pages fail is Gopher's, scaled from words to syllables, and a Vietnamese title is long in syllables and carries one fact. Every page it removed is in `open-index/vitweb-rejects` with its measured rate, so the threshold can be moved and the corpus recomposed without fetching anything again.
 
 **It is a crawl in progress and the parts are the order it happened in.** Nothing is shuffled and nothing is deduplicated across runs. Consecutive rows are frequently from one host, because a crawl of a host is a run of requests to that host, so the first N rows are a sample of one site rather than of the corpus.
 
@@ -230,6 +375,7 @@ The releases carry the signed manifest, the dedup, and the quality filtering. Th
 
 If you use this, cite the corpora it is made of. They did the collecting. This repo did the reading.
 
+
 For the assembly itself:
 
 ```bibtex