src/cli/build_study_datasets.py

"""Build frozen study-level benchmark datasets for PROVEDIt."""

from __future__ import annotations

import csv
import json
import random
import re
from collections import defaultdict
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Iterable, List, Tuple

from openpyxl import load_workbook


ROOT = Path(__file__).resolve().parents[2]
DATA_ROOT = ROOT / "data" / "PROVEDIt_1-5-Person CSVs UnFiltered"
PROCESSED_ROOT = ROOT / "data" / "processed"


@dataclass(frozen=True)
class PanelSpec:
    panel: str
    raw_root: Path
    genotype_file: Path


@dataclass(frozen=True)
class BenchmarkSpec:
    benchmark_id: str
    study_id: str
    source_mode: str
    seed: int
    known_count: int
    unknown_count: int
    panels: Tuple[PanelSpec, ...]


@dataclass
class SampleMeta:
    benchmark_id: str
    study_id: str
    panel: str
    source_mode: str
    sample_file: str
    source_csv: str
    sample_family_id: str
    folder_people_label: str
    injection_time: str
    contributor_token: str
    ratio_token: str
    true_contributors: List[int]
    total_contributors: int
    is_active_mixture_sample: int


RD14_SPEC = BenchmarkSpec(
    benchmark_id="rd14-fullref-50_seed42_v1",
    study_id="RD14-0003",
    source_mode="unfiltered",
    seed=42,
    known_count=45,
    unknown_count=5,
    panels=(
        PanelSpec(
            panel="GF",
            raw_root=DATA_ROOT / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_GF29cycles",
            genotype_file=DATA_ROOT
            / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_GF29cycles"
            / "PROVEDIt_RD14-0003 GF Known Genotypes.xlsx",
        ),
        PanelSpec(
            panel="IDPlus",
            raw_root=DATA_ROOT / "PROVEDIt_1-5-Person CSVs UnFiltered_3130_IDPlus28cycles",
            genotype_file=DATA_ROOT
            / "PROVEDIt_1-5-Person CSVs UnFiltered_3130_IDPlus28cycles"
            / "PROVEDIt_RD14-0003 IDPlus Known Genotypes.xlsx",
        ),
        PanelSpec(
            panel="F6C",
            raw_root=DATA_ROOT / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_F6C29cycles_hlfrxn",
            genotype_file=DATA_ROOT
            / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_F6C29cycles_hlfrxn"
            / "PROVEDIt_RD14-0003 F6C Known Genotypes.csv",
        ),
    ),
)

RD12_SPEC = BenchmarkSpec(
    benchmark_id="rd12-fullref-61_seed42_v1",
    study_id="RD12-0002",
    source_mode="unfiltered",
    seed=42,
    known_count=56,
    unknown_count=5,
    panels=(
        PanelSpec(
            panel="IDPlus",
            raw_root=DATA_ROOT / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_IDPlus29cycles",
            genotype_file=DATA_ROOT
            / "PROVEDIt_1-5-Person CSVs UnFiltered_3500_IDPlus29cycles"
            / "PROVEDIt_RD12-0002 IP Known Genotypes.xlsx",
        ),
        PanelSpec(
            panel="PP16HS",
            raw_root=DATA_ROOT / "PROVEDIt_1-5-Person CSVs UnFiltered_3130_PP16HS32cycles",
            genotype_file=DATA_ROOT
            / "PROVEDIt_1-5-Person CSVs UnFiltered_3130_PP16HS32cycles"
            / "PROVEDIt_RD12-0002 PP16HS Known Genotypes.xlsx",
        ),
    ),
)


def normalize_marker(marker: str) -> str:
    marker = marker.strip()
    return "AMEL" if marker in {"AM", "AMEL"} else marker


def normalize_allele(value: str) -> str:
    token = value.strip()
    if not token:
        return ""
    if token.endswith(".0"):
        token = token[:-2]
    return token


