#!/usr/bin/env python3
"""Build an auditable slice of Polish Wikipedia talk pages (ns 1+5, CC BY-SA 4.0)."""
from __future__ import annotations

import argparse
import bz2
from collections import Counter
from concurrent.futures import ProcessPoolExecutor
from datetime import datetime, timezone
from difflib import SequenceMatcher
import gzip
import hashlib
import ipaddress
import json
from pathlib import Path
import re
import time
import unicodedata
from xml.etree.ElementTree import iterparse
from urllib.parse import quote

import requests


SOURCE = "plwiki_talk"
OWN_REPO = "PiotrSty/plwiki-talk-pages"
TARGET = "SlayerLab/polish-dynaword"
DUMP_DATE = "20260901"
DUMP_BASE = f"https://dumps.wikimedia.org/plwiki/{DUMP_DATE}"
DUMPSTATUS_URL = DUMP_BASE + "/dumpstatus.json"
INDEX_URL = "https://dumps.wikimedia.org/plwiki/"
SOURCE_URL = "https://pl.wikipedia.org/"
FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
UA = {"User-Agent": "polish-dynaword/0.2 (+research; openly-licensed corpus)"}
LICENSE_SPDX = "CC-BY-SA-4.0"
LICENSE_TERMS_URL = "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use/pl&oldid=584706"
TALK_NS = {"1", "5"}
MIN_TEXT_CHARS = 500
BOILERPLATE_MIN_DOC_FREQ = 0.01
EMAIL_RE = re.compile(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b")
PHONE_RE = re.compile(r"(?i)(?:\btelefon|\btel\.|\bphone)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b")
IPV4_RE = re.compile(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b")
IPV6_RE = re.compile(r"(?i)\b(?:[0-9a-f]{1,4}:){3,}[0-9a-f]{1,4}\b")


IPV6_CANDIDATE_RE = re.compile(r"(?<![\w:])(?:[0-9a-fA-F]{0,4}:){2,}[0-9a-fA-F:.]*(?![\w:])")
NATIONAL_ID_RE = re.compile(r"(?i)\b(PESEL|NIP|REGON)\s*[:=]?\s*\d(?:[ -]?\d){8,13}\b")
BANK_ACCOUNT_RE = re.compile(r"(?<!\d)(?:PL\s*)?\d{2}(?:[ -]?\d){24}(?!\d)")


def is_ipv6(value):
    try:
        return ipaddress.ip_address(value.rstrip(".")).version == 6
    except ValueError:
        return False


def redact_pii(text):
    counts = Counter()

    def replace_ipv6(match):
        value = match.group().rstrip(".")
        if not is_ipv6(value):
            return match.group()
        counts["ipv6"] += 1
        return "[REDACTED:IP]" + match.group()[len(value):]

    text = IPV6_CANDIDATE_RE.sub(replace_ipv6, text)
    for name, pattern, replacement in (
        ("email", EMAIL_RE, "[REDACTED:EMAIL]"),
        ("labelled_phone", PHONE_RE, "[REDACTED:PHONE]"),
        ("ipv4", IPV4_RE, "[REDACTED:IP]"),
        ("ipv6_legacy_pattern", IPV6_RE, "[REDACTED:IP]"),
        ("national_identifier", NATIONAL_ID_RE, lambda match: match.group(1) + " [REDACTED:ID]"),
        ("account_candidate", BANK_ACCOUNT_RE, "[REDACTED:ACCOUNT]"),
    ):
        text, count = pattern.subn(replacement, text)
        counts[name] += count
    return text, counts


def now():
    return datetime.now(timezone.utc).isoformat()


def digest(value):
    if not isinstance(value, bytes):
        value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
    return hashlib.sha256(value).hexdigest()


def sha1_file(path):
    h = hashlib.sha1()
    with path.open("rb") as handle:
        while chunk := handle.read(1 << 22):
            h.update(chunk)
    return h.hexdigest()


def save(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")


def write_lines(path, rows):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8")


def read_lines(path):
    return [json.loads(line) for line in path.read_text(encoding="utf-8").split("\n") if line]


def load(path):
    return json.loads(path.read_text(encoding="utf-8"))


def request(url, attempts=5, timeout=(15, 90)):
    response = None
    for attempt in range(attempts):
        response = requests.get(url, headers=UA, timeout=timeout)
        if response.status_code not in (429, 500, 502, 503, 504):
            response.raise_for_status()
            return response
        time.sleep(2 ** attempt)
    response.raise_for_status()


def request_json(url):
    return request(url).json()


def _local(tag):
    return tag.rsplit("}", 1)[-1]


def strip_wikitext(wikitext):
    import mwparserfromhell
    try:
        return mwparserfromhell.parse(wikitext).strip_code(normalize=True, collapse=True).strip()
    except Exception:
        return ""


def _strip_batch(items):
    return [strip_wikitext(wikitext) for _, _, _, _, wikitext in items]


def discover(out):
    status = request_json(DUMPSTATUS_URL)
    jobs = status.get("jobs", {})
    files = []
    for job in jobs.values():
        if job.get("status") != "done":
            continue
        for name, meta in (job.get("files") or {}).items():
            if re.fullmatch(r"plwiki-\d+-pages-meta-current\d+\.xml-p\d+p\d+\.bz2", name):
                files.append({"name": name, "url": f"{DUMP_BASE}/{name}",
                              "size": meta.get("size"), "sha1": meta.get("sha1")})
    files.sort(key=lambda item: item["name"])
    if not files:
        raise ValueError("no meta-current shards found")
    selection = {
        "observed_at": now(), "dump_date": DUMP_DATE, "dump_base": DUMP_BASE,
        "dumpstatus_url": DUMPSTATUS_URL, "files": files,
        "total_bytes": sum(item["size"] for item in files),
        "talk_namespaces": sorted(TALK_NS), "min_text_chars": MIN_TEXT_CHARS,
        "license": "CC BY-SA 4.0 (Wikimedia dump terms, same basis as the shipped wikipedia shard)",
        "files_sha256": digest(files),
    }
    save(out / "selection.json", selection)
    print(json.dumps({k: selection[k] for k in ("dump_date", "total_bytes")}, indent=2))
    print("files:", len(files))


def parse_shard(path):
    records = []
    with bz2.open(path, "rb") as fh:
        title = ns = pageid = timestamp = text = None
        redirect = False
        for ev, el in iterparse(fh, events=("end",)):
            tag = _local(el.tag)
            if tag == "title":
                title = el.text
            elif tag == "ns":
                ns = el.text
            elif tag == "id" and pageid is None:
                pageid = el.text
            elif tag == "timestamp":
                timestamp = el.text
            elif tag == "redirect":
                redirect = True
            elif tag == "text":
                text = el.text
            elif tag == "page":
                if ns in TALK_NS and not redirect and text:
                    records.append((pageid, ns, title, timestamp, text))
                title = ns = pageid = timestamp = text = None
                redirect = False
                el.clear()
    return records


def acquire(out, workers):
    selection = load(out / "selection.json")
    dump_dir = out / "raw_dump"
    dump_dir.mkdir(parents=True, exist_ok=True)
    extracted_dir = out / "extracted"
    extracted_dir.mkdir(exist_ok=True)
    manifest = []
    for item in selection["files"]:
        dst = dump_dir / item["name"]
        if not dst.exists() or dst.stat().st_size != item["size"]:
            print(f"  pobieram {item['name']} ({item['size']/1e6:.0f} MB)", flush=True)
            for attempt in range(8):
                have = dst.stat().st_size if dst.exists() else 0
                headers = dict(UA)
                if have:
                    headers["Range"] = f"bytes={have}-"
                try:
                    with requests.get(item["url"], headers=headers, stream=True, timeout=(15, 300)) as r:
                        r.raise_for_status()
                        if have and r.status_code != 206:
                            have = 0
                        with dst.open("ab" if have else "wb") as f:
                            for chunk in r.iter_content(1 << 22):
                                f.write(chunk)
                    break
                except requests.RequestException as error:
                    print(f"  retry {item['name']}: {type(error).__name__}", flush=True)
                    time.sleep(min(2 ** attempt, 60))
            else:
                raise RuntimeError(f"download failed: {item['name']}")
        sha = sha1_file(dst)
        if item["sha1"] and sha != item["sha1"]:
            raise ValueError(f"sha1 mismatch {item['name']}: {sha} != {item['sha1']}")
        print(f"  {item['name']} sha1 OK", flush=True)

        out_path = extracted_dir / (item["name"] + ".jsonl.gz")
        if not out_path.exists():
            records = parse_shard(dst)
            batches = [records[i:i + 2000] for i in range(0, len(records), 2000)]
            with ProcessPoolExecutor(max_workers=workers) as pool:
                texts = [text for batch in pool.map(_strip_batch, batches) for text in batch]
            with gzip.open(out_path, "wt", encoding="utf-8") as f:
                for (pageid, ns, title, timestamp, wikitext), text in zip(records, texts):
                    f.write(json.dumps({"pageid": pageid, "ns": ns, "title": title,
                                        "timestamp": timestamp, "wikitext_chars": len(wikitext),
                                        "text": text}, ensure_ascii=False) + "\n")
        shard_records = 0
        kept_chars = 0
        with gzip.open(out_path, "rt", encoding="utf-8") as f:
            for line in f:
                row = json.loads(line)
                shard_records += 1
                kept_chars += len(row["text"])
                manifest.append({"pageid": row["pageid"], "ns": row["ns"], "title": row["title"],
                                 "timestamp": row["timestamp"],
                                 "url": page_url(row["title"])})
        print(f"  {item['name']}: {shard_records} stron dyskusji", flush=True)
    write_lines(out / "source_manifest.jsonl", manifest)
    acquisition = {
        "observed_at": now(), "dump_date": selection["dump_date"],
        "files": selection["files"], "talk_pages": len(manifest),
        "manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()),
    }
    save(out / "acquisition.json", acquisition)
    print(json.dumps(acquisition, ensure_ascii=False, indent=2))


def strip_boilerplate(texts_index):
    counts = Counter()
    for lines in texts_index:
        counts.update(set(re.sub(r"\s+", " ", line).strip() for line in lines if line.strip()))
    n = len(texts_index)
    return {line for line, count in counts.items()
            if count / n >= BOILERPLATE_MIN_DOC_FREQ and len(line) < 160}


def normalize(text):
    text = unicodedata.normalize("NFKC", text or "").replace("­", "").replace("​", "")
    text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text)
    lines = [re.sub(r"[ \t\xa0]+", " ", line).strip() for line in text.splitlines()]
    lines = [line for line in lines if not re.fullmatch(r"\d{1,4}", line)]
    text = "\n".join(lines)
    text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text)
    text = re.sub(r"(?<![.!?:;\n])\n(?!\n)(?=[a-ząćęłńóśźż])", " ", text)
    return re.sub(r"\n{3,}", "\n\n", text).strip()


def page_url(title):
    return SOURCE_URL + "wiki/" + quote((title or "").replace(" ", "_"), safe="/:")


def normalize_title(text):
    text = unicodedata.normalize("NFKD", text or "").casefold()
    text = "".join(character for character in text if not unicodedata.combining(character))
    return " ".join(re.findall(r"\w+", text))


def shingle_sketch(text, limit=5_000):
    words = re.findall(r"\w+", text.casefold())
    hashes = set()
    for index in range(max(0, len(words) - 4)):
        value = " ".join(words[index:index + 5]).encode("utf-8")
        hashes.add(int.from_bytes(hashlib.blake2b(value, digest_size=8).digest(), "big"))
    if len(hashes) > limit:
        return set(sorted(hashes)[:limit])
    return hashes


class NearDuplicateIndex:
    def __init__(self):
        self.postings = {}
        self.records = []
        self.comparisons = 0

    @staticmethod
    def prefix(sketch):
        return sorted(sketch)[:len(sketch) - (9 * len(sketch) + 9) // 10 + 1]

    def find(self, sketch):
        candidates = set()
        for value in self.prefix(sketch):
            candidates.update(self.postings.get(value, ()))
        for position in sorted(candidates):
            row_id, other = self.records[position]
            if 10 * min(len(sketch), len(other)) < 9 * max(len(sketch), len(other)):
                continue
            self.comparisons += 1
            intersection = len(sketch & other)
            score = intersection / max(len(sketch) + len(other) - intersection, 1)
            if score >= 0.90:
                return row_id, score
        return None, 0.0

    def add(self, row_id, sketch):
        position = len(self.records)
        self.records.append((row_id, sketch))
        for value in self.prefix(sketch):
            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"]
    tree = request_json(f"https://huggingface.co/api/datasets/{TARGET}/tree/{revision}?recursive=true&expand=false")
    discussions = request_json(f"https://huggingface.co/api/datasets/{TARGET}/discussions?status=open&p=0")
    paths = sorted(item.get("path", "") for item in tree)
    open_rows = [{"num": item.get("num"), "title": item.get("title"), "status": item.get("status"),
                  "author": item.get("author", {}).get("name")} for item in discussions.get("discussions", [])]
    terms = ("plwiki_talk", "wikipedia_talk", "talk", "dyskusja")
    matches = [path for path in paths if any(term in path.casefold() for term in terms)]
    discussion_matches = [row for row in open_rows if any(term in (row.get("title") or "").casefold()
                                                          for term in terms)]
    report = {
        "target": TARGET, "revision": revision, "last_modified": info.get("lastModified"),
        "tree_paths": len(paths), "source_path_matches": matches, "open_discussions": open_rows,
        "matching_open_discussions": discussion_matches, "source_absent": not matches and not discussion_matches,
        "observed_at": now(),
    }
    save(out / "target_audit.json", report)
    print(json.dumps({"revision": revision, "source_absent": report["source_absent"],
                      "tree_matches": matches, "discussion_matches": discussion_matches}, ensure_ascii=False, indent=2))


def audit_overlap(out):
    import pyarrow.parquet as pq
    from huggingface_hub import HfApi, HfFileSystem

    acquisition = load(out / "acquisition.json")
    revision = HfApi().dataset_info(TARGET).sha
    remote = f"datasets/{TARGET}@{revision}/data/wikipedia/wikipedia.parquet"
    with HfFileSystem().open(remote, "rb") as handle:
        table = pq.read_table(handle, columns=["id"])
    target_ids = set(table.column("id").to_pylist())
    candidate_ids = {f"{SOURCE}_{row['pageid']}" for row in read_lines(out / "source_manifest.jsonl")}
    collisions = sorted(candidate_ids & target_ids)
    report = {
        "target": f"{TARGET}:data/wikipedia", "target_revision": revision,
        "method": "Literal dataset-record ID comparison only. Source-specific ID prefixes make zero collisions "
                  "uninformative about page identity or text overlap. No target namespace or text audit was performed.",
        "target_rows": table.num_rows, "candidate_records": len(candidate_ids),
        "id_collisions": collisions[:50], "collision_count": len(collisions),
        "text_overlap": "not tested; quoted-article passages and target-wide text dedup remain integration gates",
        "observed_at": now(),
    }
    save(out / "overlap_audit.json", report)
    print(json.dumps({key: report[key] for key in ("target_revision", "target_rows", "candidate_records",
                                                    "collision_count")}, ensure_ascii=False, indent=2))


def build(out):
    import pyarrow as pa
    import pyarrow.parquet as pq
    import tiktoken
    from langid.langid import LanguageIdentifier, model

    build_started_at = now()
    acquisition = load(out / "acquisition.json")
    selection = load(out / "selection.json")
    encoder = tiktoken.get_encoding("cl100k_base")
    identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
    identifier.set_languages(["pl", "en", "de", "uk", "ru"])

    candidates = []
    for shard in sorted((out / "extracted").glob("*.jsonl.gz")):
        with gzip.open(shard, "rt", encoding="utf-8") as f:
            for line in f:
                row = json.loads(line)
                row["text"] = normalize(row["text"])
                candidates.append(row)
    boilerplate = strip_boilerplate([row["text"].splitlines() for row in candidates])
    print(f"boilerplate lines: {len(boilerplate)}", flush=True)

    rows, attribution, decisions, exact_seen = [], [], [], {}
    near_index = NearDuplicateIndex()
    pii = Counter()
    added = acquisition["observed_at"][:10]
    started = last_progress = time.monotonic()
    for processed, record in enumerate(candidates, 1):
        current = time.monotonic()
        if current - last_progress >= 10 or processed == len(candidates):
            print(f"  processed={processed - 1}/{len(candidates)} kept={len(rows)} "
                  f"rate={(processed - 1) / max(current - started, 0.001):.1f}/s "
                  f"near_comparisons={near_index.comparisons}", flush=True)
            last_progress = current
        text = "\n".join(line for line in record["text"].splitlines()
                         if re.sub(r"\s+", " ", line).strip() not in boilerplate)
        text = re.sub(r"\n{3,}", "\n\n", text).strip()
        replacement_count = text.count("\ufffd")
        letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text))
        language, votes = "not_checked", []
        reason = ""
        if len(text) < MIN_TEXT_CHARS:
            reason = "too_little_text"
        elif letters / max(len(text), 1) < 0.5:
            reason = "low_letter_ratio"
        elif replacement_count > 100 or replacement_count / max(len(text), 1) > 0.002:
            reason = "excessive_replacement_characters"
        if not reason:
            language, votes = language_vote(identifier, text)
            if language != "pl":
                reason = "non_polish_text"
        text = text.replace("\ufffd", "[UNREADABLE_GLYPH]")
        text, pii_counts = redact_pii(text)
        pii.update(pii_counts)
        if not reason and len(text) < MIN_TEXT_CHARS:
            reason = "too_little_text_after_redaction"
        exact_key = digest(" ".join(text.casefold().split()).encode("utf-8"))
        duplicate_of, duplicate_score = None, 0.0
        if not reason and exact_key in exact_seen:
            reason, duplicate_of, duplicate_score = "normalized_duplicate", exact_seen[exact_key], 1.0
        if not reason:
            sketch = shingle_sketch(text)
            duplicate_of, duplicate_score = near_index.find(sketch)
            if duplicate_of is not None:
                reason = "near_duplicate"
        row_id = f"{SOURCE}_{record['pageid']}"
        decision = {
            "id": row_id, "selected": not bool(reason), "reason": reason or "include",
            "characters": len(text), "letter_ratio": letters / max(len(text), 1),
            "replacement_characters": replacement_count, "language": language,
            "language_votes": [{"language": lang, "confidence": float(score)} for lang, score in votes],
        }
        if duplicate_of:
            decision.update({"duplicate_of": duplicate_of, "jaccard": duplicate_score})
        decisions.append(decision)
        if reason:
            continue
        exact_seen[exact_key] = row_id
        near_index.add(row_id, sketch)
        row = {
            "id": row_id, "text": text, "source": SOURCE, "added": added,
            "created": (record["timestamp"] or "")[:10] or "unknown",
            "token_count": len(encoder.encode_ordinary(text)),
            "license": LICENSE_SPDX, "author": "plwiki contributors",
        }
        rows.append(row)
        attribution.append({
            "id": row_id, "pageid": record["pageid"], "ns": record["ns"], "title": record["title"],
            "url": page_url(record["title"]),
            "last_revision_at": record["timestamp"], "wikitext_chars": record["wikitext_chars"],
            "license": LICENSE_SPDX,
            "license_evidence": LICENSE_TERMS_URL + " (section 7, text licensing and attribution by page URL)",
            "dump": {"date": selection["dump_date"], "files": [f["name"] for f in selection["files"]]},
            "text_sha256": digest(text.encode("utf-8")),
            "transformations": ["official pages-meta-current dump", "mwparserfromhell wikitext strip",
                                "cross-document boilerplate-line removal",
                                "Unicode/whitespace normalization", "page-number-only removal",
                                "line-wrap repair", "email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction"],
        })

    root = out / "hf_repo"
    (root / "data").mkdir(parents=True, exist_ok=True)
    (root / "artifacts").mkdir(parents=True, exist_ok=True)
    schema = pa.schema([(field, pa.int64() if field == "token_count" else pa.string()) for field in FIELDS])
    pq.write_table(pa.Table.from_pylist(rows, schema=schema), root / "data/train-00000-of-00001.parquet", compression="zstd")
    write_lines(root / "artifacts/attribution.jsonl", attribution)
    write_lines(root / "artifacts/decisions.jsonl", decisions)
    write_lines(root / "artifacts/source_manifest.jsonl", read_lines(out / "source_manifest.jsonl"))
    sample = sorted(rows, key=lambda row: digest(("sample:" + row["id"]).encode("utf-8")))[:12]
    write_lines(root / "artifacts/sample.jsonl", sample)
    save(root / "artifacts/selection.json", selection)
    save(root / "artifacts/acquisition.json", acquisition)
    save(root / "artifacts/boilerplate_lines.json", sorted(boilerplate))
    overlap = load(out / "overlap_audit.json") if (out / "overlap_audit.json").exists() else None
    target_audit = load(out / "target_audit.json") if (out / "target_audit.json").exists() else None
    if overlap:
        save(root / "artifacts/overlap_audit.json", overlap)
    if target_audit:
        save(root / "artifacts/target_audit.json", target_audit)
    stats = {
        "dump_date": selection["dump_date"], "dump_files": len(selection["files"]),
        "talk_pages": acquisition["talk_pages"],
        "kept": len(rows), "rejected": len(decisions) - len(rows),
        "tokens": sum(row["token_count"] for row in rows),
        "characters": sum(len(row["text"]) for row in rows),
        "license_counts": dict(Counter(row["license"] for row in rows)),
        "boilerplate_lines_removed": len(boilerplate),
        "sample_count": len(sample), "added": added,
    }
    qa = {
        "scope": "Polish Wikipedia article-talk (ns=1) and project-talk (ns=5) pages from the pinned pages-meta-current dump",
        "license_terms_url": LICENSE_TERMS_URL,
        "license_gate": "Wikimedia Terms of Use section 7: CC BY-SA 4.0 and page-URL attribution; third-party notices still require review",
        "rejection_counts": dict(Counter(item["reason"] for item in decisions if not item["selected"])),
        "minimum_final_text_characters": MIN_TEXT_CHARS,
        "created_field_semantics": "Last revision date from the dump, not the page creation date",
        "language_gate": "independent three-window langid vote",
        "pii_pattern_matches": dict(pii), "exact_dedup": True,
        "pii_policy": "IPv6 parsed including compressed notation; labelled PESEL/NIP/REGON and 26-digit account candidates masked conservatively without checksum validation; counts cover all candidates before rejection",
        "pii_limitations": "Unlabelled national identifiers, free-form phone numbers, names and personal disclosures may remain; this is not complete anonymization",
        "near_dedup": "deterministic capped 5-word-shingle hash Jaccard >= 0.90 within source",
        "boilerplate": f"lines occurring in >= {BOILERPLATE_MIN_DOC_FREQ:.0%} of documents removed ({len(boilerplate)} patterns)",
        "wikipedia_shard_overlap": overlap or "pending", "cross_source_text_dedup": "pending target integration",
        "benchmark_overlap": "pending", "limitations": [
            "talk pages contain informal text with typos, edit disputes and occasional abuse/vandalism",
            "user-talk namespace (ns=3) excluded by scope decision; its quality was not measured",
            "comments may quote article text; quoted passages are not disjoint from the wikipedia shard",
            "record model is a whole talk page; individual comments are not split",
            "pattern checks are not comprehensive de-identification",
        ],
    }
    save(root / "artifacts/stats.json", stats)
    save(root / "artifacts/qa.json", qa)
    protocol_id = "protocol:plwiki-talk-v1"
    run = {
        "id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "selection": selection,
                                  "acquisition": digest(acquisition)}),
        "protocol": protocol_id, "started_at": build_started_at, "finished_at": now(),
        "success": True, "actor": "actor:devin", "stats": stats,
    }
    save(root / "artifacts/run.json", run)
    excluded = {"README.md", "NOTICE.md", "artifacts/checksums.json", "artifacts/ontology.json"}
    checks = {path.relative_to(root).as_posix(): digest(path.read_bytes()) for path in sorted(root.rglob("*"))
              if path.is_file()
              and path.relative_to(root).as_posix() not in excluded
              and not path.relative_to(root).as_posix().startswith("src/")}
    save(root / "artifacts/checksums.json", checks)
    source_version = "version:source:" + digest(selection["files"])
    dataset_version = "version:dataset:" + digest(checks)
    selection_evidence = "evidence:selection:" + digest(selection)
    acquisition_evidence = "evidence:acquisition:" + digest(acquisition)
    qa_evidence = "evidence:qa:" + digest(qa)
    evidence = [
        {"id": selection_evidence, "observation_type": "dump_inventory_and_pinning",
         "artifact": "artifacts/selection.json", "content_address": digest(selection), "produced_by": run["id"]},
        {"id": acquisition_evidence, "observation_type": "dump_download_sha1_and_extraction",
         "artifact": "artifacts/acquisition.json", "content_address": digest(acquisition), "produced_by": run["id"]},
        {"id": qa_evidence, "observation_type": "source_qa", "artifact": "artifacts/qa.json",
         "content_address": digest(qa), "produced_by": run["id"]},
    ]
    overlap_evidence = None
    if overlap:
        overlap_evidence = "evidence:overlap:" + digest(overlap)
        evidence.append({"id": overlap_evidence, "observation_type": "namespace_overlap_audit",
                         "artifact": "artifacts/overlap_audit.json", "content_address": digest(overlap),
                         "produced_by": run["id"]})
    target_evidence = None
    if target_audit:
        target_evidence = "evidence:target:" + digest(target_audit)
        evidence.append({"id": target_evidence, "observation_type": "target_registry_audit",
                         "artifact": "artifacts/target_audit.json", "content_address": digest(target_audit),
                         "produced_by": run["id"]})
    ontology = {
        "schema": "slayer-research-ontology-profile-v1",
        "objects": [{"id": "object:source:plwiki-dump-" + selection["dump_date"], "type": "Source"},
                    {"id": "object:dataset:plwiki-talk", "type": "Dataset"}],
        "versions": [{"id": source_version, "object": "object:source:plwiki-dump-" + selection["dump_date"],
                      "content_address": source_version.rsplit(":", 1)[-1]},
                     {"id": dataset_version, "object": "object:dataset:plwiki-talk",
                      "content_address": dataset_version.rsplit(":", 1)[-1]}],
        "protocols": [{"id": protocol_id, "procedure": "pinned dump; sha1-verified shards; namespaces 1+5; wikitext strip; boilerplate removal; normalization; PII patterns; exact and near dedup"}],
        "runs": [run], "evidence": evidence,
        "claims": [
            {"id": "claim:talk-pages-observed",
             "statement": f"The pinned dump {selection['dump_date']} yielded {acquisition['talk_pages']} non-redirect talk pages in namespaces 1 and 5.",
             "supported_by": [selection_evidence, acquisition_evidence],
             "falsification_condition": "The pinned dump shards do not reproduce the count."},
            {"id": "claim:slice-retention",
             "statement": f"The slice retained {stats['kept']} records after text QA and within-source deduplication.",
             "supported_by": [acquisition_evidence, qa_evidence],
             "falsification_condition": "The decisions, Parquet rows, or checksums do not reproduce the retention count."},
            {"id": "claim:source-absence-at-audit",
             "statement": "Talk-namespace Wikipedia content was not registered as a source in the pinned DynaWord data tree or open pull-request list at audit time.",
             "supported_by": [target_evidence] if target_evidence else [qa_evidence],
             "falsification_condition": "The pinned target evidence contains a matching source or proposal."},
            {"id": "claim:training-value-untested",
             "statement": "Net corpus novelty and training benefit remain untested hypotheses.",
             "supported_by": [qa_evidence] + ([overlap_evidence] if overlap_evidence else []),
             "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties."},
        ],
        "actors": [{"id": "actor:piotrsty", "type": "Contributor"},
                   {"id": "actor:wikimedia", "type": "Organization"}, {"id": "actor:devin", "type": "Agent"}],
        "relations": [{"source": dataset_version, "predicate": "DERIVED_FROM", "target": source_version},
                      {"source": dataset_version, "predicate": "GENERATED_BY", "target": run["id"]}] +
                     ([{"source": dataset_version, "predicate": "VALIDATED_AGAINST",
                        "target": f"hf:dataset:{TARGET}@{target_audit['revision']}"}] if target_audit else []),
        "pending": ["quoted-article-fragment dedup vs wikipedia shard", "cross-source text deduplication",
                    "benchmark contamination check", "abuse/vandalism content screening",
                    "controlled training ablation"],
    }
    save(root / "artifacts/ontology.json", ontology)
    card = f"""---
license: cc-by-sa-4.0
language:
- pl
task_categories:
- text-generation
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-00000-of-00001.parquet
---

# Polish Wikipedia talk pages (plwiki, namespaces 1+5)

Article-talk and project-talk pages from the pinned `plwiki-{selection['dump_date']}-pages-meta-current`
dump (https://dumps.wikimedia.org/plwiki/{selection['dump_date']}/).
The source selects namespaces 1 and 5; zero collisions of source-prefixed record
IDs do not establish disjointness from the target `wikipedia` shard. Target-wide
text deduplication remains pending. This is conversational written Polish:
editorial disputes, coordination, questions and answers.

- Dump files: {stats['dump_files']} shards, sha1-verified against dumpstatus.json
- Non-redirect talk pages (ns 1+5): {stats['talk_pages']:,}
- Retained after text QA and within-source deduplication: {stats['kept']:,}
- Characters: {stats['characters']:,}
- Tokens: {stats['tokens']:,} (`cl100k_base` proxy)
- License: CC BY-SA 4.0 per record; authorship via per-page history link

## Provenance and rights

Each record keeps its page id, title, namespace, last-revision timestamp and
canonical URL (history is the attribution trail, per [Wikimedia Terms of Use,
section 7]({LICENSE_TERMS_URL})). That section grants CC BY-SA 4.0 rights to
contributor text and allows attribution via the source-page URL. Additional
third-party attribution notices must be preserved and remain a review item.
The user-talk namespace (ns=3) is excluded by scope decision; its quality was
not measured. The `created` field is the last revision date, not page creation.

## Processing and limitations

Wikitext is stripped with mwparserfromhell; lines occurring in at least
{BOILERPLATE_MIN_DOC_FREQ:.0%} of documents are removed as
cross-document boilerplate (see `artifacts/boilerplate_lines.json`). Unicode and
whitespace normalization, email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction, three-window langid
vote, exact and near deduplication within source. The final text must contain at
least {MIN_TEXT_CHARS} characters after redaction. Rejection counts:

```json
{json.dumps(qa['rejection_counts'], ensure_ascii=False, indent=2)}
```

PII filtering masks parsed IPv6 addresses (including compressed forms), labelled
PESEL/NIP/REGON and 26-digit account candidates as well as the existing patterns.
The account filter is conservative and may mask non-account numbers; unlabelled
identifiers, free-form phone numbers, names and personal disclosures may remain.
This is not complete anonymization.

Talk pages are informal: they contain typos, edit disputes, quoted article
fragments and occasional vandalism or abuse. Quoted article text is not disjoint
from the shipped `wikipedia` shard; text-level dedup against it remains a target
integration gate. The record model is a whole talk page; comments are not split.

## Review artifacts

See `artifacts/sample.jsonl`, `attribution.jsonl`, `decisions.jsonl`,
`source_manifest.jsonl`, `overlap_audit.json`, `stats.json`, `qa.json`,
`checksums.json`, `run.json` and `ontology.json`.
"""
    (root / "README.md").write_text(card, encoding="utf-8")
    (root / "NOTICE.md").write_text(
        "# Attribution and license notice\n\n"
        "Source: Polish Wikipedia talk pages, https://pl.wikipedia.org/ - Wikimedia Foundation.\n\n"
        "Text is available under the Creative Commons Attribution-ShareAlike 4.0 License "
        "(https://creativecommons.org/licenses/by-sa/4.0/). Attribution is provided via the per-record "
        "canonical page URL in `artifacts/attribution.jsonl`; each page's revision history lists its "
        "contributors.\n\n"
        "Preparation: Piotr Styla with Devin. Changes: namespace filtering (1 and 5), wikitext "
        "stripping, cross-document boilerplate removal, Unicode and whitespace normalization, limited "
        "email/labelled-phone/IP/labelled-national-ID/account-candidate redaction, language/quality filtering and within-source deduplication. No "
        "endorsement by the Wikimedia Foundation or page contributors is implied.\n",
        encoding="utf-8",
    )
    print(json.dumps(stats, ensure_ascii=False, indent=2))


