build_dynaword: preserve_id / preserve_created flags (split from #19)

.gitignore

@@ -5,3 +5,17 @@ data/european_hplt_pl_500m/
 data/european_hplt_pl_chunk_test*/
 data/european_hplt_pl_file_test/
 data/european_hplt_pl_parallel_500m*/
+__pycache__/
+*.pyc
+# Build inputs and scratch for the studia_bas source: the issue PDF cache, the
+# .jsonl.zst intermediate build_dynaword.py consumes, and one-off probe output.
+studia_bas_pdfs/
+artifacts/studia_bas*.jsonl
+artifacts/studia_bas*.jsonl.zst
+artifacts/studia_bas_download_test/
+artifacts/author_probe.txt
+artifacts/author_new.txt
+artifacts/probe_all.jsonl.zst
+artifacts/download_all.log
+artifacts/studia_bas_pii_audit.md
+artifacts/studia_bas_builder_review.md

src/build_dynaword.py

@@ -16,7 +16,7 @@ Usage:
   python3 src/build_dynaword.py --sources gutenberg --jobs 16
 """
 from __future__ import annotations
-import argparse, hashlib, json, os, re, subprocess, sys, time
+import argparse, hashlib, io, json, os, re, shutil, subprocess, sys, time
 from itertools import islice
 import multiprocessing as mp
 from pathlib import Path
@@ -70,7 +70,7 @@ def _meta_value(row: dict, keys: tuple[str, ...], default: str = "") -> str:
 
 def _process_chunk(args):
     """Worker: gate + tokenize a batch of raw lines. Returns (records, stats)."""
-    is_ocr, created, default_license, lines = args
+    is_ocr, created, default_license, preserve_created, lines = args
     kept, texts = [], []
     st = [0, 0, 0, 0]  # read, short, lang, ocr
     metas = []
@@ -91,12 +91,18 @@ def _process_chunk(args):
                 st[3] += 1; continue
         texts.append(text)
         metas.append((
+            _meta_value(row, ("created", "date", "published", "publication_date"), created)
+            if preserve_created else created,
             _meta_value(row, ("license", "licence", "rights", "edm:rights"), default_license),
             _meta_value(row, ("author", "authors", "creator", "creators")),
+            _meta_value(row, ("id", "record_id")),
         ))
     toks = [len(t) for t in _ENC.encode_ordinary_batch(texts, num_threads=1)] if texts else []
-    for t, (license_value, author), tk in zip(texts, metas, toks):
-        kept.append((t, created, tk, license_value, author, hashlib.sha1(t.encode("utf-8")).digest()))
+    for t, (created_value, license_value, author, record_id), tk in zip(texts, metas, toks):
+        kept.append((
+            t, created_value, tk, license_value, author,
+            hashlib.sha1(t.encode("utf-8")).digest(), record_id,
+        ))
     return kept, st
 
 
@@ -118,6 +124,9 @@ def build_source(name, cfg, sl_dir, out_root, pool, seen, counter):
           "licenses": {}, "authors_with_value": 0}
     t0 = time.time()
     is_ocr, created = bool(cfg.get("is_ocr")), cfg.get("created", "")
+    preserve_id = bool(cfg.get("preserve_id"))
+    preserve_created = bool(cfg.get("preserve_created"))
+    used_ids = set()
     default_license = cfg.get("license", "")
     bid, btext, bcre, btok, blic, baut = [], [], [], [], [], []
 
@@ -132,18 +141,40 @@ def build_source(name, cfg, sl_dir, out_root, pool, seen, counter):
         ], schema=SCHEMA))
         bid.clear(); btext.clear(); bcre.clear(); btok.clear(); blic.clear(); baut.clear()
 
-    proc = subprocess.Popen(["zstd", "-dc", str(src_path)],
-                            stdout=subprocess.PIPE, bufsize=1 << 22)
-    line_iter = (ln for ln in proc.stdout if ln.strip())
-    arg_iter = ((is_ocr, created, default_license, ch) for ch in _chunks(line_iter, 2000))
+    proc = None
+    stream = None
+    compressed = None
+    executable = shutil.which("zstd")
+    if executable:
+        proc = subprocess.Popen([executable, "-dc", str(src_path)],
+                                stdout=subprocess.PIPE, bufsize=1 << 22)
+        stream = proc.stdout
+    else:
+        try:
+            import zstandard
+        except ImportError as exc:
+            raise RuntimeError(
+                "reading .zst requires zstd or Python zstandard: pip install zstandard"
+            ) from exc
+        compressed = src_path.open("rb")
+        stream = io.TextIOWrapper(
+            zstandard.ZstdDecompressor().stream_reader(compressed), encoding="utf-8"
+        )
+    line_iter = (ln for ln in stream if ln.strip())
+    arg_iter = ((is_ocr, created, default_license, preserve_created, ch)
+                for ch in _chunks(line_iter, 2000))
     for kept, cst in pool.imap_unordered(_process_chunk, arg_iter, chunksize=1):
         st["read"] += cst[0]; st["drop_short"] += cst[1]
         st["drop_lang"] += cst[2]; st["drop_ocr"] += cst[3]
-        for text, cre, tok, license_value, author, h in kept:
+        for text, cre, tok, license_value, author, h, record_id in kept:
             if h in seen:
                 st["drop_dup"] += 1; continue
             seen.add(h)
-            bid.append(f"{name}_{counter[0]}"); counter[0] += 1
+            output_id = record_id if preserve_id and record_id else f"{name}_{counter[0]}"
+            if output_id in used_ids:
+                raise ValueError(f"duplicate record id in {name}: {output_id}")
+            used_ids.add(output_id)
+            bid.append(output_id); counter[0] += 1
             btext.append(text); bcre.append(cre); btok.append(tok)
             blic.append(license_value); baut.append(author)
             st["chars"] += len(text); st["tokens"] += tok; st["kept"] += 1
@@ -152,7 +183,11 @@ def build_source(name, cfg, sl_dir, out_root, pool, seen, counter):
                 st["authors_with_value"] += 1
             if len(btext) >= 2000:
                 flush()
-    flush(); writer.close(); proc.stdout.close(); proc.wait()
+    flush(); writer.close(); stream.close()
+    if compressed is not None:
+        compressed.close()
+    if proc is not None:
+        proc.wait()
     st["secs"] = round(time.time() - t0, 1)
     print(f"  {name}: read {st['read']:,} kept {st['kept']:,} | -short {st['drop_short']:,} "
           f"-lang {st['drop_lang']:,} -dup {st['drop_dup']:,} -ocr {st['drop_ocr']:,} | "

src/test_build_dynaword_flags.py

@@ -0,0 +1,45 @@
+"""The per-source opt-in flags studia_bas introduced into the generic builder.
+
+These pin that a source without the flags is gated exactly as it was before the
+studia_bas contribution, which matters because several existing sources already
+emit a per-record ``date`` or ``created`` field into their intermediate JSONL.
+"""
+
+import json
+
+import pytest
+
+from build_dynaword import _init_worker, _process_chunk
+
+
+@pytest.fixture(autouse=True)
+def _encoder():
+    # _process_chunk normally runs in a pool worker, where the encoder is a global
+    # the initializer sets up.
+    _init_worker()
+
+
+def _chunk(rows, *, preserve_created, created="2026-07-19"):
+    lines = [json.dumps(row, ensure_ascii=False) for row in rows]
+    kept, _ = _process_chunk((False, created, "CC0", preserve_created, lines))
+    return kept
+
+
+TEXT = "Ustawa o finansach publicznych reguluje zasady gospodarki budżetowej. " * 40
+
+
+def test_record_date_is_ignored_unless_the_source_opts_in():
+    # sejm_api, govpl, njkp and europeana all carry a per-record date already, so
+    # reading it by default would silently rewrite their created column.
+    kept = _chunk([{"text": TEXT, "date": "2019-04-01"}], preserve_created=False)
+    assert [row[1] for row in kept] == ["2026-07-19"]
+
+
+def test_record_date_is_used_when_the_source_opts_in():
+    kept = _chunk([{"text": TEXT, "date": "2019-04-01"}], preserve_created=True)
+    assert [row[1] for row in kept] == ["2019-04-01"]
+
+
+def test_opting_in_still_falls_back_to_the_source_constant():
+    kept = _chunk([{"text": TEXT}], preserve_created=True)
+    assert [row[1] for row in kept] == ["2026-07-19"]