build_cfms_local.py

from __future__ import annotations

import argparse
import os
from typing import Dict, Iterable, Iterator, List, Tuple, Optional
from tqdm.auto import tqdm

from datasets import Dataset, DatasetDict, Features, Sequence, Value, ClassLabel, disable_progress_bars

disable_progress_bars()


# --------------------------------------------------------------------
# Defaults: your file names (searched under base_dir if data_files unset)
# --------------------------------------------------------------------
DEFAULT_ELUT_FILES = [
    "CB660_neural_stem_cell_IEX_Wan_2015.elut",
    "G166_glioma_stem_cell_IEX_Wan_2015_Hs_HCW_2.elut",
    "G166_glioma_stem_cell_IEX_Wan_2015_Hs_HCW_3.elut",
    "IEX_Wan_2015_Hs_IEX_1.elut",
    "IEX_Wan_2015_Hs_IEX_2.elut",
    "IEX_Wan_2015_Hs_HCW_4.elut",
    "IEX_Wan_2015_Hs_HCW_5.elut",
    "IEX_Wan_2015_Hs_HCW_6.elut",
    "IEX_Wan_2015_Hs_HCW_7.elut",
    "IEX_Wan_2015_Hs_HCW_8.elut",
    "IEX_Wan_2015_Hs_HCW_9.elut",
    "HEK_293_T_cells_SEC_Mallam_2019_C1.elut",
    "HEK_293_T_cells_SEC_Mallam_2019_C2.elut",
    "NTera2_embryonal_carcinoma_stem_cells_IEX_Moutaoufik_2019_2_R1.elut",
    "NTera2_embryonal_carcinoma_stem_cells_IEX_Moutaoufik_2019_2_R2.elut",
    "NTera2_embryonal_carcinoma_stem_cells_IEX_Moutaoufik_2019_R1.elut",
    "NTera2_embryonal_carcinoma_stem_cells_IEX_Moutaoufik_2019_R2.elut",
    "NTera2_embryonal_carcinoma_stem_cells_SEC_Moutaoufik_2019_2_R1.elut",
    "NTera2_embryonal_carcinoma_stem_cells_SEC_Moutaoufik_2019_2_R2.elut",
    "NTera2_embryonal_carcinoma_stem_cells_SEC_Moutaoufik_2019_R1.elut",
    "NTera2_embryonal_carcinoma_stem_cells_SEC_Moutaoufik_2019_R2.elut",
    "T98G_glioblastoma_multiforme_cells_SEC_Conelly_2018_Bio1.elut",
    "T98G_glioblastoma_multiforme_cells_SEC_Conelly_2018_Bio2.elut",
    "U2OS_cells_SEC_Kirkwood_2013_rep1.elut",
    "U2OS_cells_SEC_Kirkwood_2013_rep2.elut",
    "U2OS_cells_SEC_Kirkwood_2013_rep3.elut",
    "U2OS_cells_SEC_Larance_2016_PT3281S1.elut",
    "U2OS_cells_SEC_Larance_2016_PT3441S1.elut",
    "U2OS_cells_SEC_Larance_2016_PT3442S1.elut",
    "U2OS_cells_SEC_Larance_2016_PT3701S1.elut",
    "U2OS_cells_SEC_Larance_2016_PTSS3801.elut",
    "U2OS_cells_SEC_Larance_2016_PTSS3802.elut",
]


DEFAULT_PAIR_FILES = {
    # split -> (pos, neg)
    "train": (
        "intact_complex_merge_20230309.train_ppis.txt",
        "intact_complex_merge_20230309.neg_train_ppis.txt",
    ),
    "test": (
        "intact_complex_merge_20230309.test_ppis.txt",
        "intact_complex_merge_20230309.neg_test_ppis.txt",
    ),
}


def read_elut_table(path: str) -> Tuple[str, List[str], Dict[str, List[int]]]:
    experiment_id = os.path.splitext(os.path.basename(path))[0]
    table: Dict[str, List[int]] = {}

    with open(path, "r", encoding="utf-8", errors="ignore") as f:
        first = f.readline().rstrip("\n\r")
        if not first:
            return experiment_id, [], {}
        cols = first.split("\t")
        fraction_names = cols[1:]

        for line in f:
            line = line.rstrip("\n\r")
            if not line:
                continue
            toks = line.split("\t")
            if not toks:
                continue
            uniprot_id = toks[0]
            trace: Li8st[int] = []
            for x in toks[1:]:
                if x == "" or x is None:
                    trace.append(0)
                else:
                    try:
                        trace.append(int(float(x)))
                    except ValueError:
                        trace.append(0)
            table[uniprot_id] = trace

    return experiment_id, fraction_names, table


