Add source: european_hplt_v3_pl (HPLT v3.0 Polish, top WDS bins, CC0)

data/european_hplt_v3_pl/european_hplt_v3_pl.md

@@ -0,0 +1,57 @@
+# european_hplt_v3_pl
+
+Filtered Polish subset of **HPLT v3.0** (`pol_Latn`), top quality bins (WDS = 10 and 9), merged into one file.
+
+## Dataset description
+- **Source (upstream):** https://hplt-project.org/datasets/v3.0 (`pol_Latn`, shards `10_1` [WDS=10] + `9_1` prefix [WDS=9])
+- **Domain:** web (modern natural Polish — informational, narrative, opinion, how-to, discussion)
+- **Language:** Polish (pl)
+- **License:** `CC0-1.0` (packaging; see licensing note)
+- **Created (range):** web crawls 2012-2024 (Internet Archive + Common Crawl)
+- **Added:** 2026-07-14
+
+## Licensing - traceable basis
+HPLT licenses the **packaging** of these text data under Creative Commons CC0 1.0 ("no rights reserved"),
+per the HPLT v3.0 Terms of Use (hplt-project.org/datasets/v3.0) and the HF card `HPLT/HPLT3.0`.
+HPLT does not own the underlying web text; a notice-and-takedown policy applies and downstream users
+remain responsible for compliance (EU CDSM Directive 2019/790, GDPR). This is a web-crawl source: it is
+offered at parity with the already-listed `european-hplt-v1` (CC0) basis and still needs maintainer
+web/legal review (`accept_after_web_review`), not auto-accept.
+
+## Provenance
+Fetched directly from the HPLT distribution (`data.hplt-project.org/three/sorted/pol_Latn/{10_1,9_1}.jsonl.zst`),
+NOT via SpeakLeash. HPLT v3 is globally deduplicated upstream and sorted into Web-Docs-Scorer (WDS) quality
+bins; only the two top bins are used. Per-document URL, WDS score, web-register, MT-probability and PII spans
+are available in the raw HPLT record and were used for filtering (not retained in the released canonical schema).
+
+## Statistics
+| documents | characters | tokens (tiktoken cl100k proxy) |
+|---:|---:|---:|
+| 110,590 | 1,426,290,944 | 512,383,778 |
+
+Composition (single merged parquet): bin-10 (WDS=10) 55,590 docs / 261,468,813 tok;
+bin-9 (WDS=9) 55,000 docs / 250,914,965 tok. See `european_hplt_v3_pl.stats.json` for the per-bin + drop breakdown.
+
+## Per-document license metadata
+| license | documents |
+|---|---:|
+| `CC0-1.0` | 110,590 |
+
+## Filters applied (src/clean_hplt_v3.py; thresholds inherited from src/filter_european_hplt.py)
+Per-shard keep: bin-10 55,590/195,874 (28.4%), bin-9 55,000/152,380 (36.1%). Drop reasons:
+`register` (not ID/OP/HI/IN/NA), `machine_translated` (MT>=0.20), `domain`
+(wikipedia/wikisource/wikimedia + file-hosts excluded), `adult_spam`, `legalish` (drops legal/parliamentary
+phrasing - serves the anti-legalese goal), `boilerplate`, `too_long` (>120k chars = book-length copyright/OCR
+risk), `mojibake` (>=3 CJK/replacement chars - upstream HPLT UTF-8->GBK mis-decode), `filehost` (PDF/file-share
+headers), `domain_cap` (>250 docs/domain). MT-probability of kept docs: mean ~0.08. Mojibake residual: 0.
+
+## Status & caveats (web-crawl - NOT "release-clean")
+- **Copyright is not fully solved by filtering.** The length cap removes obvious book-length works, but
+  in-copyright text recurs in web-crawl at ALL lengths (news reprints, blog reposts, excerpts). Inherent to
+  web sources; the reason HPLT ships CC0-on-packaging + notice-and-takedown.
+- **Near-dup NOT removed** (Dynaword leaves heavy filtering downstream). ~11.8% of an HPLT sample's 8-grams
+  overlap Polish Wikipedia; wikipedia/wikisource domain exclusion mitigates the largest sources, but
+  cross-source near/containment dedup vs the full corpus remains a downstream step.
+- Surface-metric parity with accepted sources: mojibake 0%, boilerplate ~0.2%, diacritic-ratio ~0.066,
+  TTR@500 ~0.64 (within the accepted range, ~= parliamentary). ~9% commercial/SEO-adjacent pages (web-inherent).
+- This is 2 top bins merged. The full `pol_Latn` corpus is ~270B raw tokens across WDS bins 10->5.

