scripts/manifest_builder.py

"""
manifest_builder.py — ERYON ingestion manifest generator.

Scans a processed dataset directory and writes a JSONL manifest with one
record per image.  All fields required by ingestion.md are populated.
Deterministic: sorted by file path so the same input always produces the
same manifest.

Usage:
    python manifest_builder.py \\
        --root /mnt/raw/lidc \\
        --modality CT \\
        --dataset lidc-idri \\
        --dataset-version 1.0.0 \\
        --preprocessing-version 1.0.0 \\
        --out manifests/lidc/manifest_v1.0.0.jsonl
"""

import argparse
import hashlib
import json
import sys
from pathlib import Path


def sha256_file(path: Path) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
    return h.hexdigest()


def parse_path_ids(image_path: Path) -> dict:
    """
    Infer patient_id, study_id, series_id from bucket layout:
        raw/lidc/batch_XXXX/<SeriesInstanceUID>/slice_NNNN.png
    """
    parts = image_path.parts
    try:
        series_id = parts[-2]
        batch = parts[-3]
        return {"patient_id": series_id[:8], "study_id": batch, "series_id": series_id}
    except IndexError:
        return {"patient_id": "unknown", "study_id": "unknown", "series_id": "unknown"}


def build_manifest(
    root: Path,
    modality: str,
    dataset: str,
    dataset_version: str,
    preprocessing_version: str,
    split_map: dict[str, str],
    label_map: dict[str, str],
    out_path: Path,
) -> int:
    out_path.parent.mkdir(parents=True, exist_ok=True)
    records = []
    for img_path in sorted(root.rglob("*.png")):
        ids = parse_path_ids(img_path)
        rel = str(img_path.relative_to(root))
        record = {
            "patient_id": ids["patient_id"],
            "study_id": ids["study_id"],
            "series_id": ids["series_id"],
            "image_path": rel,
            "modality": modality,
            "split": split_map.get(ids["series_id"], "unassigned"),
            "label": label_map.get(ids["series_id"], "unknown"),
            "dataset_version": dataset_version,
            "preprocessing_version": preprocessing_version,
            "sha256": sha256_file(img_path),
        }
        records.append(record)

    with open(out_path, "w") as f:
        for r in records:
            f.write(json.dumps(r) + "\n")

    print(f"Manifest written: {out_path}  ({len(records)} records)")
    return len(records)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--root", required=True)
    parser.add_argument("--modality", default="CT")
    parser.add_argument("--dataset", default="lidc-idri")
    parser.add_argument("--dataset-version", default="1.0.0")
    parser.add_argument("--preprocessing-version", default="1.0.0")
    parser.add_argument("--splits-json", default=None, help="Path to {series_id: split} JSON")
    parser.add_argument("--labels-json", default=None, help="Path to {series_id: label} JSON")
    parser.add_argument("--out", required=True)
    args = parser.parse_args()

    split_map = json.loads(Path(args.splits_json).read_text()) if args.splits_json else {}
    label_map = json.loads(Path(args.labels_json).read_text()) if args.labels_json else {}

    n = build_manifest(
        root=Path(args.root),
        modality=args.modality,
        dataset=args.dataset,
        dataset_version=args.dataset_version,
        preprocessing_version=args.preprocessing_version,
        split_map=split_map,
        label_map=label_map,
        out_path=Path(args.out),
    )
    if n == 0:
        print("WARNING: manifest is empty — no .png files found under root", file=sys.stderr)


if __name__ == "__main__":
    main()