[WIP] Proposal: Dynaword bundle layout (data.parquet + metadata.parquet)

AGENTS.md

@@ -62,6 +62,32 @@ in five more shipped sources. Rules:
 8. Never write to rights holders, accept terms, create accounts or get past a
    CAPTCHA — hand those to the maintainer.
 
+## Bundle layout (proposed for the next version)
+
+The next version moves every source to the Danish Dynaword bundle layout. A source
+directory then holds:
+
+- `data.parquet` — `id, text, source, added, created, token_count` (`DATA_SCHEMA`
+  in `src/normalize_schema.py`); `created` is a date pair `YYYY-MM-DD, YYYY-MM-DD`,
+  with `0001-01-01` as an unknown lower bound.
+- `metadata.parquet` — `id, license, author, source_ref, attribution,
+  quality_warnings` (`METADATA_SCHEMA`), one row per row of `data.parquet`, same
+  order, joined by `id`. Per-record provenance lives here instead of
+  `<key>.attribution.jsonl`: `source_ref` is the record's URI, `attribution` the
+  remaining evidence as a JSON string.
+- `<key>.md` — the datasheet, with the Danish YAML header (`pretty_name`,
+  `language`, `license`, `domains`).
+- `<key>.stats.json`, `<key>.license-evidence.json` — unchanged.
+
+`src/migrate_to_bundle.py` converts a legacy `<key>.parquet` (+ attribution
+sidecar) without touching it; it refuses a `created` value it cannot read as a
+date, year or year range rather than guess. The Hub default config is one split, so
+legacy shards and bundles never ship side by side
+(`test_a_source_ships_one_layout_and_the_corpus_does_not_mix_them`): all sources
+move in the release that switches `configs` in the README to `data/*/data.parquet`
+(plus a `metadata` config over `data/*/metadata.parquet`). Until then, add sources
+in the current layout below.
+
 ## Add a source
 
 1. Produce the artifact under `data/<key>/`:

README.md

@@ -15,7 +15,11 @@ configs:
 - config_name: default
   data_files:
   - split: train
