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:

   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 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):

   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.

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:

# 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):

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.