Share one Polish-language gate (diacritic ratio, then langid vote); exempt plwiki and plwikivoyage (v2#77)

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, io, json, os, re, shutil, subprocess, sys, time
+import argparse, hashlib, io, json, os, shutil, subprocess, sys, time
 from itertools import islice
 import multiprocessing as mp
 from pathlib import Path
@@ -24,12 +24,10 @@ import pyarrow as pa
 import pyarrow.parquet as pq
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
+from language_gate import ALPHA_RE, GATE, is_polish
 from sources import SOURCES, ADDED
 
-POLISH_RE = re.compile(r"[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]")
-ALPHA_RE = re.compile(r"[^\W\d_]", re.UNICODE)
 MIN_CHARS = 200
-MIN_POLISH_RATIO = 0.005
 MIN_ALPHA_RATIO = 0.70
 
 SCHEMA = pa.schema([
@@ -47,11 +45,6 @@ def _init_worker():
     _ENC = tiktoken.get_encoding("cl100k_base")
 
 
-def _polish_ratio(text):
-    letters = ALPHA_RE.findall(text)
-    return len(POLISH_RE.findall(text)) / len(letters) if letters else 0.0
-
-
 def _first_text(value) -> str:
     if value is None:
         return ""
@@ -70,7 +63,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, preserve_created, lines = args
+    is_ocr, lang_gate, created, default_license, preserve_created, lines = args
     kept, texts = [], []
     st = [0, 0, 0, 0]  # read, short, lang, ocr
     metas = []
@@ -83,7 +76,7 @@ def _process_chunk(args):
             continue
         if len(text) < MIN_CHARS:
             st[1] += 1; continue
-        if _polish_ratio(text) < MIN_POLISH_RATIO:
+        if lang_gate and not is_polish(text):
             st[2] += 1; continue
         if is_ocr:
             ar = len(ALPHA_RE.findall(text)) / len(text) if text else 0.0
@@ -124,6 +117,7 @@ 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", "")
+    lang_gate = not cfg.get("polish_by_origin")
     preserve_id = bool(cfg.get("preserve_id"))
     preserve_created = bool(cfg.get("preserve_created"))
     used_ids = set()
@@ -161,7 +155,7 @@ def build_source(name, cfg, sl_dir, out_root, pool, seen, counter):
             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)
+    arg_iter = ((is_ocr, lang_gate, 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]
@@ -192,7 +186,8 @@ def build_source(name, cfg, sl_dir, out_root, pool, seen, counter):
     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']:,} | "
           f"{st['chars']/1e6:.0f}M chars, {st['tokens']/1e6:.1f}M tok | {st['secs']}s", flush=True)
-    (out_dir / f"{name}.stats.json").write_text(json.dumps({**st, "license": cfg["license"]}, indent=2))
+    (out_dir / f"{name}.stats.json").write_text(json.dumps(
+        {**st, "lang_gate": GATE if lang_gate else None, "license": cfg["license"]}, indent=2))
     return st
 
 

src/build_nonsa_pl.py

@@ -20,6 +20,8 @@ from urllib.parse import quote
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "nonsa"
 OWN_REPO = "PiotrSty/nonsa-pl"
@@ -481,14 +483,6 @@ class NearDuplicateIndex:
             self.postings.setdefault(value, []).append(position)
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
-    votes = [classified[chunk] for chunk in chunks if chunk in classified]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def audit_target(out):
     info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
     revision = info["sha"]

src/build_plwiki_talk_pl.py

@@ -21,6 +21,8 @@ from urllib.parse import quote
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "plwiki_talk"
 OWN_REPO = "PiotrSty/plwiki-talk-pages"
@@ -341,14 +343,6 @@ class NearDuplicateIndex:
             self.postings.setdefault(value, []).append(position)
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
-    votes = [classified[chunk] for chunk in chunks if chunk in classified]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def audit_target(out):
     info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
     revision = info["sha"]

src/build_plwiki_usertalk_pl.py

@@ -21,6 +21,8 @@ from urllib.parse import quote
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "plwiki_user_talk"
 OWN_REPO = "PiotrSty/plwiki-user-talk-pages"
@@ -364,14 +366,6 @@ class NearDuplicateIndex:
             self.postings.setdefault(value, []).append(position)
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
-    votes = [classified[chunk] for chunk in chunks if chunk in classified]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def audit_target(out):
     info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
     revision = info["sha"]

src/build_uzp_orzeczenia_pl.py

@@ -26,6 +26,8 @@ import time
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "uzp_orzeczenia_pl"
 OWN_REPO = "PiotrSty/uzp-orzeczenia-pl"
@@ -406,14 +408,6 @@ class NearDuplicateIndex:
             self.postings.setdefault(value, []).append(position)
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
-    votes = [classified[chunk] for chunk in chunks if chunk in classified]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def audit_target(out):
     info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
     revision = info["sha"]

src/build_wiadomosci_statystyczne_pl.py

@@ -19,6 +19,8 @@ from urllib.parse import quote, urlsplit, urlunsplit
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "wiadomosci_statystyczne_pl"
 OWN_REPO = "PiotrSty/wiadomosci-statystyczne-pl-articles"
@@ -280,13 +282,6 @@ def shingle_sketch(text, limit=5_000):
     return hashes
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    votes = [identifier.classify(chunk) for chunk in chunks if chunk.strip()]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def audit_target(out):
     info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
     revision = info["sha"]

src/clean_samorzad_gov_pl.py

@@ -25,6 +25,8 @@ import pyarrow as pa
 import pyarrow.dataset as ds
 import pyarrow.parquet as pq
 
+from language_gate import GATE, is_polish
+
 SOURCE = "samorzad_gov_pl"
 LICENSE = "CC-BY-SA-4.0"
 LICENSE_URL = "https://creativecommons.org/licenses/by-sa/4.0/"
@@ -40,9 +42,6 @@ UPSTREAM_EXPECTED = {
     "record_text_sha256": UPSTREAM_TEXT_SHA256,
 }
 MIN_CHARS = 200
-MIN_POLISH_RATIO = 0.005
-POLISH_RE = re.compile(r"[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]")
-ALPHA_RE = re.compile(r"[^\W\d_]", re.UNICODE)
 _SITE_NAME_RE = re.compile(
     r"<meta\b(?=[^>]*\bproperty\s*=\s*['\"]og:site_name['\"])(?=[^>]*\bcontent\s*=\s*(['\"])(.*?)\1)[^>]*>",
     re.IGNORECASE | re.DOTALL,
@@ -321,11 +320,6 @@ def third_party_drop(title: str, text: str) -> str | None:
     return None
 
 
-def _polish_ratio(text: str) -> float:
-    letters = ALPHA_RE.findall(text)
-    return len(POLISH_RE.findall(text)) / len(letters) if letters else 0.0
-
-
 def _text_hash(text: str) -> bytes:
     return hashlib.sha256(text.encode("utf-8")).digest()
 
@@ -462,6 +456,7 @@ def build(
         "kept": 0,
         "drop_short": 0,
         "drop_lang": 0,
+        "lang_gate": GATE,
         "drop_dup": 0,
         "drop_ocr": 0,
         "drop_third_party": dict.fromkeys(THIRD_PARTY_DROPS, 0),
@@ -493,7 +488,7 @@ def build(
         if len(text) < MIN_CHARS:
             stats["drop_short"] += 1
             continue
-        if _polish_ratio(text) < MIN_POLISH_RATIO:
+        if not is_polish(text):
             stats["drop_lang"] += 1
             continue
         digest = _text_hash(text)

src/fetch_njkp.py

@@ -40,6 +40,8 @@ from xml.etree import ElementTree as ET
 
 import pyarrow as pa
 import pyarrow.parquet as pq
+
+from language_gate import MIN_POLISH_RATIO, polish_ratio
 import tiktoken
 
 URL = ("https://clip.ipipan.waw.pl/NationalCorpusOfPolish"
@@ -54,12 +56,10 @@ LICENSE = "CC-BY-4.0"
 LICENSE_URL = "https://creativecommons.org/licenses/by/4.0/"
 AUTHOR = "NKJP Consortium (IPI PAN, IJP PAN, PWN, University of Łódź)"
 
-# Gates - identical thresholds to src/build_dynaword.py so the shard matches
-# what the DynaWord build itself would keep.
+# Gates - the length threshold matches src/build_dynaword.py. The language gate is
+# the diacritic ratio alone, not language_gate.is_polish: data/nkjp1m/ATTRIBUTION.md,
+# agreed with IPI PAN, describes the filter as that ratio.
 MIN_CHARS = 200
-MIN_POLISH_RATIO = 0.005
-POLISH_RE = re.compile(r"[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]")
-ALPHA_RE = re.compile(r"[^\W\d_]", re.UNICODE)
 
 NS = "{http://www.tei-c.org/ns/1.0}"
 DIV_TAG, AB_TAG, DATE_TAG = f"{NS}div", f"{NS}ab", f"{NS}date"
@@ -119,12 +119,6 @@ def _clean(text: str) -> str:
     return re.sub(r"[ \t]{2,}", " ", _ELLIPSIS.sub(" ", text)).strip()
 
 
-def _polish_ratio(text: str) -> float:
-    """Fraction of letters that are Polish-specific diacritics (build_dynaword)."""
-    letters = ALPHA_RE.findall(text)
-    return len(POLISH_RE.findall(text)) / len(letters) if letters else 0.0
-
-
 def _norm_date(raw: str) -> str:
     """Normalize a TEI @when value to an ISO date or bare year, else "".
 
@@ -203,7 +197,7 @@ def process_file(xml_path: str) -> tuple[list[dict], list[int]]:
         if len(text) < MIN_CHARS:
             short += 1
             continue
-        if _polish_ratio(text) < MIN_POLISH_RATIO:
+        if polish_ratio(text) < MIN_POLISH_RATIO:
             lang += 1
             continue
         kept.append({

src/fetch_open_icm_pl.py

@@ -18,6 +18,8 @@ import unicodedata
 
 import requests
 
+from language_gate import language_vote
+
 
 SOURCE = "open_icm_pl"
 OWN_REPO = "PiotrSty/open-icm-pl-publications"
@@ -493,13 +495,6 @@ def shingle_sketch(text, limit=5_000):
     return hashes
 
 
-def language_vote(identifier, text):
-    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
-    votes = [identifier.classify(chunk) for chunk in chunks if chunk.strip()]
-    languages = Counter(language for language, _ in votes)
-    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
-
-
 def build(out):
     import pyarrow as pa
     import pyarrow.parquet as pq

src/fetch_wikimedia.py

@@ -36,6 +36,7 @@ from build_plwiki_talk_pl import (  # noqa: E402  shared dump helpers
     UA, digest, load, now, request, request_json, save, sha1_file,
 )
 from fetch_wikipedia import pages, text_key  # noqa: E402
+from language_gate import card_line  # noqa: E402
 from rights import (  # noqa: E402
     BY_SA_4_CUTOFF, DROPPED_PAGES, WIKINEWS_BY_4_CUTOFF, check_dropped_reached, license_for_revision,
 )
@@ -441,7 +442,7 @@ Author metadata present for **{st['authors_with_value']:,}** documents.
 
 ## Filters applied (build_dynaword.py)
 - drop documents < 200 chars: **{st['drop_short']:,}** (the fetcher already dropped {prep.get('ns0_short', 0):,})
-- drop non-Polish (diacritic ratio): **{st['drop_lang']:,}**
+{card_line(st)}
 - exact cross-source dedup (sha1): **{st['drop_dup']:,}**
 - OCR alpha-ratio < 0.70 (OCR sources only): **{st['drop_ocr']:,}**
 - read {st['read']:,} → kept {kept:,}

src/language_gate.py

@@ -0,0 +1,70 @@
+"""Shared Polish-language gate: a diacritic pre-check, then a three-window langid vote.
+
+The diacritic ratio alone dropped Polish documents with few diacritics: lists, tables
+and template skeletons (slayerlabs/polish-dynaword-v2#77). A text whose ratio reaches
+MIN_POLISH_RATIO is Polish without a langid call; a text below it is kept only if the
+langid vote over its start, middle and end windows says "pl".
+
+Sources that are Polish by origin (``polish_by_origin`` in sources.py) skip the gate:
+on plwiki the dropped pages were Polish articles whose bulk is a list of foreign names
+or titles, and langid labels the list, not the article.
+"""
+from __future__ import annotations
+
+from collections import Counter
+import re
+
+POLISH_RE = re.compile(r"[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]")
+ALPHA_RE = re.compile(r"[^\W\d_]", re.UNICODE)
+MIN_POLISH_RATIO = 0.005
+# cs and sk keep Czech and Slovak text from scoring as Polish, the nearest
+# Latin-script language left in a smaller set.
+GATE_LANGUAGES = ("pl", "en", "de", "cs", "sk", "uk", "ru")
+# Card wording: what build stats record in "lang_gate". Stats written before this
+# module existed have no such key; those builds used the diacritic ratio alone.
+GATE = "diacritic ratio, then langid vote"
+LEGACY_GATE = "diacritic ratio"
+
+_identifier = None  # per-process langid identifier, built on first use
+
+
+def polish_ratio(text: str) -> float:
+    """Fraction of letters that are Polish-specific diacritics."""
+    letters = ALPHA_RE.findall(text)
+    return len(POLISH_RE.findall(text)) / len(letters) if letters else 0.0
+
+
+def language_vote(identifier, text):
+    """Majority langid label over the first, middle and last 30,000 characters.
+
+    Returns (label, votes); the label is "unknown" for blank text, and a three-way
+    tie goes to the first window. Identical windows (short texts) are classified once.
+    """
+    chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]]
+    classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()}
+    votes = [classified[chunk] for chunk in chunks if chunk in classified]
+    languages = Counter(language for language, _ in votes)
+    return (languages.most_common(1)[0][0] if languages else "unknown", votes)
+
+
+def gate_identifier():
+    global _identifier
+    if _identifier is None:
+        from langid.langid import LanguageIdentifier, model
+        _identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
+        _identifier.set_languages(list(GATE_LANGUAGES))
+    return _identifier
+
+
+def is_polish(text: str) -> bool:
+    if polish_ratio(text) >= MIN_POLISH_RATIO:
+        return True
+    return language_vote(gate_identifier(), text)[0] == "pl"
+
+
+def card_line(stats: dict) -> str:
+    """The dataset-card bullet for the language filter, worded from the build stats."""
+    gate = stats.get("lang_gate", LEGACY_GATE)
+    if gate is None:
+        return "- drop non-Polish: not applied (Polish by origin)"
+    return f"- drop non-Polish ({gate}): **{stats.get('drop_lang', 0):,}**"

src/make_docs.py

@@ -14,6 +14,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from sources import SOURCES, EXCLUDED, ADDED
+from language_gate import card_line
 
 ROOT = Path(__file__).resolve().parent.parent
 VERSION = "0.2.5"
@@ -126,7 +127,7 @@ def datasheet(name, cfg, st):
 ## Filters applied (build_dynaword.py)
 Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
 - drop documents < 200 chars: **{st.get('drop_short', 0):,}**
-- drop non-Polish (diacritic ratio): **{st.get('drop_lang', 0):,}**
+{card_line(st)}
 - exact cross-source dedup (sha1): **{st.get('drop_dup', 0):,}**
 - OCR alpha-ratio < 0.70 (OCR sources only): **{st.get('drop_ocr', 0):,}**
 - read {st.get('read', st['kept']):,} → kept {st['kept']:,}

src/sources.py

@@ -113,6 +113,8 @@ SOURCES = {
     },
     "wikipedia": {
         "added": "2026-07-02",
+        # Polish by origin: build_dynaword skips the language gate (src/language_gate.py).
+        "polish_by_origin": True,
         "release": "0.2.0",
         "file_key": "wikipedia",
         "preserve_id": True,
@@ -421,6 +423,8 @@ SOURCES = {
     },
     "wikivoyage": {
         "added": "2026-07-02",
+        # Polish by origin: build_dynaword skips the language gate (src/language_gate.py).
+        "polish_by_origin": True,
         "release": "0.2.0",
         "file_key": "plwikivoyage",
         "preserve_id": True,

src/test_build_dynaword_flags.py

@@ -21,7 +21,7 @@ def _encoder():
 
 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))
+    kept, _ = _process_chunk((False, True, created, "CC0", preserve_created, lines))
     return kept
 
 

src/test_language_gate.py

@@ -0,0 +1,126 @@
+import json
+
+import pytest
+
+import language_gate
+from language_gate import GATE, LEGACY_GATE, MIN_POLISH_RATIO, card_line, is_polish, language_vote, polish_ratio
+
+POLISH = "Zażółć gęślą jaźń. Miasto leży nad rzeką, a jego mieszkańcy pracują w porcie. " * 10
+# Polish with almost no diacritics: a list of foreign titles under a short Polish lead.
+POLISH_LIST = (
+    "Ponizej znajduje sie lista filmow wydanych przez wytwornie w latach osiemdziesiatych. "
+    "Kazdy film ma swoja strone z opisem fabuly oraz obsada. Wiekszosc z nich byla "
+    "nagradzana na festiwalach, a niektore trafily do kin w wielu krajach. "
+) * 8
+ENGLISH = "The city lies on the river, and most of its residents work in the harbour or the shipyard. " * 10
+GERMAN = "Die Stadt liegt am Fluss, und die meisten Einwohner arbeiten im Hafen oder auf der Werft. " * 10
+CZECH = "Město leží na řece a většina jeho obyvatel pracuje v přístavu nebo v loděnici. " * 10
+RUSSIAN = "Город расположен на реке, и большинство его жителей работают в порту или на верфи. " * 10
+UKRAINIAN = "Місто розташоване на річці, і більшість його мешканців працюють у порту або на верфі. " * 10
+
+
+class _Identifier:
+    """langid stand-in: labels a window by its first character and records each call."""
+
+    def __init__(self, labels):
+        self.labels, self.calls = labels, []
+
+    def classify(self, chunk):
+        self.calls.append(chunk)
+        return self.labels[chunk[0]], 1.0
+
+
+@pytest.fixture
+def no_langid(monkeypatch):
+    def fail():
+        raise AssertionError("langid must not run when the diacritic ratio passes")
+    monkeypatch.setattr(language_gate, "gate_identifier", fail)
+
+
+def test_polish_prose_passes_on_the_ratio_without_langid(no_langid):
+    assert polish_ratio(POLISH) >= MIN_POLISH_RATIO
+    assert is_polish(POLISH)
+
+
+def test_ratio_boundary(no_langid, monkeypatch):
+    at = "ą" + "a" * 199
+    assert polish_ratio(at) == MIN_POLISH_RATIO
+    assert is_polish(at)
+    below = "ą" + "a" * 200
+    monkeypatch.setattr(language_gate, "gate_identifier", lambda: _Identifier({"ą": "en"}))
+    assert not is_polish(below)
+
+
+def test_polish_list_with_few_diacritics_is_kept_by_the_vote():
+    assert polish_ratio(POLISH_LIST) < MIN_POLISH_RATIO
+    assert language_vote(language_gate.gate_identifier(), POLISH_LIST)[0] == "pl"
+    assert is_polish(POLISH_LIST)
+
+
+@pytest.mark.parametrize("text,label", [
+    (ENGLISH, "en"), (GERMAN, "de"), (CZECH, "cs"), (RUSSIAN, "ru"), (UKRAINIAN, "uk"),
+])
+def test_other_languages_are_dropped(text, label):
+    assert language_vote(language_gate.gate_identifier(), text)[0] == label
+    assert not is_polish(text)
+
+
+def test_blank_text_votes_unknown_and_is_dropped():
+    assert language_vote(_Identifier({}), "   \n ") == ("unknown", [])
+    assert not is_polish("")
+
+
+def test_vote_windows_majority_tie_and_dedup():
+    text = "p" * 30_000 + "e" * 30_000 + "e" * 30_000
+    label, votes = language_vote(_Identifier({"p": "pl", "e": "en"}), text)
+    assert label == "en" and [v[0] for v in votes] == ["pl", "en", "en"]
+
+    tie = "p" * 30_000 + "d" * 30_000 + "e" * 30_000
+    assert language_vote(_Identifier({"p": "pl", "d": "de", "e": "en"}), tie)[0] == "pl"
+
+    identifier = _Identifier({"k": "pl"})
+    label, votes = language_vote(identifier, "krótki tekst")
+    assert label == "pl" and len(votes) == 3 and len(identifier.calls) == 1
+
+
+def test_gate_identifier_is_restricted_to_the_gate_languages():
+    language_gate._identifier = None
+    identifier = language_gate.gate_identifier()
+    assert identifier is language_gate.gate_identifier()
+    assert sorted(identifier.nb_classes) == sorted(language_gate.GATE_LANGUAGES)
+
+
+@pytest.mark.parametrize("stats,line", [
+    ({"drop_lang": 5564}, f"- drop non-Polish ({LEGACY_GATE}): **5,564**"),
+    ({"drop_lang": 3, "lang_gate": GATE}, f"- drop non-Polish ({GATE}): **3**"),
+    ({"drop_lang": 0, "lang_gate": None}, "- drop non-Polish: not applied (Polish by origin)"),
+    ({"lang_gate": GATE}, f"- drop non-Polish ({GATE}): **0**"),
+])
+def test_card_line(stats, line):
+    assert card_line(stats) == line
+
+
+def test_polish_by_origin_sources():
+    from sources import SOURCES
+    assert {name for name, cfg in SOURCES.items() if cfg.get("polish_by_origin")} == {"wikipedia", "wikivoyage"}
+
+
+@pytest.mark.parametrize("polish_by_origin,kept,dropped,gate", [(False, 1, 1, GATE), (True, 2, 0, None)])
+def test_build_source_applies_the_gate_unless_polish_by_origin(tmp_path, polish_by_origin, kept, dropped, gate):
+    import zstandard
+    import build_dynaword
+
+    build_dynaword._init_worker()
+    rows = [{"text": POLISH}, {"text": ENGLISH}]
+    (tmp_path / "src.jsonl.zst").write_bytes(zstandard.ZstdCompressor().compress(
+        "".join(json.dumps(row) + "\n" for row in rows).encode()))
+    cfg = {"file_key": "src", "license": "CC0", "created": "2026", "polish_by_origin": polish_by_origin}
+
+    class Pool:
+        def imap_unordered(self, fn, items, chunksize):
+            return map(fn, items)
+
+    st = build_dynaword.build_source("probe", cfg, tmp_path, tmp_path, Pool(), set(), [0])
+    assert (st["kept"], st["drop_lang"]) == (kept, dropped)
+    stats = json.loads((tmp_path / "data" / "probe" / "probe.stats.json").read_text())
+    assert stats["lang_gate"] == gate

src/test_studia_bas_contract.py

@@ -173,7 +173,7 @@ def test_canonical_builder_preserves_per_record_created_metadata(monkeypatch):
     monkeypatch.setattr(build_dynaword, "_ENC", _TokenStub())
     record = extract_article(article_fixture(), issue_number="77", year=2024)
     kept, stats = build_dynaword._process_chunk(
-        (False, "2021-2025", LICENSE, True, [json.dumps(record, ensure_ascii=False)])
+        (False, True, "2021-2025", LICENSE, True, [json.dumps(record, ensure_ascii=False)])
     )
     assert stats[0] == 1
     assert kept[0][1] == "2024"
@@ -263,7 +263,7 @@ def test_canonical_builder_falls_back_to_source_created_when_record_metadata_is_
     # Missing 'created' in the record
     record = {'text': 'To jest testowy polski tekst z polskimi znakami diakrytycznymi ąćęłńóśźż.' * 10}
     kept, stats = build_dynaword._process_chunk(
-        (False, '2010-2020', 'CC0', True, [json.dumps(record)])
+        (False, True, '2010-2020', 'CC0', True, [json.dumps(record)])
     )
     assert kept[0][1] == '2010-2020'
 
@@ -279,7 +279,7 @@ def test_canonical_builder_backward_compatibility(monkeypatch, tmp_path):
     # Missing 'created' falls back to source config
     record = {'text': 'To jest testowy polski tekst z polskimi znakami diakrytycznymi ąćęłńóśźż.' * 10, 'id': 'custom_123'}
     kept, _ = build_dynaword._process_chunk(
-        (False, 'fallback_created', 'fallback_license', True, [json.dumps(record)])
+        (False, True, 'fallback_created', 'fallback_license', True, [json.dumps(record)])
     )
     assert kept[0][1] == 'fallback_created'
     assert kept[0][6] == 'custom_123'