AGENTS.md

# AGENTS.md

Guidance for agents and contributors adding a source and cutting a release.
Read this before opening a PR. Source PRs and releases are separate: a source PR
adds one source with `release: None`; the maintainer later cuts one release that
bumps the version and docs for every source merged since the last one.

## How the docs are actually maintained

`src/make_docs.py` is a **scaffolding/assembly helper, not a round-trip source
of truth.** It regenerates the README source table + release totals, `LICENSE`,
a `CHANGELOG` stub, and *template* datasheets — but it does **not** reproduce the
committed docs on its own:

- It iterates `SOURCES` in `src/sources.py`; any source in `data/` but missing
  from `SOURCES` is silently dropped from the table and totals.
- It stamps a regenerated datasheet's "Added" with the source's `added` field,
  falling back to the global `ADDED` constant when the entry has none — so a new
  entry without `added` still gets a wrong date.
- It cannot reproduce hand-written README narrative (audit notes, policy notes,
  the phrase-frequency section).

So datasheets and the README narrative are **hand/contributor-maintained**.
Never run `make_docs.py` and commit the result blind — `git diff` first and
restore anything it dropped or restamped.

## Before you start: check the findings log

`artifacts/source_findings.md` records sources already investigated, including
the rejected ones and *why*. Check it before spending a day on a source someone
already found to be blocked — and append your own finding there whether the
answer was yes or no.

## Add a source

1. Produce the artifact under `data/<key>/`:
   - `<key>.parquet` — built by `src/build_dynaword.py` (LFS-tracked automatically).
   - `<key>.stats.json` — doc/token/char counts (drives all totals).
   - `<key>.md` — datasheet (see below).
2. Add the ingestion script: `src/fetch_<key>.py` or `src/clean_<key>.py`, so the
   source is reproducible. `build_source` (build_dynaword.py) expects a
   `<file_key|speakleash_key>.jsonl.zst` intermediate.
3. Register the source in `src/sources.py` (`SOURCES`) — required, or make_docs
   never sees it. Copy an existing entry's shape: `pretty`, `license`,
   `license_spdx`, `traceable`, `upstream`, `domain`, `created`, `is_ocr`, and the
   `speakleash_key`/`file_key`. If the datasheet is hand-authored (rich provenance
   or a fixed add date), add `"custom_datasheet": True` so make_docs leaves it
   alone.

   Also set `added` (the real add date) and `release`. `release` is what admits a
   source to a release's totals: `None` means "on main, not in any release yet",
   which is the correct value for a new source until the release that ships it is
   cut. Nothing is counted just because it has a `stats.json`.
4. Add a contract test: `src/test_<key>_contract.py` (canonical schema, non-empty
   text, positive token counts, uniform source/license, stats-file consistency).
   Run `python3 -m pytest src/` before committing.

### Keep the PR to your source

Many source PRs are open at once, and each one that touches shared files
conflicts with the others. A source PR changes only:

- `data/<key>/*`, `src/fetch_<key>.py` / `src/clean_<key>.py`,
  `src/test_<key>_contract.py`;
- **one** new entry in `src/sources.py`, with `release: None`;
- your entry appended to `artifacts/source_findings.md`.

It does **not** touch `README.md`, `CHANGELOG.md`, `VERSION`/`RELEASE_DATE` in
`src/make_docs.py`, the phrase-frequency report, `AGENTS.md`, or other sources'
fetchers — those change in the release commit (below) or in their own PR.
`.gitattributes` already LFS-tracks `data/*/*.attribution.jsonl` and
`*.decisions.jsonl`; do not add per-file lines.
Commit with LF line endings — a CRLF `sources.py` shows as a whole-file rewrite
and conflicts with every other PR. Rebase onto `main` before asking for review.

## What the PR must show

These two are not optional — they are the difference between a source a reviewer
can accept and one that sits in the queue. Treat every source PR as a worked
example other contributors will copy.