def read_pair_file(path: str) -> Iterable[Tuple[str, str]]:
    with open(path, "r", encoding="utf-8", errors="ignore") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            parts = line.split()
            if len(parts) != 2:
                continue
            yield parts[0], parts[1]


def build_proteins_dataset(elut_files: List[str]) -> Dataset:
    features = Features(
        {
            "experiment_id": Value("string"),
            "uniprot_id": Value("string"),
            "fraction_names": Sequence(Value("string")),
            "trace": Sequence(Value("int32")),
        }
    )

    def gen() -> Iterator[dict]:
        with tqdm(total=None, unit="ex",
                  desc="proteins: examples") as pbar:
            for elut_path in elut_files:
                exp_id, frac_names, table = read_elut_table(elut_path)
                for uid, trace in tqdm(table.items(),
                                       desc=f"{os.path.basename(elut_path)}",
                                       leave=False):
                    yield {
                        "experiment_id": exp_id,
                        "uniprot_id": uid,
                        "fraction_names": frac_names,
                        "trace": trace,
                    }
                    pbar.update(1)
    return Dataset.from_generator(gen, features=features)


def build_pairs_dataset(
        elut_files: List[str],
        split_posneg: Dict[str, Tuple[List[str], List[str]]]
) -> DatasetDict:
    features = Features(
        {
            "experiment_id": Value("string"),
            "uniprot_id1": Value("string"),
            "uniprot_id2": Value("string"),
            "elut_trace1": Sequence(Value("int32")),
            "elut_trace2": Sequence(Value("int32")),
            "label": ClassLabel(names=["neg", "pos"]),
        }
    )

    elut_tables: Dict[str, Tuple[List[str], Dict[str, List[int]]]] = {}
    for elut_path in tqdm(elut_files, desc="pairs: elution files"):
        try:
            exp_id, frac_names, table = read_elut_table(elut_path)
            elut_tables[exp_id] = (frac_names, table)
        except Exception as e:
            tqdm.write(f"WARNING: Failed to read {elut_path}: {e}")

    def make_split_gen(split: str, pos_files: List[str], neg_files: List[str]) -> Iterator[dict]:
        with tqdm(unit="ex", desc=f"{split}: examples") as pbar:
            def emit_for_pair(a: str, b: str, label: str) -> Iterator[dict]:
                for exp_id, (_fracs, table) in elut_tables.items():
                    ta = table.get(a)
                    tb = table.get(b)
                    if ta is None or tb is None:
                        continue
                    yield {
                        "experiment_id": exp_id,
                        "uniprot_id1": a,
                        "uniprot_id2": b,
                        "elut_trace1": ta,
                        "elut_trace2": tb,
                        "label": label,
                    }
                    pbar.update(1)

            #for pf in tqdm(pos_files, desc=f"{split}: positive files"):
            for pf in pos_files:
                #for a, b in tqdm(read_pair_file(pf), desc=os.path.basename(pf), leave=False):
                for a, b in read_pair_file(pf):
                    yield from emit_for_pair(a, b, "pos")

            #for nf in tqdm(neg_files, desc=f"{split}: negative files"):
            for nf in neg_files:
                #for a, b in tqdm(read_pair_file(nf), desc=os.path.basename(nf), leave=False):
                for a, b in read_pair_file(nf):
                    yield from emit_for_pair(a, b, "neg")

    dataset_dict = {}
    for split, (pos_paths, neg_paths) in split_posneg.items():
        dataset_dict[split] = Dataset.from_generator(
            make_split_gen,
            gen_kwargs={"split": split, "pos_files": pos_paths, "neg_files": neg_paths},
            features=features,
        )
    return DatasetDict(dataset_dict)


def existing(paths: List[str]) -> List[str]:
    return [p for p in paths if p and os.path.exists(p)]


