Datasets:

cihatyldz
/

pusula-tr-robustness

"""
pusula_data.py — Farkli semalardaki retrieval veri setlerini ortak formata ceviren yukleyici.
Ortak format:
    queries : {qid: metin}
    corpus  : {doc_id: metin}
    qrels   : {qid: {doc_id: skor}}   (skor > 0 = ilgili)
Sema VARSAYILMAZ: config ve sutun adlari aday listelerinden eslestirilir; eslesmezse acik hata verilir.
"""
import re
from dataclasses import dataclass, field

import numpy as np

# Aday adlar — ilk eslesen kullanilir (kucuk harfle karsilastirilir)
CONFIG_CANDIDATES = {
    "corpus":  ["corpus", "passages", "collection", "documents"],
    "queries": ["queries", "query"],
    "qrels":   ["qrels", "default"],
}
COLUMN_CANDIDATES = {
    "doc_id":   ["_id", "id", "pid", "doc_id", "docid", "corpus-id", "corpus_id"],
    "query_id": ["_id", "id", "qid", "query_id", "query-id"],
    "title":    ["title"],
    "text":     ["text", "passage", "contents", "content", "query"],
    "qrel_q":   ["query-id", "query_id", "qid"],
    "qrel_d":   ["corpus-id", "corpus_id", "pid", "doc_id", "docid"],
    "qrel_s":   ["score", "relevance", "label"],
}
QRELS_SPLIT_PREFERENCE = ["test", "dev", "validation", "train"]


@dataclass
class RetrievalSet:
    name: str
    queries: dict
    corpus: dict
    qrels: dict
    meta: dict = field(default_factory=dict)

    def stats(self):
        rel = [sum(1 for s in d.values() if s > 0) for d in self.qrels.values()]
        return {"queries": len(self.queries), "corpus": len(self.corpus),
                "qrels_queries": len(self.qrels), "avg_relevant": float(np.mean(rel)) if rel else 0.0}

    def validate(self):
        """Tutarlilik: her sorgunun metni var, en az bir ilgili dokumani var ve o dokuman korpusta."""
        problems = []
        for qid, rels in self.qrels.items():
            if qid not in self.queries:
                problems.append(f"qrels'teki sorgu {qid} queries'te yok")
            if not any(s > 0 and d in self.corpus for d, s in rels.items()):
                problems.append(f"sorgu {qid}: korpusta ilgili dokuman yok")
        empty_q = [q for q, t in self.queries.items() if not str(t).strip()]
        empty_d = [d for d, t in self.corpus.items() if not str(t).strip()]
        if empty_q:
            problems.append(f"{len(empty_q)} bos sorgu")
        if empty_d:
            problems.append(f"{len(empty_d)} bos dokuman")
        return problems


def _pick(candidates, available, what):
    avail = {a.lower(): a for a in available}
    for c in candidates:
        if c.lower() in avail:
            return avail[c.lower()]
    raise KeyError(f"{what} icin uygun ad bulunamadi. Mevcut: {sorted(available)} | Adaylar: {candidates}")


def _pick_config(role, configs):
    for c in CONFIG_CANDIDATES[role]:
        for cfg in configs:
            if c == cfg.lower() or re.search(rf"\b{c}\b", cfg.lower()):
                return cfg
    raise KeyError(f"'{role}' config'i bulunamadi. Mevcut config'ler: {configs}")


def _first_split(ds_dict, preference=None):
    names = list(ds_dict.keys())
    for p in preference or []:
        if p in names:
            return p, ds_dict[p]
    return names[0], ds_dict[names[0]]


def describe_schema(repo, list_configs, load_fn):
    """Colab'da ilk calistirilacak: her config'in split ve sutunlarini yazdirir."""
    out = {}
    for cfg in list_configs(repo):
        dd = load_fn(repo, cfg)
        out[cfg] = {split: list(ds.column_names) for split, ds in dd.items()}
    return out


