wolne_lektury: label each row with its own Wolne Lektury licence; drop 2 unlicensed rows (v2#57)

data/wolne_lektury/wolne_lektury.md

@@ -6,12 +6,12 @@ Wolne Lektury (school readings)
 - **Source (upstream):** https://wolnelektury.pl/api/books/
 - **Domain:** literature
 - **Language:** Polish (pl)
-- **License:** `CC-BY-SA-4.0 / Wolna Sztuka 1.3`
+- **License:** `per-record Wolne Lektury licence (public domain, LAL 1.3, CC BY-SA 3.0 PL/3.0/4.0)`
 - **Created (range):** 1500-01-01, 2024-12-31
 - **Added:** 2026-06-15
 
 ## Licensing — traceable basis
-Wolne Lektury publishes under CC-BY-SA 4.0 or Free Art License; texts are public-domain classics + cleared works.
+Each document's `license` is the one its own Wolne Lektury book states in dc:rights / dc:rights.license, never its parent collection's (src/wolne_lektury_licences.py, polish-dynaword-v2#57). Documents are matched to books by text: the same head and tail, or, where Wolne Lektury has edited a text since the scrape, a 5-word-shingle share of at least 0.6 at both ends; 17 were matched by hand. A label is set only when the rights text is unambiguous: a public-domain statement with no year after 1955, or one licence with its version. wolne_lektury.licences.tsv lists each document's book (its slug on wolnelektury.pl), the Wolne Lektury rights text and the label. The released text is Wolne Lektury's plain-text export without its footer, so it carries no attribution line, footnotes or motifs; the slug is the attribution link.
 
 ## Provenance
 Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `wolne_lektury_corpus`) of the upstream source above. SpeakLeash credited as intermediate aggregator; upstream license/attribution preserved.
@@ -19,18 +19,22 @@ Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `wolne_
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
-| 6,078 | 230,764,171 | 90,654,820 |
+| 6,076 | 230,761,977 | 90,653,913 |
 
 
 ## Per-document license metadata
 | license | documents |
 |---|---:|
-| `CC-BY-SA-4.0 / Wolna Sztuka 1.3` | 6,078 |
+| `public-domain` | 4,559 |
+| `LAL-1.3` | 1,467 |
+| `CC-BY-SA-3.0-PL` | 34 |
+| `CC-BY-SA-4.0` | 11 |
+| `CC-BY-SA-3.0` | 5 |
 
 Author metadata present for **0** documents. Empty values mean the upstream record did not expose a machine-readable author field.
 
 ## Legal scope note
-For v0.2.6, 63 documents whose text is an eltec_pol novel are dropped (share of a document's 5-word shingles found in one ELTeC novel >= 0.9; src/clean_wolne_lektury.py, polish-dynaword-v2#72). eltec_pol keeps those 50 novels whole under CC BY 4.0. Three documents only partly in an ELTeC novel are kept: both tomes of Mniszek's Trędowata (the ELTeC text is shorter) and Kochanowski's Pieśń IX, quoted in Łoziński's Oko proroka. Every pair is listed in wolne_lektury.eltec_pairs.tsv.
+For v0.2.6, 63 documents whose text is an eltec_pol novel are dropped (share of a document's 5-word shingles found in one ELTeC novel >= 0.9; src/clean_wolne_lektury.py, polish-dynaword-v2#72). eltec_pol keeps those 50 novels whole under CC BY 4.0. Three documents only partly in an ELTeC novel are kept: both tomes of Mniszek's Trędowata (the ELTeC text is shorter) and Kochanowski's Pieśń IX, quoted in Łoziński's Oko proroka. Every pair is listed in wolne_lektury.eltec_pairs.tsv. 2 documents are also dropped because Wolne Lektury gives them no usable licence: two Horace odes translated by Paweł Kozioł, one marked only "CC BY-SA" with no version, the other public domain for Marceli Motty's translation and "CC BY-SA" for Kozioł's (polish-dynaword-v2#57).
 
 Statistics were recomputed directly from the released parquet file.
 
@@ -40,7 +44,7 @@ Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - drop non-Polish (diacritic ratio): **0**
 - exact cross-source dedup (sha1): **0**
 - OCR alpha-ratio < 0.70 (OCR sources only): **0**
-- read 6,141 → kept 6,078
+- read 6,141 → kept 6,076
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.

data/wolne_lektury/wolne_lektury.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f308d49235551241d6c47c5e88138ba52e6235422ae272ddbc135c3b8696ae0e
-size 113055766
+oid sha256:ab0690efa4db1e0c8ea0980f35239d78f52c5fbc0d357c906056eeb4f81d829c
+size 113055020

data/wolne_lektury/wolne_lektury.stats.json

@@ -1,19 +1,24 @@
 {
   "read": 6141,
-  "kept": 6078,
+  "kept": 6076,
   "drop_short": 0,
   "drop_lang": 0,
   "drop_dup": 0,
   "drop_ocr": 0,
-  "chars": 230764171,
-  "tokens": 90654820,
+  "chars": 230761977,
+  "tokens": 90653913,
   "licenses": {
-    "CC-BY-SA-4.0 / Wolna Sztuka 1.3": 6078
+    "CC-BY-SA-3.0": 5,
+    "CC-BY-SA-3.0-PL": 34,
+    "CC-BY-SA-4.0": 11,
+    "LAL-1.3": 1467,
+    "public-domain": 4559
   },
   "authors_with_value": 0,
-  "license": "CC-BY-SA-4.0 / Wolna Sztuka 1.3",
+  "license": "per-record Wolne Lektury licence (public domain, LAL 1.3, CC BY-SA 3.0 PL/3.0/4.0)",
   "stats_recomputed_from_parquet": true,
   "drop_eltec_dup": 63,
   "input_sha256": "5833c25db296f2479b3c09745ebedd550b2425dd6ebaf021f0095e684a0221a1",
-  "eltec_sha256": "ba40061741dff11165149f6c2cf3d5526e1b6c759e7ce1e03ccc164d58838325"
+  "eltec_sha256": "ba40061741dff11165149f6c2cf3d5526e1b6c759e7ce1e03ccc164d58838325",
+  "drop_rights": 2
 }

src/clean_wolne_lektury.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-"""Drop wolne_lektury documents whose text is an eltec_pol novel (slayerlabs/polish-dynaword-v2#72).
+"""Drop wolne_lektury documents whose text is an eltec_pol novel (slayerlabs/polish-dynaword-v2#72),
+then label each kept row with its own Wolne Lektury licence (polish-dynaword-v2#57).
 
 Half of the 100 ELTeC-pol novels are also in Wolne Lektury. The maintainer chose (2026-10-06) to
 drop the Wolne Lektury copies and keep eltec_pol whole, because ELTeC's CC BY 4.0 is the clean
@@ -15,6 +16,11 @@ the released text is not changed. Docs scoring >= DROP_AT are dropped. Docs scor
 >= REPORT_AT but below DROP_AT are only partly in an ELTeC novel; they are kept and listed.
 Both groups are written to wolne_lektury.eltec_pairs.tsv.
 
+The `license` of each kept row comes from wolne_lektury.licences.tsv, which
+src/wolne_lektury_licences.py writes from Wolne Lektury's metadata; the build stops unless that file
+labels exactly the kept rows. The rows in that module's UNLICENSED, whose metadata gives no usable
+licence, are dropped first (stats `drop_rights`).
+
 Both input Parquets are pinned by SHA-256. Restore the WL Parquet before a rerun:
   git checkout v0.2.5 -- data/wolne_lektury/wolne_lektury.parquet
   python3 src/clean_wolne_lektury.py
@@ -34,6 +40,8 @@ import pyarrow.compute as pc
 import pyarrow.parquet as pq
 
 from shingle_containment import best_containment, strip_wl_footer
+from sources import SOURCES
+from wolne_lektury_licences import LABELS, LICENCES, UNLICENSED
 
 SOURCE = "wolne_lektury"
 ROOT = Path(__file__).resolve().parents[1]
@@ -60,7 +68,30 @@ def check_pin(path: Path, expected: str, restore: str) -> None:
             raise SystemExit(f"{path} does not match the pinned SHA-256; {restore}")
 
 
-def build(input_path: Path, eltec_path: Path, out_dir: Path) -> dict:
+def relabel(table: pa.Table, licences_path: Path) -> pa.Table:
+    """`table` with each row's `license` from the licences TSV, which must list exactly its rows."""
+    with licences_path.open(encoding="utf-8", newline="") as handle:
+        records = list(csv.DictReader(handle, delimiter="\t"))
+    labels = {record["id"]: record["license"] for record in records}
+    ids = table.column("id").to_pylist()
+    if len(labels) != len(records) or labels.keys() != set(ids):
+        raise SystemExit(f"{licences_path.name} does not list exactly the kept rows; "
+                         "rerun src/wolne_lektury_licences.py")
+    if not set(labels.values()) <= set(LABELS):
+        raise SystemExit(f"{licences_path.name} has labels outside {LABELS}")
+    return table.set_column(table.column_names.index("license"), "license",
+                            pa.array([labels[i] for i in ids], pa.string()))
+
+
+def drop_unlicensed(table: pa.Table) -> pa.Table:
+    """`table` without the UNLICENSED rows, every one of which must be in it."""
+    unlicensed = pc.is_in(table.column("id"), pa.array(sorted(UNLICENSED)))
+    if pc.sum(unlicensed).as_py() != len(UNLICENSED):
+        raise SystemExit("an UNLICENSED id is not among the deduplicated rows")
+    return table.filter(pc.invert(unlicensed))
+
+
+def build(input_path: Path, eltec_path: Path, licences_path: Path, out_dir: Path) -> dict:
     check_pin(input_path, INPUT_SHA256,
               f"restore it with `git checkout v0.2.5 -- data/{SOURCE}/{SOURCE}.parquet`")
     check_pin(eltec_path, ELTEC_SHA256, "it is not the v0.2.5 eltec_pol Parquet")
@@ -77,21 +108,25 @@ def build(input_path: Path, eltec_path: Path, out_dir: Path) -> dict:
             pairs.append({"wl_id": wl_id, "eltec_id": eltec_ids[novel], "score": f"{score:.4f}",
                           "action": "drop" if score >= DROP_AT else "keep_partial",
                           "wl_title": wl_title(text)})
-    kept = table.filter(pa.array(keep))
+    deduped = table.filter(pa.array(keep))
+    licensed = drop_unlicensed(deduped)
+    kept = relabel(licensed, licences_path)
 
     stats_path = out_dir / f"{SOURCE}.stats.json"
     stats = json.loads(stats_path.read_text(encoding="utf-8"))  # keeps build_dynaword's read/drop_* counts
     stats.update(
         kept=kept.num_rows,
-        drop_eltec_dup=table.num_rows - kept.num_rows,
+        drop_eltec_dup=table.num_rows - deduped.num_rows,
+        drop_rights=deduped.num_rows - licensed.num_rows,
         chars=pc.sum(pc.utf8_length(kept.column("text"))).as_py(),
         tokens=pc.sum(kept.column("token_count")).as_py(),
         licenses=dict(sorted(Counter(kept.column("license").to_pylist()).items())),
+        license=SOURCES[SOURCE]["license"],
         authors_with_value=sum(map(bool, kept.column("author").to_pylist())),
         input_sha256=INPUT_SHA256,
         eltec_sha256=ELTEC_SHA256,
     )
-    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_eltec_dup")
+    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_eltec_dup", "drop_rights")
     if stats["read"] - sum(stats[k] for k in drops) != stats["kept"]:
         raise SystemExit("stats drop counts do not add up to the kept rows")
 
@@ -120,9 +155,10 @@ def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
     parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet")
     parser.add_argument("--eltec", type=Path, default=ELTEC)
+    parser.add_argument("--licences", type=Path, default=DATA / LICENCES)
     parser.add_argument("--out", type=Path, default=DATA)
     args = parser.parse_args()
-    print(json.dumps(build(args.input, args.eltec, args.out), indent=2, ensure_ascii=False))
+    print(json.dumps(build(args.input, args.eltec, args.licences, args.out), indent=2, ensure_ascii=False))
 
 
 if __name__ == "__main__":

src/sources.py

@@ -386,10 +386,19 @@ SOURCES = {
         "release": "0.2.0",
         "speakleash_key": "wolne_lektury_corpus",
         "pretty": "Wolne Lektury (school readings)",
-        "license": "CC-BY-SA-4.0 / Wolna Sztuka 1.3",
-        "license_spdx": "CC-BY-SA-4.0",
-        "traceable": "Wolne Lektury publishes under CC-BY-SA 4.0 or Free Art "
-                     "License; texts are public-domain classics + cleared works.",
+        "license": "per-record Wolne Lektury licence (public domain, LAL 1.3, CC BY-SA 3.0 PL/3.0/4.0)",
+        "license_spdx": "MIXED",
+        "traceable": "Each document's `license` is the one its own Wolne Lektury book states in "
+                     "dc:rights / dc:rights.license, never its parent collection's "
+                     "(src/wolne_lektury_licences.py, polish-dynaword-v2#57). Documents are matched "
+                     "to books by text: the same head and tail, or, where Wolne Lektury has edited a "
+                     "text since the scrape, a 5-word-shingle share of at least 0.6 at both ends; 17 "
+                     "were matched by hand. A label is set only when the rights text is unambiguous: "
+                     "a public-domain statement with no year after 1955, or one licence with its "
+                     "version. wolne_lektury.licences.tsv lists each document's book (its slug on "
+                     "wolnelektury.pl), the Wolne Lektury rights text and the label. The released "
+                     "text is Wolne Lektury's plain-text export without its footer, so it carries no "
+                     "attribution line, footnotes or motifs; the slug is the attribution link.",
         "upstream": "https://wolnelektury.pl/api/books/",
         "domain": "literature",
         "created": "1500-01-01, 2024-12-31",
@@ -399,7 +408,11 @@ SOURCES = {
                       "50 novels whole under CC BY 4.0. Three documents only partly in an ELTeC "
                       "novel are kept: both tomes of Mniszek's Trędowata (the ELTeC text is "
                       "shorter) and Kochanowski's Pieśń IX, quoted in Łoziński's Oko proroka. "
-                      "Every pair is listed in wolne_lektury.eltec_pairs.tsv.",
+                      "Every pair is listed in wolne_lektury.eltec_pairs.tsv. 2 documents are also "
+                      "dropped because Wolne Lektury gives them no usable licence: two Horace odes "
+                      "translated by Paweł Kozioł, one marked only \"CC BY-SA\" with no version, the "
+                      "other public domain for Marceli Motty's translation and \"CC BY-SA\" for "
+                      "Kozioł's (polish-dynaword-v2#57).",
         "is_ocr": False,
     },
     "wikinews": {

src/test_wolne_lektury_contract.py

@@ -1,9 +1,11 @@
-"""Contract checks for wolne_lektury after the eltec_pol dedup (src/clean_wolne_lektury.py, v2#72)."""
+"""Contract checks for wolne_lektury after the eltec_pol dedup (src/clean_wolne_lektury.py, v2#72)
+and the per-row licence (src/wolne_lektury_licences.py, v2#57)."""
 
 import csv
 import hashlib
 import json
 import sys
+from collections import Counter
 from pathlib import Path
 
 import pyarrow as pa
@@ -14,7 +16,9 @@ import pytest
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from clean_wolne_lektury import (DATA, DROP_AT, ELTEC, ELTEC_SHA256, PAIRS, REPORT_AT, build,
-                                 wl_title)
+                                 drop_unlicensed, relabel, wl_title)
+from sources import SOURCES
+from wolne_lektury_licences import LABELS, LICENCES, MANUAL, PUBLIC_DOMAIN, UNLICENSED
 
 # Hand-checked: only part of each is in its ELTeC novel, so they stay (see the findings entry).
 PARTIAL_IDS = {"wolne_lektury_2375475", "wolne_lektury_2375476", "wolne_lektury_2376242"}
@@ -28,7 +32,7 @@ def test_build_fails_closed_on_unpinned_inputs(tmp_path):
     fake = tmp_path / "wolne_lektury.parquet"
     pq.write_table(pa.table({"id": ["a"], "text": ["b"]}), fake)
     with pytest.raises(SystemExit, match="pinned SHA-256"):
-        build(fake, ELTEC, tmp_path)
+        build(fake, ELTEC, DATA / LICENCES, tmp_path)
     assert sorted(p.name for p in tmp_path.iterdir()) == ["wolne_lektury.parquet"]
 
 
@@ -41,24 +45,74 @@ def test_release_has_no_eltec_duplicates_and_matches_stats():
     dropped = {p["wl_id"] for p in pairs if p["action"] == "drop"}
     partial = {p["wl_id"] for p in pairs if p["action"] == "keep_partial"}
 
-    assert table.num_rows == len(ids) == stats["kept"] == 6_078
+    assert table.num_rows == len(ids) == stats["kept"] == 6_076
     assert len(dropped) == stats["drop_eltec_dup"] == 63
+    assert len(UNLICENSED) == stats["drop_rights"] == 2 and not UNLICENSED & ids
     assert partial == PARTIAL_IDS
     assert not dropped & ids and partial <= ids
     assert all(float(p["score"]) >= DROP_AT for p in pairs if p["action"] == "drop")
     assert all(REPORT_AT <= float(p["score"]) < DROP_AT for p in pairs if p["action"] == "keep_partial")
     assert all(p["eltec_id"].startswith("eltec_pol_") for p in pairs)
-    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_eltec_dup")
+    drops = ("drop_short", "drop_lang", "drop_dup", "drop_ocr", "drop_eltec_dup", "drop_rights")
     assert stats["read"] - sum(stats[k] for k in drops) == stats["kept"]
     assert pc.sum(table.column("token_count")).as_py() == stats["tokens"]
     assert pc.sum(pc.utf8_length(table.column("text"))).as_py() == stats["chars"]
-    assert stats["licenses"] == {"CC-BY-SA-4.0 / Wolna Sztuka 1.3": stats["kept"]}  # #57 relabels later
     with ELTEC.open("rb") as stream:  # eltec_pol is kept whole
         assert hashlib.file_digest(stream, "sha256").hexdigest() == ELTEC_SHA256
 
 
+def _licences():
+    with (DATA / LICENCES).open(encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle, delimiter="\t"))
+
+
+def test_every_row_carries_its_own_wolne_lektury_licence():
+    stats = json.loads((DATA / "wolne_lektury.stats.json").read_text(encoding="utf-8"))
+    table = pq.read_table(DATA / "wolne_lektury.parquet", columns=["id", "license"])
+    records = _licences()
+    by_id = {r["id"]: r for r in records}
+    assert len(by_id) == len(records) == table.num_rows
+    assert dict(zip(table.column("id").to_pylist(), table.column("license").to_pylist())) == {
+        i: r["license"] for i, r in by_id.items()}
+    assert stats["licenses"] == dict(sorted(Counter(r["license"] for r in records).items()))
+    assert set(stats["licenses"]) <= set(LABELS)
+    assert all(r["slug"] and r["wl_rights"] for r in records)
+    assert {r["id"] for r in records if r["match"] == "manual"} == set(MANUAL)
+    assert {r["match"] for r in records} == {"exact", "fuzzy", "manual"}
+    assert stats["license"] == SOURCES["wolne_lektury"]["license"]
+    assert SOURCES["wolne_lektury"]["license_spdx"] == "MIXED"
+    # #57: a Proust tome is public domain in its own WL metadata; its parent is CC BY-SA 3.0 PL.
+    tome = by_id["wolne_lektury_2371693"]
+    assert tome["license"] == PUBLIC_DOMAIN and "Boy-Żeleński" in tome["wl_rights"]
+
+
+def test_drop_unlicensed_fails_closed():
+    rows = pa.table({"id": ["a", *sorted(UNLICENSED)]})
+    assert drop_unlicensed(rows).column("id").to_pylist() == ["a"]
+    with pytest.raises(SystemExit, match="UNLICENSED"):
+        drop_unlicensed(rows.slice(0, 2))  # one UNLICENSED id is missing
+
+
+def test_relabel_fails_closed(tmp_path):
+    table = pa.table({"id": ["a", "b"], "license": ["old", "old"]})
+    tsv = tmp_path / LICENCES
+    for body in ("id\tlicense\na\tpublic-domain\n",  # b missing
+                 "id\tlicense\na\tpublic-domain\nb\tpublic-domain\nc\tpublic-domain\n",  # c extra
+                 "id\tlicense\na\tpublic-domain\na\tLAL-1.3\nb\tLAL-1.3\n",  # a twice
+                 "id\tlicense\na\tpublic-domain\nb\tCC-BY-4.0\n"):  # not a WL label
+        tsv.write_text(body, encoding="utf-8")
+        with pytest.raises(SystemExit):
+            relabel(table, tsv)
+    tsv.write_text("id\tlicense\nb\tLAL-1.3\na\tpublic-domain\n", encoding="utf-8")
+    assert relabel(table, tsv).column("license").to_pylist() == ["public-domain", "LAL-1.3"]
+
+
 def test_datasheet_counts_match_stats():
     stats = json.loads((DATA / "wolne_lektury.stats.json").read_text(encoding="utf-8"))
     card = (DATA / "wolne_lektury.md").read_text(encoding="utf-8")
     assert f"| {stats['kept']:,} | {stats['chars']:,} | {stats['tokens']:,} |" in card
     assert f"{stats['drop_eltec_dup']} " in card and "eltec_pol" in card
+    assert f"{stats['drop_rights']} documents" in card and "Kozioł" in card
+    assert f"; {len(MANUAL)} were matched by hand" in card
+    for label, count in stats["licenses"].items():
+        assert f"| `{label}` | {count:,} |" in card

src/test_wolne_lektury_licences.py

@@ -0,0 +1,184 @@
+"""Unit checks for the per-row Wolne Lektury licence match (src/wolne_lektury_licences.py, v2#57)."""
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import wolne_lektury_licences
+from wolne_lektury_licences import (CC_BY_SA_3, CC_BY_SA_3_PL, CC_BY_SA_4, FUZZY_CHARS, FUZZY_SLACK, LAL,
+                                    MANUAL, PUBLIC_DOMAIN, _fetch_book, _shares, classify, dc, label_rows,
+                                    match)
+
+LAL_URL = "http://artlibre.org/licence/lal/pl/"
+BY_SA_3 = "http://creativecommons.org/licenses/by-sa/3.0/"
+
+
+@pytest.mark.parametrize("rights, urls, label", [
+    # dc:rights / dc:rights.license pairs as Wolne Lektury writes them
+    ("Domena publiczna - Jan Kochanowski zm. 1584", [], PUBLIC_DOMAIN),
+    ("Domena publiczna - Tadeusz Boy-Żeleński zm. 1941", ["Domena publiczna"], PUBLIC_DOMAIN),
+    ("Domena publiczna --- Zygmunt Krasiński zm. 1859", [], PUBLIC_DOMAIN),
+    ("Domena publiczna - XVIII w.", [], PUBLIC_DOMAIN),
+    ("domena publiczna", [], PUBLIC_DOMAIN),
+    ("Anatol France zm. 1924", [], PUBLIC_DOMAIN),
+    ("Domena publiczna - Wacław Sieroszewski zm.1945", [], PUBLIC_DOMAIN),
+    ("Domena publiczna - tłumacz nieznany, wydanie z roku 1927", [], PUBLIC_DOMAIN),
+    ("Licencja Wolnej Sztuki 1.3", [LAL_URL], LAL),
+    ("Licencja Wolnej Sztuki 1.3.", ["https://artlibre.org/licence/lal/pl"], LAL),
+    ("Creative Commons Uznanie Autorstwa - Na Tych Samych Warunkach 3.0.PL", [BY_SA_3], CC_BY_SA_3_PL),
+    ("Creative Commons Uznanie Autorstwa - Na Tych Samych Warunkach 3.0. PL", [BY_SA_3], CC_BY_SA_3_PL),
+    ("Creative Commons Uznanie Autorstwa - Na Tych Samych Warunkach 3.0 Unported", [BY_SA_3], CC_BY_SA_3),
+    ("Licencja Creative Commons Uznanie autorstwa - Na tych samych warunkach 4.0",
+     ["https://creativecommons.org/licenses/by-sa/4.0/deed.pl"], CC_BY_SA_4),
+    # fail closed: in copyright by WL's own death year, no version, two licences, nothing
+    ("Domena publiczna - Jan Kowalski zm. 1960", [], None),
+    ("Domena publiczna - Jan Kowalski zm.1960", [], None),
+    ("Domena publiczna - Jan Kowalski zm. w 1960", [], None),
+    ("Domena publiczna - Jan Kowalski (1960)", [], None),
+    ("Domena publiczna - Maria Pawlikowska-Jasnorzewska zm. 2015", [], None),  # WL's typo for 1945
+    ("CC BY-SA", [], None),
+    ("Creative Commons Uznanie Autorstwa - Na Tych Samych Warunkach", [], None),
+    ("Domena publiczna - Marceli Motty zm. 1898; CC BY-SA - Paweł Kozioł", [], None),
+    ("Domena publiczna - Adam Asnyk zm. 1897", [LAL_URL], None),
+    ("Licencja Wolnej Sztuki 1.3", [BY_SA_3], None),
+    ("", [], None),
+])
+def test_classify(rights, urls, label):
+    assert classify(rights, urls) == label
+
+
+def test_dc_reads_every_value_with_any_attribute_order():
+    header = ('<dc:rights xml:lang="pl" xmlns:dc="x">Licencja Wolnej\n  Sztuki 1.3</dc:rights>'
+              '<dc:rights.license xmlns:dc="x" xml:lang="pl">' + LAL_URL + '</dc:rights.license>')
+    assert dc(header, "rights") == ["Licencja Wolnej Sztuki 1.3"]
+    assert dc(header, "rights.license") == [LAL_URL]
+
+
+FOOTER = "\n\n-----\nTa lektura, podobnie jak tysiące innych, jest dostępna w wolnelektury.pl.\n"
+PART = "Adam Mickiewicz\n\nTo lubię\n\nSpojrzyj, Marylo, gdzie się kończą gaje"
+COLLECTION = PART + "\n\nŚwiteź\n\nKto ty jesteś, młody panie"
+
+
+def test_a_part_does_not_match_the_collection_that_starts_with_it():
+    books = {"to-lubie": PART + FOOTER, "ballady": COLLECTION + FOOTER}
+    rows = [{"id": "part", "text": PART}, {"id": "whole", "text": COLLECTION}]
+    assert match(rows, books, books, {}) == {"part": ("exact", ["to-lubie"]), "whole": ("exact", ["ballady"])}
+
+
+def test_an_exact_match_to_a_collection_and_its_identical_part_keeps_the_part():
+    books = {"ballady": PART + FOOTER, "to-lubie": PART + FOOTER, "inne": PART + FOOTER}
+    assert match([{"id": "r", "text": PART}], books, books, {"ballady": {"to-lubie"}}) == {
+        "r": ("exact", ["inne", "to-lubie"])}
+
+
+def test_match_ignores_whitespace_and_needs_both_ends():
+    body = "Autor\r\n\r\nTytuł\r\n\r\n" + " ".join(f"słowo{i}" for i in range(400))
+    heads = {"same": body + FOOTER, "edited": body.replace("słowo399", "słowo-399") + FOOTER}
+    row = {"id": "r", "text": " \n".join(body.split())}
+    assert match([row], {slug: text[:3000] for slug, text in heads.items()}, heads, {}) == {
+        "r": ("exact", ["same"])}
+
+
+def _words(start, stop):
+    return " ".join(f"wyraz{i}" for i in range(start, stop))
+
+
+def test_fuzzy_match_places_a_text_edited_at_both_ends():
+    book = "Autor\n\nTytuł\n\n" + _words(0, 800)
+    row = book.replace("wyraz3 ", "wyraz-3 ").replace("wyraz797", "wyraz797,") + " Koniec"
+    books = {"book": book + FOOTER, "other": "Autor\n\nInny\n\n" + _words(5000, 5800) + FOOTER}
+    assert match([{"id": "r", "text": row}], books, books, {}) == {"r": ("fuzzy", ["book"])}
+
+
+def test_fuzzy_match_prefers_the_part_and_never_takes_a_collection_that_only_starts_with_it():
+    part = "Autor\n\nCzęść\n\n" + _words(0, 400)
+    row = part.replace("wyraz2 ", "wyraz-2 ") + " Koniec"
+    one_part = "Zbiór\n\n" + part  # a collection of one part: both ends qualify
+    longer = part + " " + _words(1000, 1000 + FUZZY_CHARS + FUZZY_SLACK)  # only its head qualifies
+    books = {"part": part + FOOTER, "one-part": one_part + FOOTER, "longer": longer + FOOTER}
+    parts = {"one-part": {"part"}, "longer": {"part", "rest"}}
+    assert match([{"id": "r", "text": row}], books, books, parts) == {"r": ("fuzzy", ["part"])}
+    del books["part"]  # with the part gone, the one-part collection is the text's own book
+    assert match([{"id": "r", "text": row}], books, books, parts) == {"r": ("fuzzy", ["one-part"])}
+    del books["one-part"]
+    assert match([{"id": "r", "text": row}], books, books, parts) == {"r": ("fuzzy", [])}
+
+
+def test_shares_of_a_text_under_k_words_is_empty():
+    assert _shares("trzy krótkie słowa", {}) == {}
+
+
+def _cache(tmp_path, books):
+    for part in ("hdr", "head", "tail"):
+        (tmp_path / part).mkdir()
+    for slug, (text, rights) in books.items():
+        (tmp_path / "head" / f"{slug}.txt").write_text(text + FOOTER, encoding="utf-8")
+        (tmp_path / "tail" / f"{slug}.txt").write_text(text + FOOTER, encoding="utf-8")
+        (tmp_path / "hdr" / f"{slug}.rdf").write_text(f"<dc:rights>{rights}</dc:rights>", encoding="utf-8")
+    return tmp_path
+
+
+def test_label_rows_takes_each_texts_own_licence(tmp_path):
+    cache = _cache(tmp_path, {"to-lubie": (PART, "Domena publiczna - Adam Mickiewicz zm. 1855"),
+                              "ballady": (COLLECTION, "Licencja Wolnej Sztuki 1.3")})
+    out, problems = label_rows([{"id": "r1", "text": PART}, {"id": "r2", "text": COLLECTION}], cache)
+    assert problems == []
+    assert [(r["id"], r["slug"], r["license"]) for r in out] == [("r1", "to-lubie", PUBLIC_DOMAIN),
+                                                                  ("r2", "ballady", LAL)]
+
+
+def test_label_rows_fails_closed(tmp_path):
+    cache = _cache(tmp_path, {"a": (PART, "Licencja Wolnej Sztuki 1.3"), "b": (PART, "Domena publiczna"),
+                              "c": (COLLECTION, "CC BY-SA")})
+    rows = [{"id": "twins", "text": PART}, {"id": "unversioned", "text": COLLECTION},
+            {"id": "missing", "text": "Nieznany tekst"}]
+    out, problems = label_rows(rows, cache)
+    assert out == []
+    assert [line.split(":")[0] for line in problems] == ["twins", "unversioned", "missing"]
+
+
+def test_identical_texts_with_one_licence_keep_both_slugs(tmp_path):
+    cache = _cache(tmp_path, {"a": (PART, "Domena publiczna"), "b": (PART, "Domena publiczna - XIX w.")})
+    out, problems = label_rows([{"id": "r", "text": PART}], cache)
+    assert problems == [] and out[0]["slug"] == "a b" and out[0]["license"] == PUBLIC_DOMAIN
+
+
+def test_manual_rows_take_the_named_books_licence_and_stale_entries_fail(tmp_path, monkeypatch):
+    cache = _cache(tmp_path, {"to-lubie": (PART, "Domena publiczna - Adam Mickiewicz zm. 1855"),
+                              "cykl": ("", "Licencja Wolnej Sztuki 1.3")})
+    (cache / "head" / "cykl.txt").unlink()  # a collection: header, no txt
+    (cache / "tail" / "cykl.txt").unlink()
+    monkeypatch.setitem(MANUAL, "merged", "cykl")
+    monkeypatch.setitem(MANUAL, "stale", "cykl")
+    rows = [{"id": "merged", "text": "Tekst, którego nic nie zawiera"}, {"id": "stale", "text": PART}]
+    out, problems = label_rows(rows, cache)
+    assert [(r["id"], r["slug"], r["match"], r["license"]) for r in out] == [("merged", "cykl", "manual", LAL)]
+    assert problems == ["stale: in MANUAL but matches ['to-lubie']"]
+
+
+def test_unlicensed_rows_are_left_out_until_they_label_cleanly(tmp_path, monkeypatch):
+    cache = _cache(tmp_path, {"to-lubie": (PART, "Domena publiczna - Adam Mickiewicz zm. 1855"),
+                              "ballady": (COLLECTION, "CC BY-SA")})
+    monkeypatch.setattr(wolne_lektury_licences, "UNLICENSED", {"unversioned", "now-clean"})
+    rows = [{"id": "unversioned", "text": COLLECTION}, {"id": "now-clean", "text": PART}]
+    out, problems = label_rows(rows, cache)
+    assert out == []
+    assert problems == ["now-clean: in UNLICENSED but labels as {'public-domain'}"]
+
+
+def test_fetch_takes_media_urls_from_the_api_entry(tmp_path, monkeypatch):
+    for part in ("hdr", "head", "tail"):
+        (tmp_path / part).mkdir()
+    api = wolne_lektury_licences.API
+    bodies = {f"{api}slug/": json.dumps({"xml": "https://x/media/other.xml", "txt": "https://x/media/other.txt"}),
+              "https://x/media/other.xml": "<rdf:RDF><dc:rights>Domena publiczna</dc:rights></rdf:RDF><utwor>",
+              "https://x/media/other.txt": "Autor\n\nTytuł"}
+    monkeypatch.setattr(wolne_lektury_licences, "_get", lambda url, byte_range=None: bodies[url].encode())
+    monkeypatch.setattr(wolne_lektury_licences.time, "sleep", lambda seconds: None)
+    _fetch_book(tmp_path, "slug")
+    assert (tmp_path / "hdr" / "slug.rdf").read_text() == "<rdf:RDF><dc:rights>Domena publiczna</dc:rights></rdf:RDF>"
+    assert (tmp_path / "head" / "slug.txt").read_text() == (tmp_path / "tail" / "slug.txt").read_text() == "Autor\n\nTytuł"

src/wolne_lektury_licences.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""Per-row licence for wolne_lektury from each text's own Wolne Lektury metadata (polish-dynaword-v2#57).
+
+Through v0.2.5 every row was labelled `CC-BY-SA-4.0 / Wolna Sztuka 1.3`. Wolne Lektury licenses each
+text separately: most are public domain, the rest are under the Free Art Licence 1.3 (Licencja Wolnej
+Sztuki) or CC BY-SA 3.0 / 4.0. The licence is in the `dc:rights` / `dc:rights.license` fields of the
+book's XML header, which this script reads for every book in the catalogue (/api/books/).
+
+A row is matched to its book by text, not by title: titles repeat (untitled poems "***", tomes of one
+novel). The shard text is Wolne Lektury's txt export without its footer, so a row matches a book
+exactly when the book's txt starts with the row's first HEAD_CHARS characters and, footer cut, ends
+with its last TAIL_CHARS characters (whitespace collapsed). Wolne Lektury has edited some texts since
+the scrape (spelling, brackets, a changed opening line); a row with no exact match matches a book
+whose head and ending each hold FUZZY_MIN of the word shingles of the row's own opening and ending.
+Both ends matter: a collection's txt starts like its first part, and a part must not take the
+collection's licence (Boy-Żeleński's Proust tomes are public domain under a CC BY-SA 3.0 parent; see
+the #57 thread), so a collection drops out when one of its parts also matches. The few rows neither
+rule places are in MANUAL, each checked by hand.
+
+Downloads (HTTP Range: the RDF header of each XML, the first and last bytes of each txt) go to --cache
+and are reused. Output: data/wolne_lektury/wolne_lektury.licences.tsv, read by clean_wolne_lektury.py.
+  python3 src/wolne_lektury_licences.py --cache ~/speakleash/wolne_lektury_meta
+"""
+from __future__ import annotations
+
+import argparse
+import concurrent.futures as cf
+import csv
+import json
+import re
+import time
+import urllib.error
+import urllib.request
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+from shingle_containment import shingles, strip_wl_footer
+
+SOURCE = "wolne_lektury"
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+LICENCES = f"{SOURCE}.licences.tsv"
+FIELDS = ["id", "slug", "match", "license", "wl_rights", "wl_license_url"]
+API = "https://wolnelektury.pl/api/books/"
+UA = "polish-dynaword-rights-audit/1.0 (+https://huggingface.co/datasets/SlayerLab/polish-dynaword)"
+HEAD_BYTES, TAIL_BYTES = 3072, 16384  # the tail holds the text's end and the footer (< 3,000 chars)
+HEAD_CHARS, TAIL_CHARS = 600, 300
+INDEX_CHARS = 120
+# Fuzzy match: the row's first and last FUZZY_CHARS characters against the book's head and its last
+# FUZZY_CHARS + FUZZY_SLACK characters. On the v0.2.5 shard the 332 rows placed this way score 0.66 or
+# more at both ends against their own book, and no other book scores above 0.04.
+FUZZY_CHARS, FUZZY_SLACK, FUZZY_MIN = 1500, 500, 0.6
+# Polish copyright runs 70 years from the end of the author's (or translator's) death year.
+PD_DEATH_BY = 1955
+
+PUBLIC_DOMAIN = "public-domain"
+LAL = "LAL-1.3"
+CC_BY_SA_3_PL = "CC-BY-SA-3.0-PL"
+CC_BY_SA_3 = "CC-BY-SA-3.0"
+CC_BY_SA_4 = "CC-BY-SA-4.0"
+LABELS = (PUBLIC_DOMAIN, LAL, CC_BY_SA_3_PL, CC_BY_SA_3, CC_BY_SA_4)
+
+# Rows whose book Wolne Lektury has merged or reworked past what `match` accepts (their own book scores
+# 0.29-0.54, or they are parts of a merged book), each checked by hand against the current text. The
+# licence still comes from the named book's own header.
+MANUAL = {
+    # the prologue and the ten days of the Decameron, now one book (Edward Boyé's translation)
+    **{f"wolne_lektury_{n}": "boccaccio-dekameron" for n in range(2373120, 2373131)},
+    # the whole cycle, which has no txt export; each of its 11 poems is ~90% contained in the row
+    "wolne_lektury_2371820": "lesmian-w-malinowym-chrusniaku-cykl",
+    "wolne_lektury_2372184": "aleksander-dumas-trzej-muszkieterowie-tom-2",  # spelling, both ends
+    "wolne_lektury_2372202": "antoniewicz-gdzie-bluszcz-po-zimnym-grobie-sie-wije",  # spelling modernised
+    "wolne_lektury_2372206": "antoniewicz-lecz-jakze-prozne-sa-wszystkie-nadzieje",  # spelling modernised
+    "wolne_lektury_2372684": "bielany",  # Antoniewicz, spelling modernised
+    "wolne_lektury_2372321": "baczynski-1942-1943-1944-motto-i-dedykacja",  # dedication now a footnote
+}
+
+# Rows whose Wolne Lektury metadata gives no usable licence. The maintainer chose (2026-10-07) to drop them
+# rather than take a label from their collection; src/clean_wolne_lektury.py does. A row here that comes to
+# label cleanly fails the run, so the drop is reviewed again.
+UNLICENSED = {
+    # Horace, tr. Paweł Kozioł: "Domena publiczna - Marceli Motty zm. 1898; CC BY-SA - Paweł Kozioł"
+    "wolne_lektury_2373187",  # do-manliusa-torkwata
+    # Horace, tr. Paweł Kozioł: "CC BY-SA" with no version or URL; its WL footer says public domain
+    "wolne_lektury_2373208",  # do-taliarcha
+}
+
+
+def normalise(text: str) -> str:
+    return " ".join(text.lstrip("").split())
+
+
+def dc(header: str, name: str) -> list[str]:
+    """Values of one Dublin Core element, whitespace collapsed."""
+    pattern = rf"<dc:{re.escape(name)}\b[^>]*>(.*?)</dc:{re.escape(name)}>"
+    return [" ".join(value.split()) for value in re.findall(pattern, header, re.S)]
+
+
+def classify(rights: str, urls: list[str]) -> str | None:
+    """The row label for a book's dc:rights and dc:rights.license values; None when they do not fit
+    exactly one licence (then the row needs a hand check)."""
+    text = " ".join([rights, *urls]).casefold()
+    found = set()
+    if "artlibre.org/licence/lal" in text or "wolnej sztuki 1.3" in text:
+        found.add(LAL)
+    if "by-sa/4.0" in text or "na tych samych warunkach 4.0" in text:
+        found.add(CC_BY_SA_4)
+    if "by-sa/3.0" in text or "na tych samych warunkach 3.0" in text:
+        found.add(CC_BY_SA_3_PL if re.search(r"3\.0[ .]*pl\b|/3\.0/pl", text) else CC_BY_SA_3)
+    if ("cc by" in text or "creative commons" in text) and not found - {LAL}:
+        return None  # a Creative Commons licence without a version
+    if text.startswith("domena publiczna") or re.search(r"\bzm\.", text):
+        # any later year (a death "zm.1960", "zm. w 1960", "(1960)", an edition) needs a hand check
+        if any(int(year) > PD_DEATH_BY for year in re.findall(r"\b\d{4}\b", text)):
+            return None
+        found.add(PUBLIC_DOMAIN)
+    return found.pop() if len(found) == 1 else None
+
+
+def _get(url: str, byte_range: str | None = None) -> bytes | None:
+    """`url`'s body, or the part named by an HTTP byte range such as "0-99" or "-100"; None on 404."""
+    headers = {"User-Agent": UA} | ({"Range": f"bytes={byte_range}"} if byte_range else {})
+    request = urllib.request.Request(url, headers=headers)
+    for attempt in range(4):
+        try:
+            with urllib.request.urlopen(request, timeout=60) as response:
+                return response.read()
+        except urllib.error.HTTPError as error:
+            if error.code == 404:
+                return None
+            failure = error
+        except OSError as error:
+            failure = error
+        time.sleep(5 * (attempt + 1))
+    raise SystemExit(f"{url}: {failure!r}")
+
+
+def _fetch_book(cache: Path, slug: str) -> None:
+    rdf = cache / "hdr" / f"{slug}.rdf"
+    txts = [(cache / part / f"{slug}.txt", byte_range)
+            for part, byte_range in (("head", f"0-{HEAD_BYTES - 1}"), ("tail", f"-{TAIL_BYTES}"))]
+    if rdf.exists() and all(path.exists() for path, _ in txts):
+        return
+    # The media files are usually named after the slug, but not always (Korczak's "Dziecko w rodzinie"
+    # is dziecko-w-rodzinie.xml), so take their URLs from the book's API entry.
+    book = json.loads(_get(f"{API}{slug}/") or b"{}")
+    if not rdf.exists() and book.get("xml"):
+        header = (_get(book["xml"], "0-131071") or b"").decode("utf-8", "ignore")
+        if "</rdf:RDF>" in header:
+            rdf.write_text(header[: header.index("</rdf:RDF>") + len("</rdf:RDF>")], encoding="utf-8")
+    for path, byte_range in txts:
+        if not path.exists() and book.get("txt"):  # collections have no txt export
+            data = _get(book["txt"], byte_range)
+            if data is not None:
+                path.write_text(data.decode("utf-8", "ignore"), encoding="utf-8")
+    time.sleep(0.15)
+
+
+def fetch(cache: Path, workers: int) -> None:
+    """Download the catalogue and each book's header and txt head and tail into `cache`."""
+    for part in ("hdr", "head", "tail"):
+        (cache / part).mkdir(parents=True, exist_ok=True)
+    catalogue = cache / "books.json"
+    if not catalogue.exists():
+        catalogue.write_bytes(_get(API))
+    slugs = [book["slug"] for book in json.loads(catalogue.read_text(encoding="utf-8"))]
+    with cf.ThreadPoolExecutor(workers) as pool:
+        list(pool.map(lambda slug: _fetch_book(cache, slug), slugs))
+
+
+def _shingle_index(texts: dict[str, str]) -> dict[int, list[str]]:
+    index = defaultdict(list)
+    for slug, text in texts.items():
+        for shingle in shingles(text).tolist():
+            index[shingle].append(slug)
+    return index
+
+
+def _shares(text: str, index: dict[int, list[str]]) -> dict[str, float]:
+    """Slug -> share of the text's word shingles found in that book's indexed text."""
+    own = shingles(text).tolist()
+    if not own:  # under K words
+        return {}
+    counts = Counter(slug for shingle in own for slug in index.get(shingle, ()))
+    return {slug: count / len(own) for slug, count in counts.items()}
+
+
+def _without_collections(hits: list[str], parts: dict[str, set[str]]) -> list[str]:
+    """`hits` less any collection one of whose parts is also a hit: the part's licence is the text's."""
+    return [slug for slug in hits if not parts.get(slug, set()) & set(hits)]
+
+
+def match(rows: list[dict], heads: dict[str, str], tails: dict[str, str],
+          parts: dict[str, set[str]]) -> dict[str, tuple[str, list[str]]]:
+    """Row id -> ("exact" or "fuzzy", slugs). `heads` and `tails` are the cached txt heads and tails,
+    `parts` maps a collection's slug to its parts' slugs. Rows that match nothing get ("fuzzy", [])."""
+    heads = {slug: normalise(text) for slug, text in heads.items() if slug in tails}
+    tails = {slug: normalise(strip_wl_footer(text)) for slug, text in tails.items()}
+    index = defaultdict(list)
+    for slug, head in heads.items():
+        index[head[:INDEX_CHARS]].append(slug)
+    found, rest = {}, []
+    for row in rows:
+        text = normalise(row["text"])
+        head, tail = text[:HEAD_CHARS], text[-TAIL_CHARS:]
+        candidates = index.get(head[:INDEX_CHARS], ()) if len(head) >= INDEX_CHARS else heads
+        hits = sorted(slug for slug in candidates
+                      if heads[slug].startswith(head) and tails[slug].endswith(tail))
+        if hits:
+            found[row["id"]] = ("exact", _without_collections(hits, parts))
+        else:
+            rest.append((row["id"], text))
+    if rest:
+        head_index = _shingle_index(heads)
+        tail_index = _shingle_index({slug: tail[-(FUZZY_CHARS + FUZZY_SLACK):] for slug, tail in tails.items()})
+    for row_id, text in rest:
+        head = _shares(text[:FUZZY_CHARS], head_index)
+        tail = _shares(text[-FUZZY_CHARS:], tail_index)
+        hits = [slug for slug, share in head.items() if share >= FUZZY_MIN and tail.get(slug, 0) >= FUZZY_MIN]
+        found[row_id] = ("fuzzy", _without_collections(sorted(hits), parts))
+    return found
+
+
+def _read_dir(folder: Path, suffix: str = ".txt") -> dict[str, str]:
+    return {path.stem: path.read_text(encoding="utf-8") for path in sorted(folder.glob(f"*{suffix}"))}
+
+
+def label_rows(rows: list[dict], cache: Path) -> tuple[list[dict], list[str]]:
+    """One output record per row, and a line per row that needs a hand check."""
+    headers = _read_dir(cache / "hdr", ".rdf")
+    parts = {slug: {url.rstrip("/").rsplit("/", 1)[-1] for url in dc(header, "relation.hasPart")}
+             for slug, header in headers.items()}
+    matches = match(rows, _read_dir(cache / "head"), _read_dir(cache / "tail"), parts)
+    out, problems = [], []
+    for row in rows:
+        how, hits = matches[row["id"]]
+        if row["id"] in MANUAL:
+            if hits:  # the text matches again; the hand entry is stale
+                problems.append(f"{row['id']}: in MANUAL but matches {hits}")
+                continue
+            how, hits = "manual", [MANUAL[row["id"]]]
+        found = {}
+        for slug in hits:
+            header = headers.get(slug, "")
+            rights, urls = " | ".join(dc(header, "rights")), dc(header, "rights.license")
+            found[slug] = (classify(rights, urls), rights, " ".join(urls))
+        labels = {label for label, _, _ in found.values()}
+        unusable = not hits or None in labels or len(labels) > 1  # identical texts must agree on the licence
+        if row["id"] in UNLICENSED:
+            if not unusable:
+                problems.append(f"{row['id']}: in UNLICENSED but labels as {labels}")
+            continue
+        if unusable:
+            problems.append(f"{row['id']}: {found or 'no book'}")
+            continue
+        label, rights, urls = found[hits[0]]
+        out.append({"id": row["id"], "slug": " ".join(hits), "match": how, "license": label,
+                    "wl_rights": rights, "wl_license_url": urls})
+    return out, problems
+
+
+def build(input_path: Path, cache: Path, out_dir: Path) -> Counter:
+    rows = pq.read_table(input_path, columns=["id", "text"]).to_pylist()
+    out, problems = label_rows(rows, cache)
+    if problems:
+        raise SystemExit(f"{len(problems)} rows need a hand check:\n" + "\n".join(problems))
+    with (out_dir / LICENCES).open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, FIELDS, delimiter="\t", lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(out)
+    return Counter(row["license"] for row in out)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet")
+    parser.add_argument("--cache", type=Path, required=True)
+    parser.add_argument("--out", type=Path, default=DATA)
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--offline", action="store_true", help="use the cache as is; download nothing")
+    args = parser.parse_args()
+    cache = args.cache.expanduser()
+    if not args.offline:
+        fetch(cache, args.workers)
+    print(json.dumps(build(args.input, cache, args.out), indent=2))
+
+
+if __name__ == "__main__":
+    main()