def load_reference_donors(panel_specs: Iterable[PanelSpec]) -> Tuple[Dict[Tuple[str, int], Dict[str, str]], List[Dict[str, str]], List[int]]:
    donor_profiles: Dict[Tuple[str, int], Dict[str, str]] = {}
    reference_rows: List[Dict[str, str]] = []
    all_ids = set()

    for panel_spec in panel_specs:
        path = panel_spec.genotype_file
        if path.suffix.lower() == ".xlsx":
            workbook = load_workbook(path, read_only=True, data_only=True)
            sheet = workbook[workbook.sheetnames[0]]
            rows = list(sheet.iter_rows(values_only=True))
        else:
            with path.open(encoding="utf-8-sig", newline="") as handle:
                rows = list(csv.reader(handle))

        header = [str(value).strip() if value is not None else "" for value in rows[0]]
        sample_idx = header.index("Sample ID")
        ignore = {"Research ID", "Reseach ID", "Sample ID"}

        for row in rows[1:]:
            if not any(value is not None and str(value).strip() for value in row):
                continue
            person_raw = row[sample_idx]
            if person_raw is None or str(person_raw).strip() == "":
                continue

            person_id = int(str(person_raw).strip())
            all_ids.add(person_id)
            donor_profiles[(panel_spec.panel, person_id)] = {}

            for idx, name in enumerate(header):
                if name in ignore:
                    continue
                value = row[idx] if idx < len(row) else None
                if value is None or str(value).strip() == "" or str(value).strip().upper() == "N/A":
                    continue
                marker = normalize_marker(name)
                alleles = ",".join(part.strip() for part in str(value).split(",") if part.strip())
                donor_profiles[(panel_spec.panel, person_id)][marker] = alleles
                reference_rows.append(
                    {
                        "study_id": panel_spec.genotype_file.name.split()[0].replace("PROVEDIt_", ""),
                        "panel": panel_spec.panel,
                        "person_id": str(person_id),
                        "marker": marker,
                        "alleles": alleles,
                    }
                )

    return donor_profiles, reference_rows, sorted(all_ids)


def parse_sample_metadata(sample_file: str) -> Tuple[str, str, str, List[int]]:
    study_match = re.search(r"(RD\d{2}-\d{4})-", sample_file)
    if not study_match:
        raise ValueError(f"Could not parse sample file: {sample_file}")

    study_id = study_match.group(1)
    rest = sample_file[study_match.end() :]
    parts = rest.split("-", 2)
    if len(parts) < 2:
        raise ValueError(f"Could not parse sample file: {sample_file}")

    contributor_token = parts[0]
    ratio_token = parts[1].split("_")[0]
    contributor_ids = []
    for part in contributor_token.split("_"):
        id_match = re.match(r"(\d+)", part)
        if id_match:
            contributor_ids.append(int(id_match.group(1)))
    if not contributor_ids:
        raise ValueError(f"No contributor IDs found in sample file: {sample_file}")
    return study_id, contributor_token, ratio_token, contributor_ids


def source_priority(path: Path) -> Tuple[int, int, str]:
    name = path.name
    has_parentheses = 0 if "(" in name else 1
    return (has_parentheses, len(name), name)


def collect_canonical_samples(spec: BenchmarkSpec) -> Dict[Tuple[str, str], SampleMeta]:
    sample_map: Dict[Tuple[str, str], SampleMeta] = {}
    sample_priority: Dict[Tuple[str, str], Tuple[int, int, str]] = {}

    for panel_spec in spec.panels:
        for csv_path in sorted(panel_spec.raw_root.rglob("*.csv")):
            if "Known Genotypes" in csv_path.name:
                continue

            rel_parts = csv_path.relative_to(panel_spec.raw_root).parts
            folder_people_label = rel_parts[0] if len(rel_parts) > 2 else "unknown"
            injection_time = rel_parts[1] if len(rel_parts) > 2 else "unknown"

            with csv_path.open(encoding="utf-8-sig", newline="", errors="replace") as handle:
                reader = csv.DictReader(handle)
                seen = set()
                for row in reader:
                    sample_file = row["Sample File"].strip()
                    if sample_file in seen:
                        continue
                    seen.add(sample_file)

                    study_id, contributor_token, ratio_token, contributor_ids = parse_sample_metadata(sample_file)
                    if study_id != spec.study_id:
                        continue

                    key = (panel_spec.panel, sample_file)
                    priority = source_priority(csv_path)
                    if key in sample_map and priority >= sample_priority[key]:
                        continue

                    family_id = f"{study_id}|{contributor_token}|{ratio_token}"
                    sample_map[key] = SampleMeta(
                        benchmark_id=spec.benchmark_id,
                        study_id=study_id,
                        panel=panel_spec.panel,
                        source_mode=spec.source_mode,
                        sample_file=sample_file,
                        source_csv=str(csv_path.relative_to(ROOT)),
                        sample_family_id=family_id,
                        folder_people_label=folder_people_label,
                        injection_time=injection_time,
                        contributor_token=contributor_token,
                        ratio_token=ratio_token,
                        true_contributors=contributor_ids,
                        total_contributors=len(contributor_ids),
                        is_active_mixture_sample=1,
                    )
                    sample_priority[key] = priority

    return sample_map