def load_beir_like(repo, list_configs, load_fn, name=None, meta=None):
    """corpus / queries / qrels ayri config'lerde duran veri setleri (BEIR, MTEB, TR-MTEB)."""
    configs = list_configs(repo)
    c_cfg, q_cfg, r_cfg = (_pick_config(r, configs) for r in ("corpus", "queries", "qrels"))

    # qrels: tercih edilen split (test > dev > ...)
    r_split, qrels_ds = _first_split(load_fn(repo, r_cfg), QRELS_SPLIT_PREFERENCE)
    cols = qrels_ds.column_names
    rq, rd = _pick(COLUMN_CANDIDATES["qrel_q"], cols, "qrels sorgu"), _pick(COLUMN_CANDIDATES["qrel_d"], cols, "qrels dokuman")
    rs = next((c for c in COLUMN_CANDIDATES["qrel_s"] if c in cols), None)  # skor yoksa 1 kabul edilir
    qrels = {}
    for row in qrels_ds:
        score = float(row[rs]) if rs else 1.0
        qrels.setdefault(str(row[rq]), {})[str(row[rd])] = score

    # queries: qrels split'iyle ayni ad varsa onu, yoksa tum split'leri birlestir
    q_dd = load_fn(repo, q_cfg)
    q_parts = [q_dd[r_split]] if r_split in q_dd else list(q_dd.values())
    queries = {}
    for part in q_parts:
        qid_col = _pick(COLUMN_CANDIDATES["query_id"], part.column_names, "sorgu id")
        txt_col = _pick(COLUMN_CANDIDATES["text"], part.column_names, "sorgu metni")
        for row in part:
            queries[str(row[qid_col])] = strip_artifacts(row[txt_col])

    corpus = {}
    for part in load_fn(repo, c_cfg).values():
        did_col = _pick(COLUMN_CANDIDATES["doc_id"], part.column_names, "dokuman id")
        txt_col = _pick(COLUMN_CANDIDATES["text"], part.column_names, "dokuman metni")
        has_title = "title" in part.column_names
        for row in part:
            title = (row["title"] or "").strip() if has_title else ""
            body = row[txt_col] or ""
            corpus[str(row[did_col])] = strip_artifacts(f"{title}. {body}" if title else body)

    qrels = {q: d for q, d in qrels.items() if q in queries}  # metni olmayan sorgulari dusur
    info = {"source": repo, "qrels_split": r_split, "configs": [c_cfg, q_cfg, r_cfg], **(meta or {})}
    return RetrievalSet(name or repo.split("/")[-1], queries, corpus, qrels, info)


_ARTIFACT_TOKENS = re.compile(r"<[A-Z_]{3,}>|\[(?:UNK|CLS|SEP|PAD)\]")


def strip_artifacts(s):
    """Ceviri hattindan sizan ozel tokenlari sil (<EOS_TOKEN>, [UNK] ...)."""
    return re.sub(r"\s{2,}", " ", _ARTIFACT_TOKENS.sub(" ", s or "")).strip()


def drop_self_duplicates(rs):
    """Sorgunun birebir aynisi korpusta ILGISIZ olarak duruyorsa sorguyu cikar (metin tabanli)."""
    text_to_docs = {}
    for d, t in rs.corpus.items():
        text_to_docs.setdefault(_norm(t), []).append(d)
    bad = {q for q, t in rs.queries.items()
           if any(rs.qrels.get(q, {}).get(d, 0) <= 0 for d in text_to_docs.get(_norm(t), []))}
    rs.queries = {q: t for q, t in rs.queries.items() if q not in bad}
    rs.qrels = {q: d for q, d in rs.qrels.items() if q not in bad}
    rs.meta["dropped_self_duplicates"] = len(bad)
    return rs


def _norm(s):
    return re.sub(r"\s+", " ", (s or "").strip().lower())


def load_claim_factcheck(rows, query_col="claim", doc_col="fact_check", id_col="id", name="dmm", meta=None):
    """Satir basina (iddia, dogrulama) tutan veri: sorgu=iddia, ilgili dokuman=dogrulama metni.
    Ayni dogrulama metni birden fazla satirda varsa TEK dokumana indirgenir ve tum ilgili sorgulara baglanir
    (aksi halde 'dogru' cevabin kopyasi yanlis sayilir)."""
    doc_by_text, corpus, queries, qrels = {}, {}, {}, {}
    for i, row in enumerate(rows):
        claim, fc = (row.get(query_col) or "").strip(), (row.get(doc_col) or "").strip()
        if not claim or not fc:
            continue
        key = _norm(fc)
        if key not in doc_by_text:
            did = f"d{len(doc_by_text)}"
            doc_by_text[key] = did
            corpus[did] = fc
        qid = f"q{row.get(id_col, i)}"
        queries[qid] = claim
        qrels.setdefault(qid, {})[doc_by_text[key]] = 1.0
    # ayni iddia metni farkli satirlarda: tek sorguya indir, ilgili dokumanlari birlestir
    by_claim = {}
    for qid, text in list(queries.items()):
        k = _norm(text)
        if k in by_claim:
            keep = by_claim[k]
            qrels[keep].update(qrels.pop(qid))
            del queries[qid]
        else:
            by_claim[k] = qid
    return RetrievalSet(name, queries, corpus, qrels, {"native": True, **(meta or {})})