def verify(out):
    import pyarrow.parquet as pq

    root = out / "hf_repo"
    table = pq.read_table(root / "data/train-00000-of-00001.parquet")
    rows = table.to_pylist()
    stats = load(root / "artifacts/stats.json")
    decisions = read_lines(root / "artifacts/decisions.jsonl")
    attribution = read_lines(root / "artifacts/attribution.jsonl")
    sample = read_lines(root / "artifacts/sample.jsonl")
    assert table.column_names == FIELDS
    assert len(rows) == stats["kept"] == len(attribution)
    assert sum(item["selected"] for item in decisions) == len(rows)
    assert sum(row["token_count"] for row in rows) == stats["tokens"]
    assert all(row["source"] == SOURCE and row["license"] == LICENSE_SPDX for row in rows)
    assert all(EMAIL_RE.search(row["text"]) is None for row in rows)
    by_id = {row["id"]: row for row in rows}
    assert len(sample) == stats["sample_count"] and all(by_id[row["id"]] == row for row in sample)
    ontology = load(root / "artifacts/ontology.json")
    evidence = {item["id"] for item in ontology["evidence"]}
    assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence for item in ontology["claims"])
    checks = load(root / "artifacts/checksums.json")
    assert all((root / path).is_file() and digest((root / path).read_bytes()) == checksum for path, checksum in checks.items())
    for item in ontology["evidence"]:
        artifact = root / item["artifact"]
        assert artifact.is_file() and digest(load(artifact)) == item["content_address"]
    import tiktoken

    encoder = tiktoken.get_encoding("cl100k_base")
    assert len(by_id) == len(rows)
    assert set(by_id) == {item["id"] for item in attribution}
    assert set(by_id) == {item["id"] for item in decisions if item["selected"]}
    assert len(decisions) == stats["talk_pages"]
    assert len(decisions) - len(rows) == stats["rejected"]
    assert sum(len(row["text"]) for row in rows) == stats["characters"]
    short_ids = [row["id"] for row in rows if len(row["text"]) < MIN_TEXT_CHARS]
    assert all(row["token_count"] > 0 for row in rows)
    assert all(len(row["created"]) == 10 and row["author"] for row in rows)
    assert all(item["ns"] in TALK_NS and item["url"] == page_url(item["title"])
               and item["text_sha256"] == digest(by_id[item["id"]]["text"].encode("utf-8"))
               for item in attribution)
    assert all(len(encoder.encode_ordinary(row["text"])) == row["token_count"] for row in rows)
    boilerplate = set(load(root / "artifacts/boilerplate_lines.json"))
    review_ids = {row["id"] for row in sorted(sample, key=lambda item: len(item["text"]))[:3]}
    comparisons = []
    reconstructed = set()
    for shard in sorted((out / "extracted").glob("*.jsonl.gz")):
        with gzip.open(shard, "rt", encoding="utf-8") as handle:
            for line in handle:
                original = json.loads(line)
                row_id = f"{SOURCE}_{original['pageid']}"
                if row_id not in by_id:
                    continue
                text = normalize(original["text"])
                text = "\n".join(line for line in text.splitlines()
                                 if re.sub(r"\s+", " ", line).strip() not in boilerplate)
                text = re.sub(r"\n{3,}", "\n\n", text).strip().replace("\ufffd", "[UNREADABLE_GLYPH]")
                text, _ = redact_pii(text)
                before = redact_pii(original["text"])[0] if row_id in review_ids else ""
                assert text == by_id[row_id]["text"], row_id
                assert row_id not in reconstructed
                reconstructed.add(row_id)
                if row_id in review_ids:
                    comparisons.append({"id": row_id, "title": original["title"],
                                        "before_normalization_pii_patterns_redacted": before,
                                        "after": text})
    assert reconstructed == set(by_id)
    write_lines(out / "validation_samples.jsonl", comparisons)
    lengths = sorted(len(row["text"]) for row in rows)
    rejection_counts = dict(Counter(item["reason"] for item in decisions if not item["selected"]))
    residuals = {name: sum(bool(pattern.search(row["text"])) for row in rows)
                 for name, pattern in {"email": EMAIL_RE, "labelled_phone": PHONE_RE,
                                       "ipv4": IPV4_RE, "ipv6_current_pattern": IPV6_RE}.items()}
    privacy_review = {
        "compressed_ipv6_documents": sum(any(is_ipv6(match.group()) for match in IPV6_CANDIDATE_RE.finditer(row["text"])) for row in rows),
        "labelled_national_identifier_candidates": sum(bool(NATIONAL_ID_RE.search(row["text"])) for row in rows),
        "bank_account_candidates": sum(bool(BANK_ACCOUNT_RE.search(row["text"])) for row in rows),
    }
    report = {
        "observed_at": now(), "verified": not short_ids and not any(residuals.values()) and not any(privacy_review.values()), "stats": stats,
        "additional_privacy_review_document_counts": privacy_review,
        "below_minimum_length_ids": short_ids,
        "rejection_counts": rejection_counts,
        "retained_namespaces": dict(Counter(item["ns"] for item in attribution)),
        "length_quantiles": {str(q): lengths[int((len(lengths) - 1) * q)] for q in (0, 0.5, 0.9, 0.99, 1)},
        "residual_pattern_document_counts": residuals,
        "all_token_counts_recomputed": True,
        "texts_reconstructed_from_extracted_source": len(reconstructed),
        "before_after_samples": len(comparisons),
        "publication_ready": False,
        "pending": ["license evidence and attribution review", "PII coverage review",
                    "target overlap audit methodology review", "manual text quality review"],
    }
    save(out / "validation_report.json", report)
    print(json.dumps(report, ensure_ascii=False, indent=2))
    assert report["verified"], "Validation failures: see validation_report.json"


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("command", choices=["discover", "acquire", "audit_target", "audit_overlap",
                                            "build", "verify"])
    args = parser.parse_args()
    if args.command == "discover":
        discover(args.output)
    elif args.command == "acquire":
        acquire(args.output, args.workers)
    elif args.command == "audit_target":
        audit_target(args.output)
    elif args.command == "audit_overlap":
        audit_overlap(args.output)
    elif args.command == "build":
        build(args.output)
    else:
        verify(args.output)


if __name__ == "__main__":
    main()