code/pusula_data.py

"""
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}