1. **A sample of the data, inline in the PR description.** A few real documents
   (or truncated ones), verbatim, so a reviewer can see at a glance what kind of
   text this actually is — prose, transcripts, boilerplate, OCR noise, HTML
   leftovers. Include the metadata columns too, not just `text`. Don't make the
   reviewer download a parquet to find out — and a linked `.sample.jsonl` is not
   a substitute: on the Hub it renders as one escaped line per document.

   Generate it from the built shard and paste the output into the PR description:
   ```bash
   python3 src/render_sample.py data/<key>/<key>.parquet -n 3
   ```
   Each document is a fenced block — metadata as `key: value` lines, a blank
   line, then the text with its real line breaks, truncated with `[…]`:
   ````
   ```
   id: sejm_interpellations_2388
   source: sejm_interpellations
   added: 2026-07-19
   token_count: 415
   license: public-domain (official documents)
   author: Daniel Milewski

   Szanowny Panie Ministrze,

   latem 2022 roku na podlaskiej części granicy z Białorusią ukończono […]
   ```
   ````
   Pick rows that show the typical document; if the source has distinct
   document types (question vs reply, article vs talk page), show one of each.

2. **Provenance and licensing, written out in the datasheet (`data/<key>/<key>.md`)
   and summarized in the PR description:**
   - Where the data comes from — the concrete origin (institution, portal, API,
     dump), not just a domain name. Link it.
   - Under what license, and **where that license statement lives** — link the
     exact terms-of-use page, API docs section, or statute. "Public domain
     because it's government data" is a claim, not a source; cite the provision.
   - What the texts are — genre, register, time span, language variety, whether
     they are OCR'd, machine-translated, or user-generated.
   - How it was collected and filtered — dedup, minimum length, language ID,
     anything dropped and why.
   - The argument for inclusion — what this adds that the corpus does not
     already have, and any known bias or quality caveat a downstream user should
     weigh.

Yes, this is meta work on top of the fetching. That is the point: the datasheet
is the artifact other people read to learn how to contribute well.

## Normalize the text before you build

`build_dynaword.py` applies only *minimal gates* — strip, `len < 200`, Polish
diacritic ratio, OCR alpha ratio, exact sha1 dedup. It does **not** clean text.
`src/normalize_schema.py` is a schema/stats tool despite the name; it never
touches `text`. So normalization is the fetcher's job, and today each fetcher
reimplements it (`fetch_govpl.py:43` and `fetch_saos.py:42` carry byte-identical
`html_to_text`; `clean_samorzad_gov_pl.py:65` a third variant). If you are
writing a new fetcher, factor the shared parts out rather than pasting a fourth
copy.

What a fetcher should do to `text` before writing the `.jsonl.zst`:

- **Unicode**: NFKC normalize. Map non-breaking/thin/zero-width spaces to plain
  space (or drop), strip control characters and soft hyphens, normalize the
  quote/dash/ellipsis zoo. Repair mojibake if the upstream encoding is unreliable.
- **Whitespace**: collapse runs of spaces/tabs, trim per line, cap blank runs at
  one empty line. Do not flatten paragraph breaks — they carry structure.
- **Structural junk**: navigation, cookie banners, "share this", pagination,
  footnote back-references, and — for OCR/PDF sources — page headers/footers,
  running titles, and hyphenation split across line breaks.
- **Numbering**: strip standalone chapter/section/page numbers and repeated
  heading numerals (`1.`, `Art. 5.`, `Rozdział III`) *only where they are layout
  artifacts*. In `dziennik_ustaw` or `saos` the article numbering is content —
  removing it destroys the document. Judge per source, and say what you did in
  the datasheet.
- **Boilerplate**: near-identical blocks repeated across most documents of a
  source (license footers, institutional disclaimers, "Pokaż odpowiedź"-style UI
  chrome) should be detected by frequency across the shard and removed, not
  hand-listed.
