"""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)