-    path: data/*/*.parquet
+    path: data/*/data.parquet
+- config_name: metadata
+  data_files:
+  - split: train
+    path: data/*/metadata.parquet
 ---
 
 # Polish DynaWord

src/migrate_to_bundle.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Convert one legacy source (`<key>.parquet` + optional `<key>.attribution.jsonl`) into the bundle layout.
+
+Writes `data.parquet` and `metadata.parquet` into `--out` and never touches the legacy files.
+Usage: python3 src/migrate_to_bundle.py data/<key> --out <dir>
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from normalize_schema import DATA_NAME, DATA_SCHEMA, METADATA_NAME, METADATA_SCHEMA, SCHEMA
+
+BATCH_ROWS = 50_000
+# the recipe's convention for an unknown lower bound; the upper bound falls back to the row's `added`
+UNKNOWN_START = "0001-01-01"
+_DAY = r"\d{4}-\d{2}-\d{2}"
+_PAIR = re.compile(rf"({_DAY}), ({_DAY})")
+_YEARS = re.compile(r"(\d{4})(?:\s*[-–]\s*(\d{4}))?")
+_URL_KEYS = ("url", "source_ref", "canonical_url", "source_url")
+_MOVED_KEYS = ("id", "license", "author", *_URL_KEYS)
+
+
+def created_range(value: str | None, added: str) -> str:
+    text = (value or "").strip()
+    if _PAIR.fullmatch(text):
+        return text
+    if re.fullmatch(_DAY, text):
+        return f"{text}, {text}"
+    years = _YEARS.fullmatch(text)
+    if years:
+        first, last = years.group(1), years.group(2) or years.group(1)
+        return f"{first}-01-01, {last}-12-31"
+    if text in ("", "unknown"):
+        return f"{UNKNOWN_START}, {added}"
+    raise ValueError(f"created value is not a date, year or range: {text!r}")
+
+
+def read_attribution(path: Path) -> dict[str, dict]:
+    if not path.is_file():
+        return {}
+    records = {}
+    with path.open(encoding="utf-8") as lines:
+        for line in lines:
+            if line.strip():
+                record = json.loads(line)
+                records[str(record["id"])] = record
+    return records
+
+
+def metadata_fields(record: dict | None) -> tuple[str, str]:
+    if not record:
+        return "", ""
+    source_ref = next((str(record[key]) for key in _URL_KEYS if record.get(key)), "")
+    rest = {key: value for key, value in record.items() if key not in _MOVED_KEYS}
+    return source_ref, json.dumps(rest, ensure_ascii=False, sort_keys=True) if rest else ""
+
+
+def migrate(source_dir: Path, out_dir: Path) -> int:
+    key = source_dir.name
+    shard = pq.ParquetFile(source_dir / f"{key}.parquet")
+    if shard.schema_arrow.names != SCHEMA.names:
+        raise ValueError(f"{key}: legacy shard does not have the canonical schema")
+    attribution = read_attribution(source_dir / f"{key}.attribution.jsonl")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    rows = 0
+    with pq.ParquetWriter(out_dir / DATA_NAME, DATA_SCHEMA) as data, pq.ParquetWriter(out_dir / METADATA_NAME, METADATA_SCHEMA) as meta:
+        for batch in shard.iter_batches(batch_size=BATCH_ROWS):
+            table = pa.Table.from_batches([batch])
+            ids = table["id"].to_pylist()
+            added = table["added"].to_pylist()
+            created = [created_range(value, day) for value, day in zip(table["created"].to_pylist(), added)]
+            data.write_table(table.select(DATA_SCHEMA.names).set_column(4, "created", pa.array(created, pa.string())).cast(DATA_SCHEMA))
+            refs, notes = zip(*(metadata_fields(attribution.get(doc_id)) for doc_id in ids)) if ids else ((), ())
+            meta.write_table(
+                pa.table(
+                    {
+                        "id": ids,
+                        "license": table["license"].to_pylist(),
+                        "author": table["author"].to_pylist(),
+                        "source_ref": list(refs),
+                        "attribution": list(notes),
+                        "quality_warnings": [""] * len(ids),
+                    },
+                    schema=METADATA_SCHEMA,
+                )
+            )
+            rows += len(ids)
+    return rows
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("source_dir", type=Path)
+    parser.add_argument("--out", type=Path, required=True)
+    args = parser.parse_args(argv)
+    print(f"{args.source_dir.name}: {migrate(args.source_dir, args.out)} rows -> {args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/normalize_schema.py

@@ -32,6 +32,25 @@ SCHEMA = pa.schema(
         ("author", pa.string()),
     ]
 )
+# The bundle layout (data/<key>/data.parquet + metadata.parquet), row-aligned and joined by `id`.
+DATA_SCHEMA = pa.schema([field for field in SCHEMA if field.name not in ("license", "author")])
+METADATA_SCHEMA = pa.schema(
+    [
+        ("id", pa.string()),
+        ("license", pa.string()),
+        ("author", pa.string()),
+        ("source_ref", pa.string()),
+        ("attribution", pa.string()),
+        ("quality_warnings", pa.string()),
+    ]
+)
+DATA_NAME = "data.parquet"
+METADATA_NAME = "metadata.parquet"
+
+
+def shard_path(source_dir: Path) -> Path:
+    bundle = source_dir / DATA_NAME
+    return bundle if bundle.is_file() else source_dir / f"{source_dir.name}.parquet"
 
 
 def add_missing_columns(tbl: pa.Table, source: str, default_license: str) -> pa.Table:

src/test_added_dates.py

@@ -12,6 +12,7 @@ import pytest
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 import build_dynaword  # noqa: E402
 import make_docs  # noqa: E402
+from normalize_schema import shard_path  # noqa: E402
 from sources import ADDED, SOURCES  # noqa: E402
 
 DATA = Path(__file__).resolve().parents[1] / "data"
@@ -22,7 +23,7 @@ STALE_SHARDS = {
     "wikipedia": "2026-07-19", "wikinews": "2026-07-19", "wikivoyage": "2026-07-19", "wikibooks": "2026-07-19",
     "sejm_interpellations": "2026-07-19",
 }
-SHARDS = sorted(key for key in SOURCES if (DATA / key / f"{key}.parquet").is_file())
+SHARDS = sorted(key for key in SOURCES if shard_path(DATA / key).is_file())
 CARDS = sorted(key for key in SOURCES if (DATA / key / f"{key}.md").is_file())
 STATS = sorted(key for key in SOURCES if (DATA / key / f"{key}.stats.json").is_file())
 
@@ -34,7 +35,7 @@ def test_v020_sources_carry_the_v020_date():
 
 @pytest.mark.parametrize("key", SHARDS)
 def test_shard_carries_the_registry_date(key):
-    dates = pc.unique(pq.read_table(DATA / key / f"{key}.parquet", columns=["added"])["added"]).to_pylist()
+    dates = pc.unique(pq.read_table(shard_path(DATA / key), columns=["added"])["added"]).to_pylist()
     assert dates == [STALE_SHARDS.get(key, SOURCES[key]["added"])]
 
 

src/test_migrate_to_bundle.py

@@ -0,0 +1,66 @@
+import json
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+
+from migrate_to_bundle import created_range, migrate
+from normalize_schema import DATA_NAME, DATA_SCHEMA, METADATA_NAME, METADATA_SCHEMA, SCHEMA
+
+
+def _legacy(tmp_path, rows, attribution=None):
+    source = tmp_path / "data" / "probe"
+    source.mkdir(parents=True)
+    pq.write_table(pa.Table.from_pylist(rows, schema=SCHEMA), source / "probe.parquet")
+    if attribution is not None:
+        (source / "probe.attribution.jsonl").write_text("".join(json.dumps(r) + "\n" for r in attribution), encoding="utf-8")
+    return source
+
+
+def _row(doc_id, created="2002-2026", license_="CC-BY-4.0", author="A"):
+    return {"id": doc_id, "text": "t " + doc_id, "source": "probe", "added": "2026-06-15", "created": created,
+            "token_count": 3, "license": license_, "author": author}
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ("2011-12-24, 2026-05-25", "2011-12-24, 2026-05-25"),
+        ("2002-2026", "2002-01-01, 2026-12-31"),
+        ("2019", "2019-01-01, 2019-12-31"),
+        ("2020-03-04", "2020-03-04, 2020-03-04"),
+        ("unknown", "0001-01-01, 2026-06-15"),
+        ("", "0001-01-01, 2026-06-15"),
+    ],
+)
+def test_created_becomes_a_date_pair(value, expected):
+    assert created_range(value, "2026-06-15") == expected
+
+
+def test_free_text_created_is_refused_not_guessed():
+    with pytest.raises(ValueError):
+        created_range("2018-2024 (book publication metadata proxy)", "2026-06-15")
+
+
+def test_a_legacy_source_becomes_a_row_aligned_bundle(tmp_path):
+    attribution = [{"id": "b", "url": "https://example.org/b", "license": "CC-BY-4.0", "text_sha256": "x"}]
+    source = _legacy(tmp_path, [_row("a"), _row("b", license_="CC0-1.0", author="")], attribution)
+    out = tmp_path / "bundle"
+
+    assert migrate(source, out) == 2
+
+    data, meta = pq.read_table(out / DATA_NAME), pq.read_table(out / METADATA_NAME)
+    assert data.schema == DATA_SCHEMA and meta.schema == METADATA_SCHEMA
+    assert data["id"].to_pylist() == meta["id"].to_pylist() == ["a", "b"]
+    assert data["created"].to_pylist() == ["2002-01-01, 2026-12-31"] * 2
+    assert meta.to_pylist()[1] == {"id": "b", "license": "CC0-1.0", "author": "", "source_ref": "https://example.org/b",
+                                   "attribution": '{"text_sha256": "x"}', "quality_warnings": ""}
+    assert meta.to_pylist()[0]["source_ref"] == "" and (source / "probe.parquet").is_file()
+
+
+def test_a_shard_without_the_canonical_schema_is_refused(tmp_path):
+    source = tmp_path / "data" / "probe"
+    source.mkdir(parents=True)
+    pq.write_table(pa.table({"id": ["a"], "text": ["t"]}), source / "probe.parquet")
+    with pytest.raises(ValueError):
+        migrate(source, tmp_path / "bundle")

src/test_uniform_schema.py

@@ -3,13 +3,46 @@ from pathlib import Path
 
 import pyarrow.parquet as pq
 
-from normalize_schema import SCHEMA
+from normalize_schema import DATA_NAME, DATA_SCHEMA, METADATA_NAME, METADATA_SCHEMA, SCHEMA
 
 DATA = Path(__file__).resolve().parents[1] / "data"
 
 
+def _bundles():
+    return sorted(p.parent for p in DATA.glob(f"*/{DATA_NAME}"))
+
+
+def _legacy_shards():
+    return sorted(p for p in DATA.glob("*/*.parquet") if p.name not in (DATA_NAME, METADATA_NAME))
+
+
 def test_every_source_parquet_has_the_canonical_schema():
