Datasets:

Kaphathy
/

Dataset

"""Materialize new-data prompt artifacts in the old OCTFlow caption format.

Outputs:
  - adapter_manifest_v1.parquet: 41-column OCTFlow-style structured manifest.
  - captions_v2.parquet: caption_id, image_id, level, prompt_text, language, generator, grounded_in.
  - sidecar_v1.parquet: raw non-prompt details needed to audit how fields were derived.
  - README.md: artifact and prompt design summary.
"""

from __future__ import annotations

import argparse
import json
import math
from pathlib import Path
from typing import Any

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

from prompt_qc import build_prompts, clean_text, extract_finding_tags, translate_diag


DEFAULT_MANIFEST = Path(
    "/data/team/lisicheng/new_data_manifest/"
    "new_data_manifest_dedup_split_labeled_with_wds_deid_leftfundus.parquet"
)
DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_v1")

V2_MODALITY_OVERRIDES = {
    "data0410_master_fundus": "oct_bscan",
    "octbuckets_octa": "oct_bscan",
}

V2_EXCLUDE_COHORTS = {
    "fq_validfundus",
    "dual_comorbidity_fundus",
}

ADAPTER_COLUMNS = [
    "cohort",
    "study_id",
    "patient_hash",
    "visit_date",
    "eye",
    "device_vendor",
    "device_model",
    "device_serial_hash",
    "device_software_version",
    "hospital_domain",
    "ethnicity",
    "image_quality_score",
    "image_quality_band",
    "diagnosis_group",
    "lesion_tags",
    "lesion_location",
    "layer_involvement",
    "severity",
    "diagnosis_source",
    "label_confidence",
    "schema_version",
    "image_id",
    "file_path",
    "file_format",
    "modality",
    "anatomy",
    "device_technology",
    "scan_protocol",
    "scan_x_mm",
    "bscan_index",
    "image_height_px",
    "image_width_px",
    "axial_resolution_um",
    "has_segmentation",
    "n_layers_visible",
    "fovea_x_norm",
    "crt_um",
    "choroid_thickness_um",
    "oct_footprint_bbox_fundus",
    "oct_footprint_bbox_slo",
    "is_valid",
]

SIDECAR_COLUMNS = [
    "image_id",
    "source_cohort",
    "center",
    "role",
    "split",
    "original_file_path",
    "train_path",
    "deid_path",
    "pii_masked",
    "deid_method",
    "diagnosis_raw",
    "group_raw",
    "diagnosis_group_raw",
    "caption_raw",
    "ocr_age",
    "ocr_sex",
    "ocr_eye",
    "storage",
]

ADAPTER_SCHEMA = pa.schema(
    [
        ("cohort", pa.string()),
        ("study_id", pa.string()),
        ("patient_hash", pa.string()),
        ("visit_date", pa.string()),
        ("eye", pa.string()),
        ("device_vendor", pa.string()),
        ("device_model", pa.string()),
        ("device_serial_hash", pa.string()),
        ("device_software_version", pa.string()),
        ("hospital_domain", pa.string()),
        ("ethnicity", pa.string()),
        ("image_quality_score", pa.float64()),
        ("image_quality_band", pa.string()),
        ("diagnosis_group", pa.list_(pa.string())),
        ("lesion_tags", pa.list_(pa.string())),
        ("lesion_location", pa.list_(pa.string())),
        ("layer_involvement", pa.list_(pa.string())),
        ("severity", pa.string()),
        ("diagnosis_source", pa.string()),
        ("label_confidence", pa.float64()),
        ("schema_version", pa.string()),
        ("image_id", pa.string()),
        ("file_path", pa.string()),
        ("file_format", pa.string()),
        ("modality", pa.string()),
        ("anatomy", pa.string()),
        ("device_technology", pa.string()),
        ("scan_protocol", pa.string()),
        ("scan_x_mm", pa.float64()),
        ("bscan_index", pa.float64()),
        ("image_height_px", pa.float64()),
        ("image_width_px", pa.float64()),
        ("axial_resolution_um", pa.float64()),
        ("has_segmentation", pa.bool_()),
        ("n_layers_visible", pa.int64()),
        ("fovea_x_norm", pa.float64()),
        ("crt_um", pa.float64()),
        ("choroid_thickness_um", pa.float64()),
        ("oct_footprint_bbox_fundus", pa.list_(pa.int64())),
        ("oct_footprint_bbox_slo", pa.list_(pa.int64())),
        ("is_valid", pa.bool_()),
    ]
)

