feat(data): add wiktionary_examples (8.6k docs / 1.12M tok)

data/wiktionary_examples/wiktionary_examples.md

@@ -0,0 +1,41 @@
+# wiktionary_examples
+
+Polish Wiktionary usage examples
+
+## Dataset description
+- **Source (upstream):** https://dumps.wikimedia.org/plwiktionary/latest/
+- **Domain:** lexicographic
+- **Language:** Polish (pl)
+- **License:** `CC-BY-SA-3.0`
+- **Created (range):** 2004-03-22, 2026-08-15
+- **Added:** 2026-07-19
+
+## Licensing — traceable basis
+Wikimedia dumps explicitly released under CC-BY-SA 3.0; attribution to contributors + share-alike preserved. Derived subset: usage-example sections from Polish-language entries only, grouped one document per headword.
+
+## Provenance
+Parsed directly from the official Wikimedia dump (plwiktionary-latest-pages-articles.xml.bz2); not routed through SpeakLeash. Usage-example sections of Polish-language entries extracted and grouped one document per headword.
+
+## Statistics
+| documents | characters | tokens (tiktoken proxy) |
+|---:|---:|---:|
+| 8,639 | 2,889,761 | 1,115,820 |
+
+
+## Per-document license metadata
+| license | documents |
+|---|---:|
+| `CC-BY-SA-3.0` | 8,639 |
+
+Author metadata present for **8,639** documents. Empty values mean the upstream record did not expose a machine-readable author field.
+
+## Filters applied (build_dynaword.py)
+Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
+- drop documents < 200 chars: **0**
+- drop non-Polish (diacritic ratio): **0**
+- exact cross-source dedup (sha1): **481**
+- OCR alpha-ratio < 0.70 (OCR sources only): **0**
+- read 9,120 → kept 8,639
+
+Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
+Llama-3 count is computed at release.

data/wiktionary_examples/wiktionary_examples.parquet

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

data/wiktionary_examples/wiktionary_examples.stats.json

@@ -0,0 +1,16 @@
+{
+  "read": 9120,
+  "kept": 8639,
+  "drop_short": 0,
+  "drop_lang": 0,
+  "drop_dup": 481,
+  "drop_ocr": 0,
+  "chars": 2889761,
+  "tokens": 1115820,
+  "licenses": {
+    "CC-BY-SA-3.0": 8639
+  },
+  "authors_with_value": 8639,
+  "secs": 2.9,
+  "license": "CC-BY-SA-3.0"
+}