-    shards = sorted(DATA.glob("*/*.parquet"))
-    assert shards, "no source shards found under data/*/*.parquet"
+    shards = _legacy_shards()
+    assert shards or _bundles(), "no source shards found under data/*/*.parquet"
     offenders = {str(p.relative_to(DATA.parent)): pq.read_schema(p).names for p in shards if pq.read_schema(p).names != SCHEMA.names}
     assert offenders == {}
+
+
+def test_every_bundle_has_the_canonical_data_and_metadata_schemas():
+    offenders = {}
+    for bundle in _bundles():
+        for name, schema in ((DATA_NAME, DATA_SCHEMA), (METADATA_NAME, METADATA_SCHEMA)):
+            path = bundle / name
+            names = pq.read_schema(path).names if path.is_file() else None
+            if names != schema.names:
+                offenders[str(path.relative_to(DATA.parent))] = names
+    assert offenders == {}
+
+
+def test_every_bundle_metadata_row_matches_its_data_row():
+    for bundle in _bundles():
+        data_ids = pq.read_table(bundle / DATA_NAME, columns=["id"])["id"].to_pylist()
+        metadata_ids = pq.read_table(bundle / METADATA_NAME, columns=["id"])["id"].to_pylist()
+        assert data_ids == metadata_ids, bundle.name
+
+
+def test_a_source_ships_one_layout_and_the_corpus_does_not_mix_them():
+    # the Hub default config is one split: legacy 8-column shards and 6-column data.parquet cannot share it
+    bundles = {p.name for p in _bundles()}
+    legacy = {p.parent.name for p in _legacy_shards()}
+    assert not (bundles and legacy), {"bundle": sorted(bundles), "legacy": sorted(legacy)}