CAPTIONS_SCHEMA = pa.schema(
    [
        ("caption_id", pa.string()),
        ("image_id", pa.string()),
        ("level", pa.string()),
        ("prompt_text", pa.string()),
        ("language", pa.string()),
        ("generator", pa.string()),
        ("grounded_in", pa.string()),
    ]
)

SIDECAR_SCHEMA = pa.schema(
    [
        ("image_id", pa.string()),
        ("source_cohort", pa.string()),
        ("center", pa.string()),
        ("role", pa.string()),
        ("split", pa.string()),
        ("original_file_path", pa.string()),
        ("train_path", pa.string()),
        ("deid_path", pa.string()),
        ("pii_masked", pa.bool_()),
        ("deid_method", pa.string()),
        ("diagnosis_raw", pa.string()),
        ("group_raw", pa.string()),
        ("diagnosis_group_raw", pa.string()),
        ("caption_raw", pa.string()),
        ("ocr_age", pa.float64()),
        ("ocr_sex", pa.string()),
        ("ocr_eye", pa.string()),
        ("storage", pa.string()),
    ]
)

MODALITY_META = {
    "fundus_color": ("macula", "fundus_camera", "single_shot"),
    "oct_bscan": ("macula", "oct", "bscan"),
    "uwf": ("wide-field", "fundus_camera", "widefield"),
    "ffa": ("retina", "fluorescein_angiography", "angiography"),
    "octa": ("macula", "octa", "enface"),
    "bscan_us": ("globe", "ultrasound", "bscan"),
    "ubm": ("anterior_segment", "ultrasound_biomicroscopy", "bscan"),
}


def main() -> None:
    args = parse_args()
    args.out.mkdir(parents=True, exist_ok=True)

    df = pd.read_parquet(args.manifest)
    if args.limit:
        df = df.head(args.limit).copy()
    if args.policy in {"v2", "v3"}:
        df = apply_v2_policy(df)

    adapter_path = args.out / f"adapter_manifest_{args.policy}.parquet"
    captions_path = args.out / "captions_v2.parquet"
    sidecar_path = args.out / f"sidecar_{args.policy}.parquet"

    for path in [adapter_path, captions_path, sidecar_path]:
        if path.exists() and not args.overwrite:
            raise FileExistsError(f"{path} exists; pass --overwrite")
        if path.exists():
            path.unlink()

    adapter_writer: pq.ParquetWriter | None = None
    captions_writer: pq.ParquetWriter | None = None
    sidecar_writer: pq.ParquetWriter | None = None

    total_adapter = 0
    total_captions = 0
    for start in range(0, len(df), args.chunk_size):
        chunk = df.iloc[start : start + args.chunk_size]
        adapter_rows: list[dict[str, Any]] = []
        caption_rows: list[dict[str, Any]] = []
        sidecar_rows: list[dict[str, Any]] = []

        for row in chunk.to_dict("records"):
            adapter_rows.append(build_adapter_row(row))
            sidecar_rows.append(build_sidecar_row(row))
            prompts = build_prompts(row)
            grounded = grounded_in(row)
            for level in ["short", "medium", "dense"]:
                caption_rows.append(
                    {
                        "caption_id": f"{row['image_id']}_{level}",
                        "image_id": row["image_id"],
                        "level": level,
                        "prompt_text": prompts[level],
                        "language": "en",
                        "generator": f"newdata_prompt_adapter_{args.policy}",
                        "grounded_in": grounded,
                    }
                )

        adapter_writer = append_parquet(
            pd.DataFrame(adapter_rows, columns=ADAPTER_COLUMNS),
            adapter_path,
            adapter_writer,
            ADAPTER_SCHEMA,
        )
        captions_writer = append_parquet(
            pd.DataFrame(caption_rows), captions_path, captions_writer, CAPTIONS_SCHEMA
        )
        sidecar_writer = append_parquet(
            pd.DataFrame(sidecar_rows, columns=SIDECAR_COLUMNS),
            sidecar_path,
            sidecar_writer,
            SIDECAR_SCHEMA,
        )
        total_adapter += len(adapter_rows)
        total_captions += len(caption_rows)
        if total_adapter % args.log_every < len(adapter_rows):
            print(f"rows={total_adapter} captions={total_captions}", flush=True)

    for writer in [adapter_writer, captions_writer, sidecar_writer]:
        if writer is not None:
            writer.close()

    write_readme(args.out, args.manifest, len(df), total_captions, args.policy)
    write_summary(args.out, df, total_captions, args.policy)
    print(json.dumps({"out": str(args.out), "rows": len(df), "captions": total_captions}, ensure_ascii=False))