def make_known_unknown_split(all_ids: List[int], known_count: int, unknown_count: int, seed: int) -> Tuple[List[int], List[int]]:
    rng = random.Random(seed)
    ids = list(all_ids)
    rng.shuffle(ids)
    unknown_ids = sorted(ids[:unknown_count])
    known_ids = sorted(ids[unknown_count : unknown_count + known_count])
    return known_ids, unknown_ids


def make_partition_map(sample_map: Dict[Tuple[str, str], SampleMeta], seed: int) -> Dict[str, str]:
    family_ids = sorted({sample.sample_family_id for sample in sample_map.values()})
    rng = random.Random(seed)
    rng.shuffle(family_ids)

    n = len(family_ids)
    train_cut = int(n * 0.70)
    dev_cut = int(n * 0.85)

    partition_map = {}
    for idx, family_id in enumerate(family_ids):
        if idx < train_cut:
            partition_map[family_id] = "train"
        elif idx < dev_cut:
            partition_map[family_id] = "dev"
        else:
            partition_map[family_id] = "test"
    return partition_map


def join_ints(values: List[int]) -> str:
    return ",".join(str(v) for v in values)


def write_reference_donors(out_dir: Path, reference_rows: List[Dict[str, str]]) -> None:
    path = out_dir / "reference_donors.csv"
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=["study_id", "panel", "person_id", "marker", "alleles"])
        writer.writeheader()
        for row in reference_rows:
            writer.writerow(row)


def build_sample_rows(
    spec: BenchmarkSpec,
    sample_map: Dict[Tuple[str, str], SampleMeta],
    known_ids: List[int],
    unknown_ids: List[int],
    partition_map: Dict[str, str],
) -> Dict[Tuple[str, str], Dict[str, str]]:
    known_set = set(known_ids)
    unknown_set = set(unknown_ids)
    sample_rows: Dict[Tuple[str, str], Dict[str, str]] = {}

    for key, sample in sorted(sample_map.items(), key=lambda item: (item[1].panel, item[1].sample_file)):
        true_set = set(sample.true_contributors)
        known_true = sorted(true_set & known_set)
        unknown_true = sorted(true_set & unknown_set)
        sample_rows[key] = {
            "benchmark_id": spec.benchmark_id,
            "split_id": f"seed_{spec.seed}",
            "partition": partition_map[sample.sample_family_id],
            "study_id": sample.study_id,
            "panel": sample.panel,
            "source_mode": sample.source_mode,
            "sample_file": sample.sample_file,
            "source_csv": sample.source_csv,
            "sample_family_id": sample.sample_family_id,
            "folder_people_label": sample.folder_people_label,
            "injection_time": sample.injection_time,
            "true_contributors": join_ints(sample.true_contributors),
            "known_contributors_true": join_ints(known_true),
            "unknown_contributors_true": join_ints(unknown_true),
            "num_known_in_sample": str(len(known_true)),
            "num_unknown_in_sample": str(len(unknown_true)),
            "unknown_present": "1" if unknown_true else "0",
            "total_contributors": str(sample.total_contributors),
            "is_active_mixture_sample": str(sample.is_active_mixture_sample),
        }
    return sample_rows


def write_samples(out_dir: Path, sample_rows: Dict[Tuple[str, str], Dict[str, str]]) -> None:
    fieldnames = [
        "benchmark_id",
        "split_id",
        "partition",
        "study_id",
        "panel",
        "source_mode",
        "sample_file",
        "source_csv",
        "sample_family_id",
        "folder_people_label",
        "injection_time",
        "true_contributors",
        "known_contributors_true",
        "unknown_contributors_true",
        "num_known_in_sample",
        "num_unknown_in_sample",
        "unknown_present",
        "total_contributors",
        "is_active_mixture_sample",
    ]
    path = out_dir / "samples.csv"
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames)
        writer.writeheader()
        for row in sample_rows.values():
            writer.writerow(row)


