Datasets:

ADIP-QCRI
/

MTEB-lite

#!/usr/bin/env python
"""MTEB-lite (eng), step A: candidate pools for every task of MTEB(eng, v2).
One JSON per task in data/mteb_lite/pool/<task>.json (see mteb_lite_lib.py for the formats):
  Retrieval     up to --n-queries eval queries (seed 0, queries with >=1 relevant doc); corpus =
                their relevant docs (<= --max-rel per query) + the union of each query's BM25 top
                --bm25-depth (30) + --n-random (1000) random docs (depth 100 / 2000 random = 81M tokens
                per model, ~2x the encode budget). Each query keeps its own candidate list (its BM25 hits + its relevant
                docs); per-query scores are computed over that list + the shared random docs, so an
                item's score does not depend on which other items are in a subset.
  Reranking     up to --n-queries samples with their own candidate lists (positive + negative).
  Classification  the train split's texts that mteb's undersampling protocol would draw
                (n_experiments x samples_per_label per label, reproduced with seed 42) + up to
                --n-items test examples (label-stratified).
  PairClassification  up to --n-items pairs (balanced by label).
  STS           up to --n-items pairs (stratified by 5 gold-score bins).
  Clustering    up to --n-items items (stratified by label; hierarchical label lists kept).
  Summarization all documents with all their machine / human summaries.
  python scripts/mteb_lite_pool.py [--tasks A,B] [--jobs 8]      (CPU; retrieval needs ADIP_HF_ONLINE=1)
  python scripts/mteb_lite_pool.py --stats                       pool sizes + token estimate
  python scripts/mteb_lite_pool.py --suite ara [--jobs 42]       Arabic: the 42 MMTEB test tasks (Arabic subsets
                                                                 / splits as run_mteb_arabic.py); totals are split
                                                                 evenly over a task's hf_subsets; bitext items =
                                                                 gold pairs vs 1000 fixed distractor targets
"""
from __future__ import annotations

import os as _os
if _os.environ.get("ADIP_HF_ONLINE") != "1":
    _os.environ.setdefault("HF_HUB_OFFLINE", "1")
    _os.environ.setdefault("HF_DATASETS_OFFLINE", "1")
    _os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")

import argparse
import json
import math
import random
import sys
import time
from collections import Counter, defaultdict
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import mteb_lite_lib as L  # noqa: E402


# ----------------------------------------------------------------------------- sampling helpers
def stratified_sample(keys: list, n: int, rng: np.random.RandomState) -> list[int]:
    """Indices of a sample of size n with (roughly) proportional allocation per key, >=1 per key."""
    if len(keys) <= n:
        return list(range(len(keys)))
    groups = defaultdict(list)
    for i, k in enumerate(keys):
        groups[k].append(i)
    alloc = {k: max(1, int(round(n * len(v) / len(keys)))) for k, v in groups.items()}
    while sum(alloc.values()) > n:          # trim the largest groups
        k = max(alloc, key=lambda k: alloc[k])
        alloc[k] -= 1
    while sum(alloc.values()) < n:          # top up groups that still have items
        k = max((k for k in groups if alloc[k] < len(groups[k])),
                key=lambda k: len(groups[k]) - alloc[k])
        alloc[k] += 1
    out = []
    for k, v in groups.items():
        out.extend(rng.choice(v, size=min(alloc[k], len(v)), replace=False).tolist())
    return sorted(out)