def apply_v2_policy(df: pd.DataFrame) -> pd.DataFrame:
    """Apply the first human-reviewed new-data policy before prompt materialization."""
    out = df.copy()
    if "split" not in out.columns:
        raise KeyError("v2 policy requires a split column")
    if "cohort" not in out.columns:
        raise KeyError("v2 policy requires a cohort column")
    if "modality" not in out.columns:
        raise KeyError("v2 policy requires a modality column")

    out = out[out["split"].eq("train")].copy()
    out = out[~out["cohort"].isin(V2_EXCLUDE_COHORTS)].copy()
    for cohort, modality in V2_MODALITY_OVERRIDES.items():
        out.loc[out["cohort"].eq(cohort), "modality"] = modality
    return out.reset_index(drop=True)


def append_parquet(
    frame: pd.DataFrame, path: Path, writer: pq.ParquetWriter | None, schema: pa.Schema
) -> pq.ParquetWriter:
    table = pa.Table.from_pandas(frame, schema=schema, preserve_index=False)
    if writer is None:
        writer = pq.ParquetWriter(path, table.schema, compression="zstd")
    writer.write_table(table)
    return writer


def build_adapter_row(row: dict[str, Any]) -> dict[str, Any]:
    modality = str(row.get("modality") or "unknown")
    anatomy, technology, protocol = MODALITY_META.get(
        modality, ("unknown", "unknown", "unknown")
    )
    if row.get("cohort") == "tongren_external_fundus":
        anatomy = "anterior_segment"
        technology = "external_photography"
        protocol = "single_shot"

    train_path = str(row.get("train_path") or row.get("file_path") or "")
    diagnosis_group = canonical_diagnoses(row)
    lesion_tags = canonical_lesions(row)
    has_label = bool(diagnosis_group or lesion_tags or clean_text(row.get("caption")))

    return {
        "cohort": row.get("cohort"),
        "study_id": row.get("image_id"),
        "patient_hash": None,
        "visit_date": None,
        "eye": normalize_eye(row.get("ocr_eye")),
        "device_vendor": "unknown",
        "device_model": "unknown",
        "device_serial_hash": None,
        "device_software_version": None,
        "hospital_domain": "new_data",
        "ethnicity": "unknown",
        "image_quality_score": None,
        "image_quality_band": "unknown",
        "diagnosis_group": diagnosis_group,
        "lesion_tags": lesion_tags,
        "lesion_location": [],
        "layer_involvement": [],
        "severity": "unknown",
        "diagnosis_source": diagnosis_source(row),
        "label_confidence": 1.0 if has_label else None,
        "schema_version": "newdata_adapter_v1",
        "image_id": row.get("image_id"),
        "file_path": train_path,
        "file_format": file_format(train_path),
        "modality": modality,
        "anatomy": anatomy,
        "device_technology": technology,
        "scan_protocol": protocol,
        "scan_x_mm": None,
        "bscan_index": None,
        "image_height_px": None,
        "image_width_px": None,
        "axial_resolution_um": None,
        "has_segmentation": False,
        "n_layers_visible": 0,
        "fovea_x_norm": None,
        "crt_um": None,
        "choroid_thickness_um": None,
        "oct_footprint_bbox_fundus": None,
        "oct_footprint_bbox_slo": None,
        "is_valid": True,
    }


def build_sidecar_row(row: dict[str, Any]) -> dict[str, Any]:
    return {
        "image_id": row.get("image_id"),
        "source_cohort": row.get("cohort"),
        "center": row.get("center"),
        "role": row.get("role"),
        "split": row.get("split"),
        "original_file_path": row.get("file_path"),
        "train_path": row.get("train_path"),
        "deid_path": row.get("deid_path"),
        "pii_masked": bool(row.get("pii_masked")),
        "deid_method": row.get("deid_method"),
        "diagnosis_raw": row.get("diagnosis_raw"),
        "group_raw": row.get("group_raw"),
        "diagnosis_group_raw": row.get("diagnosis_group"),
        "caption_raw": row.get("caption"),
        "ocr_age": clean_scalar(row.get("ocr_age")),
        "ocr_sex": clean_scalar(row.get("ocr_sex")),
        "ocr_eye": clean_scalar(row.get("ocr_eye")),
        "storage": row.get("storage"),
    }


def canonical_diagnoses(row: dict[str, Any]) -> list[str]:
    out: list[str] = []
    for key in ["diagnosis_raw", "diagnosis_group", "group_raw"]:
        text = clean_text(row.get(key))
        if not text:
            continue
        val = translate_diag(text)
        if is_canonical_label(val):
            add_unique(out, val)
    return out