def resolve_elut_files(base_dir: str, user_elut: Optional[List[str]]):
    if user_elut:
        return existing([os.path.abspath(p) for p in user_elut])
    # Fall back to defaults under base_dir
    candidates = [os.path.join(base_dir, f) for f in DEFAULT_ELUT_FILES]
    files = existing(candidates)
    if not files:
        raise FileNotFoundError("No .elut files found. Provide --elut or place defaults under --base_dir")
    return files


def resolve_pair_files(
        base_dir: str,
        train_pos: Optional[List[str]],
        train_neg: Optional[List[str]],
        test_pos: Optional[List[str]],
        test_neg: Optional[List[str]]
) -> Dict[str, Tuple[List[str], List[str]]]:
    out = {}
    if any([train_pos, train_neg, test_pos, test_neg]):
        if train_pos or train_neg:
            out["train"] = (
                existing([os.path.abspath(p) for p in train_pos or []]),
                existing([os.path.abspath(p) for p in train_neg or []])
            )
        if test_pos or test_neg:
            out["test"] = (
                existing([os.path.abspath(p) for p in test_pos or []]),
                existing([os.path.abspath(p) for p in test_neg or []])
            )
    else:
        # Use defaults under base_dir
        for split, (pos_path, neg_path) in DEFAULT_PAIR_FILES.items():
            out[split] = (
                existing([os.path.join(base_dir, pos_path)]),
                existing([os.path.join(base_dir, neg_path)])
            )
    if not out:
        raise ValueError("No pair files specified for 'pairs'.")
    return out


def main():
    ap = argparse.ArgumentParser(
        description="Build CF-MS dataset from .elut tables and .txt files. Uses both 'pairs' and 'proteins' configurations."
    )
    ap.add_argument("--view", choices=["proteins", "pairs"], default="pairs",
                    help="Dataset configuration to build (default: pairs).")
    ap.add_argument("--base_dir", type=str, default=os.getcwd(),
                    help="Directory to search for default files if paths not provided via '--elut' or --{test/train}_{pos/neg}")
    ap.add_argument("--elut", type=str, nargs="*",
                    help="Path(s) to .elut files. If omitted, defaults under '--base_dir' are used.")
    ap.add_argument("--train_pos", type=str, nargs="*",
                    help="Path(s) to positive TRAINING pairs .txt")
    ap.add_argument("--train_neg", type=str, nargs="*",
                    help="Path(s) to negative TRAINING pairs .txt")
    ap.add_argument("--test_pos", type=str, nargs="*",
                    help="Path(s) to positive TEST pairs .txt")
    ap.add_argument("--test_neg", type=str, nargs="*",
                    help="Path(s) to positive TEST pairs .txt")
    ap.add_argument("--out_dir", type=str, default=os.getcwd(),
                    help="Output directory for dataset .parquet files")
    args = ap.parse_args()

    base_dir = os.path.abspath(args.base_dir)
    os.makedirs(args.out_dir, exist_ok=True)

    elut_files = resolve_elut_files(base_dir, args.elut)

    # Create individual protein elutions dataset
    if args.view == "proteins":
        ds = build_proteins_dataset(elut_files)
        # saved as single 'train' split for consistency with original behavior
        #DatasetDict({"train": ds}).to_parquet(args.out_dir)
        ds.to_parquet(os.path.join(args.out_dir, "proteins_indiv_elut.parquet"))
        print(f"[ok] proteins dataset saved to {args.out_dir}")
    else:
        split_posneg = resolve_pair_files(
            base_dir,
            args.train_pos, args.train_neg,
            args.test_pos, args.test_neg
        )
        dataset_dict = build_pairs_dataset(elut_files, split_posneg)
        ds_train = dataset_dict["train"]
        ds_test = dataset_dict["test"]
        ds_train.to_parquet(os.path.join(args.out_dir, "pairs_elut_TRAIN.parquet"))
        ds_test.to_parquet(os.path.join(args.out_dir, "pairs_elut_TEST.parquet"))
        # quick counts
        for split, ds in dataset_dict.items():
            print(f"[ok] {split}: {len(ds):,} examples")
        print(f"[ok] pairs dataset saved to {args.out_dir}")

if __name__ == "__main__":
    main()