2026-10 update

LICENSE.md

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -2,15 +2,47 @@
 license: apache-2.0
 language:
 - nl
+- en
+- de
+pretty_name: Dutch GOV Belastingdienst
 size_categories:
 - 1K<n<10K
+task_categories:
+- text-generation
+- question-answering
+tags:
+- tax
+- dutch
+- government
+configs:
+- config_name: pages
+  default: true
+  data_files: data/pages/*.parquet
+- config_name: raw
+  data_files: data/raw/*.parquet
+- config_name: legacy
+  data_files: data/legacy/belastingdienst.csv
 ---
 
 # Dutch GOV Belastingdienst
 
-This dataset is created by scraping https://www.belastingdienst.nl/, I used the titemap to get all possible allowed URLS.
-It possible some URLS are missing.
-The reason for creating this dataset is I couldn't find any other existing dataset with this data.
-So here is this dataset, Enjoy!
+Public pages of [belastingdienst.nl](https://www.belastingdienst.nl) (the Dutch Tax Administration), from both sitemaps
+listed in its robots.txt. Rebuilt monthly; each run is tagged `YYYY-MM`.
 
-### Please note this dataset is not complety checked or cleaned, this was a personal research project.
+| Config | One row per | Use |
+|---|---|---|
+| `pages` (default) | page, main content as Markdown | training, RAG (pages are short) |
+| `raw` | page, original HTML | lossless source |
+| `legacy` | 2024 scrape (`belastingdienst.csv`), unmaintained | old version |
+
+```python
+from datasets import load_dataset
+
+pages = load_dataset("ethux/belastingdienst-dataset", split="train")
+```
+
+Columns: [documentation/schema.md](documentation/schema.md). Source and method: [documentation/source.md](documentation/source.md).
+Run history: [documentation/changelog.md](documentation/changelog.md).
+
+Built by [ethux/Dutch-GOV-Datasets](https://github.com/ethux/Dutch-GOV-Datasets). Not an official Belastingdienst
+publication; check belastingdienst.nl before relying on a text.

data/pages/pages-00000-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f56983e76f3909fe71db50a6e97b1af8bd10e51dfd2b98d4c08233348047f89
+size 713212

data/pages/pages-00001-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a3702f63245cff1ff498ec1a5fcbf83e55414e7ec580ed833bd12505a4f671c
+size 662938

data/pages/pages-00002-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f19b485f00b5ed21797dd89a86e853df4894d337b0151f5927944c89269d2ac
+size 650858

data/pages/pages-00003-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:634fed5347485c5fc2c1b7110e1f0b5fae726f25514e6b311b50a61c5b094e08
+size 666412

data/raw/raw-00000-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3a3a43f15bb306ecfc76b609f60c140b202c4b8ece63b989d44b1e871992860
+size 1580856

data/raw/raw-00001-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:961a783859f7b4acb676bcb5a7a9ab4c034428e97b11f9a8cc8b5286cededd21
+size 1463074

data/raw/raw-00002-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:491ed720a0e7addc79d06301a25b36f0816630a9a0d00c0c5e2504642dc7b6cb
+size 1454377

data/raw/raw-00003-of-00004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0830c5f404a9ad2bfe04c373c2ddef0b09ddf12179530d44a00b605e7008305c
+size 1466186

documentation/changelog.md

@@ -0,0 +1,7 @@
+# Changelog
+
+One row per monthly run. Rows = row count per config.
+
+| Run date | Complete | Rows | Added | Changed | Removed | Failed | Pending |
+|---|---|---|---|---|---|---|---|
+| 2026-10-01 | yes | raw=8431, pages=8428 | 8431 | 0 | 0 | 0 | 0 |

documentation/schema.md

@@ -0,0 +1,23 @@
+# Schema
+
+## `pages`
+
+| Column | Example | Notes |
+|---|---|---|
+| `url` | `https://www.belastingdienst.nl/wps/wcm/connect/nl/schenken/content/wie-betaalt-de-schenkbelasting` | |
+| `title` | `Wie betaalt de schenkbelasting?` | |
+| `topic` | `schenken` | from the URL path |
+| `language` | `nl` | `nl`, `en` or `de`, from the URL path |
+| `audience` | `particulier` | `particulier`, `zakelijk`, `intermediair` or null |
+| `lastmod` | `2026-03-11T14:30:04+01:00` | from the sitemap |
+| `text` | | main content as Markdown, navigation removed |
+
+Pages without extractable content are left out of `pages` but kept in `raw`.
+
+## `raw`
+
+| Column | Notes |
+|---|---|
+| `url`, `lastmod` | as above |
+| `fetched_at` | UTC timestamp of the download |
+| `html` | original HTML |

documentation/source.md

@@ -0,0 +1,7 @@
+# Source
+
+- Page list: the sitemaps named in `https://www.belastingdienst.nl/robots.txt`
+  (`sitemap-dv.xml`: questions and answers; `sitemap-bieb.xml`: brochures, forms, publications).
+- URLs disallowed by robots.txt are skipped. Requests are limited to 2 per second.
+- Monthly runs only download pages that are new or whose sitemap `lastmod` changed.
+- Text is extracted with [trafilatura](https://trafilatura.readthedocs.io). Linked PDFs are not included.

documentation/stats.json

@@ -0,0 +1,13 @@
+{
+  "run_date": "2026-10-01",
+  "complete": true,
+  "counts": {
+    "raw": 8431,
+    "pages": 8428
+  },
+  "added": 8431,
+  "changed": 0,
+  "removed": 0,
+  "failed": 0,
+  "pending": 0
+}

scripts/README.md

@@ -0,0 +1,3 @@
+# scripts
+
+Copy of the scraper that built this dataset. Source and instructions: https://github.com/ethux/Dutch-GOV-Datasets

scripts/govdata/belastingdienst/extract.py

@@ -0,0 +1,41 @@
+import re
+
+import trafilatura
+
+AUDIENCE = {
+    "prive": "particulier",
+    "individuals": "particulier",
+    "privatpersonen": "particulier",
+    "zakelijk": "zakelijk",
+    "business": "zakelijk",
+    "unternehmen": "zakelijk",
+    "intermediairs": "intermediair",
+    "intermediaries": "intermediair",
+}
+CONTENT = re.compile(r"/wps/wcm/connect/(?:bldcontent(nl|en|de)|(nl|en|de))/(.*)")
+
+
+def classify(url: str) -> tuple[str | None, str | None, str | None]:
+    """(topic, language, audience) from the URL path."""
+    m = CONTENT.search(url)
+    if not m:
+        return None, None, None
+    language = m.group(1) or m.group(2)
+    parts = [p for p in m.group(3).split("/") if p]
+    if m.group(1) and parts and parts[0] in ("belastingdienst", "standaard_functies", "themaoverstijgend"):
+        parts = parts[1:]
+    audience = AUDIENCE.get(parts[0]) if parts else None
+    if audience and m.group(1) and len(parts) > 2:
+        parts = parts[1:]
+    return (parts[0] if parts else None), language, audience
+
+
+def extract_page(html: str, url: str) -> dict | None:
+    text = trafilatura.extract(
+        html, url=url, output_format="markdown", include_tables=True, include_comments=False, favor_precision=True
+    )
+    if not text or not text.strip():
+        return None
+    meta = trafilatura.extract_metadata(html, default_url=url)
+    title = meta.title.strip() if meta and meta.title else None
+    return {"title": title, "text": text.strip()}

scripts/govdata/belastingdienst/index.py

@@ -0,0 +1,55 @@
+"""Page list from the sitemaps named in belastingdienst.nl/robots.txt."""
+
+from dataclasses import dataclass
+
+from lxml import etree
+
+from govdata.common.http import Fetcher
+
+BASE = "https://www.belastingdienst.nl"
+SM = "{http://www.sitemaps.org/schemas/sitemap/0.9}"
+
+
+@dataclass(frozen=True)
+class Page:
+    url: str
+    lastmod: str
+
+
+def sitemap_urls(robots_txt: str) -> list[str]:
+    return [
+        line.split(":", 1)[1].strip()
+        for line in robots_txt.splitlines()
+        if line.lower().startswith("sitemap:")
+    ]
+
+
+def parse_sitemap(xml: bytes) -> tuple[list[tuple[str, str]], list[str]]:
+    """(page url, lastmod) pairs, and nested sitemap urls when this is a sitemap index."""
+    root = etree.fromstring(xml)
+    urls = [
+        (u.findtext(f"{SM}loc").strip(), (u.findtext(f"{SM}lastmod") or "").strip())
+        for u in root.iter(f"{SM}url")
+        if u.findtext(f"{SM}loc")
+    ]
+    subs = [s.findtext(f"{SM}loc").strip() for s in root.iter(f"{SM}sitemap") if s.findtext(f"{SM}loc")]
+    return urls, subs
+
+
+def fetch_index(fetcher: Fetcher, limit: int | None = None) -> dict[str, Page]:
+    todo = sitemap_urls(fetcher.get(f"{BASE}/robots.txt").text)
+    if not todo:
+        raise RuntimeError("no sitemaps listed in robots.txt")
+    seen: set[str] = set()
+    out: dict[str, Page] = {}
+    while todo:
+        sm = todo.pop(0)
+        if sm in seen:
+            continue
+        seen.add(sm)
+        urls, subs = parse_sitemap(fetcher.get(sm).content)
+        todo += subs
+        for url, lastmod in urls:
+            if url not in out and fetcher.allowed(url):
+                out[url] = Page(url, lastmod)
+    return dict(list(out.items())[:limit]) if limit else out

scripts/govdata/belastingdienst/source.py

@@ -0,0 +1,64 @@
+from datetime import datetime, timezone
+
+import pyarrow as pa
+
+from govdata.belastingdienst import extract
+from govdata.belastingdienst.index import Page, fetch_index
+from govdata.common.http import Fetcher
+
+S = pa.string()
+PAGES = pa.schema(
+    [("url", S), ("title", S), ("topic", S), ("language", S), ("audience", S), ("lastmod", S), ("text", S)]
+)
+
+
+class Belastingdienst:
+    name = "belastingdienst"
+    repo_id = "ethux/belastingdienst-dataset"
+    n_shards = 4
+    key_col = "url"
+    mod_col = "lastmod"
+    shard_col = "url"
+    raw_schema = pa.schema([("url", S), ("lastmod", S), ("fetched_at", S), ("html", S)])
+    configs = {"pages": PAGES}
+    rate = 2.0
+    robots_exempt = frozenset()
+    legacy = ("belastingdienst.csv", "data/legacy/belastingdienst.csv")
+
+    def index(self, fetcher: Fetcher, limit: int | None) -> dict[str, Page]:
+        return fetch_index(fetcher, limit)
+
+    def modified(self, rec: Page) -> str:
+        return rec.lastmod
+
+    def fetch(self, fetcher: Fetcher, key: str, rec: Page) -> dict:
+        r = fetcher.get(key)
+        return {
+            "url": key,
+            "lastmod": rec.lastmod,
+            "fetched_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "html": r.text,
+        }
+
+    def build(self, raw: pa.Table, index: dict[str, Page], run_date: str) -> dict[str, list[dict]]:
+        pages = []
+        for row in raw.to_pylist():
+            page = extract.extract_page(row["html"], row["url"])
+            if page is None:
+                continue
+            topic, language, audience = extract.classify(row["url"])
+            pages.append(
+                {
+                    "url": row["url"],
+                    "title": page["title"],
+                    "topic": topic,
+                    "language": language,
+                    "audience": audience,
+                    "lastmod": row["lastmod"],
+                    "text": page["text"],
+                }
+            )
+        return {"pages": pages}
+
+
+SOURCE = Belastingdienst()

scripts/govdata/cli.py

@@ -0,0 +1,27 @@
+import argparse
+import importlib
+import json
+from pathlib import Path
+
+from govdata.common.pipeline import Options, run
+
+DATASETS = ["wetten", "belastingdienst"]
+
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(prog="govdata", description="Rebuild a dataset and publish it to Hugging Face.")
+    p.add_argument("dataset", choices=DATASETS)
+    p.add_argument("--limit", type=int, help="only index/fetch the first N records (for smoke runs)")
+    p.add_argument("--no-upload", action="store_true", help="build locally, skip HF download and upload")
+    p.add_argument("--out", type=Path, default=Path("out"))
+    p.add_argument("--budget-hours", type=float, default=5.0, help="stop fetching after this long")
+    args = p.parse_args(argv)
+
+    src = importlib.import_module(f"govdata.{args.dataset}.source").SOURCE
+    opt = Options(limit=args.limit, upload=not args.no_upload, out=args.out, budget_s=args.budget_hours * 3600)
+    stats = run(src, opt, repo_root=Path(__file__).resolve().parents[2])
+    print(json.dumps(stats, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/govdata/common/guard.py

@@ -0,0 +1,9 @@
+def check_counts(previous: dict[str, int] | None, current: dict[str, int], max_drop: float = 0.10) -> list[str]:
+    """Configs whose row count dropped more than max_drop. Configs absent on either side are skipped."""
+    if not previous:
+        return []
+    return [
+        f"{cfg}: {prev} -> {current[cfg]}"
+        for cfg, prev in previous.items()
+        if cfg in current and prev and current[cfg] < prev * (1 - max_drop)
+    ]

scripts/govdata/common/http.py

@@ -0,0 +1,92 @@
+import threading
+import time
+import urllib.robotparser
+from urllib.parse import urlsplit
+
+import httpx
+
+USER_AGENT = "Dutch-GOV-Datasets (+https://github.com/ethux/Dutch-GOV-Datasets)"
+RETRY_STATUS = {429, 500, 502, 503, 504}
+
+
+class FetchError(Exception):
+    pass
+
+
+class RateLimiter:
+    """Spaces calls at least 1/per_second apart, across threads."""
+
+    def __init__(self, per_second: float):
+        self.interval = 1.0 / per_second
+        self.lock = threading.Lock()
+        self.next_at = 0.0
+
+    def wait(self) -> None:
+        with self.lock:
+            now = time.monotonic()
+            at = max(now, self.next_at)
+            self.next_at = at + self.interval
+        time.sleep(max(0.0, at - now))
+
+
+class Fetcher:
+    def __init__(
+        self,
+        per_second: float,
+        *,
+        max_retries: int = 5,
+        backoff: float = 2.0,
+        robots_exempt: set[str] = frozenset(),
+        transport: httpx.BaseTransport | None = None,
+    ):
+        self.client = httpx.Client(
+            headers={"User-Agent": USER_AGENT, "Accept": "application/xml, text/html;q=0.9, */*;q=0.8"},
+            timeout=120,
+            follow_redirects=True,
+            transport=transport,
+        )
+        self.limiter = RateLimiter(per_second)
+        self.max_retries = max_retries
+        self.backoff = backoff
+        self.robots_exempt = set(robots_exempt)
+        self._robots: dict[str, urllib.robotparser.RobotFileParser] = {}
+        self._robots_lock = threading.Lock()
+
+    def allowed(self, url: str) -> bool:
+        parts = urlsplit(url)
+        if parts.hostname in self.robots_exempt:
+            return True
+        origin = f"{parts.scheme}://{parts.netloc}"
+        with self._robots_lock:
+            rp = self._robots.get(origin)
+            if rp is None:
+                rp = urllib.robotparser.RobotFileParser()
+                try:
+                    r = self.client.get(origin + "/robots.txt")
+                    rp.parse(r.text.splitlines() if r.status_code == 200 else [])
+                except httpx.HTTPError:
+                    rp.parse([])
+                self._robots[origin] = rp
+        return rp.can_fetch(USER_AGENT, url)
+
+    def get(self, url: str) -> httpx.Response:
+        if not self.allowed(url):
+            raise FetchError(f"disallowed by robots.txt: {url}")
+        last = ""
+        for attempt in range(self.max_retries + 1):
+            self.limiter.wait()
+            try:
+                r = self.client.get(url)
+            except httpx.TransportError as e:
+                last = repr(e)
+            except httpx.HTTPError as e:
+                raise FetchError(f"{e!r}: {url}") from e
+            else:
+                if r.status_code == 200:
+                    return r
+                if r.status_code not in RETRY_STATUS:
+                    raise FetchError(f"HTTP {r.status_code}: {url}")
+                last = f"HTTP {r.status_code}"
+            if attempt < self.max_retries:
+                time.sleep(self.backoff**attempt if self.backoff else 0)
+        raise FetchError(f"gave up after {self.max_retries} retries ({last}): {url}")

