reader.py

"""S3/HTTPS WebDataset consumer using SpatialEncoder's native geometry code.

Shards stream through WebDataset; only the current sample is materialized.
Linux memfd handles allow existing PIL/OpenCV readers to seek inside a sample.
HDF5 requires a real path and uses a bounded per-sample temporary file instead.
Install this module alongside the matching SpatialEncoder checkout.
"""
from __future__ import annotations

import base64
import copy
import json
import os
import random
import re
import tempfile
from contextlib import contextmanager
from pathlib import Path


def restore_blobs(value):
    if isinstance(value, dict):
        if set(value) == {"__bytes_base64__"}:
            return base64.b64decode(value["__bytes_base64__"], validate=True)
        return {k: restore_blobs(v) for k, v in value.items()}
    if isinstance(value, list):
        return [restore_blobs(v) for v in value]
    return value


def header_of(sample):
    header = restore_blobs(json.loads(sample["meta.json"]))
    if header.get("schema") != "spatialencoder-wds-native-v1":
        raise ValueError("Unsupported WDS schema")
    return header


@contextmanager
def memory_assets(sample):
    """Suffix-preserving handles; HDF5 alone needs a real temporary file."""
    descriptors = []
    with tempfile.TemporaryDirectory(prefix="spatial-wds-", dir=os.environ.get("SPATIAL_WDS_TMPDIR")) as directory:
        paths = {}
        try:
            for field, data in sample.items():
                if field.startswith("__") or field == "meta.json":
                    continue
                if not re.fullmatch(r"[a-zA-Z0-9_]+\.[a-zA-Z0-9]+", field):
                    raise ValueError(f"Unsafe asset field: {field}")
                path = Path(directory) / field
                if field.endswith(".h5"):
                    # HDF5's sec2 driver resolves realpath and rejects Linux
                    # anonymous memfd objects. Cache only this sequence, not
                    # the shard; the context always removes it after decoding.
                    path.write_bytes(data)
                    paths[field] = str(path)
                    continue
                descriptor = os.memfd_create("spatial-wds", flags=os.MFD_CLOEXEC)
                descriptors.append(descriptor)
                view = memoryview(data)
                while view:
                    view = view[os.write(descriptor, view):]
                path.symlink_to(f"/proc/{os.getpid()}/fd/{descriptor}")
                paths[field] = str(path)
            yield Path(directory), paths
        finally:
            for descriptor in descriptors:
                os.close(descriptor)


def native_instance(header, *, training=True, transforms=None, capture=False, **options):
    from sam3.train.data.ca1m_dataset import (
        _CA1MDatapointMixin, CA1MTrainIterableDataset, DEFAULT_CA1M_EXCLUSION_MANIFEST,
    )
    from sam3.train.data.object_detection_dataset import ObjectDetectionDataset
    from sam3.train.data.uco3d_dataset import UCO3DDetectionDataset
    if transforms is None:
        from sam3.train.transforms.basic_for_api import ToTensorAPI
        transforms = [ToTensorAPI()]
    kind = header["kind"]
    cls = {"object": ObjectDetectionDataset, "ca1m": CA1MTrainIterableDataset,
           "uco3d": UCO3DDetectionDataset}[kind]
    instance = cls.__new__(cls)
    settings = {"resolution": 1024, "resolution_aug_scale": (0.8, 1.2),
                "min_crop_visible_ratio": 0.2, "spatial_type": "vggt", "spatial_resolution": 518,
                "exclusion_manifest": DEFAULT_CA1M_EXCLUSION_MANIFEST if kind == "ca1m" else None}
    settings.update({k:v for k,v in options.items() if k in settings})
    _CA1MDatapointMixin.__init__(instance, transforms=[] if transforms is None else transforms, training=training,
        load_segmentation=True, max_train_queries=100000, max_val_queries=100000, **settings)
    values = {"predict_metric": True, "use_extrinsic": False, "norm_scale": 2.5,
              "video_split_per_frame": 15, "frame_num_range": (2, 8),
              "frame_sample_gap_range": (1, 5), "max_num_objects": 12}
    values.update(header.get("options", {}))
    values.update(options)
    for key, value in values.items():
        setattr(instance, key, value)
    instance.dataset_name = header["dataset"]
    instance.default_scale = float(header["default_scale"])
    instance.base_dir = ""
    instance.meta_base_dir = None
    if capture:
        instance._assemble_clip_datapoint = lambda **kwargs: kwargs
    return instance