data/european_hplt_v3_pl/european_hplt_v3_pl.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6295b3280cef2b99e9bf511a1c48be9c94cd219455d2e9666ebf17363771b714
+size 610242503

data/european_hplt_v3_pl/european_hplt_v3_pl.stats.json

@@ -0,0 +1,41 @@
+{
+  "read": 348254,
+  "kept": 110590,
+  "drop_short": 0,
+  "drop_lang": 2,
+  "drop_dup": 0,
+  "drop_ocr": 0,
+  "chars": 1426290944,
+  "tokens": 512383778,
+  "licenses": {
+    "CC0-1.0": 110590
+  },
+  "authors_with_value": 0,
+  "license": "CC0-1.0",
+  "stats_recomputed_from_parquet": true,
+  "drop_detail": {
+    "machine_translated": 46477,
+    "adult_spam": 18682,
+    "register": 128956,
+    "legalish": 15881,
+    "domain": 23234,
+    "boilerplate": 3183,
+    "mojibake": 241,
+    "too_long": 216,
+    "filehost": 7,
+    "lang_prob": 2,
+    "domain_cap": 785
+  },
+  "shards": {
+    "bin10_WDS10": {
+      "kept": 55590,
+      "tokens": 261468813
+    },
+    "bin9_WDS9": {
+      "kept": 55000,
+      "tokens": 250914965
+    }
+  },
+  "mt_prob_mean_kept": 0.08,
+  "source_repo": "HPLT/HPLT3.0 pol_Latn WDS bins 10+9 (data.hplt-project.org)"
+}