- **Personal data**: do not keep a scrubber in this repo. Apply
  [`SlayerLab/NERGAL`](https://huggingface.co/SlayerLab/NERGAL) before the
  parquet is written (frozen regex ∪ model; placeholders `[PII]` / `[Telefon]`).
  Names of public officials acting in an official capacity are not PII and
  should stay — removing them would gut parliamentary and judicial sources.
  A source scrubbed some other way may still merge with `release: None`, but it
  is not admitted to a release until its shard has been re-run through NERGAL.
  Say in the datasheet which scrubber ran. Note that `main` is public on the Hub
  whether or not a source is released.

Two rules about all of the above:

1. **The normalization must live in the committed fetch/clean script**, so the
   shard is reproducible. A shard whose datasheet describes a cleaning step that
   no script in `src/` performs is not reproducible, however good the intent.
2. **Report it in the datasheet**: which steps ran, and what the gates dropped.
   Include a handful of before/after excerpts in the PR — this is the fastest way
   for a reviewer to see whether normalization ate real content.

## Cut the release (maintainer, one commit after the source PRs merge)

0. In `src/sources.py`, set `release` on each merged source this release ships
   (check its shard went through NERGAL first).
1. In `src/make_docs.py`: bump `VERSION` and `RELEASE_DATE`. Add a row for the new
   version to the version table and a row for each new contributor to the
   Contributors table (both are literal rows in the template).
2. Regenerate the phrase-frequency report and charts (registry-independent — it
   globs `data/*/*.parquet`):
   ```bash
   python3 src/pattern_frequency_report.py
   ```
   Writes `artifacts/pattern_frequency_hf_snippet.md` + 10 PNGs. Splice the tables
   and chart embeds into the README "Results" section by hand.
3. Update `README.md` by hand: header totals, version table, source table row,
   Contributors row. The document/token totals must equal the sum of the
   per-source `stats.json` files.
4. Prepend the release notes to `CHANGELOG.md` under a new `## vX.Y.Z (date)`
   heading. History is append-only — never rewrite earlier releases.
5. Tag the commit where the docs and the artifacts agree, and push the tag:
   ```bash
   git tag -a vX.Y.Z <commit> -m "vX.Y.Z stable: <docs> documents / <tokens> tokens / <n> sources"
   git push origin vX.Y.Z
   ```
   A release with no tag can only be cited by hash, and every later doc fix
   makes that hash a worse citation than the one before it — which is how
   `v0.2.5` ended up cited three different ways. Tag it once and cite the tag.

## Push to Hugging Face

`origin` is the Hub itself
(`https://huggingface.co/datasets/SlayerLab/polish-dynaword`) — there is no GitHub
remote. `git push` authenticates through the git credential helper (macOS:
`osxkeychain`), which is separate from `hf auth login`: pushes can work fine while
`hf auth whoami` still reports "Not logged in". The Python API and `hf` CLI need
the login (or `HF_TOKEN`).

Hub pull requests use no forks and no named branches. A PR *is* the ref
`refs/pr/N` and the Hub assigns `N`, so you cannot open one by pushing — the ref
has to exist first. (Plain branches can be pushed, but a branch is not a PR and
nobody reviews it.)

Open a PR for work already committed locally:

```bash
# 1. create the empty PR (needs the write token)
python3 -c "
from huggingface_hub import HfApi
pr = HfApi().create_pull_request(
    'SlayerLab/polish-dynaword', repo_type='dataset',
    title='<title>', description='<what changed and why>')
print(pr.num, pr.url)"

# 2. push your local branch onto that ref
git push origin <local-branch>:refs/pr/<N>
```

Opened this way the PR starts in **draft** — publish it from the web UI.

Pick up an existing PR (42 here):

```bash
GIT_LFS_SKIP_SMUDGE=1 git -c fetch.negotiationAlgorithm=noop fetch origin refs/pr/42:pr/42
git checkout pr/42
git push origin pr/42:refs/pr/42
```

The `noop` negotiation is needed: for some refs the Hub fails the have/ack
exchange (`fatal: expected 'acknowledgments'`), and skipping it makes the server
send the full history instead. `GIT_LFS_SKIP_SMUDGE=1` keeps it to pointers;
pull a single blob with `git lfs pull --include <path>`.

`repo_type='dataset'` is required on every `huggingface_hub` call — this is a
dataset repo, not a model. Push straight to `main` only when cutting a release.

## Do not commit

`*.log` (fetch/build logs), `.DS_Store`, `src/__pycache__/`. Only `logs/` is in
`.gitignore` — root-level logs and OS cruft are not, so check `git status`
before staging. `*.parquet` is LFS-tracked; commit the pointer, not the blob.

## Known drift / cleanup opportunities

- `europeana` is in `SOURCES` but has no `data/` shard anywhere, and
  `parlamint_pl` has one only in some working trees — it is not committed.
  make_docs skips both with `! no stats`. Intentional placeholders or stale —
  confirm before relying on `build_dynaword.py --all`.
- `european_hplt_v3_pl` keeps `release: "0.2.3"`, but its data was removed from
  main after v0.2.5 (licence under review). make_docs skips it, so a README
  regenerated from main undercounts every release from v0.2.3 on. Keep the
  hand-written v0.2.5 table until the next release settles it.
- make_docs computes the current release's totals from main's `stats.json`, so
  a source rebuilt after its release (`samorzad_gov_pl` v0.2, #46) shifts the
  regenerated v0.2.5 row away from what was tagged.