def subsample(rs, n_queries, corpus_size, seed=0):
    """Ilgili dokumanlari HER ZAMAN koruyarak alt-ornekleme.
    1) Korpusta en az bir ilgili dokumani olan sorgulardan n_queries tanesi secilir
    2) Korpus = secilen sorgularin tum ilgili dokumanlari + rastgele dokumanlar (corpus_size'a kadar)"""
    rng = np.random.default_rng(seed)
    eligible = sorted(q for q, d in rs.qrels.items()
                      if q in rs.queries and any(s > 0 and doc in rs.corpus for doc, s in d.items()))
    chosen = eligible if len(eligible) <= n_queries else sorted(rng.choice(eligible, n_queries, replace=False))

    must = sorted({d for q in chosen for d, s in rs.qrels[q].items() if s > 0 and d in rs.corpus})
    pool = sorted(set(rs.corpus) - set(must))
    n_extra = max(0, min(len(pool), corpus_size - len(must)))
    extra = list(rng.choice(pool, n_extra, replace=False)) if n_extra else []
    keep = set(must) | set(extra)

    sub = RetrievalSet(
        rs.name,
        {q: rs.queries[q] for q in chosen},
        {d: rs.corpus[d] for d in sorted(keep)},
        {q: {d: s for d, s in rs.qrels[q].items() if d in keep} for q in chosen},
        {**rs.meta, "subsample": {"n_queries": len(chosen), "corpus_size": len(keep),
                                  "relevant_kept": len(must), "seed": seed,
                                  "full_queries": len(eligible), "full_corpus": len(rs.corpus)}},
    )
    return sub


# ═══ DMM: PDF'ten cikarilmis bulten kayitlari → (baslik sorgusu, analiz dokumani) ═══
_QUOTED = re.compile(r"[“\"][^”\"]*[”\"]")                 # tirnak icindeki alinti
_TOC_MARK = re.compile(r"[”\"]\s*İddia")                    # '” Iddiasi' kalibi
_LEADING_IDDIA = re.compile(r"^(İddiası|İddiaları)\b\s*")
_PAGE_FOOTER = re.compile(r"\s\d{1,3}\s*—(?=\s|$)")          # "25 —" sayfa altligi
_HEADLINE = re.compile(r'^\s*[“"](?P<title>[^”"]{8,400}?)[”"]\s*(?P<rest>.*)$', re.S)


def clean_pdf_text(s):
    s = (s or "").replace("\u00ad", "")                        # yumusak tire
    s = re.sub(r"-\n(?=[a-zçğıöşü])", "", s)                   # satir sonu heceleme
    s = re.sub(r"\s+", " ", s)
    s = _PAGE_FOOTER.sub(" ", " " + s + " ")
    return re.sub(r"\s+", " ", s).strip()