def write_manifest(
    out_dir: Path,
    spec: BenchmarkSpec,
    known_ids: List[int],
    unknown_ids: List[int],
    partition_map: Dict[str, str],
) -> None:
    manifest = {
        "benchmark_id": spec.benchmark_id,
        "study_id": spec.study_id,
        "source_mode": spec.source_mode,
        "seed": spec.seed,
        "known_ids": known_ids,
        "unknown_ids": unknown_ids,
        "family_partition_map": partition_map,
    }
    path = out_dir / "split_manifest.json"
    path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")


def build_marker_and_peak_tables(
    out_dir: Path,
    spec: BenchmarkSpec,
    sample_map: Dict[Tuple[str, str], SampleMeta],
    sample_rows: Dict[Tuple[str, str], Dict[str, str]],
) -> None:
    peak_fieldnames = [
        "benchmark_id",
        "split_id",
        "partition",
        "study_id",
        "panel",
        "sample_file",
        "sample_family_id",
        "marker",
        "dye",
        "peak_index",
        "allele_label_raw",
        "allele_label_norm",
        "size",
        "height",
        "is_ol",
        "is_empty",
        "num_known_in_sample",
        "unknown_present",
        "total_contributors",
    ]
    marker_fieldnames = [
        "benchmark_id",
        "split_id",
        "partition",
        "study_id",
        "panel",
        "sample_file",
        "sample_family_id",
        "marker",
        "dye",
        "peak_count_total",
        "peak_count_non_ol",
        "observed_alleles_all",
        "observed_alleles_non_ol",
        "max_height",
        "sum_height",
        "has_ol",
        "num_known_in_sample",
        "unknown_present",
        "total_contributors",
    ]

    peak_path = out_dir / "peak_table.csv"
    marker_path = out_dir / "marker_table.csv"

    marker_agg: Dict[Tuple[str, str, str], Dict[str, object]] = {}
    sample_to_source = {
        (sample.panel, sample.sample_file): ROOT / sample.source_csv for sample in sample_map.values()
    }

    with peak_path.open("w", newline="", encoding="utf-8") as peak_handle:
        peak_writer = csv.DictWriter(peak_handle, fieldnames=peak_fieldnames)
        peak_writer.writeheader()

        for panel_spec in spec.panels:
            for csv_path in sorted(panel_spec.raw_root.rglob("*.csv")):
                if "Known Genotypes" in csv_path.name:
                    continue
                with csv_path.open(encoding="utf-8-sig", newline="", errors="replace") as handle:
                    reader = csv.DictReader(handle)
                    for row in reader:
                        sample_file = row["Sample File"].strip()
                        key = (panel_spec.panel, sample_file)
                        if key not in sample_rows:
                            continue
                        if sample_to_source[key] != csv_path:
                            continue

                        sample_row = sample_rows[key]
                        marker = normalize_marker(row["Marker"])
                        dye = row["Dye"].strip()
                        marker_key = (panel_spec.panel, sample_file, marker)

                        if marker_key not in marker_agg:
                            marker_agg[marker_key] = {
                                "benchmark_id": sample_row["benchmark_id"],
                                "split_id": sample_row["split_id"],
                                "partition": sample_row["partition"],
                                "study_id": sample_row["study_id"],
                                "panel": panel_spec.panel,
                                "sample_file": sample_file,
                                "sample_family_id": sample_row["sample_family_id"],
                                "marker": marker,
                                "dye": set(),
                                "peak_count_total": 0,
                                "peak_count_non_ol": 0,
                                "observed_alleles_all": set(),
                                "observed_alleles_non_ol": set(),
                                "max_height": 0.0,
                                "sum_height": 0.0,
                                "has_ol": 0,
                                "num_known_in_sample": sample_row["num_known_in_sample"],
                                "unknown_present": sample_row["unknown_present"],
                                "total_contributors": sample_row["total_contributors"],
                            }

                        agg = marker_agg[marker_key]
                        agg["dye"].add(dye)

                        for idx in range(1, 101):
                            allele_raw = row.get(f"Allele {idx}", "")
                            size_raw = row.get(f"Size {idx}", "")
                            height_raw = row.get(f"Height {idx}", "")
                            if allele_raw is None or str(allele_raw).strip() == "":
                                continue

                            allele_raw = str(allele_raw).strip()
                            allele_norm = normalize_allele(allele_raw)
                            try:
                                size = float(size_raw)
                            except (TypeError, ValueError):
                                size = ""
                            try:
                                height = float(height_raw)
                            except (TypeError, ValueError):
                                height = 0.0

                            is_ol = 1 if allele_norm.upper() == "OL" else 0
                            agg["peak_count_total"] += 1
                            agg["observed_alleles_all"].add(allele_norm)
                            agg["sum_height"] += height
                            if height > agg["max_height"]:
                                agg["max_height"] = height
                            if is_ol:
                                agg["has_ol"] = 1
                            else:
                                agg["peak_count_non_ol"] += 1
                                agg["observed_alleles_non_ol"].add(allele_norm)

                            peak_writer.writerow(
                                {
                                    "benchmark_id": sample_row["benchmark_id"],
                                    "split_id": sample_row["split_id"],
                                    "partition": sample_row["partition"],
                                    "study_id": sample_row["study_id"],
                                    "panel": panel_spec.panel,
                                    "sample_file": sample_file,
                                    "sample_family_id": sample_row["sample_family_id"],
                                    "marker": marker,
                                    "dye": dye,
                                    "peak_index": idx,
                                    "allele_label_raw": allele_raw,
                                    "allele_label_norm": allele_norm,
                                    "size": size,
                                    "height": height,
                                    "is_ol": is_ol,
                                    "is_empty": 0,
                                    "num_known_in_sample": sample_row["num_known_in_sample"],
                                    "unknown_present": sample_row["unknown_present"],
                                    "total_contributors": sample_row["total_contributors"],
                                }
                            )

    with marker_path.open("w", newline="", encoding="utf-8") as marker_handle:
        writer = csv.DictWriter(marker_handle, fieldnames=marker_fieldnames)
        writer.writeheader()
        for _, agg in sorted(marker_agg.items(), key=lambda item: (item[1]["panel"], item[1]["sample_file"], item[1]["marker"])):
            writer.writerow(
                {
                    "benchmark_id": agg["benchmark_id"],
                    "split_id": agg["split_id"],
                    "partition": agg["partition"],
                    "study_id": agg["study_id"],
                    "panel": agg["panel"],
                    "sample_file": agg["sample_file"],
                    "sample_family_id": agg["sample_family_id"],
                    "marker": agg["marker"],
                    "dye": "|".join(sorted(agg["dye"])),
                    "peak_count_total": agg["peak_count_total"],
                    "peak_count_non_ol": agg["peak_count_non_ol"],
                    "observed_alleles_all": "|".join(sorted(a for a in agg["observed_alleles_all"] if a)),
                    "observed_alleles_non_ol": "|".join(sorted(a for a in agg["observed_alleles_non_ol"] if a)),
                    "max_height": f"{agg['max_height']:.6f}",
                    "sum_height": f"{agg['sum_height']:.6f}",
                    "has_ol": agg["has_ol"],
                    "num_known_in_sample": agg["num_known_in_sample"],
                    "unknown_present": agg["unknown_present"],
                    "total_contributors": agg["total_contributors"],
                }
            )