src/clean_hplt_v3.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""clean_hplt_v3.py — filtr Polish HPLT v3 bin-10 (WDS=10) -> kanoniczna schema DynaWord.
+
+Adaptacja src/filter_european_hplt.py maintainera do SUROWEGO formatu HPLT v3 (jsonl.zst,
+pobrany z data.hplt-project.org). Te same progi jakosci; mapowanie pol v3 -> pol v1.
+Output: kanoniczna 8-kolumnowa schema (id/text/source/added/created/token_count/license/author)
++ stats.json (format DynaWord + drop-reasons + register/MT/domain) + karta .md.
+
+Pola v3: text, lang[list], prob[list], u(url), doc_scores[list], web-register{dict}, c(mime), id.
+"""
+from __future__ import annotations
+import argparse, json, os, re, sys, time
+from pathlib import Path
+from urllib.parse import urlparse
+import zstandard as zstd
+import pyarrow as pa, pyarrow.parquet as pq
+import tiktoken
+
+ADDED = "2026-07-14"
+SOURCE = "european_hplt_v3_pl"
+LICENSE = "CC0-1.0"
+
+BOILERPLATE_RE = re.compile(
+    r"(cookies?|privacy policy|terms of service|all rights reserved|"
+    r"polityka prywatno\u015bci|regulamin|wszelkie prawa zastrze\u017cone|"
+    r"zaloguj|rejestracja|newsletter)", re.I)
+ADULT_SPAM_RE = re.compile(
+    r"(porn|sex|escort|casino|viagra|cialis|bukmacher|hazard|"
+    r"porno|seks|erotycz|kasyno|randki)", re.I)
+LEGALISH_RE = re.compile(
+    r"\b(ustawa|rozporz\u0105dzenie|dz\.u\.|sejm|senat|parlament|eur-lex|"
+    r"trybuna\u0142|s\u0105d|wyrok|kodeks|komisja europejska)\b", re.I)
+EXCLUDED_DOMAIN_PARTS = {".bip.", "bip.", "docplayer.pl", "mapa-kodow-pocztowych.pl",
+                         "slideplayer.pl", "wikipedia.org", "wikisource.org", "wikibooks.org",
+                         "wikiquote.org", "wikivoyage.org", "chomikuj.pl", "scribd.com",
+                         "pdfcoffee.com", "dokumen.pub", "docer.pl", "ebookpoint", "wolnelektury.pl"}
+# mojibake: polskie znaki UTF-8 zdekodowane jako CJK/inne (upstream HPLT extraction bug)
+MOJIBAKE_RE = re.compile(r"[\u2e00-\u9fff\uff00-\uffef\ufffd]")
+# naglowki serwisow wymiany plikow / PDF-ripow (ryzyko piractwa)
+PDFHOST_RE = re.compile(r"(\d+\s*Pages?\s*[\u2022\u00b7]|Uploaded at|\d+\s*Words?\s*[\u2022\u00b7])", re.I)
+MAX_CHARS = 120000  # ~40k tok: powyzej to ksiazki (copyright/OCR-risk), nie strony web
+ALLOWED_REGISTERS = {"ID", "OP", "HI", "IN", "NA"}
+
+CANON = pa.schema([("id", pa.string()), ("text", pa.string()), ("source", pa.string()),
+                   ("added", pa.string()), ("created", pa.string()),
+                   ("token_count", pa.int64()), ("license", pa.string()), ("author", pa.string())])
+
+ENC = tiktoken.get_encoding("cl100k_base")
+
+def domain(url):
+    if not url:
+        return ""
+    h = urlparse(url).netloc.lower()
+    return h[4:] if h.startswith("www.") else h
+
+def top_register(reg):
+    if not isinstance(reg, dict) or not reg:
+        return "", 0.0
+    k, v = max(reg.items(), key=lambda kv: kv[1] or 0.0)
+    return str(k), float(v or 0.0)
+
+def keep(o, min_chars, min_words, min_lang_prob, max_mt, dom_counts, max_per_domain):
+    lang = o.get("lang")
+    if not (isinstance(lang, list) and lang and lang[0] == "pol_Latn"):
+        return None, "language"
+    prob = o.get("prob")
+    lp = float(prob[0]) if isinstance(prob, list) and prob else 0.0
+    if lp < min_lang_prob:
+        return None, "lang_prob"
+    host = domain(o.get("u"))
+    if any(p in host for p in EXCLUDED_DOMAIN_PARTS):
+        return None, "domain"
+    if max_per_domain and dom_counts.get(host, 0) >= max_per_domain:
+        return None, "domain_cap"
+    reg = o.get("web-register") or {}
+    mt = float(reg.get("MT", 0.0)) if isinstance(reg, dict) else 0.0
+    if mt >= max_mt:
+        return None, "machine_translated"
+    rtop, _ = top_register(reg)
+    if ALLOWED_REGISTERS and rtop not in ALLOWED_REGISTERS:
+        return None, "register"
+    text = (o.get("text") or "").strip()
+    if len(text) < min_chars:
+        return None, "short"
+    if len(text.split()) < min_words:
+        return None, "few_words"
+    if len(text) > MAX_CHARS:
+        return None, "too_long"
+    if PDFHOST_RE.search(text[:200]):
+        return None, "filehost"
+    if len(MOJIBAKE_RE.findall(text[:3000])) >= 3:
+        return None, "mojibake"
+    s = text[:5000]
+    if len(BOILERPLATE_RE.findall(s)) >= 3:
+        return None, "boilerplate"
+    if ADULT_SPAM_RE.search(s):
+        return None, "adult_spam"
+    if LEGALISH_RE.search(s):
+        return None, "legalish"
+    return text, "kept"
+
+def open_input(path):
+    """Local file or URL (stream) -> binary readable context manager."""
+    if str(path).startswith("http"):
+        import urllib.request
+        return urllib.request.urlopen(urllib.request.Request(path, headers={"User-Agent": "slayer-dsbench/1.0"}), timeout=120)
+    return open(path, "rb")
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in", dest="inp", default=r"C:\ProjektyPublic\datasets\hplt_v3_pl\10_1.jsonl.zst")
+    ap.add_argument("--out-dir", default=r"C:\ProjektyPublic\datasets\hplt_v3_pl\data\european_hplt_v3_pl")
+    ap.add_argument("--source", default="european_hplt_v3_pl", help="wartosc kolumny source")
+    ap.add_argument("--out-name", default="", help="basename plikow (domyslnie = source); id prefix")
+    ap.add_argument("--bin-label", default="WDS=10")
+    ap.add_argument("--min-chars", type=int, default=400)
+    ap.add_argument("--min-words", type=int, default=80)
+    ap.add_argument("--min-lang-prob", type=float, default=0.80)
+    ap.add_argument("--max-mt-prob", type=float, default=0.20)
+    ap.add_argument("--max-per-domain", type=int, default=250)
+    ap.add_argument("--max-records", type=int, default=0)
+    a = ap.parse_args()
+    src = a.source; out = a.out_name or a.source
+    outd = Path(a.out_dir); outd.mkdir(parents=True, exist_ok=True)
+    t0 = time.time()
+
+    drops = {}; regs = {}; doms = {}; dom_counts = {}
+    ids, texts, tokens = [], [], []
+    read = kept = chars = toks = 0
+    mt_sum = 0.0
+    writer = pq.ParquetWriter(outd / f"{out}.parquet", CANON, compression="zstd")
+
+    def flush():
+        nonlocal ids, texts, tokens
+        if not ids:
+            return
+        n = len(ids)
+        writer.write_table(pa.table({
+            "id": ids, "text": texts, "source": [src]*n, "added": [ADDED]*n,
+            "created": [""]*n, "token_count": tokens, "license": [LICENSE]*n, "author": [""]*n},
+            schema=CANON))
+        ids, texts, tokens = [], [], []
+
+    with open_input(a.inp) as fh:
+        reader = zstd.ZstdDecompressor().stream_reader(fh)
+        buf = b""
+        while True:
+            chunk = reader.read(1 << 20)
+            if not chunk:
+                break
+            buf += chunk
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+                if not line.strip():
+                    continue
+                try:
+                    o = json.loads(line)
+                except Exception:
+                    continue
+                read += 1
+                text, reason = keep(o, a.min_chars, a.min_words, a.min_lang_prob,
+                                    a.max_mt_prob, dom_counts, a.max_per_domain)
+                if text is None:
+                    drops[reason] = drops.get(reason, 0) + 1
+                    continue
+                host = domain(o.get("u")); dom_counts[host] = dom_counts.get(host, 0) + 1
+                if len(doms) < 500:
+                    doms[host] = doms.get(host, 0) + 1
+                reg = o.get("web-register") or {}
+                rtop, _ = top_register(reg); regs[rtop] = regs.get(rtop, 0) + 1
+                mt_sum += float(reg.get("MT", 0.0)) if isinstance(reg, dict) else 0.0
+                tk = len(ENC.encode(text, disallowed_special=()))
+                ids.append(f"{out}_{kept}"); texts.append(text); tokens.append(tk)
+                kept += 1; chars += len(text); toks += tk
+                if len(ids) >= 1000:
+                    flush()
+                if read % 20000 == 0:
+                    print(f"  read={read:,} kept={kept:,} tok={toks:,} ({time.time()-t0:.0f}s)", flush=True)
+                if a.max_records and kept >= a.max_records:
+                    buf = b""; break
+            else:
+                continue
+            break
+    flush(); writer.close()
+
+    stats = {"read": read, "kept": kept, "drop_short": drops.get("short", 0),
+             "drop_lang": drops.get("language", 0) + drops.get("lang_prob", 0),
+             "drop_dup": 0, "drop_ocr": 0, "chars": chars, "tokens": toks,
+             "licenses": {LICENSE: kept}, "authors_with_value": 0, "license": LICENSE,
+             "stats_recomputed_from_parquet": True,
+             "drop_detail": drops, "registers": regs,
+             "mt_prob_mean_kept": round(mt_sum / max(1, kept), 3),
+             "domains_top_sample": dict(sorted(doms.items(), key=lambda x: -x[1])[:30]),
+             "secs": round(time.time()-t0, 1),
+             "source_repo": f"HPLT/HPLT3.0 pol_Latn {a.bin_label} via {a.inp}"}
+    (outd / f"{out}.stats.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2)+"\n", encoding="utf-8")
+    print("=== STATS ===")
+    print(json.dumps({k: v for k, v in stats.items() if k not in ("domains_top_sample",)}, ensure_ascii=False, indent=2))
+    print(f"parquet={outd/(out+'.parquet')} ({os.path.getsize(outd/(out+'.parquet')):,}B)")
+
+if __name__ == "__main__":
+    main()

src/sources.py

@@ -229,6 +229,31 @@ SOURCES = {
                       "records should remain separately labeled or held until "
                       "legal review confirms their US status.",
     },
+    "european_hplt_v3_pl": {
+        "file_key": "european_hplt_v3_pl",
+        "pretty": "HPLT v3.0 Polish (web, top WDS bins 10-9)",
+        "license": "CC0-1.0",
+        "license_spdx": "CC0-1.0",
+        "traceable": "HPLT v3.0 Terms of Use license the data packaging under CC0-1.0 "
+                     "(hplt-project.org/datasets/v3.0; HF card HPLT/HPLT3.0). HPLT does not "
+                     "own the underlying web text; notice-and-takedown applies and downstream "
+                     "legal/provenance review remains the user's responsibility.",
+        "upstream": "https://data.hplt-project.org/three/sorted/pol_Latn/",
+        "provenance": "Fetched directly from the HPLT v3 distribution (pol_Latn shards "
+                      "10_1 [WDS=10] and 9_1 prefix [WDS=9]) by src/clean_hplt_v3.py, NOT via "
+                      "SpeakLeash. Filtered: lang=pol_Latn + prob>=0.80, MT-prob<0.20, register "
+                      "in ID/OP/HI/IN/NA, min 400 chars / 80 words, boilerplate/adult/legalish "
+                      "drop, length cap 120k chars, CJK-mojibake drop, wikipedia/wikisource/"
+                      "wikimedia + file-host domains excluded. Token counts via tiktoken cl100k.",
+        "domain": "web",
+        "created": "2012-01-01, 2024-12-31",
+        "is_ocr": False,
+        "legal_note": "Web-crawl derived: accept_after_web_review. HPLT is globally "
+                      "deduplicated upstream and WDS quality-sorted; only top bins used. "
+                      "Copyright recurs at all lengths in web crawl, so per-source near/"
+                      "containment dedup vs existing sources is left to downstream per "
+                      "Dynaword guidelines. Parity with the accepted european-hplt-v1 CC0 basis.",
+    },
 }
 
 ADDED = "2026-06-15"

src/test_hplt_v3_contract.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Lokalny kontrakt-test artefaktu european_hplt_v3_pl (wzorzec: test_europeana_contract.py).
+
+Ćwiczy inwarianty bramki merge DynaWord, które da się sprawdzić bez repo/CI:
+canonical schema (typy+kolejność), licencja open+niepusta, brak pustego tekstu, token_count>0,
+stats.json spójny z parquetem. NIE zastępuje `dsbench audit`/CI po stronie repo (licencja finalnie
+podnoszona z src/sources.py — wpis MUSI być w PR).
+"""
+import json, sys
+from pathlib import Path
+import pyarrow as pa, pyarrow.parquet as pq
+import pyarrow.compute as pc
+
+D = Path(r"C:\ProjektyPublic\datasets\hplt_v3_pl\data\european_hplt_v3_pl")
+PARQUET = D / "european_hplt_v3_pl.parquet"
+STATS = D / "european_hplt_v3_pl.stats.json"
+ACCEPTED = {"cc0-1.0", "cc-by-3.0", "cc-by-4.0", "cc-by-sa-3.0", "cc-by-sa-4.0",
+            "public-domain", "mit", "apache-2.0", "bsd-3-clause"}
+CANON = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+CANON_TYPES = {"id": "string", "text": "string", "source": "string", "added": "string",
+               "created": "string", "token_count": "int64", "license": "string", "author": "string"}
+
+def main():
+    fails = []
+    pf = pq.ParquetFile(PARQUET)
+    sch = pf.schema_arrow
+    # 1. schema exact (order + types)
+    if sch.names != CANON:
+        fails.append(f"schema names != canonical: {sch.names}")
+    for name in CANON:
+        if name in sch.names and str(sch.field(name).type) != CANON_TYPES[name]:
+            fails.append(f"type {name}={sch.field(name).type} != {CANON_TYPES[name]}")
+    tbl = pf.read()
+    n = tbl.num_rows
+    # 2. licenses open + non-empty
+    lic = set(pc.unique(tbl["license"]).to_pylist())
+    bad = {l for l in lic if (l or "").lower() not in ACCEPTED}
+    if bad:
+        fails.append(f"non-accepted/empty licenses: {bad}")
+    # 3. no empty text
+    empty = pc.sum(pc.equal(pc.utf8_trim_whitespace(tbl["text"]), "")).as_py() or 0
+    if empty:
+        fails.append(f"empty text rows: {empty}")
+    # 4. token_count > 0
+    nonpos = pc.sum(pc.less_equal(tbl["token_count"], 0)).as_py() or 0
+    if nonpos:
+        fails.append(f"token_count<=0 rows: {nonpos}")
+    # 5. source uniform
+    srcs = set(pc.unique(tbl["source"]).to_pylist())
+    if srcs != {"european_hplt_v3_pl"}:
+        fails.append(f"source not uniform: {srcs}")
+    # 6. stats.json consistent
+    st = json.loads(STATS.read_text(encoding="utf-8"))
+    if st["kept"] != n:
+        fails.append(f"stats.kept={st['kept']} != parquet rows={n}")
+    tok_sum = pc.sum(tbl["token_count"]).as_py()
+    if st["tokens"] != tok_sum:
+        fails.append(f"stats.tokens={st['tokens']} != parquet sum={tok_sum}")
+
+    print(f"rows={n:,} tokens={tok_sum:,} licenses={lic} source={srcs}")
+    if fails:
+        print("CONTRACT FAIL:"); [print("  -", f) for f in fails]; sys.exit(1)
+    print("CONTRACT PASS (schema+license+text+token+stats invariants)")
+
+if __name__ == "__main__":
+    main()