def load_headline_claims(rows, title_col="claim", tail_col="fact_check", id_col="id",
                         max_title_words=25, min_doc_words=15, name="dmm", meta=None):
    """Sorgu = tirnak icindeki iddia basligi; dokuman = kaydin geri kalani (analiz + dogrulama).
    Atlanan her satirin nedeni sayilir — sessiz veri kaybi olmaz."""
    skipped = {"baslik_yok": 0, "baslik_cok_uzun": 0, "icindekiler": 0, "dokuman_kisa": 0}
    corpus, queries, qrels, doc_by_text, examples = {}, {}, {}, {}, []
    for i, row in enumerate(rows):
        full = clean_pdf_text(f"{row.get(title_col) or ''} {row.get(tail_col) or ''}")
        m = _HEADLINE.match(full)
        if not m:
            skipped["baslik_yok"] += 1
            continue
        title, doc = m.group("title").strip(), m.group("rest").strip()
        if len(title.split()) > max_title_words:
            skipped["baslik_cok_uzun"] += 1
            continue
        if len(_TOC_MARK.findall(doc)) >= 2:          # baska basliklar listeleniyor → icindekiler sayfasi
            skipped["icindekiler"] += 1
            continue
        doc = _LEADING_IDDIA.sub("", doc)
        if len(_QUOTED.sub(" ", doc).split()) < min_doc_words:   # alintilanan iddia sayilmaz
            skipped["dokuman_kisa"] += 1
            continue
        key = _norm(doc)
        if key not in doc_by_text:
            doc_by_text[key] = f"d{len(doc_by_text)}"
            corpus[doc_by_text[key]] = doc
        qid = f"q{row.get(id_col, i)}"
        queries[qid] = title
        qrels.setdefault(qid, {})[doc_by_text[key]] = 1.0
    by_title = {}                                               # ayni baslik → tek sorgu
    for qid, text in list(queries.items()):
        k = _norm(text)
        if k in by_title:
            qrels[by_title[k]].update(qrels.pop(qid)); del queries[qid]
        else:
            by_title[k] = qid
    info = {"native": True, "rows": len(rows), "skipped": skipped, **(meta or {})}
    return RetrievalSet(name, queries, corpus, qrels, info)


# ═══ Teshis: degerlendirmeyi sessizce bozabilecek durumlar ═══
_ARTIFACT = re.compile(r"<[A-Z_]{3,}>|\[(?:UNK|CLS|SEP)\]")