def balanced_sample(labels: list, n: int, rng: np.random.RandomState) -> list[int]:
    """Equal numbers per label (all of a label if it has fewer, the rest filled from the others)."""
    if len(labels) <= n:
        return list(range(len(labels)))
    groups = defaultdict(list)
    for i, y in enumerate(labels):
        groups[y].append(i)
    ks = sorted(groups, key=lambda k: len(groups[k]))
    out, left = [], n
    for j, k in enumerate(ks):
        take = min(len(groups[k]), left // (len(ks) - j))
        out.extend(rng.choice(groups[k], size=take, replace=False).tolist())
        left -= take
    return sorted(out)


# ----------------------------------------------------------------------------- BM25
class BM25:
    """Okapi BM25 (k1=0.9, b=0.4 as in pyserini) over sklearn's tokenizer + English stop words."""

    def __init__(self, docs: list[str], k1: float = 0.9, b: float = 0.4):
        from sklearn.feature_extraction.text import CountVectorizer
        self.vec = CountVectorizer(lowercase=True, stop_words="english", dtype=np.float32,
                                   token_pattern=r"(?u)\b\w+\b")
        tf = self.vec.fit_transform(docs).tocsr()            # docs x terms
        n = tf.shape[0]
        dl = np.asarray(tf.sum(1)).ravel()
        avg = max(dl.mean(), 1e-9)
        df = np.bincount(tf.indices, minlength=tf.shape[1])
        idf = np.log(1 + (n - df + 0.5) / (df + 0.5)).astype(np.float32)
        tf = tf.tocoo()
        denom = tf.data + k1 * (1 - b + b * dl[tf.row] / avg)
        w = tf.data * (k1 + 1) / denom * idf[tf.col]
        from scipy.sparse import csr_matrix
        self.W = csr_matrix((w.astype(np.float32), (tf.row, tf.col)), shape=tf.shape).T.tocsr()  # terms x docs

    def topk(self, queries: list[str], k: int, chunk: int = 64) -> list[list[int]]:
        q = self.vec.transform(queries)
        q.data[:] = 1.0
        out = []
        for s in range(0, q.shape[0], chunk):
            sc = (q[s:s + chunk] @ self.W).toarray()
            kk = min(k, sc.shape[1])
            idx = np.argpartition(-sc, kk - 1, axis=1)[:, :kk]
            for r in range(sc.shape[0]):
                row = idx[r][np.argsort(-sc[r, idx[r]])]
                out.append([int(i) for i in row if sc[r, i] > 0])
        return out


# ----------------------------------------------------------------------------- per type
def subset_data(task):
    """The eval-split dataset dict of the task's (English) subset."""
    ds = task.dataset
    sub = task.hf_subsets[0]
    if task.eval_splits[0] not in ds and sub in ds:
        return ds[sub]
    return ds


def build_retrieval(task, args) -> dict:
    sp = task.eval_splits[0]
    c, q, r = task.corpus, task.queries, task.relevant_docs
    if sp not in c and "default" in c:
        c, q, r = c["default"], q["default"], r["default"]
    corpus = {str(k): L.doc_text(v) for k, v in c[sp].items()}
    queries = {str(k): (v if isinstance(v, str) else " ".join(v)) for k, v in q[sp].items()}
    qrels = {str(k): {str(d): int(s) for d, s in v.items()} for k, v in r[sp].items()}
    eligible = sorted(k for k in qrels if k in queries and any(s > 0 for s in qrels[k].values()))
    rng = np.random.RandomState(0)
    pick = sorted(rng.choice(eligible, size=min(args.n_queries, len(eligible)), replace=False).tolist())
    doc_ids = list(corpus)
    t0 = time.time()
    bm = BM25([corpus[d] for d in doc_ids])
    hits = bm.topk([queries[k] for k in pick], args.bm25_depth)
    print(f"  bm25 over {len(doc_ids)} docs: {time.time() - t0:.0f}s", flush=True)
    cand = {}
    keep = set()
    for k, h in zip(pick, hits):
        rel = sorted(d for d, s in qrels[k].items() if d in corpus and s > 0)
        if len(rel) > args.max_rel:          # TREC-COVID: hundreds of judged-relevant docs per query
            rel = sorted(rng.choice(rel, size=args.max_rel, replace=False).tolist())
        lst = list(dict.fromkeys([doc_ids[i] for i in h] + rel))
        cand[k] = lst
        keep.update(lst)
    rest = [d for d in doc_ids if d not in keep]
    rnd = sorted(rng.choice(rest, size=min(args.n_random, len(rest)), replace=False).tolist()) if rest else []
    keep.update(rnd)
    return {"queries": {k: queries[k] for k in pick},
            "corpus": {d: corpus[d] for d in sorted(keep)},
            # full positive qrels (ideal DCG over all relevant docs, also those capped out of the pool)
            "qrels": {k: {d: s for d, s in qrels[k].items() if d in keep or s > 0} for k in pick},
            "candidates": cand, "random_docs": rnd,
            "ignore_identical_ids": bool(getattr(task, "ignore_identical_ids", False)),
            "full_sizes": {"queries": len(eligible), "corpus": len(corpus)}}


def build_reranking(task, args) -> dict:
    d = subset_data(task)[task.eval_splits[0]]
    rows = [i for i in range(len(d)) if len(d[i]["positive"]) > 0 and len(d[i]["negative"]) > 0]
    rng = np.random.RandomState(0)
    pick = sorted(rng.choice(rows, size=min(args.n_queries, len(rows)), replace=False).tolist())
    items = []
    for i in pick:
        x = d[int(i)]
        items.append({"id": f"r{i}", "query": x["query"], "positive": list(x["positive"]),
                      "negative": list(x["negative"])})
    return {"items": items, "full_sizes": {"queries": len(rows)}}


def build_classification(task, args) -> dict:
    ds = subset_data(task)
    tr, te = ds["train"], ds[task.eval_splits[0]]
    ytr = list(tr["label"])
    spl = task.samples_per_label
    n_exp = task.n_experiments
    # mteb's _undersample_data: a persistent index permutation, reshuffled every experiment
    rng = np.random.RandomState(42)
    idxs = np.arange(len(ytr))
    exps = []
    for _ in range(n_exp):
        rng.shuffle(idxs)
        cnt, sel = defaultdict(int), []
        for i in idxs:
            if cnt[ytr[i]] < spl:
                sel.append(int(i))
                cnt[ytr[i]] += 1
        exps.append(sel)
    used = sorted({i for e in exps for i in e})
    pos = {i: j for j, i in enumerate(used)}
    trt = tr["text"]
    yte = list(te["label"])
    pick = stratified_sample(yte, args.n_items, np.random.RandomState(0))
    tet = te["text"]
    return {"train": {"text": [trt[i] for i in used], "label": [ytr[i] for i in used],
                      "orig_index": used},
            "experiments": [[pos[i] for i in e] for e in exps],
            "samples_per_label": spl, "n_experiments": n_exp,
            "items": [{"id": f"t{i}", "text": tet[i], "label": yte[i]} for i in pick],
            "full_sizes": {"train": len(ytr), "test": len(yte)}}


def _flat_pairs(d):
    """Pair-classification splits are one row holding lists (or one row per pair)."""
    if len(d) == 1 and isinstance(d[0]["sentence1"], list):
        x = d[0]
        return list(x["sentence1"]), list(x["sentence2"]), list(x["labels"])
    return list(d["sentence1"]), list(d["sentence2"]), list(d["labels"])


def build_pairclf(task, args) -> dict:
    s1, s2, y = _flat_pairs(subset_data(task)[task.eval_splits[0]])
    pick = balanced_sample(y, args.n_items, np.random.RandomState(0))
    # inverse sampling rates: AP on the balanced pool reweighted to the full label prior
    full_n = Counter(int(v) for v in y)
    pool_n = Counter(int(y[i]) for i in pick)
    return {"items": [{"id": f"p{i}", "sentence1": s1[i], "sentence2": s2[i], "label": int(y[i])} for i in pick],
            "label_weights": {str(k): full_n[k] / pool_n[k] for k in pool_n},
            "full_sizes": {"pairs": len(y), "positives": int(sum(y))}}


def build_sts(task, args) -> dict:
    d = subset_data(task)[task.eval_splits[0]]
    sc = [float(s) for s in d["score"]]
    lo, hi = task.metadata_dict.get("min_score", min(sc)), task.metadata_dict.get("max_score", max(sc))
    bins = [min(4, int(5 * (s - lo) / max(hi - lo, 1e-9))) for s in sc]
    pick = stratified_sample(bins, args.n_items, np.random.RandomState(0))
    s1, s2 = d["sentence1"], d["sentence2"]
    return {"items": [{"id": f"s{i}", "sentence1": s1[i], "sentence2": s2[i], "score": sc[i]} for i in pick],
            "min_score": lo, "max_score": hi, "full_sizes": {"pairs": len(sc)}}


def build_clustering(task, args) -> dict:
    d = subset_data(task)[task.eval_splits[0]]
    labs = [lab if isinstance(lab, list) else [lab] for lab in d["labels"]]
    labs = [[str(x) for x in lab] for lab in labs]
    md = getattr(task, "max_depth", None)
    if md is not None:
        labs = [lab[:md] for lab in labs]
    key = ["/".join(lab) for lab in labs]
    pick = stratified_sample(key, args.n_items, np.random.RandomState(0))
    # mteb's own downsample of the documents it embeds (ClusteringFast: random.Random(seed).sample);
    # small ones are added to the pool so the pool can also be scored with mteb's exact protocol
    n = len(labs)
    frac = getattr(task, "max_fraction_of_documents_to_embed", None)
    mde = getattr(task, "max_document_to_embed", None)
    mteb_ids = []
    if frac is not None or mde is not None:
        k = min(n, int(frac * n) if frac is not None else mde)
        mteb_idx = random.Random(task.seed).sample(range(n), k=k)
        if k <= 500:
            pick = sorted(set(pick) | set(mteb_idx))
            mteb_ids = [f"c{i}" for i in mteb_idx]
    sent = d["sentences"]
    return {"items": [{"id": f"c{i}", "text": sent[i], "labels": labs[i]} for i in pick],
            "mteb_ids": mteb_ids, "mteb_cluster_size": getattr(task, "max_documents_per_cluster", 16384),
            "mteb_n_embedded": (min(n, int(frac * n) if frac is not None else mde)
                                if (frac is not None or mde is not None) else n),
            "n_levels": max(len(lab) for lab in labs), "fast": "Fast" in type(task).__mro__[1].__name__,
            "full_sizes": {"items": len(labs), "n_labels_level0": len({lab[0] for lab in labs})}}


def build_summarization(task, args) -> dict:
    d = subset_data(task)[task.eval_splits[0]]
    items = []
    for i in range(len(d)):
        x = d[i]
        items.append({"id": str(x.get("id", i)), "machine": list(x["machine_summaries"]),
                      "human": list(x["human_summaries"]), "relevance": [float(v) for v in x["relevance"]]})
    return {"items": items, "full_sizes": {"documents": len(d)}}


BUILDERS = {"Retrieval": build_retrieval, "Reranking": build_reranking, "Classification": build_classification,
            "PairClassification": build_pairclf, "STS": build_sts, "Clustering": build_clustering,
            "Summarization": build_summarization}


# ----------------------------------------------------------------------------- Arabic suite (multi-subset)
def ar_split(task, sub: str):
    """The eval split of one hf_subset (monolingual tasks: the split itself)."""
    ds, sp = task.dataset, task._lite_split
    if sub in ds and sp not in ds:
        return ds[sub][sp]
    return ds[sp]


def ar_subs(task) -> tuple[list[str], bool]:
    subs = list(task.hf_subsets)
    return subs, len(subs) > 1


def build_retrieval_ar(task, args) -> dict:
    sp = task._lite_split
    subs, multi = ar_subs(task)
    rng = np.random.RandomState(0)
    nq = math.ceil(args.n_queries / len(subs))
    nr = max(200, math.ceil(args.n_random / len(subs))) if multi else args.n_random

    def part(x, sub):
        if sp in x and sub not in x:
            return x[sp]
        return x[sub][sp]
    out = {"queries": {}, "corpus": {}, "qrels": {}, "candidates": {}}
    rnd_by, qsub, full_q, full_c = {}, {}, 0, 0
    for sub in subs:
        pre = f"{sub}|" if multi else ""
        corpus = {pre + str(k): L.doc_text(v) for k, v in part(task.corpus, sub).items()}
        queries = {pre + str(k): (v if isinstance(v, str) else " ".join(v)) for k, v in part(task.queries, sub).items()}
        qrels = {pre + str(k): {pre + str(d): int(s) for d, s in v.items()}
                 for k, v in part(task.relevant_docs, sub).items()}
        eligible = sorted(k for k in qrels if k in queries and any(s > 0 for s in qrels[k].values()))
        full_q += len(eligible)
        full_c += len(corpus)
        pick = sorted(rng.choice(eligible, size=min(nq, len(eligible)), replace=False).tolist())
        doc_ids = list(corpus)
        hits = BM25([corpus[d] for d in doc_ids]).topk([queries[k] for k in pick], args.bm25_depth)
        keep = set()
        for k, h in zip(pick, hits):
            rel = sorted(d for d, s in qrels[k].items() if d in corpus and s > 0)
            if len(rel) > args.max_rel:
                rel = sorted(rng.choice(rel, size=args.max_rel, replace=False).tolist())
            out["candidates"][k] = list(dict.fromkeys([doc_ids[i] for i in h] + rel))
            keep.update(out["candidates"][k])
        rest = [d for d in doc_ids if d not in keep]
        rnd = sorted(rng.choice(rest, size=min(nr, len(rest)), replace=False).tolist()) if rest else []
        keep.update(rnd)
        rnd_by[sub] = rnd
        for k in pick:
            out["queries"][k] = queries[k]
            out["qrels"][k] = {d: s for d, s in qrels[k].items() if d in keep or s > 0}
            qsub[k] = sub
        out["corpus"].update({d: corpus[d] for d in sorted(keep)})
    if multi:
        out.update({"random_docs_by_subset": rnd_by, "query_subset": qsub})
    else:
        out["random_docs"] = rnd_by[subs[0]]
    out.update({"ignore_identical_ids": bool(getattr(task, "ignore_identical_ids", False)),
                "full_sizes": {"queries": full_q, "corpus": full_c}})
    return out


def build_reranking_ar(task, args) -> dict:
    subs, multi = ar_subs(task)
    rng = np.random.RandomState(0)
    n = math.ceil(args.n_queries / len(subs))
    items, full = [], 0
    for sub in subs:
        d = ar_split(task, sub)
        rows = [i for i in range(len(d)) if len(d[i]["positive"]) > 0 and len(d[i]["negative"]) > 0]
        full += len(rows)
        has_cand = "candidates" in d.column_names
        for i in sorted(rng.choice(rows, size=min(n, len(rows)), replace=False).tolist()):
            x = d[int(i)]
            it = {"id": (f"{sub}|r{i}" if multi else f"r{i}"), "query": x["query"], "positive": list(x["positive"]),
                  "negative": list(x["negative"])}
            if has_cand:
                it["candidates"] = list(x["candidates"])
            if multi:
                it["subset"] = sub
            items.append(it)
    return {"items": items, "full_sizes": {"queries": full}}


def build_classification_ar(task, args) -> dict:
    subs, multi = ar_subs(task)
    n = math.ceil(args.n_items / len(subs))
    groups, items, full = {}, [], {}
    for sub in subs:
        ds = task.dataset[sub] if (sub in task.dataset and "train" not in task.dataset) else task.dataset
        tr, te = ds["train"], ds[task._lite_split]
        ytr = list(tr["label"])
        rng = np.random.RandomState(42)
        idxs = np.arange(len(ytr))
        exps = []
        for _ in range(task.n_experiments):
            rng.shuffle(idxs)
            cnt, sel = defaultdict(int), []
            for i in idxs:
                if cnt[ytr[i]] < task.samples_per_label:
                    sel.append(int(i))
                    cnt[ytr[i]] += 1
            exps.append(sel)
        used = sorted({i for e in exps for i in e})
        pos = {i: j for j, i in enumerate(used)}
        trt = tr["text"]
        key = sub if multi else ""
        groups[key] = {"train": {"text": [trt[i] for i in used], "label": [ytr[i] for i in used], "orig_index": used},
                       "experiments": [[pos[i] for i in e] for e in exps]}
        yte, tet = list(te["label"]), te["text"]
        for i in stratified_sample(yte, n, np.random.RandomState(0)):
            it = {"id": (f"{sub}|t{i}" if multi else f"t{i}"), "text": tet[i], "label": yte[i]}
            if multi:
                it["subset"] = sub
            items.append(it)
        full[sub] = {"train": len(ytr), "test": len(yte)}
    return {"groups": groups, "items": items, "samples_per_label": task.samples_per_label,
            "n_experiments": task.n_experiments, "full_sizes": full}


def build_pairclf_ar(task, args) -> dict:
    subs, multi = ar_subs(task)
    n = math.ceil(args.n_items / len(subs))
    items, full_n, pool_n = [], Counter(), Counter()
    for sub in subs:
        s1, s2, y = _flat_pairs(ar_split(task, sub))
        pick = balanced_sample(y, n, np.random.RandomState(0))
        full_n.update(int(v) for v in y)
        pool_n.update(int(y[i]) for i in pick)
        for i in pick:
            it = {"id": (f"{sub}|p{i}" if multi else f"p{i}"), "sentence1": s1[i], "sentence2": s2[i], "label": int(y[i])}
            if multi:
                it["subset"] = sub
            items.append(it)
    return {"items": items, "label_weights": {str(k): full_n[k] / pool_n[k] for k in pool_n},
            "full_sizes": {"pairs": sum(full_n.values()), "positives": full_n[1]}}


def build_sts_ar(task, args) -> dict:
    subs, multi = ar_subs(task)
    n = math.ceil(args.n_items / len(subs))
    items, full = [], 0
    for sub in subs:
        d = ar_split(task, sub)
        sc = [float(v) for v in d["score"]]
        lo, hi = task.metadata_dict.get("min_score", min(sc)), task.metadata_dict.get("max_score", max(sc))
        bins = [min(4, int(5 * (v - lo) / max(hi - lo, 1e-9))) for v in sc]
        s1, s2 = d["sentence1"], d["sentence2"]
        full += len(sc)
        for i in stratified_sample(bins, n, np.random.RandomState(0)):
            it = {"id": (f"{sub}|s{i}" if multi else f"s{i}"), "sentence1": s1[i], "sentence2": s2[i], "score": sc[i]}
            if multi:
                it["subset"] = sub
            items.append(it)
    return {"items": items, "full_sizes": {"pairs": full}}


def build_clustering_ar(task, args) -> dict:
    subs, _ = ar_subs(task)
    sets = []                                      # (group key, sentences, labels)
    for sub in subs:
        d = ar_split(task, sub)
        if len(d) and isinstance(d[0]["sentences"], list):        # legacy clustering: rows of clustering sets
            for r in range(len(d)):
                sets.append((f"{sub}#{r}" if len(d) > 1 else sub, list(d[r]["sentences"]), list(d[r]["labels"])))
        else:
            sets.append((sub, list(d["sentences"]), list(d["labels"])))
    multi = len(sets) > 1
    n = math.ceil(args.n_items / len(sets))
    items = []
    for key, sent, lab in sets:
        labs = [[str(x) for x in (v if isinstance(v, list) else [v])] for v in lab]
        for i in stratified_sample(["/".join(v) for v in labs], n, np.random.RandomState(0)):
            it = {"id": (f"{key}|c{i}" if multi else f"c{i}"), "text": sent[i], "labels": labs[i]}
            if multi:
                it["subset"] = key
            items.append(it)
    return {"items": items, "n_levels": max(len(x["labels"]) for x in items), "mteb_ids": [],
            "full_sizes": {"sets": len(sets), "items": sum(len(s[1]) for s in sets)}}


def build_bitext_ar(task, args) -> dict:
    """Items = gold pairs; per subset a fixed set of --n-distractors target sentences (parallel datasets:
    the same rows for every language pair, so target texts are shared)."""
    subs, _ = ar_subs(task)
    sp = task._lite_split
    parallel = bool(getattr(task, "parallel_subsets", False))
    n = math.ceil(args.n_items / len(subs))
    rng = np.random.RandomState(0)
    items, texts, cands, full = [], {}, {}, {}
    shared_rows = None
    for sub in subs:
        if parallel:
            l1, l2 = sub.split("-")
            d = task.dataset[sp]
            s1, s2 = list(d[l1]), list(d[l2])
            gold = [(i, i) for i in range(len(s1))]
            tkey = lambda j: f"{l2}|{j}"  # noqa: E731
        else:
            d = task.dataset[sub][sp] if sub in task.dataset and sp not in task.dataset else task.dataset[sp]
            s1, s2 = list(d["sentence1"]), list(d["sentence2"])
            cols = d.column_names if hasattr(d, "column_names") else list(d.keys())
            gold = [tuple(g) for g in d["gold"]] if "gold" in cols else [(i, i) for i in range(len(s1))]
            tkey = lambda j, sub=sub: f"{sub}|{j}"  # noqa: E731
        full[sub] = len(gold)
        if parallel and shared_rows is None:
            shared_rows = sorted(rng.choice(len(s2), size=min(args.n_distractors, len(s2)), replace=False).tolist())
        rows = shared_rows if parallel else sorted(
            rng.choice(len(s2), size=min(args.n_distractors, len(s2)), replace=False).tolist())
        cands[sub] = [tkey(j) for j in rows]
        for j in rows:
            texts[tkey(j)] = s2[j]
        for gi in sorted(rng.choice(len(gold), size=min(n, len(gold)), replace=False).tolist()):
            i, j = gold[gi]
            texts[tkey(j)] = s2[j]
            items.append({"id": f"{sub}|b{gi}", "subset": sub, "sentence1": s1[i], "target": tkey(j)})
    return {"items": items, "bitext_texts": texts, "bitext_candidates": cands, "parallel": parallel,
            "full_sizes": full}


BUILDERS_AR = {"Retrieval": build_retrieval_ar, "Reranking": build_reranking_ar,
               "Classification": build_classification_ar, "PairClassification": build_pairclf_ar,
               "STS": build_sts_ar, "Clustering": build_clustering_ar, "BitextMining": build_bitext_ar}


def build_one(name: str, args) -> str:
    L.configure(args.suite)
    task = L.get_task(name)
    t0 = time.time()
    if args.suite == "eng":
        task.load_data()
        pool = BUILDERS[task.metadata.type](task, args)
    else:
        task.load_data(eval_splits=[task._lite_split])
        pool = BUILDERS_AR[task.metadata.type](task, args)
    pool.update({"task": name, "type": task.metadata.type, "main_score": task.metadata.main_score,
                 "eval_split": task._lite_split,
                 "hf_subset": task.hf_subsets[0] if args.suite == "eng" else list(task.hf_subsets),
                 "build_args": {k: getattr(args, k) for k in ("n_queries", "n_items", "bm25_depth", "n_random", "max_rel")
                                + (("n_distractors",) if args.suite == "ara" else ())}})
    L.save_pool(pool)
    return f"[pool] {name}: {L.pool_size_str(pool)} ({time.time() - t0:.0f}s)"


def stats(args) -> None:
    """Pool sizes and the number of tokens one model has to encode (Qwen3 tokenizer)."""
    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-Embedding-0.6B")
    rows, tot = [], 0
    for name in L.task_names():
        p = L.pool_path(name)
        if not p.exists():
            rows.append((name, "MISSING", 0, 0))
            continue
        pool = L.load_pool(name)
        texts = L.texts_to_encode(pool)
        n_tok = 0
        cap = args.max_tokens
        for s in range(0, len(texts), 4096):
            enc = tok([t for t, _ in texts[s:s + 4096]], add_special_tokens=False)["input_ids"]
            n_tok += sum(min(len(e), cap) + (20 if role != "document" else 1) for e, (_, role) in
                         zip(enc, texts[s:s + 4096]))
        rows.append((name, L.pool_size_str(pool), len(texts), n_tok))
        tot += n_tok
    out = {"rows": [{"task": a, "pool": b, "texts": c, "tokens": d} for a, b, c, d in rows], "total_tokens": tot,
           "max_tokens_per_text": args.max_tokens}
    (L.LITE / "pool_stats.json").write_text(json.dumps(out, indent=1))
    for a, b, c, d in rows:
        print(f"{a:42s} {b:60s} texts={c:7d} tokens={d / 1e6:6.2f}M")
    print(f"TOTAL texts={sum(r[2] for r in rows)} tokens={tot / 1e6:.1f}M (each text capped at {args.max_tokens})")


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--suite", choices=["eng", "ara"], default="eng")
    ap.add_argument("--tasks", default=None)
    ap.add_argument("--n-queries", type=int, default=1000)
    ap.add_argument("--n-items", type=int, default=1000)
    ap.add_argument("--bm25-depth", type=int, default=30, help="(100 -> 81M tokens/model; 30 -> ~43M)")
    ap.add_argument("--n-random", type=int, default=1000)
    ap.add_argument("--max-rel", type=int, default=100, help="max relevant docs per query kept in the corpus")
    ap.add_argument("--jobs", type=int, default=1)
    ap.add_argument("--skip-existing", action="store_true")
    ap.add_argument("--stats", action="store_true")
    ap.add_argument("--n-distractors", type=int, default=1000, help="ara bitext: target sentences per subset")
    ap.add_argument("--max-tokens", type=int, default=None,
                    help="--stats: per-text token cap (default: 8192 eng, 512 ara = run_mteb_arabic --max-length)")
    args = ap.parse_args()
    L.configure(args.suite)
    if args.max_tokens is None:
        args.max_tokens = 512 if args.suite == "ara" else 8192
    if args.stats:
        return stats(args)
    names = args.tasks.split(",") if args.tasks else L.task_names()
    if args.skip_existing:
        names = [n for n in names if not L.pool_path(n).exists()]
    if args.jobs > 1:
        from concurrent.futures import ProcessPoolExecutor
        with ProcessPoolExecutor(args.jobs) as ex:
            futs = {ex.submit(build_one, n, args): n for n in names}
            for f, n in futs.items():
                try:
                    print(f.result(), flush=True)
                except Exception as e:
                    print(f"[pool] {n}: FAILED {type(e).__name__}: {e}", flush=True)
    else:
        for n in names:
            print(build_one(n, args), flush=True)


if __name__ == "__main__":
    main()