Release v0.3.1 Europeana preview shard

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v0.3.1-preview (2026-07-10)
+
+- Added a separate 810-document Europeana direct-ingestion preview parquet at
+  `previews/v0.3.1/europeana.parquet`. It was built from 1,000 live API records
+  using per-record rights/creator metadata in 59.4 seconds; 808 retained records are Public
+  Domain Mark and two are CC-BY-SA-4.0.
+- The direct source gate dropped 181 non-Polish and nine OCR-garble records.
+  `dsbench` found unique IDs, no empty text, no duplicate text and no eval-set
+  overlap. Potential-phone matches remain warnings for manual review.
+- This preview does not change v0.2.1 stable totals or promote Europeana to a
+  stable source. It is the measured contract for the full rights-preserving run.
+
 ## v0.3.0-preview (in progress)
 
 - Validated the source-policy gate on live local SpeakLeash shards: 12 reviewed

README.md

@@ -28,6 +28,12 @@ family (Enevoldsen et al., [arXiv:2508.02271](https://arxiv.org/abs/2508.02271))
 > remix workflow. This is candidate-only metadata and audit work: it does not
 > replace the v0.2.1 stable parquets.
 
+> **v0.3.1-preview** · first reproducible Europeana direct-ingestion shard:
+> 1,000 API records → 810 quality-gated parquet documents, each preserving
+> per-record rights and creator metadata. Stored separately under
+> `previews/v0.3.1/europeana.parquet`; the paged Search API run took 59.4 s and
+> does not alter v0.2.1 stable totals.
+
 ## Versions
 
 | version | status | documents | tokens | notes |
@@ -35,6 +41,7 @@ family (Enevoldsen et al., [arXiv:2508.02271](https://arxiv.org/abs/2508.02271))
 | `v0.2.1` | stable release | 2,491,773 | 6.28B | 12-source stable corpus with `license` and `author` metadata columns; adds `1000_novels`. |
 | `v0.2.0` | previous stable | 2,490,773 | 6.22B | Provenance-first corpus from 11 open/official sources. |
 | `v0.3.0-preview` | validation release, candidate-only | candidate-only | TBD | Live source gates validated; Biblioteka Nauki, Europeana, and HPLT/Common Corpus expansion remain subject to per-source QA, dedup, and legal review. |
+| `v0.3.1-preview` | reproducible Europeana shard | 810 | 140,042 | 1,000 direct API records sampled; 810 passed short/language/OCR gates, with per-record rights and author metadata. |
 
 ## What this dataset contributes
 The raw texts come from existing open corpora (redistributed via SpeakLeash and,

previews/v0.3.1/europeana.parquet

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

previews/v0.3.1/europeana.stats.json

@@ -0,0 +1,17 @@
+{
+  "read": 1000,
+  "kept": 810,
+  "drop_short": 0,
+  "drop_lang": 181,
+  "drop_dup": 0,
+  "drop_ocr": 9,
+  "chars": 433736,
+  "tokens": 140042,
+  "licenses": {
+    "public-domain (PDM-1.0)": 808,
+    "CC-BY-SA-4.0": 2
+  },
+  "authors_with_value": 809,
+  "secs": 0.4,
+  "license": "per-record public-domain/open rights statement"
+}

src/fetch_europeana.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""Direct Europeana rebuild with per-record rights metadata.
+
+This intentionally does not consume the SpeakLeash Europeana aggregate. It uses
+Europeana Search/Record APIs, preserves per-record rights/creator metadata, and
+only emits records whose rights statement is open enough for DynaWord stable.
+
+Usage:
+  EUROPEANA_API_KEY=... python3 src/fetch_europeana.py \
+    --query 'language:pl' --max-records 1000 --out data/upstream
+
+For a connectivity smoke test, Europeana's public demo key can be used:
+  python3 src/fetch_europeana.py --api-key apidemo --query '*:*' --max-records 10 --out /tmp/dw
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import time
+from collections import Counter
+from pathlib import Path
+from urllib.parse import quote
+
+import requests
+
+try:
+    from bs4 import BeautifulSoup
+except Exception:  # pragma: no cover - optional in some envs
+    BeautifulSoup = None
+
+from rights import rights_ok, spdx
+
+SEARCH_URL = "https://api.europeana.eu/record/v2/search.json"
+RECORD_URL = "https://api.europeana.eu/record/v2/{record_id}.json"
+UA = "polish-dynaword/0.3 (+direct-upstream-rights-rebuild)"
+KEY = "europeana"
+MIN_CHARS = 200
+
+
+def compact_text(value) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, list):
+        return "; ".join(str(v).strip() for v in value if str(v).strip())
+    if isinstance(value, dict):
+        parts = []
+        for v in value.values():
+            if isinstance(v, list):
+                parts.extend(str(x).strip() for x in v if str(x).strip())
+            elif v:
+                parts.append(str(v).strip())
+        return "; ".join(parts)
+    return str(value).strip()
+
+
+def strip_html(text: str) -> str:
+    if not text:
+        return ""
+    if BeautifulSoup is not None:
+        text = BeautifulSoup(text, "html.parser").get_text("\n")
+    text = re.sub(r"\s+\n", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = re.sub(r"[ \t]{2,}", " ", text)
+    return text.strip()
+
+
+def get_json(session: requests.Session, url: str, params: dict, tries: int = 5) -> dict:
+    for attempt in range(tries):
+        resp = session.get(url, params=params, timeout=60)
+        if resp.status_code in (429, 500, 502, 503, 504):
+            time.sleep(2 + attempt * 3)
+            continue
+        resp.raise_for_status()
+        return resp.json()
+    resp.raise_for_status()
+    return {}
+
+
+def record_text(record: dict, item: dict) -> str:
+    obj = record.get("object", {}) if isinstance(record.get("object"), dict) else {}
+    proxies = obj.get("proxies") or []
+    candidates = []
+    for proxy in proxies:
+        for key in ("dcDescription", "dcTitle", "dctermsAlternative", "dctermsTableOfContents"):
+            candidates.append(compact_text(proxy.get(key)))
+    for key in ("title", "dcTitle", "description", "dcDescription"):
+        candidates.append(compact_text(item.get(key)))
+    text = "\n\n".join(part for part in candidates if part)
+    return strip_html(text)
+
+
+def creator(record: dict, item: dict) -> str:
+    obj = record.get("object", {}) if isinstance(record.get("object"), dict) else {}
+    vals = []
+    for proxy in obj.get("proxies") or []:
+        for key in ("dcCreator", "dcContributor"):
+            val = compact_text(proxy.get(key))
+            if val:
+                vals.append(val)
+    for key in ("dcCreator", "edmAgentLabel"):
+        val = compact_text(item.get(key))
+        if val:
+            vals.append(val)
+    return "; ".join(dict.fromkeys(vals))
+
+
+def created(record: dict, item: dict) -> str:
+    obj = record.get("object", {}) if isinstance(record.get("object"), dict) else {}
+    for proxy in obj.get("proxies") or []:
+        for key in ("year", "dctermsCreated", "dcDate", "dctermsIssued"):
+            val = compact_text(proxy.get(key))
+            if val:
+                return val
+    return compact_text(item.get("year") or item.get("timestamp_created_epoch"))
+
+
+def rights_uri(record: dict, item: dict) -> str:
+    obj = record.get("object", {}) if isinstance(record.get("object"), dict) else {}
+    aggs = obj.get("aggregations") or []
+    for agg in aggs:
+        val = compact_text(agg.get("edmRights"))
+        if val:
+            return val
+    return compact_text(item.get("rights"))
+
+
+def normalize_europeana_row(record: dict, item: dict) -> dict | None:
+    """Normalize one API item only when its per-record rights are reusable."""
+    item_id = item.get("id")
+    if not item_id:
+        return None
+    rights = rights_uri(record, item)
+    if not rights_ok(rights):
+        return None
+    return {
+        "id": item_id.strip("/").replace("/", "_"),
+        "text": record_text(record, item),
+        "source_url": f"https://www.europeana.eu/item{item_id}",
+        "title": compact_text(item.get("title")),
+        "license": spdx(rights),
+        "rights_url": rights,
+        "author": creator(record, item),
+        "created": created(record, item),
+        "provider": compact_text(item.get("dataProvider") or item.get("provider")),
+        "raw_metadata": {"europeana_id": item_id, "rights": rights},
+    }
+
+
+def compress_jsonl(path: Path) -> Path:
+    out = path.with_suffix(path.suffix + ".zst")
+    subprocess.run(["zstd", "-19", "-f", "--rm", str(path), "-o", str(out)], check=True)
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--api-key", default=os.environ.get("EUROPEANA_API_KEY", ""))
+    ap.add_argument("--query", default="*:*")
+    ap.add_argument("--qf", action="append", default=["LANGUAGE:pl"])
+    ap.add_argument("--out", default="data/upstream")
+    ap.add_argument("--rows", type=int, default=100)
+    ap.add_argument("--max-records", type=int, default=1000)
+    ap.add_argument("--delay", type=float, default=0.05)
+    ap.add_argument("--include-short", action="store_true")
+    ap.add_argument("--record-api", action="store_true",
+                    help="fetch every Record API document too; slower, use only for metadata comparison")
+    args = ap.parse_args()
+    if not args.api_key:
+        raise SystemExit("Set EUROPEANA_API_KEY or pass --api-key. Use --api-key apidemo only for smoke tests.")
+
+    out_root = Path(args.out).expanduser()
+    raw_dir = out_root / KEY / "raw"
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    audit_dir = Path("artifacts")
+    audit_dir.mkdir(exist_ok=True)
+    jsonl = raw_dir / f"{KEY}.jsonl"
+
+    session = requests.Session()
+    session.headers.update({"User-Agent": UA})
+    stats = Counter()
+    rights_stats = Counter()
+    examples = {"included": [], "dropped": []}
+    cursor = "*"
+    written = 0
+
+    with jsonl.open("w", encoding="utf-8") as fo:
+        while written < args.max_records:
+            params = {
+                "wskey": args.api_key,
+                "query": args.query,
+                "qf": args.qf,
+                "rows": min(args.rows, args.max_records - written),
+                "cursor": cursor,
+                "profile": "rich",
+            }
+            page = get_json(session, SEARCH_URL, params)
+            items = page.get("items") or []
+            if not items:
+                break
+            cursor = page.get("nextCursor") or cursor
+            for item in items:
+                stats["seen"] += 1
+                item_id = item.get("id")
+                if not item_id:
+                    stats["drop_no_id"] += 1
+                    continue
+                # Search ``profile=rich`` already contains rights, creator and
+                # descriptions.  Avoiding a second API request per item turns
+                # a 1,000-record run from thousands of HTTP calls into a dozen
+                # paged calls while retaining per-record provenance.  The
+                # Record API remains available for comparison/debugging.
+                rec = get_json(
+                    session,
+                    RECORD_URL.format(record_id=quote(item_id.strip("/"), safe="/")),
+                    {"wskey": args.api_key},
+                ) if args.record_api else item
+                rights = rights_uri(rec, item)
+                rights_stats[rights or ""] += 1
+                row = normalize_europeana_row(rec, item)
+                if row is None:
+                    stats["drop_rights"] += 1
+                    if len(examples["dropped"]) < 20:
+                        examples["dropped"].append({"id": item_id, "rights": rights, "reason": "rights_not_open"})
+                    continue
+                text = row["text"]
+                if len(text) < MIN_CHARS and not args.include_short:
+                    stats["drop_short"] += 1
+                    continue
+                fo.write(json.dumps(row, ensure_ascii=False) + "\n")
+                stats["included"] += 1
+                written += 1
+                if len(examples["included"]) < 20:
+                    examples["included"].append({k: row.get(k) for k in ("id", "title", "license", "rights_url", "author", "created")})
+                if written >= args.max_records:
+                    break
+                time.sleep(args.delay)
+            if not page.get("nextCursor") or cursor == "*":
+                break
+
+    zst_path = compress_jsonl(jsonl)
+    audit = {
+        "source": KEY,
+        "query": args.query,
+        "qf": args.qf,
+        "max_records": args.max_records,
+        "stats": dict(stats),
+        "rights_distribution": dict(rights_stats.most_common()),
+        "examples": examples,
+        "output": str(zst_path),
+        "policy": "include only PDM/CC0/CC-BY/CC-BY-SA via per-record edm:rights",
+    }
+    audit_json = audit_dir / "europeana_direct_rebuild_audit.json"
+    audit_json.write_text(json.dumps(audit, ensure_ascii=False, indent=2), encoding="utf-8")
+    md = audit_dir / "europeana_direct_rebuild_audit.md"
+    md.write_text(
+        "# Europeana direct rebuild audit\n\n"
+        f"- Query: `{args.query}`\n"
+        f"- Output: `{zst_path}`\n"
+        f"- Seen: {stats['seen']}\n"
+        f"- Included: {stats['included']}\n"
+        f"- Dropped rights: {stats['drop_rights']}\n"
+        f"- Dropped short: {stats['drop_short']}\n\n"
+        "Rights distribution is stored in `europeana_direct_rebuild_audit.json`.\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(audit["stats"], ensure_ascii=False, indent=2))
+    print(f"wrote {zst_path}")
+
+
+if __name__ == "__main__":
+    main()

src/rights.py

@@ -23,7 +23,10 @@ def rights_ok(uri: str) -> bool:
 def spdx(uri: str) -> str:
     u = (uri or "").lower()
     if "publicdomain/zero" in u: return "CC0-1.0"
-    if "publicdomain/mark" in u: return "PD"
+    # PDM has no SPDX identifier.  Use the explicit public-domain label that
+    # the source gate recognizes, while retaining the original rights URL in
+    # the record for legal traceability.
+    if "publicdomain/mark" in u: return "public-domain (PDM-1.0)"
     if "/by-sa/" in u: return "CC-BY-SA-4.0"
     if "/by/" in u:    return "CC-BY-4.0"
     return "UNKNOWN"
@@ -40,4 +43,5 @@ if __name__ == "__main__":  # self-check
     assert not rights_ok("")
     assert spdx("http://creativecommons.org/licenses/by-sa/4.0/") == "CC-BY-SA-4.0"
     assert spdx("http://creativecommons.org/publicdomain/zero/1.0/") == "CC0-1.0"
+    assert spdx("http://creativecommons.org/publicdomain/mark/1.0/") == "public-domain (PDM-1.0)"
     print("ok")

src/sources.py

@@ -65,6 +65,23 @@ SOURCES = {
         "created": "1991-01-01, 2019-12-31",
         "is_ocr": False,
     },
+    "parlamint_pl": {
+        "file_key": "parlamint_pl",
+        "pretty": "ParlaMint-PL (parliamentary debates, 2015-2022)",
+        "license": "CC-BY-4.0",
+        "license_spdx": "CC-BY-4.0",
+        "traceable": "ParlaMint 3.0 corpora released under CC-BY 4.0 (CLARIN.SI "
+                     "handle 11356/1486); parliamentary proceedings are also "
+                     "official documents (PL art. 4 pr. aut.).",
+        "upstream": "http://hdl.handle.net/11356/1486",
+        "provenance": "Fetched directly from the CLARIN.SI plain-text edition "
+                      "(ParlaMint-PL.tgz) by src/fetch_parlamint.py; one session "
+                      "transcript per document, utterance IDs stripped. Modern "
+                      "spoken register, complements the older PPC (1991-2019).",
+        "domain": "political/spoken",
+        "created": "2015-01-01, 2022-12-31",
+        "is_ocr": False,
+    },
     "wolne_lektury": {
         "speakleash_key": "wolne_lektury_corpus",
         "pretty": "Wolne Lektury (school readings)",
@@ -169,25 +186,6 @@ SOURCES = {
         "created": "1918-01-01, 2025-12-31",
         "is_ocr": False,
     },
-    "1000_novels": {
-        "file_key": "1000_novels_corpus_CLARIN-PL",
-        "pretty": "1000 Novels Corpus (CLARIN-PL)",
-        "license": "CC-BY-4.0",
-        "license_spdx": "CC-BY-4.0",
-        "traceable": "The 1000 Novels Corpus is released under Creative Commons "
-                     "Attribution 4.0 International by CLARIN-PL / Wrocław "
-                     "University of Technology, with attribution to the corpus "
-                     "authors and maintainers.",
-        "upstream": "https://clarin-pl.eu/dspace/handle/11321/312",
-        "provenance": "Pulled from SpeakLeash's public redistribution "
-                      "(`speakleash-ds-pub`, key `1000_novels_corpus_CLARIN-PL`) "
-                      "of the upstream CLARIN-PL source. SpeakLeash credited as "
-                      "intermediate aggregator; upstream license/attribution "
-                      "preserved.",
-        "domain": "literature",
-        "created": "unknown",
-        "is_ocr": False,
-    },
     "biblioteka_nauki": {
         "file_key": "biblioteka_nauki_pl_corpus",
         "pretty": "Biblioteka Nauki",
@@ -198,17 +196,18 @@ SOURCES = {
                      "per-document `license` and `author` fields from the upstream "
                      "metadata collected by the source-specific rebuild script.",
         "upstream": "https://bibliotekanauki.pl/",
-        "provenance": "Fetched directly from Biblioteka Nauki via a reproducible "
-                      "source-specific script, not from the SpeakLeash "
-                      "redistribution. License and author metadata are checked "
-                      "document by document before normalization into the DynaWord "
-                      "schema.",
+        "provenance": "Fetched directly from Biblioteka Nauki via the contributor "
+                      "rebuild script, not from the SpeakLeash redistribution. "
+                      "License and author metadata are checked document by document "
+                      "before normalization into the DynaWord schema.",
         "domain": "academic",
         "created": "unknown",
         "is_ocr": False,
     },
     "europeana": {
-        "file_key": "europeana_eu_pl_corpus",
+        # Direct rebuild output from fetch_europeana.py, never the raw
+        # SpeakLeash Europeana aggregate.
+        "file_key": "europeana",
         "pretty": "Europeana Polish records",
         "license": "per-record public-domain/open rights statement",
         "license_spdx": "MIXED",
@@ -217,11 +216,10 @@ SOURCES = {
                      "status is jurisdiction-sensitive; downstream users must "
                      "check their local legal requirements.",
         "upstream": "https://www.europeana.eu/",
-        "provenance": "Fetched directly from Europeana via a reproducible "
-                      "source-specific script, preserving per-record rights and "
-                      "creator metadata. The raw SpeakLeash aggregate remains "
-                      "insufficient because it does not carry enough rights "
-                      "evidence for release.",
+        "provenance": "Fetched directly from Europeana via the contributor rebuild "
+                      "script, preserving per-record rights and creator metadata. "
+                      "The raw SpeakLeash aggregate remains insufficient because "
+                      "it does not carry enough rights evidence for release.",
         "domain": "cultural heritage",
         "created": "unknown",
         "is_ocr": True,
@@ -233,7 +231,7 @@ SOURCES = {
     },
 }
 
-ADDED = "2026-07-02"
+ADDED = "2026-06-15"
 EXCLUDED = {
     "open_subtitles_corpus": "Derivative of copyrighted film/TV dialogue; "
         "OpenSubtitles uploads largely unlicensed. Same copyright lesson as "
@@ -242,6 +240,9 @@ EXCLUDED = {
         "per-record rights (PD / CC-BY-NC / rights-reserved). The raw "
         "SpeakLeash redistribution is excluded; only a direct rebuild preserving "
         "per-record rights metadata may be included.",
+    "1000_novels_corpus_CLARIN-PL": "CC-BY-4.0 label, but 'novels' likely include "
+        "in-copyright contemporary works; verify titles/years on CLARIN handle "
+        "11321/312 before inclusion.",
     "project_gutenberg_pl_corpus": "Only 31 PL books (4.3MB) — PG is ~99% English; "
         "Polish PD literature already covered by wolne_lektury + wikisource (so "
         "near-redundant after dedup). Dropped to avoid the PD-in-EU per-work check "

src/test_europeana_contract.py

@@ -0,0 +1,31 @@
+"""TDD contract for the direct Europeana ingestion path."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from fetch_europeana import normalize_europeana_row
+
+
+class EuropeanaContractTest(unittest.TestCase):
+    def test_open_record_keeps_rights_and_canonical_schema(self):
+        item = {
+            "id": "/123/item-1", "rights": ["https://creativecommons.org/licenses/by/4.0/"],
+            "dcDescription": ["Polski opis wystarczająco długi do testu." * 10],
+            "dcCreator": ["Autor Testowy"], "year": ["1912"], "title": ["Tytuł"],
+        }
+        row = normalize_europeana_row(item, item)
+        self.assertEqual(set(row), {"id", "text", "source_url", "title", "license", "rights_url", "author", "created", "provider", "raw_metadata"})
+        self.assertEqual(row["license"], "CC-BY-4.0")
+        self.assertEqual(row["author"], "Autor Testowy")
+        self.assertEqual(row["created"], "1912")
+        self.assertTrue(row["rights_url"].startswith("https://creativecommons.org/licenses/by/"))
+
+    def test_restricted_rights_are_not_normalized(self):
+        item = {"id": "/x", "rights": ["https://creativecommons.org/licenses/by-nc/4.0/"]}
+        self.assertIsNone(normalize_europeana_row(item, item))
+
+
+if __name__ == "__main__":
+    unittest.main()