scripts/govdata/common/pipeline.py

@@ -0,0 +1,176 @@
+"""Index -> diff against previous raw -> fetch changes -> merge + build per shard -> publish."""
+
+import json
+import shutil
+import time
+from collections.abc import Callable, Iterable
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
+from dataclasses import dataclass, field
+from datetime import date
+from pathlib import Path
+from typing import Any, Protocol
+
+import pyarrow as pa
+
+from govdata.common import publish, store
+from govdata.common.guard import check_counts
+from govdata.common.http import Fetcher, FetchError
+
+MAX_FAIL_RATE = 0.02
+
+
+def log(msg: str) -> None:
+    print(msg, flush=True)
+
+
+class Source(Protocol):
+    name: str
+    repo_id: str
+    n_shards: int
+    key_col: str
+    mod_col: str
+    shard_col: str
+    raw_schema: pa.Schema
+    configs: dict[str, pa.Schema]
+    rate: float
+    robots_exempt: frozenset[str]
+    legacy: tuple[str, str] | None
+
+    def index(self, fetcher: Fetcher, limit: int | None) -> dict[str, Any]: ...
+    def modified(self, rec: Any) -> str: ...
+    def fetch(self, fetcher: Fetcher, key: str, rec: Any) -> dict: ...
+    def build(self, raw: pa.Table, index: dict[str, Any], run_date: str) -> dict[str, list[dict]]: ...
+
+
+@dataclass
+class FetchResult:
+    fetched: int = 0
+    failed: list[str] = field(default_factory=list)
+    pending: int = 0
+
+
+def fetch_all(
+    keys: Iterable[str],
+    fetch_one: Callable[[str], dict],
+    sink: Callable[[dict], None],
+    deadline: float | None,
+    workers: int = 8,
+) -> FetchResult:
+    """Fetch in a thread pool; sink runs on the calling thread. Stops submitting once deadline passes."""
+    res = FetchResult()
+    it = iter(keys)
+    pending: dict = {}
+
+    def top_up(pool) -> bool:
+        while len(pending) < workers * 4:
+            if deadline is not None and time.monotonic() >= deadline:
+                return False
+            k = next(it, None)
+            if k is None:
+                return False
+            pending[pool.submit(fetch_one, k)] = k
+        return True
+
+    with ThreadPoolExecutor(workers) as pool:
+        more = top_up(pool)
+        while pending:
+            done, _ = wait(pending, return_when=FIRST_COMPLETED)
+            for f in done:
+                k = pending.pop(f)
+                try:
+                    sink(f.result())
+                    res.fetched += 1
+                except FetchError as e:
+                    res.failed.append(k)
+                    log(f"fetch failed: {e}")
+                done_n = res.fetched + len(res.failed)
+                if done_n % 1000 == 0:
+                    log(f"fetched {done_n}")
+            if more:
+                more = top_up(pool)
+    res.pending = sum(1 for _ in it)
+    return res
+
+
+@dataclass
+class Options:
+    limit: int | None = None
+    upload: bool = True
+    out: Path = Path("out")
+    budget_s: float | None = 5 * 3600
+    run_date: str = field(default_factory=lambda: date.today().isoformat())
+
+
+def run(src: Source, opt: Options, repo_root: Path) -> dict:
+    work = opt.out / src.name
+    if work.exists():
+        shutil.rmtree(work)
+    prev, staged, repo = work / "previous", work / "staging", work / "repo"
+    deadline = time.monotonic() + opt.budget_s if opt.budget_s is not None else None
+
+    if opt.upload:
+        if src.legacy and publish.move_legacy(src.repo_id, *src.legacy):
+            log(f"moved legacy file {src.legacy[0]} -> {src.legacy[1]}")
+        publish.download_previous(
+            src.repo_id, prev, ["data/raw/*", "documentation/stats.json", "documentation/changelog.md"]
+        )
+
+    fetcher = Fetcher(src.rate, robots_exempt=src.robots_exempt)
+    index = src.index(fetcher, opt.limit)
+    previous = store.read_index(prev / "data" / "raw", src.key_col, src.mod_col)
+    d = store.diff({k: src.modified(r) for k, r in index.items()}, previous)
+    log(f"index {len(index)}: {d.added} new, {d.changed} changed, {len(d.removed)} removed, {d.unchanged} unchanged")
+
+    staging = store.Staging(staged, src.raw_schema, src.shard_col, src.n_shards)
+    res = fetch_all(d.fetch, lambda k: src.fetch(fetcher, k, index[k]), staging.add, deadline)
+    staging.flush()
+    attempted = res.fetched + len(res.failed)
+    if attempted and len(res.failed) / attempted > MAX_FAIL_RATE:
+        raise RuntimeError(f"too many fetch failures: {len(res.failed)}/{attempted}")
+    complete = res.pending == 0
+    log(f"fetched {res.fetched}, failed {len(res.failed)}, pending {res.pending}")
+
+    counts = {"raw": 0} | ({c: 0 for c in src.configs} if complete else {})
+    for s in range(src.n_shards):
+        raw = store.merge_shard(
+            store.read_shard(prev / "data" / "raw", "raw", s, src.n_shards),
+            staging.read_shard(s),
+            d.removed,
+            src.key_col,
+            src.raw_schema,
+        )
+        store.write_shard(raw, repo / "data" / "raw", "raw", s, src.n_shards)
+        counts["raw"] += raw.num_rows
+        if complete:
+            for cfg, rows in src.build(raw, index, opt.run_date).items():
+                t = pa.Table.from_pylist(rows, schema=src.configs[cfg])
+                if t.num_rows:
+                    store.write_shard(t, repo / "data" / cfg, cfg, s, src.n_shards)
+                counts[cfg] += t.num_rows
+
+    stats_file = prev / "documentation" / "stats.json"
+    prev_counts = json.loads(stats_file.read_text())["counts"] if stats_file.exists() else None
+    if problems := check_counts(prev_counts, counts):
+        raise RuntimeError(f"row count dropped more than 10%, not uploading: {problems}")
+
+    stats = {
+        "run_date": opt.run_date,
+        "complete": complete,
+        "counts": counts,
+        "added": d.added,
+        "changed": d.changed,
+        "removed": len(d.removed),
+        "failed": len(res.failed),
+        "pending": res.pending,
+    }
+    publish.stage_repo(repo_root, src.name, repo, stats, prev / "documentation" / "changelog.md")
+    if not complete:
+        (repo / "README.md").unlink()  # its configs point at files a backfill hasn't built yet
+
+    if opt.upload:
+        month = opt.run_date[:7]
+        deletes = ["data/raw/*"] + ([f"data/{c}/*" for c in src.configs] if complete else [])
+        message = f"{month} update" if complete else f"{month} backfill progress ({res.pending} pending)"
+        publish.push(src.repo_id, repo, message, month if complete else None, deletes)
+        log(f"published {src.repo_id}: {message}")
+    return stats