def canonical_lesions(row: dict[str, Any]) -> list[str]:
    out: list[str] = []
    for key in ["caption", "diagnosis_raw", "diagnosis_group", "group_raw"]:
        for tag in extract_finding_tags(clean_text(row.get(key))):
            add_unique(out, tag)
    return out


def is_canonical_label(text: str) -> bool:
    if not text or "_" in text or len(text) > 80:
        return False
    return not any("\u4e00" <= ch <= "\u9fff" for ch in text)


def add_unique(out: list[str], value: str) -> None:
    if value and value.lower() not in {v.lower() for v in out}:
        out.append(value)


def diagnosis_source(row: dict[str, Any]) -> str:
    if clean_text(row.get("caption")):
        return "clinical_report"
    if clean_text(row.get("diagnosis_raw")) or clean_text(row.get("diagnosis_group")):
        return "file_label"
    if clean_text(row.get("group_raw")):
        return "folder_label"
    return "none"


def grounded_in(row: dict[str, Any]) -> str:
    parts = ["manifest_fields"]
    if (
        clean_scalar(row.get("ocr_age")) is not None
        or clean_scalar(row.get("ocr_sex")) is not None
        or clean_scalar(row.get("ocr_eye")) is not None
    ):
        parts.append("nonidentifying_demographics")
    if diagnosis_source(row) != "none":
        parts.append("clinical_labels")
    return "+".join(parts)


def normalize_eye(value: Any) -> str:
    eye = str(value or "").upper()
    if eye in {"OD", "OS", "OU"}:
        return eye
    return "unknown"


def file_format(path: str) -> str:
    suffix = path.split("::", 1)[1] if "::" in path else path
    ext = Path(suffix).suffix.lower().lstrip(".")
    return ext or "unknown"


def clean_scalar(value: Any) -> Any:
    if value is None:
        return None
    if isinstance(value, float) and math.isnan(value):
        return None
    return value


def write_readme(out: Path, manifest: Path, rows: int, captions: int, policy: str) -> None:
    policy_note = ""
    if policy in {"v2", "v3"}:
        policy_note = f"""
Human-reviewed {policy} data policy:

- keep only `split=train`;
- exclude cohorts: `{", ".join(sorted(V2_EXCLUDE_COHORTS))}`;
- modality overrides: `{json.dumps(V2_MODALITY_OVERRIDES, ensure_ascii=False)}`.
"""

    text = f"""# New Data Prompt Adapter {policy}

Source manifest:

```text
{manifest}
```

Artifacts:

- `adapter_manifest_{policy}.parquet`: OCTFlow-style structured manifest. It follows the old
  41-column adapter schema. `file_path` points to the actual training image path.
- `captions_v2.parquet`: SD3 text-conditioning table with columns
  `caption_id,image_id,level,prompt_text,language,generator,grounded_in`.
- `sidecar_{policy}.parquet`: raw audit fields that are not copied into prompts.
- `summary.json`: counts and coverage.

Rows: {rows}
Caption rows: {captions}

{policy_note}

Prompt policy:

- `short`: modality phrase only.
- `medium`: modality phrase + reliable non-identifying demographics + up to 3 English labels.
- `dense`: modality phrase + reliable non-identifying demographics + up to 8 English labels.
- No center, hospital, cohort, dataset name, file name, ID, exact date, DOB, raw OCR text, or
  raw Chinese report text is copied into `prompt_text`.
- Age enters prompts only as buckets such as `in their 60s`, never exact age.

The original de-identified image routing remains controlled by the source manifest's `train_path`.
"""
    (out / "README.md").write_text(text, encoding="utf-8")


def write_summary(out: Path, df: pd.DataFrame, captions: int, policy: str) -> None:
    summary = {
        "policy": policy,
        "rows": int(len(df)),
        "captions": int(captions),
        "by_modality": df.groupby("modality").size().astype(int).to_dict(),
        "by_cohort": df.groupby("cohort").size().astype(int).to_dict(),
        "pii_masked": int(df["pii_masked"].fillna(False).sum()) if "pii_masked" in df else 0,
    }
    if policy in {"v2", "v3"}:
        summary[f"{policy}_exclude_cohorts"] = sorted(V2_EXCLUDE_COHORTS)
        summary[f"{policy}_modality_overrides"] = V2_MODALITY_OVERRIDES
    (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
    parser.add_argument("--chunk-size", type=int, default=100_000)
    parser.add_argument("--log-every", type=int, default=500_000)
    parser.add_argument("--limit", type=int, default=None)
    parser.add_argument("--overwrite", action="store_true")
    parser.add_argument("--policy", choices=["v1", "v2", "v3"], default="v1")
    return parser.parse_args()


if __name__ == "__main__":
    main()