def diagnostics(rs):
    q_art = sum(bool(_ARTIFACT.search(t)) for t in rs.queries.values())
    d_art = sum(bool(_ARTIFACT.search(t)) for t in rs.corpus.values())
    text_to_docs = {}
    for d, t in rs.corpus.items():
        text_to_docs.setdefault(_norm(t), []).append(d)
    # sorgunun birebir aynisi korpusta ILGISIZ dokuman olarak duruyor mu? (ID degil METIN kontrolu)
    self_dup = sum(1 for q, t in rs.queries.items()
                   if any(rs.qrels.get(q, {}).get(d, 0) <= 0 for d in text_to_docs.get(_norm(t), [])))
    return {"sorgu artefakt": q_art, "doküman artefakt": d_art, "sorgu=ilgisiz doküman (metin)": self_dup}

	"""
	pusula_data.py — Farkli semalardaki retrieval veri setlerini ortak formata ceviren yukleyici.

	Ortak format:
	queries : {qid: metin}
	corpus : {doc_id: metin}
	qrels : {qid: {doc_id: skor}} (skor > 0 = ilgili)

	Sema VARSAYILMAZ: config ve sutun adlari aday listelerinden eslestirilir; eslesmezse acik hata verilir.
	"""
	import re
	from dataclasses import dataclass, field

	import numpy as np

	# Aday adlar — ilk eslesen kullanilir (kucuk harfle karsilastirilir)
	CONFIG_CANDIDATES = {
	"corpus": ["corpus", "passages", "collection", "documents"],
	"queries": ["queries", "query"],
	"qrels": ["qrels", "default"],
	}
	COLUMN_CANDIDATES = {
	"doc_id": ["_id", "id", "pid", "doc_id", "docid", "corpus-id", "corpus_id"],
	"query_id": ["_id", "id", "qid", "query_id", "query-id"],
	"title": ["title"],
	"text": ["text", "passage", "contents", "content", "query"],
	"qrel_q": ["query-id", "query_id", "qid"],
	"qrel_d": ["corpus-id", "corpus_id", "pid", "doc_id", "docid"],
	"qrel_s": ["score", "relevance", "label"],
	}
	QRELS_SPLIT_PREFERENCE = ["test", "dev", "validation", "train"]


	@dataclass
	class RetrievalSet:
	name: str
	queries: dict
	corpus: dict
	qrels: dict
	meta: dict = field(default_factory=dict)

	def stats(self):
	rel = [sum(1 for s in d.values() if s > 0) for d in self.qrels.values()]
	return {"queries": len(self.queries), "corpus": len(self.corpus),
	"qrels_queries": len(self.qrels), "avg_relevant": float(np.mean(rel)) if rel else 0.0}

	def validate(self):
	"""Tutarlilik: her sorgunun metni var, en az bir ilgili dokumani var ve o dokuman korpusta."""
	problems = []
	for qid, rels in self.qrels.items():
	if qid not in self.queries:
	problems.append(f"qrels'teki sorgu {qid} queries'te yok")
	if not any(s > 0 and d in self.corpus for d, s in rels.items()):
	problems.append(f"sorgu {qid}: korpusta ilgili dokuman yok")
	empty_q = [q for q, t in self.queries.items() if not str(t).strip()]
	empty_d = [d for d, t in self.corpus.items() if not str(t).strip()]
	if empty_q:
	problems.append(f"{len(empty_q)} bos sorgu")
	if empty_d:
	problems.append(f"{len(empty_d)} bos dokuman")
	return problems


	def _pick(candidates, available, what):
	avail = {a.lower(): a for a in available}
	for c in candidates:
	if c.lower() in avail:
	return avail[c.lower()]
	raise KeyError(f"{what} icin uygun ad bulunamadi. Mevcut: {sorted(available)} \| Adaylar: {candidates}")


	def _pick_config(role, configs):
	for c in CONFIG_CANDIDATES[role]:
	for cfg in configs:
	if c == cfg.lower() or re.search(rf"\b{c}\b", cfg.lower()):
	return cfg
	raise KeyError(f"'{role}' config'i bulunamadi. Mevcut config'ler: {configs}")


	def _first_split(ds_dict, preference=None):
	names = list(ds_dict.keys())
	for p in preference or []:
	if p in names:
	return p, ds_dict[p]
	return names[0], ds_dict[names[0]]


	def describe_schema(repo, list_configs, load_fn):
	"""Colab'da ilk calistirilacak: her config'in split ve sutunlarini yazdirir."""
	out = {}
	for cfg in list_configs(repo):
	dd = load_fn(repo, cfg)
	out[cfg] = {split: list(ds.column_names) for split, ds in dd.items()}
	return out


	def load_beir_like(repo, list_configs, load_fn, name=None, meta=None):
	"""corpus / queries / qrels ayri config'lerde duran veri setleri (BEIR, MTEB, TR-MTEB)."""
	configs = list_configs(repo)
	c_cfg, q_cfg, r_cfg = (_pick_config(r, configs) for r in ("corpus", "queries", "qrels"))

	# qrels: tercih edilen split (test > dev > ...)
	r_split, qrels_ds = _first_split(load_fn(repo, r_cfg), QRELS_SPLIT_PREFERENCE)
	cols = qrels_ds.column_names
	rq, rd = _pick(COLUMN_CANDIDATES["qrel_q"], cols, "qrels sorgu"), _pick(COLUMN_CANDIDATES["qrel_d"], cols, "qrels dokuman")
	rs = next((c for c in COLUMN_CANDIDATES["qrel_s"] if c in cols), None) # skor yoksa 1 kabul edilir
	qrels = {}
	for row in qrels_ds:
	score = float(row[rs]) if rs else 1.0
	qrels.setdefault(str(row[rq]), {})[str(row[rd])] = score

	# queries: qrels split'iyle ayni ad varsa onu, yoksa tum split'leri birlestir
	q_dd = load_fn(repo, q_cfg)
	q_parts = [q_dd[r_split]] if r_split in q_dd else list(q_dd.values())
	queries = {}
	for part in q_parts:
	qid_col = _pick(COLUMN_CANDIDATES["query_id"], part.column_names, "sorgu id")
	txt_col = _pick(COLUMN_CANDIDATES["text"], part.column_names, "sorgu metni")
	for row in part:
	queries[str(row[qid_col])] = strip_artifacts(row[txt_col])

	corpus = {}
	for part in load_fn(repo, c_cfg).values():
	did_col = _pick(COLUMN_CANDIDATES["doc_id"], part.column_names, "dokuman id")
	txt_col = _pick(COLUMN_CANDIDATES["text"], part.column_names, "dokuman metni")
	has_title = "title" in part.column_names
	for row in part:
	title = (row["title"] or "").strip() if has_title else ""
	body = row[txt_col] or ""
	corpus[str(row[did_col])] = strip_artifacts(f"{title}. {body}" if title else body)

	qrels = {q: d for q, d in qrels.items() if q in queries} # metni olmayan sorgulari dusur
	info = {"source": repo, "qrels_split": r_split, "configs": [c_cfg, q_cfg, r_cfg], **(meta or {})}
	return RetrievalSet(name or repo.split("/")[-1], queries, corpus, qrels, info)


	_ARTIFACT_TOKENS = re.compile(r"<[A-Z_]{3,}>\|\[(?:UNK\|CLS\|SEP\|PAD)\]")


	def strip_artifacts(s):
	"""Ceviri hattindan sizan ozel tokenlari sil (<EOS_TOKEN>, [UNK] ...)."""
	return re.sub(r"\s{2,}", " ", _ARTIFACT_TOKENS.sub(" ", s or "")).strip()


	def drop_self_duplicates(rs):
	"""Sorgunun birebir aynisi korpusta ILGISIZ olarak duruyorsa sorguyu cikar (metin tabanli)."""
	text_to_docs = {}
	for d, t in rs.corpus.items():
	text_to_docs.setdefault(_norm(t), []).append(d)
	bad = {q for q, t in rs.queries.items()
	if any(rs.qrels.get(q, {}).get(d, 0) <= 0 for d in text_to_docs.get(_norm(t), []))}
	rs.queries = {q: t for q, t in rs.queries.items() if q not in bad}
	rs.qrels = {q: d for q, d in rs.qrels.items() if q not in bad}
	rs.meta["dropped_self_duplicates"] = len(bad)
	return rs


	def _norm(s):
	return re.sub(r"\s+", " ", (s or "").strip().lower())


	def load_claim_factcheck(rows, query_col="claim", doc_col="fact_check", id_col="id", name="dmm", meta=None):
	"""Satir basina (iddia, dogrulama) tutan veri: sorgu=iddia, ilgili dokuman=dogrulama metni.
	Ayni dogrulama metni birden fazla satirda varsa TEK dokumana indirgenir ve tum ilgili sorgulara baglanir
	(aksi halde 'dogru' cevabin kopyasi yanlis sayilir)."""
	doc_by_text, corpus, queries, qrels = {}, {}, {}, {}
	for i, row in enumerate(rows):
	claim, fc = (row.get(query_col) or "").strip(), (row.get(doc_col) or "").strip()
	if not claim or not fc:
	continue
	key = _norm(fc)
	if key not in doc_by_text:
	did = f"d{len(doc_by_text)}"
	doc_by_text[key] = did
	corpus[did] = fc
	qid = f"q{row.get(id_col, i)}"
	queries[qid] = claim
	qrels.setdefault(qid, {})[doc_by_text[key]] = 1.0
	# ayni iddia metni farkli satirlarda: tek sorguya indir, ilgili dokumanlari birlestir
	by_claim = {}
	for qid, text in list(queries.items()):
	k = _norm(text)
	if k in by_claim:
	keep = by_claim[k]
	qrels[keep].update(qrels.pop(qid))
	del queries[qid]
	else:
	by_claim[k] = qid
	return RetrievalSet(name, queries, corpus, qrels, {"native": True, **(meta or {})})


	def subsample(rs, n_queries, corpus_size, seed=0):
	"""Ilgili dokumanlari HER ZAMAN koruyarak alt-ornekleme.
	1) Korpusta en az bir ilgili dokumani olan sorgulardan n_queries tanesi secilir
	2) Korpus = secilen sorgularin tum ilgili dokumanlari + rastgele dokumanlar (corpus_size'a kadar)"""
	rng = np.random.default_rng(seed)
	eligible = sorted(q for q, d in rs.qrels.items()
	if q in rs.queries and any(s > 0 and doc in rs.corpus for doc, s in d.items()))
	chosen = eligible if len(eligible) <= n_queries else sorted(rng.choice(eligible, n_queries, replace=False))

	must = sorted({d for q in chosen for d, s in rs.qrels[q].items() if s > 0 and d in rs.corpus})
	pool = sorted(set(rs.corpus) - set(must))
	n_extra = max(0, min(len(pool), corpus_size - len(must)))
	extra = list(rng.choice(pool, n_extra, replace=False)) if n_extra else []
	keep = set(must) \| set(extra)

	sub = RetrievalSet(
	rs.name,
	{q: rs.queries[q] for q in chosen},
	{d: rs.corpus[d] for d in sorted(keep)},
	{q: {d: s for d, s in rs.qrels[q].items() if d in keep} for q in chosen},
	{**rs.meta, "subsample": {"n_queries": len(chosen), "corpus_size": len(keep),
	"relevant_kept": len(must), "seed": seed,
	"full_queries": len(eligible), "full_corpus": len(rs.corpus)}},
	)
	return sub


	# ═══ DMM: PDF'ten cikarilmis bulten kayitlari → (baslik sorgusu, analiz dokumani) ═══
	_QUOTED = re.compile(r"[“\"][^”\"]*[”\"]") # tirnak icindeki alinti
	_TOC_MARK = re.compile(r"[”\"]\s*İddia") # '” Iddiasi' kalibi
	_LEADING_IDDIA = re.compile(r"^(İddiası\|İddiaları)\b\s*")
	_PAGE_FOOTER = re.compile(r"\s\d{1,3}\s*—(?=\s\|$)") # "25 —" sayfa altligi
	_HEADLINE = re.compile(r'^\s[“"](?P<title>[^”"]{8,400}?)[”"]\s(?P<rest>.*)$', re.S)


	def clean_pdf_text(s):
	s = (s or "").replace("\u00ad", "") # yumusak tire
	s = re.sub(r"-\n(?=[a-zçğıöşü])", "", s) # satir sonu heceleme
	s = re.sub(r"\s+", " ", s)
	s = _PAGE_FOOTER.sub(" ", " " + s + " ")
	return re.sub(r"\s+", " ", s).strip()


	def load_headline_claims(rows, title_col="claim", tail_col="fact_check", id_col="id",
	max_title_words=25, min_doc_words=15, name="dmm", meta=None):
	"""Sorgu = tirnak icindeki iddia basligi; dokuman = kaydin geri kalani (analiz + dogrulama).
	Atlanan her satirin nedeni sayilir — sessiz veri kaybi olmaz."""
	skipped = {"baslik_yok": 0, "baslik_cok_uzun": 0, "icindekiler": 0, "dokuman_kisa": 0}
	corpus, queries, qrels, doc_by_text, examples = {}, {}, {}, {}, []
	for i, row in enumerate(rows):
	full = clean_pdf_text(f"{row.get(title_col) or ''} {row.get(tail_col) or ''}")
	m = _HEADLINE.match(full)
	if not m:
	skipped["baslik_yok"] += 1
	continue
	title, doc = m.group("title").strip(), m.group("rest").strip()
	if len(title.split()) > max_title_words:
	skipped["baslik_cok_uzun"] += 1
	continue
	if len(_TOC_MARK.findall(doc)) >= 2: # baska basliklar listeleniyor → icindekiler sayfasi
	skipped["icindekiler"] += 1
	continue
	doc = _LEADING_IDDIA.sub("", doc)
	if len(_QUOTED.sub(" ", doc).split()) < min_doc_words: # alintilanan iddia sayilmaz
	skipped["dokuman_kisa"] += 1
	continue
	key = _norm(doc)
	if key not in doc_by_text:
	doc_by_text[key] = f"d{len(doc_by_text)}"
	corpus[doc_by_text[key]] = doc
	qid = f"q{row.get(id_col, i)}"
	queries[qid] = title
	qrels.setdefault(qid, {})[doc_by_text[key]] = 1.0
	by_title = {} # ayni baslik → tek sorgu
	for qid, text in list(queries.items()):
	k = _norm(text)
	if k in by_title:
	qrels[by_title[k]].update(qrels.pop(qid)); del queries[qid]
	else:
	by_title[k] = qid
	info = {"native": True, "rows": len(rows), "skipped": skipped, **(meta or {})}
	return RetrievalSet(name, queries, corpus, qrels, info)


	# ═══ Teshis: degerlendirmeyi sessizce bozabilecek durumlar ═══
	_ARTIFACT = re.compile(r"<[A-Z_]{3,}>\|\[(?:UNK\|CLS\|SEP)\]")


	def diagnostics(rs):
	q_art = sum(bool(_ARTIFACT.search(t)) for t in rs.queries.values())
	d_art = sum(bool(_ARTIFACT.search(t)) for t in rs.corpus.values())
	text_to_docs = {}
	for d, t in rs.corpus.items():
	text_to_docs.setdefault(_norm(t), []).append(d)
	# sorgunun birebir aynisi korpusta ILGISIZ dokuman olarak duruyor mu? (ID degil METIN kontrolu)
	self_dup = sum(1 for q, t in rs.queries.items()
	if any(rs.qrels.get(q, {}).get(d, 0) <= 0 for d in text_to_docs.get(_norm(t), [])))
	return {"sorgu artefakt": q_art, "doküman artefakt": d_art, "sorgu=ilgisiz doküman (metin)": self_dup}