src/fetch_wiktionary_examples.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""Build the `wiktionary_examples` source from the official Polish Wiktionary dump.
+
+Extracts usage-example sections (`{{przykłady}}`) from Polish-language entries
+of pl.wiktionary.org and emits a `.jsonl.zst` file in the format expected by
+`src/build_dynaword.py` (fields: text / license / author).
+
+Unlike most sources in this registry, this one is NOT routed through
+SpeakLeash's redistribution — it is parsed directly from the Wikimedia dump.
+The `provenance` field in sources.py records this.
+
+One document = one headword; all its example sentences are concatenated,
+newline-separated, in source order. Citation attribution found in
+`{{źródło|...}}` templates is stripped from the text and written to a
+side-car file for auditing (not part of the corpus).
+
+Only the standard library is required for parsing; `zstandard` is used for
+output compression (falls back to plain .jsonl with a warning).
+
+Usage:
+  # download the dump yourself, then:
+  python3 src/fetch_wiktionary_examples.py \
+      --dump plwiktionary-latest-pages-articles.xml.bz2 \
+      
+
+  # dump URL:
+  # https://dumps.wikimedia.org/plwiktionary/latest/plwiktionary-latest-pages-articles.xml.bz2
+"""
+from __future__ import annotations
+
+import argparse
+import bz2
+import html
+import json
+import re
+import sys
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+SOURCE_NAME = "wiktionary_examples"
+LICENSE = "CC-BY-SA-3.0"
+AUTHOR = "Wikimedia contributors"
+
+# Gates mirrored from build_dynaword.py so the preview count matches the build.
+MIN_CHARS = 200
+MIN_EXAMPLE_CHARS = 10
+
+# `== <headword> ({{język polski}}) ==` opens the Polish section of an entry.
+PL_HEADING = re.compile(r"^==\s*(.+?)\s*\(\{\{język polski\}\}\)\s*==\s*$", re.M)
+NEXT_HEADING = re.compile(r"^==[^=]", re.M)
+
+# Blocks run until the next top-level `{{template}}` marker.
+EXAMPLES_BLOCK = re.compile(
+    r"\{\{przykłady\}\}(.*?)(?=\{\{[a-ząćęłńóśźż]+\}\}|\Z)", re.S
+)
+# Numbered lines: `: (1.1) <sentence>`
+NUMBERED_LINE = re.compile(r"^:\s*\(([\d.]+)\)\s*(.+?)\s*$", re.M)
+SENSE_NUMBER = re.compile(r"\(\d+\.\d+\)")
+
+CITATION_FIELDS = ("autor", "tytuł", "tytul", "rozdział", "rozdzial", "rok", "isbn")
+
+
+def split_templates(text: str) -> tuple[str, list[str]]:
+    """Remove `{{...}}` spans, counting braces so nested templates are handled.
+
+    A regex cannot do this correctly: `{{źródło|tytuł={{...}}}}` occurs in the
+    dump and a non-greedy match closes at the wrong brace pair.
+    """
+    kept: list[str] = []
+    removed: list[str] = []
+    i = 0
+    while i < len(text):
+        if text.startswith("{{", i):
+            depth, j = 0, i
+            while j < len(text):
+                if text.startswith("{{", j):
+                    depth += 1
+                    j += 2
+                elif text.startswith("}}", j):
+                    depth -= 1
+                    j += 2
+                    if depth == 0:
+                        break
+                else:
+                    j += 1
+            removed.append(text[i:j])
+            i = j
+        else:
+            kept.append(text[i])
+            i += 1
+    return "".join(kept), removed
+
+
+def describe_citation(template: str) -> str:
+    """Flatten a `{{źródło|autor=…|tytuł=…}}` template into a readable string."""
+    fields: dict[str, str] = {}
+    for chunk in template.strip("{}").split("|")[1:]:
+        if "=" in chunk:
+            key, value = chunk.split("=", 1)
+            fields[key.strip().lower()] = value.strip()
+    parts = [fields[k] for k in CITATION_FIELDS if fields.get(k)]
+    return " | ".join(parts)
+
+
+def unlink(text: str) -> str:
+    """`[[target|label]]` -> label, `[[word]]` -> word, external links -> label."""
+    for _ in range(5):
+        stripped = re.sub(r"\[\[([^\[\]|]*)\|(.*?)\]\]", r"\2", text)
+        stripped = re.sub(r"\[\[([^\[\]|]+?)\]\]", r"\1", stripped)
+        if stripped == text:
+            break
+        text = stripped
+    # Safety net for malformed nesting, e.g. `[[zaskoczyć|zaskoczył[y]]]`.
+    text = re.sub(r"\[\[[^\[\]]*?\|", "[[", text)
+    text = text.replace("[[", "").replace("]]", "")
+    text = re.sub(r"\[https?://\S+\s+([^\]]+)\]", r"\1", text)
+    text = re.sub(r"\[https?://\S+\]", "", text)
+    text = re.sub(r"https?://\S+", "", text)
+    return text
+
+
+def clean(text: str) -> str:
+    """Strip wiki and HTML markup. Square brackets are kept deliberately:
+    `[…]` marks an omission and `[= gloss]` an editorial insertion — both are
+    philological convention inside quotations, not markup residue."""
+    text = re.sub(r"<ref[^>]*>.*?</ref>", "", text, flags=re.S)
+    text = re.sub(r"<ref[^>]*/>", "", text)
+    text = re.sub(r"<[^>]+>", "", text)
+    text = unlink(text)
+    text = re.sub(r"'{2,}", "", text)
+    text = html.unescape(html.unescape(text))   # some entities are double-encoded
+    text = text.replace("\u00a0", " ")
+    text = SENSE_NUMBER.sub("", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip(" -–—•\t")
+
+
+def polish_section(wikitext: str) -> tuple[str, str] | None:
+    match = PL_HEADING.search(wikitext)
+    if not match:
+        return None
+    headword = match.group(1).strip()
+    rest = wikitext[match.end():]
+    end = NEXT_HEADING.search(rest)
+    if end:
+        rest = rest[: end.start()]
+    return headword, rest
+
+
+def examples_and_citations(section: str) -> tuple[list[str], list[str]]:
+    match = EXAMPLES_BLOCK.search(section)
+    if not match:
+        return [], []
+    examples, citations = [], []
+    for _, raw in NUMBERED_LINE.findall(match.group(1)):
+        without_templates, templates = split_templates(raw)
+        for template in templates:
+            if template.startswith(("{{źródło", "{{zrodlo")):
+                described = describe_citation(clean(template))
+                if described:
+                    citations.append(described)
+        sentence = clean(without_templates)
+        if len(sentence) >= MIN_EXAMPLE_CHARS:
+            examples.append(sentence)
+    return examples, sorted(set(citations))
+
+
+def iter_pages(dump_path: Path):
+    """Yield (namespace, wikitext) for every page, streaming the bz2 dump."""
+    with bz2.open(dump_path, "rb") as handle:
+        for _, element in ET.iterparse(handle, events=("end",)):
+            if element.tag.rsplit("}", 1)[-1] != "page":
+                continue
+            values = {}
+            for child in element.iter():
+                tag = child.tag.rsplit("}", 1)[-1]
+                if tag in ("ns", "text") and tag not in values:
+                    values[tag] = child.text
+            yield (values.get("ns") or "").strip(), values.get("text") or ""
+            element.clear()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dump", required=True,
+                        help="plwiktionary-latest-pages-articles.xml.bz2")
+    parser.add_argument("--out", default=".",
+                        help="directory to write <source>.jsonl.zst into")
+    parser.add_argument("--min-chars", type=int, default=MIN_CHARS,
+                        help=f"document length gate (default {MIN_CHARS}, "
+                             "matching build_dynaword.py)")
+    args = parser.parse_args()
+
+    dump_path = Path(args.dump).expanduser()
+    if not dump_path.exists():
+        sys.exit(f"dump not found: {dump_path}")
+    out_dir = Path(args.out).expanduser()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pages = entries = with_examples = with_citations = 0
+    documents: list[tuple[str, str]] = []
+    citation_index: list[dict] = []
+
+    for namespace, wikitext in iter_pages(dump_path):
+        pages += 1
+        if pages % 100_000 == 0:
+            print(f"  {pages:,} pages scanned, {entries:,} Polish entries",
+                  flush=True)
+        if namespace != "0":
+            continue
+        section = polish_section(wikitext)
+        if section is None:
+            continue
+        entries += 1
+        headword, body = section
+        examples, citations = examples_and_citations(body)
+        if not examples:
+            continue
+        with_examples += 1
+        if citations:
+            with_citations += 1
+            citation_index.append({"headword": headword, "citations": citations})
+        documents.append((headword, "\n".join(examples)))
+
+    kept = [(h, t) for h, t in documents if len(t) >= args.min_chars]
+    chars = sum(len(t) for _, t in kept)
+
+    print()
+    print(f"pages scanned:            {pages:,}")
+    print(f"Polish entries:           {entries:,}")
+    print(f"entries with examples:    {with_examples:,}")
+    print(f"entries with attribution: {with_citations:,}")
+    print(f"documents >= {args.min_chars} chars:  {len(kept):,}")
+    print(f"characters:               {chars:,}")
+
+    payload = "\n".join(
+        json.dumps({"text": text, "license": LICENSE, "author": AUTHOR},
+                   ensure_ascii=False)
+        for _, text in kept
+    ) + "\n"
+
+    plain = out_dir / f"{SOURCE_NAME}.jsonl"
+    plain.write_text(payload, encoding="utf-8")
+
+    try:
+        import zstandard as zstd
+    except ImportError:
+        print(f"\nwrote {plain} — install `zstandard` (or run `zstd {plain.name}`) "
+              "to produce the .jsonl.zst the build expects")
+    else:
+        compressed = out_dir / f"{SOURCE_NAME}.jsonl.zst"
+        compressed.write_bytes(zstd.ZstdCompressor(level=10).compress(
+            payload.encode("utf-8")))
+        plain.unlink()
+        print(f"\nwrote {compressed}")
+
+    audit = out_dir / f"{SOURCE_NAME}.citations.jsonl"
+    audit.write_text(
+        "\n".join(json.dumps(row, ensure_ascii=False) for row in citation_index) + "\n",
+        encoding="utf-8",
+    )
+    print(f"wrote {audit} (attribution audit trail, not part of the corpus)")
+    print()
+    print(f"next: python3 src/build_dynaword.py --sources {SOURCE_NAME} "
+          f"--speakleash-dir {out_dir} --out .")
+
+
+if __name__ == "__main__":
+    main()

src/sources.py

@@ -39,6 +39,24 @@ SOURCES = {
         "created": "2005-01-01, 2026-06-14",
         "is_ocr": False,
     },
+    "wiktionary_examples": {
+        "file_key": "wiktionary_examples",
+        "pretty": "Polish Wiktionary usage examples",
+        "provenance": "Parsed directly from the official Wikimedia dump "
+                      "(plwiktionary-latest-pages-articles.xml.bz2); not routed "
+                      "through SpeakLeash. Usage-example sections of Polish-language "
+                      "entries extracted and grouped one document per headword.",
+        "license": "CC-BY-SA-3.0",
+        "license_spdx": "CC-BY-SA-3.0",
+        "traceable": "Wikimedia dumps explicitly released under CC-BY-SA 3.0; "
+                     "attribution to contributors + share-alike preserved. "
+                     "Derived subset: usage-example sections from Polish-language "
+                     "entries only, grouped one document per headword.",
+        "upstream": "https://dumps.wikimedia.org/plwiktionary/latest/",
+        "domain": "lexicographic",
+        "created": "2004-03-22, 2026-08-15",
+        "is_ocr": False,
+    },
     "eurlex": {
         "speakleash_key": "eurlex_corpus",
         "pretty": "EUR-Lex (EU legal acts, Polish)",