class SpatialWDSDecoder:
    """Map raw WDS dictionaries to native training Datapoints.

    A block owns 64 clip starts plus up to 14 lookahead frames. By default one
    owned start is sampled uniformly each visit, keeping temporal windows
    intact. Use iter_block() to enumerate all owned starts for evaluation or an
    exact clip-coverage pass. Normal native filtering can produce None.
    """
    def __init__(self, training=True, transforms=None, **options):
        self.training, self.transforms, self.options = training, transforms, options

    def __call__(self, sample, start=None, capture=False):
        header = header_of(sample)
        instance = native_instance(header, training=self.training, transforms=self.transforms,
                                   capture=capture, **self.options)
        if start is None:
            start = random.randrange(header.get("owned_starts", 1)) if self.training else 0
        if not 0 <= start < header.get("owned_starts", 1):
            raise ValueError("Start must belong to this sample's owned region")
        kind = header["kind"]
        if kind == "ca1m":
            metadata = header["metadata"]
            selected = list(metadata["frames"])[start:start + instance.video_split_per_frame]
            records = [{"ts": r["ts"], "key": r["key"], "data": {"data": sample[r["field"]]}}
                       for r in header["records"] if r["ts"] in selected]
            frames = instance._sampled_frames_from_webdataset(metadata, records)
            result = instance._build_train_sample(metadata, frames)
        else:
            with memory_assets(sample) as (directory, paths):
                if kind == "uco3d":
                    sequence = copy.deepcopy(header["sequence"])
                    sequence["_video_path"] = paths["video.mp4"]
                    sequence["_depth_video_path"] = paths["depth.h5"]
                    instance._sequence_and_frames = lambda _: (sequence, header["box"], header["frames"])
                    result = instance._load_clip(header["source_id"])
                else:
                    metadata = copy.deepcopy(header["metadata"])
                    original_assemble = instance._assemble_clip_datapoint
                    def assemble_global_start(**kwargs):
                        kwargs["scene_id"] = f"{metadata['scene_id']}_{header['start_frame'] + start}"
                        return original_assemble(**kwargs)
                    instance._assemble_clip_datapoint = assemble_global_start
                    bindings = {source: paths[field] for source, field in header["bindings"].items()}
                    for frame in metadata["frames"].values():
                        if "wds_tfrecord_binding" in frame:
                            # Keep movi variant in path: native depth conversion
                            # uses it to select the official native pixel grid.
                            binding = frame.pop("wds_tfrecord_binding")
                            frame["tfrecord_path"] = binding
                            frame["tfrecord_offset"] = 0
                    instance._resolve_path = lambda original: bindings[original]
                    meta_path = directory / "scene.json"
                    meta_path.write_text(json.dumps(metadata, allow_nan=False))
                    length = min(instance.video_split_per_frame, header["frame_count"] - start)
                    result = instance._load_frames(header["dataset"], instance.default_scale,
                                                   str(meta_path), length, start)
        if result is not None and not capture:
            result.reference_payload["wds_source"] = {
                "key": sample.get("__key__"), "url": sample.get("__url__"),
                "dataset": header["dataset"], "split": header["split"],
                "source_id": header["source_id"], "start_frame": header.get("start_frame", 0) + start,
            }
        return result

    def iter_block(self, sample):
        for start in range(header_of(sample).get("owned_starts", 1)):
            result = self(sample, start=start)
            if result is not None:
                yield result


def dataset(urls, *, training=True, shuffle_shards=True, **decoder_options):
    """URLs may be HTTPS, local tar paths, or trusted `pipe:aws s3 cp ... -`."""
    import webdataset as wds
    decoder = SpatialWDSDecoder(training=training, **decoder_options)
    source = wds.WebDataset(urls, shardshuffle=100 if shuffle_shards else False,
        nodesplitter=wds.split_by_node, workersplitter=wds.split_by_worker)
    return source.map(decoder).select(lambda value: value is not None)