scripts/govdata/common/publish.py

@@ -0,0 +1,87 @@
+import json
+import shutil
+from pathlib import Path
+
+from huggingface_hub import CommitOperationCopy, CommitOperationDelete, HfApi, snapshot_download
+
+LEGACY_TAG = "v1-2024"
+CHANGELOG_HEADER = (
+    "# Changelog\n\n"
+    "One row per monthly run. Rows = row count per config.\n\n"
+    "| Run date | Complete | Rows | Added | Changed | Removed | Failed | Pending |\n"
+    "|---|---|---|---|---|---|---|---|\n"
+)
+SCRIPTS_README = (
+    "# scripts\n\n"
+    "Copy of the scraper that built this dataset. Source and instructions: "
+    "https://github.com/ethux/Dutch-GOV-Datasets\n"
+)
+IGNORE = shutil.ignore_patterns("__pycache__", "*.pyc")
+
+
+def download_previous(repo_id: str, dest: Path, patterns: list[str]) -> None:
+    snapshot_download(repo_id=repo_id, repo_type="dataset", local_dir=dest, allow_patterns=patterns)
+
+
+def stage_repo(repo_root: Path, name: str, dest: Path, stats: dict, previous_changelog: Path) -> None:
+    """Lay out everything except data/ as it should appear in the HF repo."""
+    ds = repo_root / "datasets" / name
+    pkg = repo_root / "src" / "govdata"
+    dest.mkdir(parents=True, exist_ok=True)
+    shutil.copy(ds / "README.md", dest / "README.md")
+    shutil.copy(repo_root / "LICENSE", dest / "LICENSE.md")
+    docs = dest / "documentation"
+    shutil.copytree(ds / "documentation", docs, dirs_exist_ok=True)
+
+    scripts = dest / "scripts"
+    for part in ("common", name):
+        shutil.copytree(pkg / part, scripts / "govdata" / part, ignore=IGNORE, dirs_exist_ok=True)
+    for f in ("__init__.py", "cli.py"):
+        shutil.copy(pkg / f, scripts / "govdata" / f)
+    (scripts / "README.md").write_text(SCRIPTS_README)
+
+    (docs / "stats.json").write_text(json.dumps(stats, indent=2) + "\n")
+    log = previous_changelog.read_text() if previous_changelog.exists() else CHANGELOG_HEADER
+    rows = ", ".join(f"{k}={v}" for k, v in stats["counts"].items())
+    log = log.rstrip("\n") + "\n" + (
+        f"| {stats['run_date']} | {'yes' if stats['complete'] else 'no'} | {rows} | {stats['added']} "
+        f"| {stats['changed']} | {stats['removed']} | {stats['failed']} | {stats['pending']} |\n"
+    )
+    (docs / "changelog.md").write_text(log)
+
+
+def push(
+    repo_id: str, folder: Path, message: str, tag: str | None, delete_patterns: list[str], api: HfApi | None = None
+) -> str:
+    api = api or HfApi()
+    info = api.upload_folder(
+        repo_id=repo_id,
+        repo_type="dataset",
+        folder_path=folder,
+        commit_message=message,
+        delete_patterns=delete_patterns,
+    )
+    if tag:
+        refs = api.list_repo_refs(repo_id, repo_type="dataset")
+        if any(t.name == tag for t in refs.tags):
+            api.delete_tag(repo_id, tag=tag, repo_type="dataset")
+        api.create_tag(repo_id, tag=tag, repo_type="dataset", revision=info.oid)
+    return info.oid
+
+
+def move_legacy(repo_id: str, src_path: str, dst_path: str, api: HfApi | None = None) -> bool:
+    """One-time: tag the pre-monorepo state, then move the old CSV into data/legacy/."""
+    api = api or HfApi()
+    if src_path not in api.list_repo_files(repo_id, repo_type="dataset"):
+        return False
+    api.create_tag(repo_id, tag=LEGACY_TAG, repo_type="dataset", exist_ok=True)
+    api.create_commit(
+        repo_id=repo_id,
+        repo_type="dataset",
+        operations=[
+            CommitOperationCopy(src_path_in_repo=src_path, path_in_repo=dst_path),
+            CommitOperationDelete(path_in_repo=src_path),
+        ],
+        commit_message=f"Move {src_path} to {dst_path}",
+    )
+    return True