def write_docs(out_dir: Path, spec: BenchmarkSpec, universe_size: int) -> None:
    readme = f"""# {spec.benchmark_id}

Frozen benchmark dataset built from PROVEDIt `UnFiltered`.

## Summary

- study: `{spec.study_id}`
- source_mode: `{spec.source_mode}`
- panels included: {", ".join(panel.panel for panel in spec.panels)}
- reference universe size: `{universe_size}`
- known donors in split: `{spec.known_count}`
- unknown donors in split: `{spec.unknown_count}`
- split seed: `{spec.seed}`

## Files

- `reference_donors.csv`: donor-level ground-truth reference alleles
- `samples.csv`: one row per sample with task labels
- `marker_table.csv`: one row per sample-marker pair
- `peak_table.csv`: one row per peak
- `split_manifest.json`: frozen donor split and family partition assignment
- `SCHEMA.md`: column dictionary for all dataset files
"""
    schema = """# Schema

## samples.csv

- `benchmark_id`: dataset release identifier
- `split_id`: split identifier
- `partition`: train/dev/test assignment
- `study_id`: PROVEDIt study ID
- `panel`: STR panel / kit
- `source_mode`: filtered vs unfiltered source flag
- `sample_file`: original sample name from raw CSV
- `source_csv`: raw CSV file from which the sample was kept
- `sample_family_id`: family/group key used to reduce leakage
- `folder_people_label`: original folder label such as `1-Person`, `2-Person`
- `injection_time`: timing label from the raw path, e.g. `5 sec`
- `true_contributors`: comma-separated contributor IDs parsed from the sample name
- `known_contributors_true`: comma-separated contributor IDs belonging to the known split
- `unknown_contributors_true`: comma-separated contributor IDs belonging to the unknown split
- `num_known_in_sample`: count of known contributors in the sample
- `num_unknown_in_sample`: count of unknown contributors in the sample
- `unknown_present`: 1 if at least one unknown contributor is present, else 0
- `total_contributors`: total contributor count parsed from the sample name
- `is_active_mixture_sample`: 1 for samples that belong to the active raw study universe

## marker_table.csv

- `benchmark_id`: dataset release identifier
- `split_id`: split identifier
- `partition`: train/dev/test assignment
- `study_id`: PROVEDIt study ID
- `panel`: STR panel / kit
- `sample_file`: original sample name
- `sample_family_id`: family/group key used to reduce leakage
- `marker`: marker/locus name
- `dye`: dye channel(s) observed for that sample-marker
- `peak_count_total`: total non-empty peak slots for the marker
- `peak_count_non_ol`: total non-OL peaks for the marker
- `observed_alleles_all`: all observed allele labels joined by `|`
- `observed_alleles_non_ol`: non-OL allele labels joined by `|`
- `max_height`: maximum peak height for the marker
- `sum_height`: sum of peak heights for the marker
- `has_ol`: 1 if at least one OL peak is present, else 0
- `num_known_in_sample`: inherited sample-level label
- `unknown_present`: inherited sample-level label
- `total_contributors`: inherited sample-level label

## peak_table.csv

- `benchmark_id`: dataset release identifier
- `split_id`: split identifier
- `partition`: train/dev/test assignment
- `study_id`: PROVEDIt study ID
- `panel`: STR panel / kit
- `sample_file`: original sample name
- `sample_family_id`: family/group key used to reduce leakage
- `marker`: marker/locus name
- `dye`: dye channel
- `peak_index`: original peak slot index from the raw CSV row
- `allele_label_raw`: raw allele label as stored in the source CSV
- `allele_label_norm`: normalized allele label after whitespace / `.0` cleanup
- `size`: reported fragment size for the peak
- `height`: reported peak height for the peak
- `is_ol`: 1 if the peak label is `OL`, else 0
- `is_empty`: reserved flag; materialized peaks are written as 0
- `num_known_in_sample`: inherited sample-level label
- `unknown_present`: inherited sample-level label
- `total_contributors`: inherited sample-level label
"""
    (out_dir / "README.md").write_text(readme, encoding="utf-8")
    (out_dir / "SCHEMA.md").write_text(schema, encoding="utf-8")


def build_benchmark_dataset(spec: BenchmarkSpec) -> None:
    out_dir = PROCESSED_ROOT / spec.benchmark_id
    out_dir.mkdir(parents=True, exist_ok=True)

    _, reference_rows, all_ids = load_reference_donors(spec.panels)
    sample_map = collect_canonical_samples(spec)
    known_ids, unknown_ids = make_known_unknown_split(all_ids, spec.known_count, spec.unknown_count, spec.seed)
    partition_map = make_partition_map(sample_map, spec.seed)
    sample_rows = build_sample_rows(spec, sample_map, known_ids, unknown_ids, partition_map)

    write_reference_donors(out_dir, reference_rows)
    write_samples(out_dir, sample_rows)
    write_manifest(out_dir, spec, known_ids, unknown_ids, partition_map)
    build_marker_and_peak_tables(out_dir, spec, sample_map, sample_rows)
    write_docs(out_dir, spec, len(all_ids))


def main() -> None:
    build_benchmark_dataset(RD14_SPEC)
    build_benchmark_dataset(RD12_SPEC)


if __name__ == "__main__":
    main()