"""Portable helpers for reading ZoomPath auxiliary parent-child training pairs.""" from __future__ import annotations import io import json import math import tarfile from pathlib import Path from typing import Any, Iterator MAGNIFICATION_TO_TRAINING_SCALE = { 40.0: (0.25, "high"), 20.0: (0.50, "high"), 10.0: (1.0, "mid"), 5.0: (2.0, "mid"), 2.5: (4.0, "low"), 1.0: (10.0, "low"), } def asset_bytes(root: Path, relative: str, archive: dict | None = None) -> bytes: path = Path(relative) if path.is_absolute() or ".." in path.parts: raise ValueError(f"Not a package-relative asset: {relative}") if archive is None: return (root / path).read_bytes() packed = Path(archive["path"]) if packed.is_absolute() or ".." in packed.parts: raise ValueError("Not a package-relative archive") offset, length = archive["offset"], archive["bytes"] if (type(offset) is not int or type(length) is not int or offset < 512 or offset % 512 or length < 1): raise ValueError("Invalid uncompressed TAR member range") with (root / packed).open("rb") as stream: if offset + length > (root / packed).stat().st_size: raise ValueError("TAR member range exceeds archive") stream.seek(offset - 512) header = stream.read(512) try: member = tarfile.TarInfo.frombuf(header, "utf-8", "strict") except tarfile.HeaderError as exc: raise ValueError("Invalid TAR member header") from exc if member.name != relative or member.size != length or not member.isreg(): raise ValueError("TAR header differs from requested package member") value = stream.read(length) if len(value) != length: raise ValueError("Truncated TAR member") return value def load_image(root: Path, image: dict): from PIL import Image with Image.open(io.BytesIO(asset_bytes(root, image["path"], image.get("archive")))) as opened: return opened.convert("RGB") def nominal_training_scale(magnification: float) -> tuple[list[float], str]: if magnification not in MAGNIFICATION_TO_TRAINING_SCALE: raise ValueError(f"Unsupported training magnification: {magnification}") mpp, level = MAGNIFICATION_TO_TRAINING_SCALE[magnification] return [mpp, mpp], level def training_scale_from_mpp(mpp: list[float]) -> tuple[float, str]: # This is a training bin, not a recovery of the scanner's objective power. mean_mpp = sum(mpp) / 2 if not math.isfinite(mean_mpp) or mean_mpp <= 0: raise ValueError("MPP must be positive and finite") magnification = min(MAGNIFICATION_TO_TRAINING_SCALE, key=lambda value: abs( math.log(mean_mpp / MAGNIFICATION_TO_TRAINING_SCALE[value][0]) )) return magnification, MAGNIFICATION_TO_TRAINING_SCALE[magnification][1] class AuxiliaryTrainingReader: def __init__(self, root: str | Path): self.root = Path(root).resolve() self._annotation_path: str | None = None self._annotation_archive: dict | None = None self._targets: list[dict[str, Any]] = [] self._groups: dict[tuple[str, str], list[dict[str, Any]]] = {} self._ignored_groups: dict[tuple[str, str], list[dict[str, Any]]] = {} def resolve(self, relative: str) -> Path: path = Path(relative) if path.is_absolute() or ".." in path.parts: raise ValueError(f"Not a package-relative path: {relative}") return self.root / path def iter_records(self, dataset: str | None = None) -> Iterator[dict[str, Any]]: with (self.root / "manifest.jsonl").open(encoding="utf-8") as stream: for line in stream: if line.strip(): row = json.loads(line) if dataset is None or row["dataset"] == dataset: yield row def annotation_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: path = row["annotations_path"] if path != self._annotation_path or row.get("annotations_archive") != self._annotation_archive: payload = self.annotation_payload(row) self._targets = payload["targets"] self._groups = {} self._ignored_groups = {} for target in self._targets: groups = self._groups if target.get("training_eligible", True) else self._ignored_groups for key in ("label", "expression"): if key in target: groups.setdefault((key, target[key]), []).append(target) self._annotation_path = path self._annotation_archive = row.get("annotations_archive") return self._targets def annotation_payload(self, row: dict[str, Any]) -> dict[str, Any]: return json.loads(asset_bytes(self.root, row["annotations_path"], row.get("annotations_archive"))) def valid_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: self.annotation_targets(row) rule = row["valid_targets_filter"] if set(rule) not in ({"label"}, {"expression"}): raise ValueError(f"Unsupported valid target filter: {rule}") key, value = next(iter(rule.items())) matches = self._groups.get((key, value), []) if len(matches) != row["target_count"]: raise ValueError(f"Target count mismatch: {row['record_id']}") return matches def ignored_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: """Source-supported query matches excluded from positive training supervision.""" self.annotation_targets(row) key, value = next(iter(row["valid_targets_filter"].items())) return self._ignored_groups.get((key, value), []) def load_pair(self, row: dict[str, Any]) -> dict[str, Any]: parent = load_image(self.root, row["parent_image"]) child = load_image(self.root, row["child_image"]) return { "record_id": row["record_id"], "dataset": row["dataset"], "parent_image": parent, "child_image": child, "question": row["question"], "child_bbox_xyxy_in_parent": row["child_bbox_xyxy_in_parent"], "valid_target_bboxes_xyxy_in_parent": [target["bbox_xyxy"] for target in self.valid_targets(row)], "ignored_target_bboxes_xyxy_in_parent": [target["bbox_xyxy"] for target in self.ignored_targets(row)], "ignored_targets_are_not_negatives": bool(row.get("quality_filter")), "organ": row["organ"], "mpp": row["parent_image"]["mpp"], "magnification": row["parent_image"].get("magnification"), "mpp_is_approximate": row["parent_image"].get("mpp_is_approximate", False), "level": row["parent_image"]["level"], "metadata": row, }