scripts/govdata/common/store.py

@@ -0,0 +1,107 @@
+import zlib
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+
+def shard_of(value: str, n: int) -> int:
+    return zlib.crc32(value.encode()) % n
+
+
+def shard_name(config: str, s: int, n: int) -> str:
+    return f"{config}-{s:05d}-of-{n:05d}.parquet"
+
+
+def read_shard(directory: Path, config: str, s: int, n: int) -> pa.Table | None:
+    path = Path(directory) / shard_name(config, s, n)
+    return pq.read_table(path) if path.exists() else None
+
+
+def write_shard(table: pa.Table, directory: Path, config: str, s: int, n: int) -> Path:
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / shard_name(config, s, n)
+    pq.write_table(table, path, compression="zstd")
+    return path
+
+
+def read_index(raw_dir: Path, key_col: str, mod_col: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for f in sorted(Path(raw_dir).glob("*.parquet")):
+        t = pq.read_table(f, columns=[key_col, mod_col])
+        out.update(zip(t.column(key_col).to_pylist(), t.column(mod_col).to_pylist()))
+    return out
+
+
+@dataclass
+class Diff:
+    fetch: list[str]
+    removed: set[str]
+    added: int
+    changed: int
+    unchanged: int
+
+
+def diff(current: dict[str, str], previous: dict[str, str]) -> Diff:
+    added = [k for k in current if k not in previous]
+    changed = [k for k in current if k in previous and previous[k] != current[k]]
+    return Diff(
+        fetch=added + changed,
+        removed=set(previous) - set(current),
+        added=len(added),
+        changed=len(changed),
+        unchanged=len(current) - len(added) - len(changed),
+    )
+
+
+class Staging:
+    """Buffers fetched rows to per-shard Parquet files so a shard is read back without scanning the rest."""
+
+    def __init__(self, directory: Path, schema: pa.Schema, shard_col: str, n_shards: int, flush_rows: int = 100):
+        self.dir = Path(directory)
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.schema = schema
+        self.shard_col = shard_col
+        self.n = n_shards
+        self.flush_rows = flush_rows
+        self.buffers: dict[int, list[dict]] = defaultdict(list)
+        self.seq = 0
+
+    def add(self, row: dict) -> None:
+        s = shard_of(row[self.shard_col], self.n)
+        self.buffers[s].append(row)
+        if len(self.buffers[s]) >= self.flush_rows:
+            self._flush_shard(s)
+
+    def flush(self) -> None:
+        for s in list(self.buffers):
+            self._flush_shard(s)
+
+    def _flush_shard(self, s: int) -> None:
+        rows = self.buffers.pop(s, [])
+        if not rows:
+            return
+        self.seq += 1
+        pq.write_table(pa.Table.from_pylist(rows, schema=self.schema), self.dir / f"{s:05d}-{self.seq:07d}.parquet")
+
+    def read_shard(self, s: int) -> pa.Table:
+        files = sorted(self.dir.glob(f"{s:05d}-*.parquet"))
+        if not files:
+            return self.schema.empty_table()
+        return pa.concat_tables(pq.read_table(f).cast(self.schema) for f in files)
+
+
+def merge_shard(
+    previous: pa.Table | None, fetched: pa.Table, removed: set[str], key_col: str, schema: pa.Schema
+) -> pa.Table:
+    parts = []
+    if previous is not None and previous.num_rows:
+        drop = pa.array(sorted(set(removed) | set(fetched.column(key_col).to_pylist())), pa.string())
+        keep = pc.invert(pc.is_in(previous.column(key_col), value_set=drop))
+        parts.append(previous.filter(keep).select(schema.names).cast(schema))
+    parts.append(fetched.select(schema.names).cast(schema))
+    return pa.concat_tables(parts).sort_by(key_col)