Add files using upload-large-folder tool

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/common/io_utils.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import glob
+from dataclasses import dataclass
+
+import imageio
+import numpy as np
+
+from cosmos_policy._src.imaginaire.utils import log
+
+
+@dataclass
+class VideoData:
+    frames: np.ndarray  # Shape: [B, H, W, C]
+    fps: int
+    duration: int  # in seconds
+
+
+def get_video_filepaths(input_dir: str) -> list[str]:
+    """Get a list of filepaths for all videos in the input directory."""
+    paths = glob.glob(f"{input_dir}/**/*.mp4", recursive=True)
+    paths += glob.glob(f"{input_dir}/**/*.avi", recursive=True)
+    paths += glob.glob(f"{input_dir}/**/*.mov", recursive=True)
+    paths = sorted(paths)
+    log.debug(f"Found {len(paths)} videos")
+    return paths
+
+
+def read_video(filepath: str) -> VideoData:
+    """Read a video file and extract its frames and metadata."""
+    try:
+        reader = imageio.get_reader(filepath, "ffmpeg")
+    except Exception as e:
+        raise ValueError(f"Failed to read video file: {filepath}") from e
+
+    # Extract metadata from the video file
+    try:
+        metadata = reader.get_meta_data()
+        fps = metadata.get("fps")
+        duration = metadata.get("duration")
+    except Exception as e:
+        reader.close()
+        raise ValueError(f"Failed to extract metadata from video file: {filepath}") from e
+
+    # Extract frames from the video file
+    try:
+        frames = np.array([frame for frame in reader])
+    except Exception as e:
+        raise ValueError(f"Failed to extract frames from video file: {filepath}") from e
+    finally:
+        reader.close()
+
+    return VideoData(frames=frames, fps=fps, duration=duration)
+
+
+def save_video(filepath: str, frames: np.ndarray, fps: int) -> None:
+    """Save a video file from a sequence of frames."""
+    try:
+        writer = imageio.get_writer(filepath, fps=fps, macro_block_size=1)
+        for frame in frames:
+            writer.append_data(frame)
+    except Exception as e:
+        raise ValueError(f"Failed to save video file to {filepath}") from e
+    finally:
+        writer.close()

REGEN-main/cosmos_policy/_src/imaginaire/datasets/augmentors/merge_datadict.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.utils import log
+
+
+class DataDictMerger(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Merge the dictionary associated with the input keys into data_dict. Only keys in output_keys are merged.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict with dictionary associated with the input keys merged.
+        """
+        for key in self.input_keys:
+            if key not in data_dict:
+                log.warning(
+                    f"DataDictMerger dataloader error: missing {key}, {data_dict['__url__']}, {data_dict['__key__']}",
+                    rank0_only=False,
+                )
+                return None
+            key_dict = data_dict.pop(key)
+            if key == "depth" and "depth" in self.output_keys:
+                data_dict["depth"] = key_dict
+            if key == "human_annotation" and "human_annotation" in self.output_keys:
+                data_dict["human_annotation"] = key_dict
+            elif key == "segmentation" and "segmentation" in self.output_keys:
+                data_dict["segmentation"] = key_dict
+            elif key == "canny" and "canny" in self.output_keys:
+                data_dict["canny"] = key_dict
+            for sub_key in key_dict:
+                if sub_key in self.output_keys and sub_key not in data_dict:
+                    data_dict[sub_key] = key_dict[sub_key]
+            del key_dict
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/augmentors/v3_text_transforms.py

@@ -0,0 +1,213 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+from typing import Optional
+
+import numpy as np
+import torch
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+
+
+def pad_and_resize(
+    arr_np: np.ndarray, ntokens: int, is_mask_all_ones: bool = False
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""Function for padding and resizing a numpy array.
+    Args:
+        arr (np.ndarray): Input array
+        ntokens (int): Number of output tokens after padding
+        is_mask_all_ones (bool): if true, set mask to ones
+    Returns:
+        arr_padded (torch.Tensor): Padded output tensor
+        mask (torch.Tensor): Padding mask
+    """
+
+    if isinstance(arr_np, np.ndarray):
+        arr = torch.from_numpy(arr_np)
+    elif isinstance(arr_np, torch.Tensor):
+        arr = arr_np.clone().detach()
+    else:
+        raise TypeError("`arr_np` should be a numpy array or torch tensor.")
+    embed_dim = arr.shape[1]
+
+    arr_padded = torch.zeros(ntokens, embed_dim, device=arr.device, dtype=torch.float32)
+
+    # If the input text is larger than num_text_tokens, clip it.
+    if arr.shape[0] > ntokens:
+        arr = arr[0:ntokens]
+
+    mask = torch.LongTensor(ntokens).zero_()
+    if len(arr.shape) > 1:
+        mask[0 : arr.shape[0]] = 1
+
+    if len(arr.shape) > 1:
+        arr_padded[0 : arr.shape[0]] = arr
+
+    if is_mask_all_ones:
+        mask.fill_(1)
+
+    return arr_padded, mask
+
+
+def _obtain_embeddings(cfg: dict, embeddings_captions: dict[str, list], caption_idx: int) -> dict:
+    r"""Function for obtaining text embeddings and text mask.
+    Args:
+        cfg (dict): Config dict
+        embeddings_captions (np.ndarray): Caption embeddings
+        caption_idx (int): Caption index
+    Returns:
+        Dictionary containing embeddings and mask
+    """
+    out_dict = dict()
+    is_mask_all_ones = cfg["is_mask_all_ones"]
+    if "byt5_tokens" in cfg:
+        out_byt5_text, out_byt5_text_mask = pad_and_resize(
+            embeddings_captions["byt5_fp8"][caption_idx],
+            cfg["byt5_tokens"]["num"],
+            is_mask_all_ones=is_mask_all_ones,
+        )
+        out_dict["byt5_text_embeddings"] = out_byt5_text
+        out_dict["byt5_text_mask"] = out_byt5_text_mask
+
+    if "t5_tokens" in cfg:
+        out_t5, out_t5_mask = pad_and_resize(
+            embeddings_captions["t5_xxl_fp8"][caption_idx],
+            cfg["t5_tokens"]["num"],
+            is_mask_all_ones=is_mask_all_ones,
+        )
+        out_dict["t5_text_embeddings"] = out_t5
+        out_dict["t5_text_mask"] = out_t5_mask
+
+    return out_dict
+
+
+def obtain_data_dict_from_mixed_gt_and_ai_captions(data_dict: dict, input_keys: list, args: Optional[dict] = None):
+    out_pkl_dict = dict()
+
+    captions_gt = data_dict[input_keys[0]]
+    decoded_captions_ai = data_dict[input_keys[1]]
+    embeddings_captions_gt = data_dict[input_keys[2]]
+    embeddings_captions_ai = data_dict[input_keys[3]]
+
+    assert args is not None, "Please specify args in augmentation"
+    probabilities = [args["caption_probs"]["ground_truth"], args["caption_probs"]["vfc_fidelity"]]
+    valid_captions_indices = list(range(len(probabilities)))
+    caption_idx = random.choices(valid_captions_indices, weights=probabilities, k=1)[0]
+
+    # If VFC Fidelity caption is not valid, we will use the ground truth caption
+    if caption_idx == 1 and decoded_captions_ai["had_parse_issue"]:
+        caption_idx = 0
+
+    # Merging GT and AI caption raw text
+    captions = captions_gt["text"] + [decoded_captions_ai["captions"]["vfc_fidelity"]]
+
+    # Merging GT and AI caption embeddings
+    gt_embeddings = []
+    for key in ["ground_truth_headline", "ground_truth"]:
+        if key in embeddings_captions_gt:
+            if embeddings_captions_gt[key] is not None:
+                gt_embeddings.append(embeddings_captions_gt[key])
+
+    # Randomly select one of the GT embeddings
+    gt_embedding = random.choice(gt_embeddings)
+    embeddings_captions = {}
+    for key in embeddings_captions_ai["vfc_fidelity"]["embeddings"].keys():
+        embeddings_captions[key] = [
+            gt_embedding["embeddings"][key],
+            embeddings_captions_ai["vfc_fidelity"]["embeddings"][key],
+        ]
+
+    # Sampling raw caption and embeddings
+    raw_captions = captions[caption_idx]
+    data_dict["raw_captions"] = raw_captions
+
+    embeddings_dict = _obtain_embeddings(
+        cfg=args,
+        embeddings_captions=embeddings_captions,
+        caption_idx=caption_idx,
+    )
+    out_pkl_dict.update(embeddings_dict)
+
+    data_dict.update(out_pkl_dict)
+    for key in input_keys:
+        del data_dict[key]
+
+    return data_dict
+
+
+class TextTransform(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs camera transformation.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict with camera attributes added
+        """
+        return obtain_data_dict_from_mixed_gt_and_ai_captions(data_dict, self.input_keys, self.args)
+
+
+class TextTransformAIOnly(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs text transform for datasets where there are only AI captions (ex., NVCC).
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict with camera attributes added
+        """
+
+        out_pkl_dict = dict()
+        decoded_captions_ai = data_dict[self.input_keys[0]]
+        embeddings_captions_ai = data_dict[self.input_keys[1]]
+
+        assert self.args is not None, "Please specify args in augmentation"
+
+        raw_captions = decoded_captions_ai["captions"]["vfc"]
+        embeddings_captions = {}
+
+        if decoded_captions_ai["had_parse_issue"]:
+            raw_captions = decoded_captions_ai["captions"]["kosmos_2"]
+            _embeddings_captions = embeddings_captions_ai["kosmos2"]
+        else:
+            raw_captions = decoded_captions_ai["captions"]["vfc"]
+            _embeddings_captions = embeddings_captions_ai["vfc_fidelity"]
+
+        for key in _embeddings_captions["embeddings"].keys():
+            embeddings_captions[key] = [
+                _embeddings_captions["embeddings"][key],
+            ]
+
+        # Sampling raw caption and embeddings
+        data_dict["raw_captions"] = raw_captions
+        embeddings_dict = _obtain_embeddings(
+            cfg=self.args,
+            embeddings_captions=embeddings_captions,
+            caption_idx=0,
+        )
+        out_pkl_dict.update(embeddings_dict)
+
+        data_dict.update(out_pkl_dict)
+        for key in self.input_keys:
+            del data_dict[key]
+
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/decoders/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/datasets/decoders/json_loader.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import re
+from typing import Optional
+
+
+def json_decoder(key: str, data: bytes) -> Optional[dict]:
+    r"""
+    Function to decode a json file.
+    Args:
+        key: Data key.
+        data: Data dict.
+    """
+    extension = re.sub(r".*[.]", "", key)
+    if extension == "json":
+        data_dict = json.loads(data)
+        return data_dict
+    else:
+        return None

REGEN-main/cosmos_policy/_src/imaginaire/datasets/decoders/pkl_loader.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pickle
+import re
+from typing import Optional
+
+
+def pkl_decoder(key: str, data: bytes) -> Optional[dict]:
+    r"""
+    Function to decode a pkl file.
+    Args:
+        key: Data key.
+        data: Data dict.
+    """
+    extension = re.sub(r".*[.]", "", key)
+    if extension == "pkl":
+        data_dict = pickle.loads(data)
+        return data_dict
+    else:
+        return None

REGEN-main/cosmos_policy/_src/imaginaire/datasets/decoders/video_decoder.py

@@ -0,0 +1,775 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import math
+import re
+from random import randint
+from typing import Callable, List, Tuple
+
+import decord
+import numpy as np
+import torch
+from PIL import Image
+
+from cosmos_policy._src.imaginaire.utils import log
+
+Image.MAX_IMAGE_PIXELS = 933120000
+_VIDEO_EXTENSIONS = "mp4 avi webm mov".split()
+
+VIDEO_DECODER_OPTIONS = {}
+
+
+def video_decoder_register(key):
+    def decorator(func):
+        VIDEO_DECODER_OPTIONS[key] = func
+        return func
+
+    return decorator
+
+
+@video_decoder_register("video_decoder_metadata")
+def video_decoder_metadata(num_threads, **kwargs):
+    """
+    Video decoder using the video's native fps
+    """
+
+    def video_decoder(key: str, data: bytes):
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+        video_buffer = io.BytesIO(data)
+        reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+        num_frames = len(reader)
+        video_fps = int(np.round(reader.get_avg_fps()))
+        length_in_s = float(num_frames) / float(video_fps)
+        bitrate = video_buffer.getbuffer().nbytes * 8 / length_in_s
+        video_frames = reader.get_batch([0]).asnumpy()
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+        return video_frames, {"fps": video_fps, "num_frames": num_frames, "bitrate": bitrate}
+
+    return video_decoder
+
+
+@video_decoder_register("video_decoder_w_controlled_fps")
+def video_decoder_w_controlled_fps(
+    sequence_length: int = 34,
+    chunk_size: int = 0,
+    use_fps_control: bool = False,
+    min_fps_thres: int = 4,
+    max_fps_thres: int = 30,
+    sampling_reweighting: bool = False,
+    sampling_reweighting_factor: int = 1,
+    num_threads=4,
+    limit_fps_range: bool = False,
+    save_raw: bool = False,
+):
+    """
+    Video decoder using with fps control.
+    This function samples videos with fps in the range [min_fps_thres, max_fps_thres].
+    We adjust the fps range if min and max fps cannot be supported to get the sequence length with desired chunk size.
+
+    Parameters:
+    - sequence_length (int) : Number of frames returned by the function
+    - chunk_size (int): How the video is divided into chunks. Only return frames within a chunk. chunk_size=0 means we use full video length. Defaults to 0.
+    - min_fps_thres (int): Minimum fps threshold to sample from.
+    - max_fps_thres (int): Maximum fps threshold to sample from.
+    - sampling_reweighting (bool): If False, sample fps weights uniformly. If True, reweight sampling distrubution.
+    - sampling_reweighting_factor (int): The fps sampling distribution reweighting factor. If sampling_reweighting_factor  > 1, sample more on lower fps side.
+    - num_thread (int): Number of threads for decord.
+    - save_raw (bool): If True, will also return entire raw video in data_dict key "video_raw_bytes", alongside with the video frames. Only enable this for visualization and debug.
+    """
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ):
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        video_buffer = io.BytesIO(data)
+        video_reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+        num_target_frames = sequence_length if sequence_length > 0 else len(video_reader)
+        num_orig_frames = len(video_reader)
+
+        # Obtain the number of chunks
+        if chunk_size == 0:
+            curr_chunk_size = num_orig_frames
+        else:
+            curr_chunk_size = chunk_size
+        num_chunks = max(num_orig_frames // curr_chunk_size, 1)
+
+        # Checks to ensure that number of target frames we need is present in the video / chunk.
+        if num_target_frames > curr_chunk_size:
+            raise ValueError(
+                f"Specified sequence_length {num_target_frames} exceeds curr_chunk_size {curr_chunk_size}, num_orig_frames={num_orig_frames}, chunk_size={chunk_size}"
+            )
+
+        if num_target_frames > num_orig_frames:
+            raise ValueError(
+                f"Specified sequence_length {num_target_frames} exceeds num frames in video {num_orig_frames}."
+            )
+
+        # Now obtain min and max fps that we can use within this chunk
+        video_fps = int(np.round(video_reader.get_avg_fps()))
+
+        if video_fps < 1:
+            raise ValueError("Video fps lower than 1, skipping")
+        if limit_fps_range:
+            if video_fps < min_fps_thres:
+                raise ValueError(f"Video fps {video_fps} lower than {min_fps_thres}, skipping")
+            if video_fps > max_fps_thres:
+                raise ValueError(f"Video fps {video_fps} larger than {max_fps_thres}, skipping")
+
+        # Check if the last chunk has separate window
+        # This happens only if remainder frames >= curr_chunk_size / 2 [data annotation was done this way]
+        # Else this is used as a part of previous window.
+        num_frames_in_last_chunk = num_orig_frames - num_chunks * curr_chunk_size
+        if num_frames_in_last_chunk >= int(0.5 * curr_chunk_size):
+            if num_frames_in_last_chunk > num_target_frames:
+                num_chunks += 1
+
+        # Sample which chunk to use
+        chunk_index = randint(0, num_chunks - 1)
+
+        if chunk_index == num_chunks - 1:
+            # For the last chunk, use all of the remaining frames
+            num_samples_in_chunk = num_orig_frames - chunk_index * curr_chunk_size
+        else:
+            # Else use only the chunk size
+            num_samples_in_chunk = curr_chunk_size
+
+        if use_fps_control:
+            # When fps control is provided, sample random fps.
+            min_fps = max(min_fps_thres, math.ceil(video_fps * float(num_target_frames) / float(num_samples_in_chunk)))
+            max_fps = min(max_fps_thres, video_fps)
+
+            # Randomly sample a target fps in the range of (min_fps, max_fps)
+            if max_fps > min_fps:
+                fps_selections = list(range(min_fps, max_fps + 1))
+
+                # Sample reweighting favors the smaller fps more
+                if sampling_reweighting:
+                    dist = [1 / (float(pp) ** sampling_reweighting_factor) for pp in fps_selections]
+                    target_fps = np.random.choice(fps_selections, 1, p=[pp / sum(dist) for pp in dist])
+                else:
+                    target_fps = np.random.choice(fps_selections, 1)
+            else:
+                target_fps = max_fps
+
+        else:
+            # If not, use native fps
+            target_fps = video_fps
+
+        # stride used for subsampling video
+        stride = int(video_fps / target_fps)
+
+        # This is the actual target fps we obtain after subsampling
+        target_fps = video_fps / stride
+
+        # Select the frame start index and frame end index
+        chunk_frame_start = chunk_index * curr_chunk_size
+        if num_samples_in_chunk <= num_target_frames * stride:
+            raise ValueError(
+                f"Decoded video not long enough, num_samples_in_chunk={num_samples_in_chunk}, num_target_frames={num_target_frames}, stride={stride}, video_fps={video_fps}, target_fps={target_fps}, min_fps_thres={min_fps_thres}, max_fps_thres={max_fps_thres}, use_fps_control={use_fps_control}"
+            )
+        # Start index is randomly selected in the chunk
+        frame_start = chunk_frame_start + int(
+            np.random.choice(num_samples_in_chunk - int(num_target_frames * stride), 1)
+        )
+        frame_end = frame_start + num_target_frames * stride
+
+        # Subsample the frames
+        if "depth" in key:
+            frame_start = video_decoder.frame_start
+            frame_end = video_decoder.frame_end
+            stride = video_decoder.stride
+            chunk_index = video_decoder.chunk_index
+        else:
+            video_decoder.frame_start = frame_start
+            video_decoder.frame_end = frame_end
+            video_decoder.stride = stride
+            video_decoder.chunk_index = chunk_index
+        video_frames = video_reader.get_batch(np.arange(frame_start, frame_end, stride).tolist()).asnumpy()
+
+        # Return the frames and metadata
+        if num_target_frames is not None and video_frames.shape[0] < num_target_frames:
+            raise ValueError("Decoded video not long enough, skipping")
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+        video_reader.seek(0)  # set video reader point back to 0 to clean up cache
+        del video_reader  # delete the reader to avoid memory leak
+
+        ret_dict = {
+            "video": video_frames,
+            "fps": float(target_fps),
+            "num_frames": video_frames.shape[1],
+            "chunk_index": chunk_index,
+            "frame_start": frame_start,
+            "frame_end": frame_end,
+            "stride": stride,
+            "orig_num_frames": num_orig_frames,
+        }
+        if save_raw:
+            ret_dict["video_raw_bytes"] = data
+        return ret_dict
+
+    return video_decoder
+
+
+@video_decoder_register("video_decoder_for_kd_dataset")
+def video_decoder_for_kd_dataset(
+    sequence_length: int = 34,
+    num_threads: int = 4,
+    save_raw: bool = False,
+    **kwargs,
+):
+    """
+    Video decoder for Knowledge Distillation dataset.
+    This function reads in the raw video frames, without any fps control.
+
+    Parameters:
+    - sequence_length (int) : Number of frames returned by the function
+    - num_thread (int): Number of threads for decord.
+    - save_raw (bool): If True, will also return entire raw video in data_dict key "video_raw_bytes", alongside with the video frames. Only enable this for visualization and debug.
+    """
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ):
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        video_buffer = io.BytesIO(data)
+        video_reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+        num_target_frames = sequence_length if sequence_length > 0 else len(video_reader)
+        num_orig_frames = len(video_reader)
+        assert num_target_frames == num_orig_frames, (
+            "Number of target frames must be equal to the number of original frames"
+        )
+
+        # Now obtain min and max fps that we can use within this chunk
+        video_fps = int(np.round(video_reader.get_avg_fps()))
+        assert video_fps == 24, "Generated video FPS should be 24"
+
+        # Sample which chunk to use
+        chunk_index = 0
+        frame_start = 0
+        stride = 1
+        frame_end = frame_start + num_target_frames * stride
+        video_frames = video_reader.get_batch(np.arange(frame_start, frame_end, stride).tolist()).asnumpy()
+
+        # Return the frames and metadata
+        if num_target_frames is not None and video_frames.shape[0] < num_target_frames:
+            raise ValueError("Decoded video not long enough, skipping")
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+        video_reader.seek(0)  # set video reader point back to 0 to clean up cache
+        del video_reader  # delete the reader to avoid memory leak
+
+        ret_dict = {
+            "video": video_frames,
+            "fps": float(video_fps),
+            "num_frames": video_frames.shape[1],
+            "chunk_index": chunk_index,
+            "frame_start": frame_start,
+            "frame_end": frame_end,
+            "stride": stride,
+            "orig_num_frames": num_orig_frames,
+        }
+        if save_raw:
+            ret_dict["video_raw_bytes"] = data
+        return ret_dict
+
+    return video_decoder
+
+
+@video_decoder_register("video_decoder_basic")
+def video_decoder_basic(
+    sequence_length: int = 25,
+    use_fps_control: bool = False,
+    min_fps_thres: int = 4,
+    max_fps_thres: int = 30,
+    num_threads=4,
+    **kwargs,
+) -> Callable[[str, bytes], dict[str, torch.Tensor | int]]:
+    """Basic video decoder for a specified sequence length.
+
+    If loaded video has fewer frames than requested, temporally pads with the last frame.
+    Optionally, allows subsampling video with a variable FPS in [`min_fps_thres` .. `max_fps_thres`].
+
+    Args:
+        sequence_length (int) : The number of frames to sample from the loaded video.
+        use_fps_control (bool) : Controls whether to temporally subsample.
+        min_fps_thres (int): Minimum FPS threshold to sample from.
+        max_fps_thres (int): Maximum FPS threshold to sample from.
+        num_thread (int): Number of threads for the decord.
+
+    Returns:
+        Returns a callable that returns a dictionary of:
+            - The sampled video(torch.Tensor, torch.uint8), layout (C, T, H, W).
+            - The FPS (int) of the sample.
+    """
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ) -> dict[str, torch.Tensor | int]:
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        video_buffer = io.BytesIO(data)
+        video_reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+
+        # video and request metadata.
+        num_target_frames = sequence_length if sequence_length > 0 else len(video_reader)
+        num_orig_frames = len(video_reader)
+        assert num_orig_frames > 0, "Video has no frames."
+        video_fps = max(1, int(video_reader.get_avg_fps() + 0.5))
+
+        if use_fps_control:
+            # When fps control is provided, sample random fps.
+            min_fps = max(min_fps_thres, math.ceil(video_fps * float(num_target_frames) / float(num_orig_frames)))
+            max_fps = min(max_fps_thres, video_fps)
+
+            # If frame range is valid, sample random fps in the range of (min_fps, max_fps)
+            if max_fps > min_fps:
+                fps_selections = list(range(min_fps, max_fps + 1))
+                target_fps = np.random.choice(fps_selections, 1)
+            else:
+                target_fps = max_fps
+        else:
+            target_fps = video_fps
+
+        # This is the actual target fps we obtain after subsampling.
+        stride = int(video_fps / target_fps)
+        target_fps = video_fps / stride
+        num_target_stride_frames = int(num_target_frames * stride)
+
+        # Start index is randomly selected in the
+        valid_length = max(num_orig_frames - num_target_stride_frames, 1)
+        frame_start = np.random.choice(valid_length, 1)
+        frame_end = min(frame_start + num_target_stride_frames, num_orig_frames)
+        frame_indices = np.arange(frame_start, frame_end, stride).tolist()
+
+        # Grab the frames.
+        video_frames = video_reader.get_batch(frame_indices).asnumpy()
+
+        # If sampled frames are less than requested, pad with the last frame via replication
+        if video_frames.shape[0] < num_target_frames:
+            pad_size = num_target_frames - video_frames.shape[0]
+            video_frames = np.pad(video_frames, ((0, pad_size), (0, 0), (0, 0), (0, 0)), mode="edge")
+
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+        video_reader.seek(0)  # set video reader point back to 0 to clean up cache
+        del video_reader  # delete the reader to avoid memory leak
+        return {
+            "video": video_frames,
+            "fps": float(target_fps),
+        }
+
+    return video_decoder
+
+
+@video_decoder_register("video_decoder_still_padding")
+def video_decoder_still_padding(
+    sequence_length: int = 25,
+    use_fps_control: bool = False,
+    min_fps_thres: int = 4,
+    max_fps_thres: int = 30,
+    num_threads=4,
+    sampling_reweighting: bool = False,
+    sampling_reweighting_factor: int = 1,
+    limit_fps_range: bool = False,
+    **kwargs,
+) -> Callable[[str, bytes], dict[str, torch.Tensor | int]]:
+    """Video decoder for a specified sequence length.
+
+    If loaded video has fewer frames than requested, temporally pads with the last frame.
+    Optionally, allows subsampling video with a variable FPS in [`min_fps_thres` .. `max_fps_thres`].
+
+    Args:
+        sequence_length (int) : The number of frames to sample from the loaded video.
+        use_fps_control (bool) : Controls whether to temporally subsample.
+        min_fps_thres (int): Minimum FPS threshold to sample from.
+        max_fps_thres (int): Maximum FPS threshold to sample from.
+        num_thread (int): Number of threads for the decord.
+
+    Returns:
+        Returns a callable that returns a dictionary of:
+            - The sampled video(torch.Tensor, torch.uint8), layout (C, T, H, W).
+            - number of video frames
+            - frame_start
+            - frame_end
+    """
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ) -> dict[str, torch.Tensor | int]:
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        video_buffer = io.BytesIO(data)
+        video_reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+
+        # video and request metadata.
+        num_target_frames = sequence_length if sequence_length > 0 else len(video_reader)
+        num_orig_frames = len(video_reader)
+        assert num_orig_frames > 0, "Video has no frames."
+
+        if num_target_frames > num_orig_frames:
+            log.warning(
+                f"Specified sequence_length {num_target_frames} exceeds num frames in video {num_orig_frames}. Padding last frame"
+            )
+            # Grab the frames.
+            video_frames = video_reader.get_batch(range(num_orig_frames)).asnumpy()
+
+            # Pad with the last frame via replication
+            pad_size = num_target_frames - video_frames.shape[0]
+            video_frames = np.pad(video_frames, ((0, pad_size), (0, 0), (0, 0), (0, 0)), mode="edge")
+
+            video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+            video_reader.seek(0)  # set video reader point back to 0 to clean up cache
+            del video_reader  # delete the reader to avoid memory leak
+            return {
+                "video": video_frames,
+                "frame_start": 0,
+                "frame_end": num_orig_frames,
+                "num_frames": video_frames.shape[1],
+            }
+
+        video_fps = max(1, int(video_reader.get_avg_fps() + 0.5))
+
+        if video_fps < 1:
+            raise ValueError("Video fps lower than 1, skipping")
+        if limit_fps_range:
+            if video_fps < min_fps_thres:
+                raise ValueError(f"Video fps {video_fps} lower than {min_fps_thres}, skipping")
+            if video_fps > max_fps_thres:
+                raise ValueError(f"Video fps {video_fps} larger than {max_fps_thres}, skipping")
+
+        if use_fps_control:
+            # When fps control is provided, sample random fps.
+            min_fps = max(min_fps_thres, math.ceil(video_fps * float(num_target_frames) / float(num_orig_frames)))
+            max_fps = min(max_fps_thres, video_fps)
+
+            # If frame range is valid, sample random fps in the range of (min_fps, max_fps)
+            if max_fps > min_fps:
+                fps_selections = list(range(min_fps, max_fps + 1))
+
+                # Sample reweighting favors the smaller fps more
+                if sampling_reweighting:
+                    dist = [1 / (float(pp) ** sampling_reweighting_factor) for pp in fps_selections]
+                    target_fps = np.random.choice(fps_selections, 1, p=[pp / sum(dist) for pp in dist])
+                else:
+                    target_fps = np.random.choice(fps_selections, 1)
+            else:
+                target_fps = max_fps
+        else:
+            target_fps = video_fps
+
+        # This is the actual target fps we obtain after subsampling.
+        stride = int(video_fps / target_fps)
+        target_fps = video_fps / stride
+        num_target_stride_frames = int(num_target_frames * stride)
+
+        # Start index is randomly selected in the
+        valid_length = max(num_orig_frames - num_target_stride_frames, 1)
+        frame_start = np.random.choice(valid_length, 1)
+        frame_end = min(frame_start + num_target_stride_frames, num_orig_frames)
+        frame_indices = np.arange(frame_start, frame_end, stride).tolist()
+
+        # Grab the frames.
+        video_frames = video_reader.get_batch(frame_indices).asnumpy()
+
+        # If sampled frames are less than requested, pad with the last frame via replication
+        if video_frames.shape[0] < num_target_frames:
+            pad_size = num_target_frames - video_frames.shape[0]
+            video_frames = np.pad(video_frames, ((0, pad_size), (0, 0), (0, 0), (0, 0)), mode="edge")
+
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+        video_reader.seek(0)  # set video reader point back to 0 to clean up cache
+        del video_reader  # delete the reader to avoid memory leak
+        return {
+            "video": video_frames,
+            "frame_start": frame_start,
+            "frame_end": frame_end,
+            "num_frames": video_frames.shape[1],
+        }
+
+    return video_decoder
+
+
+def video_decoder_w_lower_fps_get_indices(
+    num_orig_frames: int,
+    video_fps: int,
+    min_fps_thres: int,
+    max_fps_thres: int,
+    sequence_length: int,
+) -> Tuple[List[int], float]:
+    """Generates frame indices for video sampling with FPS control.
+
+    This function determines valid stride lengths for sampling frames from a video,
+    preferring lower FPS (larger strides) when multiple options are available.
+    It returns both the selected frame indices and the resulting FPS.
+
+    Args:
+        num_orig_frames: Total number of frames in the original video.
+        video_fps: Original video frames per second.
+        min_fps_thres: Minimum allowed frames per second.
+        max_fps_thres: Maximum allowed frames per second.
+        sequence_length: Number of frames to sample.
+
+    Returns:
+        A tuple containing:
+            - list[int]: Frame indices to sample from the original video.
+            - float: The resulting frames per second after sampling.
+
+    Raises:
+        ValueError: If no valid stride options are available given the constraints.
+        ValueError: If input parameters are invalid (e.g., negative values).
+    """
+    # Validate input parameters
+    if num_orig_frames <= 0:
+        raise ValueError("num_orig_frames must be positive")
+    if video_fps <= 0:
+        raise ValueError("video_fps must be positive")
+    if min_fps_thres <= 0:
+        raise ValueError("min_fps_thres must be positive")
+    if max_fps_thres < min_fps_thres:
+        raise ValueError("max_fps_thres must be greater than or equal to min_fps_thres")
+    if sequence_length <= 1:
+        raise ValueError("sequence_length must be greater than 1")
+    if sequence_length > num_orig_frames:
+        raise ValueError("sequence_length cannot be greater than num_orig_frames")
+
+    # Calculate stride range
+    min_stride = 1
+    max_stride = (num_orig_frames - 1) // (sequence_length - 1)
+
+    valid_strides = []
+    for stride in range(min_stride, max_stride + 1):
+        # Check if we can get sequence_length frames with this stride
+        if (num_orig_frames - stride * (sequence_length - 1)) > 0:
+            new_fps = video_fps / stride
+            if min_fps_thres <= new_fps <= max_fps_thres:
+                valid_strides.append(stride)
+
+    if not valid_strides:
+        raise ValueError(
+            f"No valid stride options available for the given constraints. "
+            f"stride range = [{min_stride}, {max_stride}]; "
+            f"original FPS = {video_fps}; "
+            f"sequence_length = {sequence_length}; "
+            f"min_fps_thres = {min_fps_thres}; "
+            f"max_fps_thres = {max_fps_thres}; "
+            f"original num_frames = {num_orig_frames}"
+        )
+
+    # Select stride with weighted probability
+    if len(valid_strides) >= 2:
+        stride_choices = valid_strides[-2:]  # Taking last two as they're the largest
+        weights = [0.01, 0.99]  # [smaller_stride, larger_stride]
+        selected_stride = np.random.choice(stride_choices, p=weights)
+    else:
+        selected_stride = valid_strides[0]
+
+    # Calculate the maximum valid start index and random start frame
+    max_start_idx = num_orig_frames - (sequence_length - 1) * selected_stride
+    frame_start = np.random.randint(0, max_start_idx)
+
+    # Generate frame indices
+    frame_indices = [frame_start + i * selected_stride for i in range(sequence_length)]
+    return frame_indices, video_fps / selected_stride
+
+
+@video_decoder_register("video_decoder_w_lower_fps")
+def video_decoder_w_lower_fps(
+    chunk_size: int = 0,
+    sequence_length: int = 34,
+    min_fps_thres: int = 4,
+    max_fps_thres: int = 30,
+    num_threads: int = 4,
+    return_frame_indices: bool = False,
+    **kwargs,
+) -> dict:
+    """
+    Simplified video decoder with FPS control and frame sampling.
+
+    Args:
+        key: Video file name/key
+        data: Video binary data
+        min_fps_thres: Minimum FPS threshold
+        max_fps_thres: Maximum FPS threshold
+        sequence_length: Number of frames to return
+        num_threads: Number of threads for decord
+        limit_fps_range: Whether to enforce FPS limits
+        return_frame_indices: Whether to return frame indices
+
+    Returns:
+        dict with video frames tensor and target FPS
+    """
+    del kwargs  # Unused
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ) -> dict[str, torch.Tensor | int]:
+        # Check video extension
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        # Read video
+        video_buffer = io.BytesIO(data)
+        video_reader = decord.VideoReader(video_buffer, num_threads=num_threads)
+        num_target_frames = sequence_length if sequence_length > 0 else len(video_reader)
+
+        # Get video metadata
+        num_orig_frames = len(video_reader)
+        video_fps = int(np.round(video_reader.get_avg_fps()))
+
+        # Basic validations
+        # Obtain the number of chunks
+        if chunk_size == 0:
+            curr_chunk_size = num_orig_frames
+        else:
+            curr_chunk_size = chunk_size
+        num_chunks = max(num_orig_frames // curr_chunk_size, 1)
+
+        # Checks to ensure that number of target frames we need is present in the video / chunk.
+        if num_target_frames > curr_chunk_size:
+            raise ValueError("Specified sequence_length exceeds curr_chunk_size.")
+
+        if num_target_frames > num_orig_frames:
+            raise ValueError(
+                f"Specified sequence_length {num_target_frames} exceeds num frames in video {num_orig_frames}."
+            )
+
+        if video_fps < 1:
+            raise ValueError("Video fps lower than 1, skipping")
+        if video_fps < min_fps_thres:
+            raise ValueError(f"Video fps {video_fps} lower than {min_fps_thres}, skipping")
+
+        # Check if the last chunk has separate window
+        # This happens only if remainder frames >= curr_chunk_size / 2 [data annotation was done this way]
+        # Else this is used as a part of previous window.
+        num_frames_in_last_chunk = num_orig_frames - num_chunks * curr_chunk_size
+        if num_frames_in_last_chunk >= int(0.5 * curr_chunk_size):
+            if num_frames_in_last_chunk > num_target_frames:
+                num_chunks += 1
+
+        # Sample which chunk to use
+        chunk_index = randint(0, num_chunks - 1)
+
+        if chunk_index == num_chunks - 1:
+            # For the last chunk, use all of the remaining frames
+            num_samples_cur_chunk = num_orig_frames - chunk_index * curr_chunk_size
+        else:
+            # Else use only the chunk size
+            num_samples_cur_chunk = curr_chunk_size
+        idx_first_in_cur_chunk = chunk_index * curr_chunk_size
+
+        frame_indices, adjusted_fps = video_decoder_w_lower_fps_get_indices(
+            num_orig_frames=num_samples_cur_chunk,
+            video_fps=video_fps,
+            min_fps_thres=min_fps_thres,
+            max_fps_thres=max_fps_thres,
+            sequence_length=num_target_frames,
+        )
+        frame_indices = [idx_first_in_cur_chunk + idx for idx in frame_indices]
+
+        # Sample frames
+        video_frames = video_reader.get_batch(frame_indices).asnumpy()
+        video_frames = torch.from_numpy(video_frames).permute(3, 0, 1, 2)  # (T, H, W, C) -> (C, T, H, W)
+
+        # Clean up
+        video_reader.seek(0)
+        del video_reader
+
+        output = {
+            "video": video_frames,
+            "fps": float(adjusted_fps),
+            "orig_fps": video_fps,
+            "frame_start": frame_indices[0],
+            "frame_end": frame_indices[-1],
+            "num_frames": video_frames.shape[1],
+            "orig_num_frames": num_orig_frames,
+            "chunk_index": chunk_index,
+        }
+        if return_frame_indices:
+            output["frame_indices"] = frame_indices
+        return output
+
+    return video_decoder
+
+
+@video_decoder_register("video_naive_bytes")
+def video_naive_bytes(*args, **kwargs):
+    """
+    do nothing, just return the video bytes
+    """
+    del args, kwargs
+
+    def video_decoder(
+        key: str,
+        data: bytes,
+    ):
+        extension = re.sub(r".*[.]", "", key)
+        if extension.lower() not in _VIDEO_EXTENSIONS:
+            return None
+
+        return data
+
+    return video_decoder
+
+
+def construct_video_decoder(
+    video_decoder_name: str = "video_decoder_w_controlled_fps",
+    sequence_length: int = 34,
+    chunk_size: int = 0,
+    use_fps_control: bool = False,
+    min_fps_thres: int = 4,
+    max_fps_thres: int = 24,
+    sampling_reweighting: bool = False,
+    sampling_reweighting_factor: int = 1,
+    num_threads=4,
+    limit_fps_range: bool = False,
+    # if true, video decoder will additionally save the raw video (alongside with processed frames) to the data_dict
+    # set to true for inference/debugging
+    save_raw: bool = False,
+):
+    return VIDEO_DECODER_OPTIONS[video_decoder_name](
+        sequence_length=sequence_length,
+        chunk_size=chunk_size,
+        use_fps_control=use_fps_control,
+        min_fps_thres=min_fps_thres,
+        max_fps_thres=max_fps_thres,
+        sampling_reweighting=sampling_reweighting,
+        sampling_reweighting_factor=sampling_reweighting_factor,
+        num_threads=num_threads,
+        limit_fps_range=limit_fps_range,
+        save_raw=save_raw,
+    )
+
+
+def construct_video_decoder_metadata(
+    num_threads=4,
+):
+    return VIDEO_DECODER_OPTIONS["video_decoder_metadata"](num_threads=num_threads)

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/augmentor.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Iterable
+from typing import Any, Generator, Optional
+
+
+class Augmentor:
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        r"""Base augmentor class
+
+        Args:
+            input_keys (list): List of input keys
+            output_keys (list): List of output keys
+            args (dict): Arguments associated with the augmentation
+        """
+        self.input_keys = input_keys
+        self.output_keys = output_keys
+        self.args = args
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        raise ValueError("Augmentor not implemented")
+
+
+class IterableAugmentor:
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        r"""Base augmentor class
+
+        Args:
+            input_keys (list): List of input keys
+            output_keys (list): List of output keys
+            args (dict): Arguments associated with the augmentation
+        """
+        self.input_keys = input_keys
+        self.output_keys = output_keys
+        self.args = args
+        self.is_generator = True
+
+    def __call__(self, data: Iterable) -> Generator:
+        r"""Example usage:
+
+        for data_dict in data:
+            # Do something to data_dict
+            data_dict["input"] = data_dict["raw_sequence"][:, :-1]
+            data_dict["target"] = data_dict["raw_sequence"][:, 1:]
+            # Skip sample if needed
+            if data_dict["input"].shape[1] < 64:
+                continue
+            # Construct a generator
+            yield data_dict
+        """
+        raise ValueError("Augmentor not implemented")

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/geometry/camera.py

@@ -0,0 +1,184 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Camera parameter augmentors for webdataset."""
+
+from typing import Optional
+
+import torch
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.modules.camera import Camera
+
+
+class CameraParamDecoder(Augmentor):
+    """Decodes camera parameters from text files.
+
+    The text file format is: fx fy cx cy qx qy qz qw tx ty tz
+    where:
+        - fx, fy: focal lengths
+        - cx, cy: principal points
+        - qx, qy, qz, qw: quaternion rotation (world to camera)
+        - tx, ty, tz: translation vector (world to camera)
+    """
+
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        """Initialize the camera parameter decoder.
+
+        Args:
+            input_keys: List of input keys (typically ['camera'])
+            output_keys: List of output keys (typically ['intrinsics', 'world_to_cam'])
+            args: Additional arguments (not used)
+        """
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Decode camera parameters from text data.
+
+        Args:
+            data_dict: Input data dictionary containing camera text data
+
+        Returns:
+            data_dict: Output data dictionary with decoded camera parameters
+        """
+        # Get the camera text data
+        camera_text = data_dict[self.input_keys[0]]
+
+        # Convert text to string if it's bytes
+        if isinstance(camera_text, bytes):
+            camera_text = camera_text.decode("utf-8")
+
+        # Parse the camera parameters
+        parts = list(map(float, camera_text.strip().split()))
+        if len(parts) != 11:
+            raise ValueError(f"Invalid camera parameter format. Expected 11 values, got {len(parts)}")
+
+        # Extract parameters
+        fx, fy, cx, cy = parts[0:4]  # focal lengths and principal points
+        quat = parts[4:8]  # qx, qy, qz, qw
+        trans = parts[8:11]  # tx, ty, tz
+
+        # Convert intrinsics to 3x3 matrix via helper
+        intrinsics = Camera.intrinsic_params_to_matrices(torch.tensor([fx, fy, cx, cy], dtype=torch.float32))
+
+        # Convert quaternion + translation to 4x4 World->Cam matrix via helper
+        qxyzw_t = torch.tensor([*quat, *trans], dtype=torch.float32)
+        w2c_3x4 = Camera.extrinsic_params_to_matrices(qxyzw_t)
+        world_to_cam = torch.eye(4, dtype=torch.float32)
+        world_to_cam[:3, :] = w2c_3x4
+
+        # Convert to torch tensors
+        intrinsics = intrinsics.float()
+        world_to_cam = world_to_cam.float()
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = intrinsics
+        data_dict[self.output_keys[1]] = world_to_cam
+
+        # Remove the original camera text data
+        data_dict.pop(self.input_keys[0])
+
+        return data_dict
+
+
+class CameraParamListDecoder(Augmentor):
+    """Decodes a list of camera parameters from text files.
+
+    The text file format is multiple lines, where each line contains:
+    fx fy cx cy qx qy qz qw tx ty tz
+    where:
+        - fx, fy: focal lengths
+        - cx, cy: principal points
+        - qx, qy, qz, qw: quaternion rotation (world to camera)
+        - tx, ty, tz: translation vector (world to camera)
+
+    Each line corresponds to one frame's camera parameters.
+    """
+
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        """Initialize the camera parameter list decoder.
+
+        Args:
+            input_keys: List of input keys (typically ['camera'])
+            output_keys: List of output keys (typically ['intrinsics', 'world_to_cam'])
+            args: Additional arguments (not used)
+        """
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Decode a list of camera parameters from text data.
+
+        Args:
+            data_dict: Input data dictionary containing camera text data
+
+        Returns:
+            data_dict: Output data dictionary with decoded camera parameters as lists
+        """
+        # Get the camera text data
+        camera_text = data_dict[self.input_keys[0]]
+
+        # Convert text to string if it's bytes
+        if isinstance(camera_text, bytes):
+            camera_text = camera_text.decode("utf-8")
+
+        # Split into lines and parse each line
+        lines = camera_text.strip().split("\n")
+        num_frames = len(lines)
+
+        if num_frames == 0:
+            raise ValueError("Empty camera parameter file")
+
+        # Initialize lists to store camera parameters
+        intrinsics_list = []
+        world_to_cam_list = []
+
+        # Parse each line
+        for i, line in enumerate(lines):
+            line = line.strip()
+            if not line:  # Skip empty lines
+                continue
+
+            parts = list(map(float, line.split()))
+            if len(parts) != 11:
+                raise ValueError(
+                    f"Invalid camera parameter format at line {i + 1}. Expected 11 values, got {len(parts)}"
+                )
+
+            # Extract parameters
+            fx, fy, cx, cy = parts[0:4]  # focal lengths and principal points
+            quat = parts[4:8]  # qx, qy, qz, qw
+            trans = parts[8:11]  # tx, ty, tz
+
+            # Convert intrinsics and extrinsics via helpers
+            intrinsics = Camera.intrinsic_params_to_matrices(torch.tensor([fx, fy, cx, cy], dtype=torch.float32))
+            qxyzw_t = torch.tensor([*quat, *trans], dtype=torch.float32)
+            w2c_3x4 = Camera.extrinsic_params_to_matrices(qxyzw_t)
+            world_to_cam = torch.eye(4, dtype=torch.float32)
+            world_to_cam[:3, :] = w2c_3x4
+
+            intrinsics_list.append(intrinsics)
+            world_to_cam_list.append(world_to_cam)
+
+        # Convert lists to torch tensors with batch dimension
+        intrinsics_tensor = torch.stack(intrinsics_list).float()  # T x 3 x 3
+        world_to_cam_tensor = torch.stack(world_to_cam_list).float()  # T x 4 x 4
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = intrinsics_tensor
+        data_dict[self.output_keys[1]] = world_to_cam_tensor
+
+        # Remove the original camera text data
+        data_dict.pop(self.input_keys[0])
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/geometry/depth.py

@@ -0,0 +1,184 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Depth augmentors for webdataset."""
+
+from typing import Optional
+
+import torch
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+
+
+class DepthMask(Augmentor):
+    """Generates a binary mask for valid depth values.
+
+    This augmentor takes a depth image and generates a binary mask indicating
+    which pixels have valid depth values. A pixel is considered valid if:
+    1. Its depth value is greater than min_depth
+    2. Its depth value is less than max_depth
+    3. Its depth value is not NaN or infinite
+    4. Its depth value is not larger than median_multiplier times the median depth
+
+    Args:
+        min_depth (float): Minimum valid depth value
+        max_depth (float): Maximum valid depth value
+        median_multiplier (float): Maximum allowed depth as a multiple of median depth
+    """
+
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        """Initialize the depth mask generator.
+
+        Args:
+            input_keys: List of input keys (typically ['depth'])
+            output_keys: List of output keys (typically ['depth_mask'])
+            args: Additional arguments including:
+                - min_depth (float): Minimum valid depth value
+                - max_depth (float): Maximum valid depth value
+                - median_multiplier (float): Maximum allowed depth as a multiple of median depth
+        """
+        super().__init__(input_keys, output_keys, args)
+        self.min_depth = args.get("min_depth", 0.1) if args else 0.1
+        self.max_depth = args.get("max_depth", 100.0) if args else 100.0
+        self.median_multiplier = args.get("median_multiplier", 10) if args else 10
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Generate depth mask.
+
+        Args:
+            data_dict: Input data dictionary containing depth image
+
+        Returns:
+            data_dict: Output data dictionary with depth mask
+        """
+        # Get depth image
+        depth = data_dict[self.input_keys[0]]  # H x W
+
+        # Create mask for valid depth values
+        mask = torch.ones_like(depth, dtype=torch.bool)
+
+        # Check for minimum depth
+        mask = mask & (depth > self.min_depth)
+
+        # Check for maximum depth
+        mask = mask & (depth < self.max_depth)
+
+        # Check for NaN and infinite values
+        mask = mask & torch.isfinite(depth) & (~torch.isnan(depth))
+
+        # Compute median depth from currently valid depths
+        if mask.any():
+            valid_depths = depth[mask]
+            median_depth = torch.median(valid_depths)
+
+            # Filter out depths larger than median_multiplier times the median
+            max_allowed_depth = self.median_multiplier * median_depth
+            mask = mask & (depth <= max_allowed_depth)
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = mask
+        data_dict[self.input_keys[0]][~mask] = self.max_depth
+        return data_dict
+
+
+class ConsecutiveFrameSampler(Augmentor):
+    """Randomly samples N consecutive frames from a video sequence.
+
+    This augmentor takes a video sequence and randomly samples N consecutive frames
+    starting from a random position within the valid range.
+
+    Args:
+        num_frames (int): Number of consecutive frames to sample
+    """
+
+    def __init__(
+        self,
+        input_keys: list,
+        output_keys: Optional[list] = None,
+        random_sample: bool = True,
+        args: Optional[dict] = None,
+    ) -> None:
+        """Initialize the consecutive frame sampler.
+
+        Args:
+            input_keys: List of input keys (typically ['depth', 'points', etc.])
+            output_keys: List of output keys (same as input_keys)
+            args: Additional arguments including:
+                - num_frames (int): Number of consecutive frames to sample
+        """
+        super().__init__(input_keys, output_keys, args)
+        self.num_frames = args.get("num_frames", 25) if args else 25
+        self.random_sample = random_sample
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Sample consecutive frames from video sequences.
+
+        Args:
+            data_dict: Input data dictionary containing video sequences
+
+        Returns:
+            data_dict: Output data dictionary with sampled frames
+        """
+
+        # Get the first input key to determine the temporal dimension
+        first_key = self.input_keys[0]
+        video_tensor = data_dict[first_key]
+
+        if video_tensor.dim() == 4:  # CxTxHxW
+            total_frames = video_tensor.shape[1]
+        elif video_tensor.dim() == 3:  # TxHxW
+            total_frames = video_tensor.shape[0]
+        else:
+            raise ValueError(f"Expected 3D (TxHxW) or 4D (CxTxHxW) tensor, got {video_tensor.dim()}D")
+
+        # Calculate valid start indices
+        max_start_idx = max(0, total_frames - self.num_frames)
+        if self.num_frames > total_frames:
+            return None
+
+        if max_start_idx == 0:
+            # If video is shorter than requested frames, use all available frames
+            start_idx = 0
+            actual_num_frames = total_frames
+        else:
+            if self.random_sample:
+                # Randomly sample start index
+                start_idx = torch.randint(0, max_start_idx + 1, size=(1,)).item()
+            else:
+                start_idx = 0
+            actual_num_frames = self.num_frames
+
+        # Sample frames for all input keys
+        for input_key, output_key in zip(self.input_keys, self.output_keys):
+            tensor = data_dict[input_key]
+
+            if tensor.dim() == 4:  # CxTxHxW
+                sampled_tensor = tensor[:, start_idx : start_idx + actual_num_frames, :, :]
+                assert sampled_tensor.shape[1] == actual_num_frames, (
+                    f"Sampled tensor {input_key} has {sampled_tensor.shape[1]} frames, expected {actual_num_frames}"
+                )
+            elif tensor.dim() == 3:  # TxHxW
+                sampled_tensor = tensor[start_idx : start_idx + actual_num_frames, :, :]
+                assert sampled_tensor.shape[0] == actual_num_frames, (
+                    f"Sampled tensor {input_key} has {sampled_tensor.shape[0]} frames, expected {actual_num_frames}"
+                )
+            else:
+                raise ValueError(f"Expected 3D (TxHxW) or 4D (CxTxHxW) tensor for {input_key}, got {tensor.dim()}D")
+
+            data_dict[output_key] = sampled_tensor
+        data_dict["frame_start"] = start_idx
+        data_dict["frame_end"] = start_idx + actual_num_frames
+
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/geometry/pointcloud.py

@@ -0,0 +1,390 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Point cloud augmentors for webdataset."""
+
+from typing import Optional
+
+import torch
+from einops import rearrange
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.modules.camera import Camera
+
+
+class DepthToPointcloud(Augmentor):
+    """Converts depth images to point clouds using camera intrinsics.
+
+    This augmentor takes a depth image and camera intrinsics to generate a point cloud.
+    The depth image should be in meters and the intrinsics should be a 3x3 matrix.
+
+    Args:
+        to_world_coords (bool): If True, uses the first frame as the coordinate frame for video sequences
+    """
+
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        """Initialize the depth to point cloud converter.
+
+        Args:
+            input_keys: List of input keys (typically ['depth', 'intrinsics', 'world_to_cam'])
+            output_keys: List of output keys (typically ['points'])
+            args: Additional arguments including:
+                - to_world_coords (bool): Whether to use first frame as coordinate frame
+        """
+        assert "depth" in input_keys, "Depth image is required for point cloud conversion"
+        assert "intrinsics" in input_keys, "Intrinsics are required for point cloud conversion"
+        assert "world_to_cam" in input_keys or not self.to_world_coords, (
+            "World to camera matrix is required for point cloud conversion"
+        )
+        super().__init__(input_keys, output_keys, args)
+        self.to_world_coords = args.get("to_world_coords", False) if args else False
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Convert depth image to point cloud.
+
+        Args:
+            data_dict: Input data dictionary containing depth image and camera intrinsics
+
+        Returns:
+            data_dict: Output data dictionary with point cloud
+        """
+        # Get depth image and intrinsics
+        depth = data_dict[self.input_keys[0]]  # T x H x W or H x W
+        intrinsics = data_dict[self.input_keys[1]]  # T x 3 x 3 or 3 x 3
+
+        # Check if we're dealing with video sequences (temporal dimension)
+        if depth.dim() == 3 and intrinsics.dim() == 3:
+            # Video sequence: T x H x W and T x 3 x 3
+            T, H, W = depth.shape
+
+            # Create pixel coordinates (same for all frames)
+            y, x = torch.meshgrid(
+                torch.arange(H, device=depth.device), torch.arange(W, device=depth.device), indexing="ij"
+            )
+            pixels = torch.stack([x, y, torch.ones_like(x)], dim=-1).float()  # H x W x 3
+            pixels_hw3 = pixels.reshape(-1, 3)  # (H*W) x 3
+
+            # Back-project to camera space using Camera.image2camera
+            pixels_batched = pixels_hw3.unsqueeze(0).expand(T, -1, -1)  # T x (H*W) x 3
+            points_cam = Camera.image2camera(pixels_batched, intrinsics)  # T x (H*W) x 3
+            depth_flat = depth.reshape(T, -1)
+            points_cam = points_cam * depth_flat.unsqueeze(-1)
+
+            # Transform to first frame coordinate system if requested
+            if self.to_world_coords:
+                world_to_cam = data_dict[self.input_keys[2]]  # T x 4 x 4
+                w2c = world_to_cam[:, :3, :]  # T x 3 x 4
+                # relative pose from cam_t to cam_0: rel = w2c_0 ∘ c2w_t
+                w2c0 = w2c[0]
+                c2w = Camera.invert_pose(w2c)  # T x 3 x 4
+                w2c0_exp = w2c0.unsqueeze(0).expand_as(c2w)
+                rel = Camera.compose_poses([w2c0_exp, c2w])  # T x 3 x 4
+                points = Camera.world2camera(points_cam, rel)  # T x (H*W) x 3
+            else:
+                points = points_cam
+
+            # Reshape to T x 3 x H x W
+            points = rearrange(points, "t (h w) c -> c t h w", h=H, w=W, c=3)
+
+        else:
+            # Single frame: H x W and 3 x 3
+            H, W = depth.shape[-2:]
+
+            # Create pixel coordinates
+            y, x = torch.meshgrid(
+                torch.arange(H, device=depth.device), torch.arange(W, device=depth.device), indexing="ij"
+            )
+
+            # Create homogeneous coordinates and convert to float
+            pixels = torch.stack([x, y, torch.ones_like(x)], dim=-1).float()  # H x W x 3
+            pixels_hw3 = pixels.reshape(-1, 3)
+            depth_flat = depth.reshape(-1)  # (H*W)
+
+            # Back-project to camera space
+            points_cam = Camera.image2camera(pixels_hw3, intrinsics)  # (H*W) x 3
+            points_cam = points_cam * depth_flat.unsqueeze(-1)  # (H*W) x 3
+
+            # For single frame, just use camera coordinates or transform to world coords as before
+            if self.to_world_coords:
+                world_to_cam = data_dict[self.input_keys[2]]  # 4 x 4
+                w2c = world_to_cam[:3, :]
+                points = Camera.camera2world(points_cam, w2c)  # (H*W) x 3
+            else:
+                points = points_cam
+
+            # Reshape to 3 x H x W
+            points = rearrange(points, "(h w) c -> c h w", h=H, w=W, c=3)
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = points
+
+        return data_dict
+
+
+class PointcloudRescale(Augmentor):
+    """Rescales point clouds to have a mean distance of 1 from the origin.
+
+    This augmentor takes a point cloud and rescales it so that the mean distance
+    of all points from the origin is 1. It also adjusts the world-to-camera
+    transformation matrix accordingly.
+
+    Args:
+        input_keys: List of input keys (typically ['points', 'world_to_cam'])
+        output_keys: List of output keys (typically ['points', 'world_to_cam'])
+    """
+
+    def __init__(
+        self,
+        input_keys: list,
+        output_keys: Optional[list] = None,
+        mask_key: Optional[str] = None,
+        args: Optional[dict] = None,
+    ) -> None:
+        """Initialize the point cloud rescaler.
+
+        Args:
+            input_keys: List of input keys (typically ['points', 'world_to_cam'])
+            output_keys: List of output keys (typically ['points', 'world_to_cam'])
+            args: Additional arguments (not used in this augmentor)
+        """
+        assert "points" in input_keys, "Points are required for rescaling"
+        assert "world_to_cam" in input_keys, "World to camera matrix is required for rescaling"
+        super().__init__(input_keys, output_keys, args)
+        self.mask_key = mask_key
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Rescale point cloud and adjust world-to-camera transformation.
+
+        This augmentor computes the average Euclidean distance of all 3D points to the origin
+        and uses this scale to normalize both the camera translations and point cloud.
+
+        Args:
+            data_dict: Input data dictionary containing points and world_to_cam
+
+        Returns:
+            data_dict: Output data dictionary with rescaled points and adjusted world_to_cam
+        """
+        # Get points and world_to_cam
+        points = data_dict[self.input_keys[0]]  # 3 x T x H x W or 3 x H x W
+        world_to_cam = data_dict[self.input_keys[1]]  # T x 4 x 4 or 4 x 4
+
+        # Check if we're dealing with video sequences (temporal dimension)
+        if points.dim() == 4 and world_to_cam.dim() == 3:
+            # Video sequence: 3 x T x H x W and T x 4 x 4
+            T = world_to_cam.shape[0]
+
+            # Reshape points to T x N x 3 for easier computation
+            points_flat = points.permute(1, 0, 2, 3).reshape(T, 3, -1).transpose(1, 2)  # T x N x 3
+
+            # Compute average Euclidean distance to origin across all frames
+            if self.mask_key is not None:
+                # Get mask and reshape to match points
+                mask = data_dict[self.mask_key]  # T x H x W
+                mask_flat = mask.reshape(T, -1)  # T x N
+
+                # Only compute average over valid points across all frames
+                # Compute squared distances for all frames at once
+                squared_distances = torch.sum(points_flat**2, dim=2)  # T x N
+
+                # Apply mask and compute mean across all frames
+                valid_distances = torch.sqrt(squared_distances[mask_flat])
+                avg_dist = valid_distances.mean()  # Single value
+            else:
+                # Compute average Euclidean distance to origin for all points across all frames
+                avg_dist = torch.sqrt(torch.sum(points_flat**2, dim=2)).mean()  # Single value
+
+            # Compute scale factor to achieve average distance of 1 across all frames
+            scale = 1.0 / avg_dist  # Single value
+
+            # Rescale points for all frames at once
+            points_scaled = points * scale  # 3 x T x H x W
+
+            # Adjust world_to_cam matrix for all frames at once
+            # We need to scale the translation component by the same factor
+            world_to_cam_scaled = world_to_cam.clone()
+            world_to_cam_scaled[:, :3, 3] *= scale  # T x 4 x 4
+
+            # Scale depth for all frames at once
+            depth = data_dict[self.input_keys[2]]  # T x H x W
+            depth_scaled = depth * scale  # T x H x W
+        else:
+            # Single frame: 3 x H x W and 4 x 4
+            # Reshape points to N x 3 for easier computation
+            points_flat = points.reshape(3, -1).T  # N x 3
+
+            # Compute average Euclidean distance to origin
+            if self.mask_key is not None:
+                # Get mask and reshape to match points
+                mask = data_dict[self.mask_key]  # H x W
+                mask_flat = mask.reshape(-1)  # N
+
+                # Only compute average over valid points
+                valid_points = points_flat[mask_flat]
+                # Compute average Euclidean distance to origin
+                avg_dist = torch.sqrt(torch.sum(valid_points**2, dim=1)).mean()
+            else:
+                # Compute average Euclidean distance to origin for all points
+                avg_dist = torch.sqrt(torch.sum(points_flat**2, dim=1)).mean()
+
+            # Compute scale factor to achieve average distance of 1
+            scale = 1.0 / avg_dist
+
+            # Rescale points
+            points_scaled = points * scale
+
+            # Adjust world_to_cam matrix
+            # We need to scale the translation component by the same factor
+            world_to_cam_scaled = world_to_cam.clone()
+            world_to_cam_scaled[:3, 3] *= scale
+
+            # Scale depth
+            depth = data_dict[self.input_keys[2]]  # H x W
+            depth_scaled = depth * scale
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = points_scaled
+        data_dict[self.output_keys[1]] = world_to_cam_scaled
+        data_dict[self.output_keys[2]] = depth_scaled
+        return data_dict
+
+
+class PointcloudMaskFill(Augmentor):
+    """Fills point cloud values with 0 when point cloud mask is False.
+
+    This augmentor takes a point cloud and a point cloud mask, and sets point cloud values to 0
+    wherever the mask is False. This is useful for cleaning up point clouds by
+    removing invalid or unreliable point measurements.
+
+    Args:
+        input_keys: List of input keys (typically ['points', 'pcd_mask'])
+        output_keys: List of output keys (typically ['points'])
+    """
+
+    def __init__(
+        self, input_keys: list, output_keys: Optional[list] = None, fill_value: float = 0.0, args: Optional[dict] = None
+    ) -> None:
+        """Initialize the point cloud mask filler.
+
+        Args:
+            input_keys: List of input keys (typically ['points', 'pcd_mask'])
+            output_keys: List of output keys (typically ['points'])
+            args: Additional arguments (not used in this augmentor)
+        """
+        super().__init__(input_keys, output_keys, args)
+        self.fill_value = fill_value
+
+    def __call__(self, data_dict: dict) -> dict:
+        """Fill point cloud values with 0 where point cloud mask is False.
+
+        Args:
+            data_dict: Input data dictionary containing point cloud and point cloud mask
+
+        Returns:
+            data_dict: Output data dictionary with masked point cloud
+        """
+        # Get point cloud and point cloud mask
+        points = data_dict[self.input_keys[0]]  # 3 x T x H x W or 3 x H x W
+        depth_mask = data_dict[self.input_keys[1]]  # T x H x W or H x W
+
+        # Check if we're dealing with video sequences (temporal dimension)
+        if points.dim() == 4 and depth_mask.dim() == 3:
+            # Video sequence: 3 x T x H x W and T x H x W
+            # Create a copy of the point cloud
+            points_filled = points.clone()
+
+            # Expand mask to match points dimensions: 3 x T x H x W
+            mask_expanded = depth_mask.unsqueeze(0).expand(3, -1, -1, -1)  # 3 x T x H x W
+
+            # Set point cloud values to fill_value where mask is False for all channels at once
+            points_filled[~mask_expanded] = self.fill_value
+
+        else:
+            # Single frame: 3 x H x W and H x W
+            # Create a copy of the point cloud
+            points_filled = points.clone()
+
+            # Expand mask to match points dimensions: 3 x H x W
+            mask_expanded = depth_mask.unsqueeze(0).expand(3, -1, -1)  # 3 x H x W
+
+            # Set point cloud values to fill_value where mask is False for all channels at once
+            points_filled[~mask_expanded] = self.fill_value
+
+        # Store in output dictionary
+        data_dict[self.output_keys[0]] = points_filled
+
+        return data_dict
+
+
+def verify_backprojection(data_dict: dict, scale: float) -> bool:
+    """Verify that backprojection of rescaled depth and camera poses matches rescaled point cloud.
+
+    This function checks if the backprojection of the rescaled depth image using
+    the rescaled camera poses produces the same point cloud as the rescaled point cloud.
+
+    Args:
+        data_dict: Dictionary containing:
+            - points_scaled: Rescaled point cloud (3 x H x W)
+            - depth_scaled: Rescaled depth image (H x W)
+            - world_to_cam_scaled: Rescaled world to camera matrix (4 x 4)
+            - intrinsics: Camera intrinsics matrix (3 x 3)
+        scale: The scale factor used for rescaling
+
+    Returns:
+        bool: True if backprojection matches rescaled point cloud within tolerance
+    """
+    # Get required data
+    points_scaled = data_dict["points"]  # 3 x H x W
+    depth_scaled = data_dict["depth"]  # H x W
+    world_to_cam_scaled = data_dict["world_to_cam"]  # 4 x 4
+    intrinsics = data_dict["intrinsics"]  # 3 x 3
+
+    # Get image dimensions
+    H, W = depth_scaled.shape[-2:]
+
+    # Create pixel coordinates
+    y, x = torch.meshgrid(
+        torch.arange(H, device=depth_scaled.device), torch.arange(W, device=depth_scaled.device), indexing="ij"
+    )
+
+    # Create homogeneous coordinates
+    pixels = torch.stack([x, y, torch.ones_like(x)], dim=-1).float()  # H x W x 3
+
+    # Reshape for batch processing
+    pixels = pixels.reshape(-1, 3)  # (H*W) x 3
+    depth_flat = depth_scaled.reshape(-1)  # (H*W)
+
+    # Get inverse of intrinsics
+    intrinsics_inv = torch.inverse(intrinsics)
+
+    # Back-project to camera space
+    points_cam = (intrinsics_inv @ pixels.T).T  # (H*W) x 3
+    points_cam = points_cam * depth_flat.unsqueeze(-1)  # (H*W) x 3
+
+    # Convert to world coordinates
+    cam_to_world = torch.inverse(world_to_cam_scaled)  # 4 x 4
+    points_cam_h = torch.cat([points_cam, torch.ones_like(points_cam[:, :1])], dim=-1)  # (H*W) x 4
+    points_world_h = (cam_to_world @ points_cam_h.T).T  # (H*W) x 4
+    points_world = points_world_h[:, :3]  # (H*W) x 3
+
+    # Reshape back to image dimensions
+    points_world = points_world.reshape(H, W, 3)  # H x W x 3
+    points_world = points_world.permute(2, 0, 1)  # 3 x H x W
+
+    # Compare with rescaled point cloud
+    # Use a small tolerance for floating point comparison
+    tolerance = 1e-6
+    is_close = torch.allclose(points_world, points_scaled, rtol=tolerance, atol=tolerance)
+
+    return is_close

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/cropping.py

@@ -0,0 +1,122 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+import torchvision.transforms.functional as transforms_F
+from loguru import logger as logging
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.image.misc import (
+    obtain_augmentation_size,
+    obtain_image_size,
+)
+
+
+class CenterCrop(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs center crop.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are center cropped.
+            We also save the cropping parameters in the aug_params dict
+            so that it will be used by other transforms.
+        """
+        assert (self.args is not None) and ("size" in self.args), "Please specify size in args"
+
+        img_size = obtain_augmentation_size(data_dict, self.args)
+        width, height = img_size
+
+        orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+        for key in self.input_keys:
+            data_dict[key] = transforms_F.center_crop(data_dict[key], [height, width])
+
+        # We also add the aug params we use. This will be useful for other transforms
+        crop_x0 = (orig_w - width) // 2
+        crop_y0 = (orig_h - height) // 2
+        cropping_params = {
+            "resize_w": orig_w,
+            "resize_h": orig_h,
+            "crop_x0": crop_x0,
+            "crop_y0": crop_y0,
+            "crop_w": width,
+            "crop_h": height,
+        }
+
+        if "aug_params" not in data_dict:
+            data_dict["aug_params"] = dict()
+
+        data_dict["aug_params"]["cropping"] = cropping_params
+        data_dict["padding_mask"] = torch.zeros((1, cropping_params["crop_h"], cropping_params["crop_w"]))
+        return data_dict
+
+
+class RandomCrop(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs random crop.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are center cropped.
+            We also save the cropping parameters in the aug_params dict
+            so that it will be used by other transforms.
+        """
+
+        img_size = obtain_augmentation_size(data_dict, self.args)
+        width, height = img_size
+
+        orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+        # Obtaining random crop coords
+        try:
+            crop_x0 = int(torch.randint(0, orig_w - width + 1, size=(1,)).item())
+            crop_y0 = int(torch.randint(0, orig_h - height + 1, size=(1,)).item())
+        except Exception:
+            logging.warning(
+                f"Random crop failed. Performing center crop, original_size(wxh): {orig_w}x{orig_h}, random_size(wxh): {width}x{height}"
+            )
+            for key in self.input_keys:
+                data_dict[key] = transforms_F.center_crop(data_dict[key], [height, width])
+            crop_x0 = (orig_w - width) // 2
+            crop_y0 = (orig_h - height) // 2
+
+        # We also add the aug params we use. This will be useful for other transforms
+        cropping_params = {
+            "resize_w": orig_w,
+            "resize_h": orig_h,
+            "crop_x0": crop_x0,
+            "crop_y0": crop_y0,
+            "crop_w": width,
+            "crop_h": height,
+        }
+
+        if "aug_params" not in data_dict:
+            data_dict["aug_params"] = dict()
+
+        data_dict["aug_params"]["cropping"] = cropping_params
+
+        # We must perform same random cropping for all input keys
+        for key in self.input_keys:
+            data_dict[key] = transforms_F.crop(data_dict[key], crop_y0, crop_x0, height, width)
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/flip.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+import torchvision.transforms.functional as transforms_F
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+
+
+class HorizontalFlip(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs horizontal flipping.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are center cropped.
+        """
+        flip_enabled = getattr(self.args, "enabled", True)
+        if flip_enabled:
+            p = getattr(self.args, "prob", 0.5)
+            coin_flip = torch.rand(1).item() > p
+            for key in self.input_keys:
+                if coin_flip:
+                    data_dict[key] = transforms_F.hflip(data_dict[key])
+
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/misc.py

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Union
+
+import torch
+from PIL import Image
+
+
+def obtain_image_size(data_dict: dict, input_keys: list) -> tuple[int, int]:
+    r"""Function for obtaining the image size from the data dict.
+
+    Args:
+        data_dict (dict): Input data dict
+        input_keys (list): List of input keys
+    Returns:
+        width (int): Width of the input image
+        height (int): Height of the input image
+    """
+
+    data1 = data_dict[input_keys[0]]
+    if isinstance(data1, Image.Image):
+        width, height = data1.size
+    elif isinstance(data1, torch.Tensor):
+        height, width = data1.size()[-2:]
+    else:
+        raise ValueError("data to random crop should be PIL Image or tensor")
+
+    return width, height
+
+
+def obtain_augmentation_size(data_dict: dict, augmentor_cfg: dict) -> Union[int, tuple]:
+    r"""Function for obtaining size of the augmentation.
+    When dealing with multi-aspect ratio dataloaders, we need to
+    find the augmentation size from the aspect ratio of the data.
+
+    Args:
+        data_dict (dict): Input data dict
+        augmentor_cfg (dict): Augmentor config
+    Returns:
+        aug_size (int): Size of augmentation
+    """
+    if "__url__" in data_dict and "aspect_ratio" in data_dict["__url__"].meta.opts:
+        aspect_ratio = data_dict["__url__"].meta.opts["aspect_ratio"]
+        aug_size = augmentor_cfg["size"][aspect_ratio]
+    else:  # Non-webdataset format
+        aspect_ratio = data_dict["aspect_ratio"]
+        aug_size = augmentor_cfg["size"][aspect_ratio]
+    return aug_size

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/normalize.py

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+import torchvision.transforms.functional as transforms_F
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+
+
+class Normalize(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs data normalization.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are center cropped.
+        """
+        assert self.args is not None, "Please specify args"
+
+        mean = self.args["mean"]
+        std = self.args["std"]
+
+        for key in self.input_keys:
+            if isinstance(data_dict[key], torch.Tensor):
+                data_dict[key] = data_dict[key].to(dtype=torch.get_default_dtype()).div(255)
+            else:
+                data_dict[key] = transforms_F.to_tensor(data_dict[key])  # division by 255 is applied in to_tensor()
+
+            data_dict[key] = transforms_F.normalize(tensor=data_dict[key], mean=mean, std=std)
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/padding.py

@@ -0,0 +1,82 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import omegaconf
+import torch
+import torchvision.transforms.functional as transforms_F
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.image.misc import (
+    obtain_augmentation_size,
+    obtain_image_size,
+)
+
+
+class ReflectionPadding(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs reflection padding. This function also returns a padding mask.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are center cropped.
+        """
+
+        assert self.args is not None, "Please specify args in augmentation"
+        if self.output_keys is None:
+            self.output_keys = self.input_keys
+
+        # Obtain image and augmentation sizes
+        orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+        target_size = obtain_augmentation_size(data_dict, self.args)
+
+        assert isinstance(target_size, (tuple, omegaconf.listconfig.ListConfig)), "Please specify target size as tuple"
+        target_w, target_h = target_size
+
+        target_w = int(target_w)
+        target_h = int(target_h)
+
+        # Calculate padding vals
+        padding_left = int((target_w - orig_w) / 2)
+        padding_right = target_w - orig_w - padding_left
+        padding_top = int((target_h - orig_h) / 2)
+        padding_bottom = target_h - orig_h - padding_top
+        padding_vals = [padding_left, padding_top, padding_right, padding_bottom]
+
+        for inp_key, out_key in zip(self.input_keys, self.output_keys):
+            if max(padding_vals[0], padding_vals[2]) >= orig_w or max(padding_vals[1], padding_vals[3]) >= orig_h:
+                # In this case, we can't perform reflection padding. This is because padding values
+                # are larger than the image size. So, perform edge padding instead.
+                data_dict[out_key] = transforms_F.pad(data_dict[inp_key], padding_vals, padding_mode="edge")
+            else:
+                # Perform reflection padding
+                data_dict[out_key] = transforms_F.pad(data_dict[inp_key], padding_vals, padding_mode="reflect")
+
+            if out_key != inp_key:
+                del data_dict[inp_key]
+
+        # Return padding_mask when padding is performed.
+        # Padding mask denotes which pixels are padded.
+        padding_mask = torch.ones((1, target_h, target_w))
+        padding_mask[:, padding_top : (padding_top + orig_h), padding_left : (padding_left + orig_w)] = 0
+        data_dict["padding_mask"] = padding_mask
+        data_dict["image_size"] = torch.tensor([target_h, target_w, orig_h, orig_w], dtype=torch.float)
+
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/augmentors/image/resize.py

@@ -0,0 +1,190 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import omegaconf
+import torchvision.transforms.functional as transforms_F
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.image.misc import (
+    obtain_augmentation_size,
+    obtain_image_size,
+)
+
+
+class ResizeSmallestSide(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs resizing to smaller side
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are resized
+        """
+
+        if self.output_keys is None:
+            self.output_keys = self.input_keys
+        assert self.args is not None, "Please specify args in augmentations"
+
+        for inp_key, out_key in zip(self.input_keys, self.output_keys):
+            out_size = obtain_augmentation_size(data_dict, self.args)
+            assert isinstance(out_size, int), "Arg size in resize should be an integer"
+            data_dict[out_key] = transforms_F.resize(
+                data_dict[inp_key],
+                size=out_size,  # type: ignore
+                interpolation=getattr(self.args, "interpolation", transforms_F.InterpolationMode.BICUBIC),
+                antialias=True,
+            )
+            if out_key != inp_key:
+                del data_dict[inp_key]
+        return data_dict
+
+
+class ResizeLargestSide(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs resizing to larger side
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are resized
+        """
+
+        if self.output_keys is None:
+            self.output_keys = self.input_keys
+        assert self.args is not None, "Please specify args in augmentations"
+
+        for inp_key, out_key in zip(self.input_keys, self.output_keys):
+            out_size = obtain_augmentation_size(data_dict, self.args)
+            assert isinstance(out_size, int), "Arg size in resize should be an integer"
+            orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+
+            scaling_ratio = min(out_size / orig_w, out_size / orig_h)
+            target_size = [int(scaling_ratio * orig_h), int(scaling_ratio * orig_w)]
+
+            data_dict[out_key] = transforms_F.resize(
+                data_dict[inp_key],
+                size=target_size,
+                interpolation=getattr(self.args, "interpolation", transforms_F.InterpolationMode.BICUBIC),
+                antialias=True,
+            )
+            if out_key != inp_key:
+                del data_dict[inp_key]
+        return data_dict
+
+
+class ResizeSmallestSideAspectPreserving(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs aspect-ratio preserving resizing.
+        Image is resized to the dimension which has the smaller ratio of (size / target_size).
+        First we compute (w_img / w_target) and (h_img / h_target) and resize the image
+        to the dimension that has the smaller of these ratios.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are resized
+        """
+
+        if self.output_keys is None:
+            self.output_keys = self.input_keys
+        assert self.args is not None, "Please specify args in augmentations"
+
+        img_size = obtain_augmentation_size(data_dict, self.args)
+        assert isinstance(img_size, (tuple, omegaconf.listconfig.ListConfig)), (
+            f"Arg size in resize should be a tuple, get {type(img_size)}, {img_size}"
+        )
+        img_w, img_h = img_size
+
+        orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+        scaling_ratio = max((img_w / orig_w), (img_h / orig_h))
+        target_size = (int(scaling_ratio * orig_h + 0.5), int(scaling_ratio * orig_w + 0.5))
+
+        assert target_size[0] >= img_h and target_size[1] >= img_w, (
+            f"Resize error. orig {(orig_w, orig_h)} desire {img_size} compute {target_size}"
+        )
+
+        for inp_key, out_key in zip(self.input_keys, self.output_keys):
+            data_dict[out_key] = transforms_F.resize(
+                data_dict[inp_key],
+                size=target_size,  # type: ignore
+                interpolation=(
+                    self.args["interpolation"]
+                    if "interpolation" in self.args
+                    else transforms_F.InterpolationMode.BICUBIC
+                ),
+                antialias=True,
+            )
+
+            if out_key != inp_key:
+                del data_dict[inp_key]
+        return data_dict
+
+
+class ResizeLargestSideAspectPreserving(Augmentor):
+    def __init__(self, input_keys: list, output_keys: Optional[list] = None, args: Optional[dict] = None) -> None:
+        super().__init__(input_keys, output_keys, args)
+
+    def __call__(self, data_dict: dict) -> dict:
+        r"""Performs aspect-ratio preserving resizing.
+        Image is resized to the dimension which has the larger ratio of (size / target_size).
+        First we compute (w_img / w_target) and (h_img / h_target) and resize the image
+        to the dimension that has the larger of these ratios.
+
+        Args:
+            data_dict (dict): Input data dict
+        Returns:
+            data_dict (dict): Output dict where images are resized
+        """
+
+        if self.output_keys is None:
+            self.output_keys = self.input_keys
+        assert self.args is not None, "Please specify args in augmentations"
+
+        img_size = obtain_augmentation_size(data_dict, self.args)
+        assert isinstance(img_size, (tuple, omegaconf.listconfig.ListConfig)), (
+            f"Arg size in resize should be a tuple, get {type(img_size)}, {img_size}"
+        )
+        img_w, img_h = img_size
+
+        orig_w, orig_h = obtain_image_size(data_dict, self.input_keys)
+        scaling_ratio = min((img_w / orig_w), (img_h / orig_h))
+        target_size = (int(scaling_ratio * orig_h + 0.5), int(scaling_ratio * orig_w + 0.5))
+
+        assert target_size[0] <= img_h and target_size[1] <= img_w, (
+            f"Resize error. orig {(orig_w, orig_h)} desire {img_size} compute {target_size}"
+        )
+
+        for inp_key, out_key in zip(self.input_keys, self.output_keys):
+            data_dict[out_key] = transforms_F.resize(
+                data_dict[inp_key],
+                size=target_size,  # type: ignore
+                interpolation=getattr(self.args, "interpolation", transforms_F.InterpolationMode.BICUBIC),
+                antialias=True,
+            )
+
+            if out_key != inp_key:
+                del data_dict[inp_key]
+        return data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/config/schema.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Type
+
+import attrs
+from torch.utils.data import IterableDataset
+
+from cosmos_policy._src.imaginaire import config
+from cosmos_policy._src.imaginaire.config import make_freezable
+from cosmos_policy._src.imaginaire.datasets.webdataset.augmentors.augmentor import Augmentor
+
+
+@make_freezable
+@attrs.define(slots=False)
+class DatasetInfo:
+    object_store_config: config.ObjectStoreConfig  # Object strore config
+    wdinfo: list[str]  # List of wdinfo files
+    opts: dict = attrs.Factory(dict)  # Additional dataset info args
+    per_dataset_keys: list[str] = attrs.Factory(list)  # List of keys per dataset
+    source: str = ""  # data source
+
+
+@make_freezable
+@attrs.define(slots=False)
+class TarSample:
+    path: str  # Path to the sample
+    root: str  # Root folder
+    keys: list  # List of keys to be loaded from the webdataset
+    meta: DatasetInfo  # Metadata
+    dset_id: str  # Dataset id
+    sample_keys_full_list: str = None  # Path to the file containing full sample keys for the tar file
+
+
+@make_freezable
+@attrs.define(slots=False)
+class Wdinfo:
+    tar_files: list[TarSample]  # List of all tar samples
+    total_key_count: int  # Total number of elements present in the dataset
+    chunk_size: int  # Number of elements present in each tar
+
+
+@make_freezable
+@attrs.define(slots=False)
+class AugmentorConfig:
+    # Type of augmentor
+    type: Type[Augmentor]
+    # Input keys used by the augmentor
+    input_keys: list[str]
+    # Output keys returned by the augmentor
+    output_keys: Optional[list[str]] = None
+    # Additional arguments used by the augmentor
+    args: Optional[dict] = None
+
+    def make_instance(self) -> Augmentor:
+        return self.type(input_keys=self.input_keys, output_keys=self.output_keys, args=self.args)
+
+
+@make_freezable
+@attrs.define(slots=False)
+class DatasetConfig:
+    keys: list[str]  # List of keys used
+    buffer_size: int  # Buffer size used by each worker
+    dataset_info: list[DatasetInfo]  # List of dataset info files, one for each dataset
+    distributor: IterableDataset  # Iterator for returning list of tar files
+    decoders: list  # List of decoder functions for decoding bytestream
+    augmentation: dict[str, AugmentorConfig]  # Dictionary containing all augmentations
+    streaming_download: bool = True  # Whether to use streaming loader
+    remove_extension_from_keys: bool = True  # True: objects will have a key of data_type; False: data_type.extension
+    sample_keys_full_list_path: Optional[str] = (
+        None  # Path to the file containing all keys present in the dataset, e.g., "index"
+    )

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/dataloader.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import webdataset
+
+import cosmos_policy._src.imaginaire.datasets.webdataset.webdataset
+from cosmos_policy._src.imaginaire.utils.distributed import get_world_size
+
+
+class Sampler:
+    r"""
+    A sampler function for setting the epoch number and iteration number.
+    In webdataset, information is propagated using environment flags.
+    In our case,
+        WDS_EPOCH_NUM: Epoch number
+        WDS_START_INDEX: Start index in this epoch.
+    """
+
+    def __init__(self, mode: str):
+        self.mode = mode
+        assert self.mode in ["train", "val"]
+
+    def set_epoch(self, epoch: int):
+        if self.mode == "train":
+            os.environ["WDS_EPOCH_NUM"] = str(epoch)
+        else:
+            pass
+
+    def set_iteration(self, start_index: int):
+        # start_index should be iters * batch_size
+        # It is the number of samples that have been seen by one GPU
+        if self.mode == "train":
+            os.environ["WDS_START_INDEX"] = str(start_index)
+        else:
+            pass
+
+
+class DataLoader(webdataset.WebLoader):
+    r"""
+    This class is a wrapper on webloader class with a len attribute.
+    len function is needed in Imaginaire dataloaders.
+    """
+
+    def __init__(
+        self,
+        dataset: cosmos_policy._src.imaginaire.datasets.webdataset.webdataset.Dataset,
+        batch_size: int = 1,
+        *args,
+        **kw,
+    ):  # type: ignore
+        # Setting data length. Webdataset is an iterable dataset, so it does not have data_len attr.
+        # So, we compute it from dataset and set it.
+        dataset_obj = dataset.build_dataset()
+        world_size = get_world_size()
+        if dataset_obj.total_images < world_size * batch_size:  # type: ignore
+            data_length = 1
+        else:
+            data_length = dataset_obj.total_images // (world_size * batch_size)  # type: ignore
+        self.data_len = data_length
+
+        super().__init__(dataset_obj, batch_size, *args, **kw)
+
+    def __len__(self) -> int:
+        return self.data_len

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/decoders/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/decoders/depth.py

@@ -0,0 +1,153 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Depth decoder for EXR files."""
+
+import re
+from io import BytesIO
+
+import numpy as np
+import torch
+
+_EXR_EXTENSIONS = "exr"
+MAX_DEPTH = 100000
+_NPZ_EXTENSIONS = "npz"
+
+
+def exr_loader(key, data):
+    """Load depth data from EXR file.
+
+    Args:
+        key (str): Key of the data
+        data (bytes): Raw EXR file data
+
+    Returns:
+        torch.Tensor: Depth map as tensor
+    """
+    # pyrefly: ignore  # import-error
+    import OpenEXR
+
+    extension = re.sub(r".*[.]", "", key)
+    if extension.lower() not in _EXR_EXTENSIONS:
+        return None
+
+    # Convert bytes to BytesIO for OpenEXR
+    exr_file = OpenEXR.InputFile(BytesIO(data))
+
+    # Get the header information
+    header = exr_file.header()
+    dw = header["dataWindow"]
+    w = dw.max.x - dw.min.x + 1
+    h = dw.max.y - dw.min.y + 1
+
+    # Read the depth data from 'R' channel
+    depth = np.frombuffer(exr_file.channel("R"), dtype=np.float32).reshape((h, w))
+    mask = depth == np.nan
+    depth = depth.copy()
+    depth[mask] = MAX_DEPTH
+
+    # Convert to tensor and normalize to [0, 1]
+    depth = torch.from_numpy(depth).float()
+
+    depth = depth.unsqueeze(0)
+    return depth
+
+
+def npz_loader(key, data):
+    """Load depth data from NPZ file."""
+
+    extension = re.sub(r".*[.]", "", key)
+    if extension.lower() not in _NPZ_EXTENSIONS:
+        return None
+
+    # Convert bytes to BytesIO for np.load
+    npz_file = BytesIO(data)
+
+    # Load the NPZ file
+    with np.load(npz_file) as npz_data:
+        # Assuming the depth data is stored in the first array
+        # You may need to adjust this based on your specific NPZ file structure
+        depth_array = npz_data[list(npz_data.keys())[0]]
+    # Convert to tensor and normalize to [0, 1] if needed
+    depth = torch.from_numpy(depth_array).float()
+
+    return depth
+
+
+def construct_videodepth_decoder():
+    """Construct videodepth decoder with frame count filtering.
+
+    Args:
+        min_frames (int): Minimum number of frames required. Samples with fewer frames will be skipped.
+
+    Returns:
+        callable: Videodepth decoder function that filters by frame count
+    """
+
+    def videodepth_decoder(key, data):
+        """Decode depth video data from NPZ file and filter by frame count.
+
+        Args:
+            key (str): Key of the data
+            data (bytes): Raw NPZ file data
+
+        Returns:
+            torch.Tensor: Depth video tensor if it has enough frames, None otherwise (to skip)
+        """
+        # Load the depth data using npz_loader
+        depth = npz_loader(key, data)
+        if depth is None:
+            return None
+
+        # Check frame count - determine temporal dimension
+        if depth.dim() == 4:  # CxTxHxW
+            total_frames = depth.shape[1]
+        elif depth.dim() == 3:  # TxHxW
+            total_frames = depth.shape[0]
+        else:
+            # For 2D depth maps (single frame), skip filtering
+            return depth
+
+        return depth
+
+    return videodepth_decoder
+
+
+def construct_depth_decoder(sequence_length: int = 0):
+    """Construct depth decoder.
+
+    Args:
+        sequence_length (int): Number of frames to decode. Set to 0 for single frame.
+
+    Returns:
+        callable: Depth decoder function
+    """
+
+    def depth_decoder(key, sample):
+        """Decode depth data from sample.
+
+        Args:
+            key (str): Key of the data
+            sample (dict): Sample dictionary containing depth data
+
+        Returns:
+            dict: Sample dictionary with decoded depth data
+        """
+        depth = exr_loader(key, sample)
+        if depth is None:
+            return None
+        return depth
+
+    return depth_decoder

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/decoders/image.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import re
+from typing import Optional
+
+from PIL import Image
+
+Image.MAX_IMAGE_PIXELS = 933120000
+_IMG_EXTENSIONS = "jpg jpeg png ppm pgm pbm pnm".split()
+
+
+def pil_loader(key: str, data: bytes) -> Optional[Image.Image]:
+    r"""
+    Function to load an image.
+    If the image is corrupt, it returns a black image.
+    Args:
+        key (str): Image key.
+        data (bytes): Image data stream.
+    Returns:
+        PIL image
+    """
+    extension = re.sub(r".*[.]", "", key)
+    if extension.lower() not in _IMG_EXTENSIONS:
+        return None
+
+    with io.BytesIO(data) as stream:
+        img = Image.open(stream)
+        img.load()
+        img = img.convert("RGB")
+
+    return img

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/decoders/pickle.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pickle
+import re
+from typing import Optional
+
+
+def pkl_decoder(key: str, data: bytes) -> Optional[dict]:
+    r"""
+    Function to decode a pkl file.
+    Args:
+        key: Data key.
+        data: Data dict.
+    """
+    extension = re.sub(r".*[.]", "", key)
+    if extension == "pkl" or extension == "pickle":
+        data_dict = pickle.loads(data)
+        return data_dict
+    else:
+        return None

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.distributors.basic import ShardlistBasic
+from cosmos_policy._src.imaginaire.datasets.webdataset.distributors.multi_aspect_ratio import ShardlistMultiAspectRatio
+from cosmos_policy._src.imaginaire.datasets.webdataset.distributors.multi_aspect_ratio_v2 import (
+    ShardlistMultiAspectRatioInfinite,
+)
+
+distributors_list = {
+    "basic": ShardlistBasic,
+    "multi_aspect_ratio": ShardlistMultiAspectRatio,
+    "multi_aspect_ratio_infinite": ShardlistMultiAspectRatioInfinite,
+}

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/basic.py

@@ -0,0 +1,158 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+import time
+
+from webdataset.pytorch import IterableDataset
+from webdataset.utils import pytorch_worker_info
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import TarSample
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.misc import repeat_list
+from cosmos_policy._src.imaginaire.utils import log
+
+
+class ShardlistBasic(IterableDataset):
+    r"""
+    An iterable dataset that parses and yields tar files.
+    The dataset restored from an iteration number and index number.
+    """
+
+    def __init__(
+        self,
+        shuffle: bool = True,
+        split_by_node: bool = True,
+        split_by_worker: bool = True,
+        resume_flag: bool = True,
+        verbose: bool = False,
+        is_infinite_loader: bool = False,
+        max_epochs: int = 100000,
+        repeat_url: bool = True,
+    ):
+        r"""Create a ShardList.
+        Args:
+            shuffle (bool): shuffle samples before iterating.
+            split_by_node (bool): split shards by node if True
+            split_by_worker (bool): split shards by worker if True
+            resume_flag (bool): If enabled, resumes from a specific iteration and epoch number.
+            verbose (bool): Prints some logs if true
+            is_infinite_loader (bool): If true, creates an infinite dataloader.
+                So, the dataset will be only one epoch and will not terminate.
+            max_epochs (int): Infinite dataloader is created with max_epochs number of epochs.
+                Should be a very large number.
+            repeat_url (bool): If true, each worker will receive the same number of batches by repeating urls.
+        """
+        super().__init__()
+
+        self.verbose = verbose
+        if self.verbose:
+            log.info("ShardListWithResumes init")
+        self.epoch = 0
+        self.start_index = 0
+        self.shuffle = shuffle
+        self.split_by_node = split_by_node
+        self.split_by_worker = split_by_worker
+        self.resume_flag = resume_flag
+        self.is_infinite_loader = is_infinite_loader
+        self.max_epochs = max_epochs
+        self.repeat_url = repeat_url
+
+    def set_urls(self, urls: list[TarSample]):
+        """Set urls
+
+        Args:
+            urls (list[TarSample]): a list of tar files along with their metadata
+        """
+        self.urls = urls
+
+    def set_chunk_size(self, chunk_size: int):
+        """Set chunk size
+
+        Args:
+            chunk_size (int): chunk size used in webdataset creation
+        """
+        self.chunk_size = chunk_size
+
+    def set_epoch(self, epoch: int, start_index: int):
+        r"""Set the current epoch. Used for per-node shuffling.
+        Args:
+            epoch (int): Epoch number
+            start_index (int): iteraton number
+        """
+        self.epoch = epoch
+        self.start_index = start_index
+
+    def obtain_url_list(self):
+        r"""Return an iterator over the shards."""
+
+        rank, world_size, worker_id, num_workers = pytorch_worker_info()
+
+        # Setting epoch and start index
+        if self.resume_flag:
+            self.epoch = int(os.environ.get("WDS_EPOCH_NUM", 0))
+            # This tells us number of chunks that have been seen by one GPU
+            self.start_index = int(os.environ.get("WDS_START_INDEX", 0)) // self.chunk_size
+
+        urls = self.urls
+        num_urls = len(urls)
+
+        if self.repeat_url:
+            # Extending urls so that each workers receive the same number of batches.
+            # This serves the job of ddp_equalize.
+            nworkers_all = world_size * num_workers
+            num_urls_per_process = (num_urls + nworkers_all - 1) // nworkers_all
+            extended_url_list_size = num_urls_per_process * nworkers_all
+            urls = repeat_list(urls, extended_url_list_size)
+
+        # Splits the urls by node and worker id. This ensures each worker sees different urls.
+        if self.split_by_node:
+            urls = urls[rank::world_size]
+        if self.split_by_worker:
+            urls = urls[worker_id::num_workers]
+
+        if self.verbose:
+            log.info("List of urls (before shuffle)")
+            log.info(urls[0:10])
+
+        if self.shuffle:
+            # Shuffle based on the world worker id.
+            random.Random(rank * num_workers + worker_id).shuffle(urls)
+
+        # This tells us the number of chunks seen by one worker.
+        # Do not iterate over the seen chunks.
+        start_index_per_worker = self.start_index // num_workers
+        if not self.is_infinite_loader:
+            urls = urls[start_index_per_worker:]
+
+        if self.verbose:
+            log.info("List of urls (after shuffle)")
+            log.info(urls[0:10])
+            log.info(f"PytorchShardList got {len(urls)} urls")
+
+        return urls
+
+    def __iter__(self):
+        url_list = self.obtain_url_list()
+
+        if self.is_infinite_loader:
+            for _ in range(self.max_epochs):
+                cur_time = int(time.time())
+                random.Random(cur_time).shuffle(url_list)
+                for url in url_list:
+                    yield dict(url=url)
+        else:
+            for url in url_list:
+                yield dict(url=url)

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/multi_aspect_ratio.py

@@ -0,0 +1,274 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script contains the code for multi-aspect ratio shard iterator
+
+import math
+import os
+import random
+import time
+from collections import defaultdict
+from copy import deepcopy
+
+from webdataset.pytorch import IterableDataset
+from webdataset.utils import pytorch_worker_info
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import TarSample
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.misc import repeat_list
+from cosmos_policy._src.imaginaire.utils import log
+
+
+class ShardlistMultiAspectRatio(IterableDataset):
+    r"""
+    An iterable dataset that parses and yields tar files.
+    This distributor handles the multi-aspect ratio case. For the dataloader to be successful,
+    each worker should load only one aspect ratio. Else, there can be a batch where two
+    aspect ratios would be present which would raise an error in collate function.
+    So, we design data distribution strategy so that each worker sees only one aspect ratio.
+    """
+
+    def __init__(
+        self,
+        shuffle: bool = True,
+        split_by_node: bool = True,
+        split_by_worker: bool = True,
+        chunk_size: int = 1,
+        resume_flag: bool = True,
+        verbose: bool = False,
+        is_infinite_loader: bool = False,
+    ):
+        r"""Create a multi-aspect ratio ShardList.
+        Args:
+            urls (list[TarSample]): a list of tar files along with their metadata
+            epoch_shuffle (bool): Shuffles the whole epoch. If disabled, each node will see the same set of urls.
+            shuffle (bool): shuffle samples before iterating.
+            split_by_node (bool): split shards by node if True
+            split_by_worker (bool): split shards by worker if True
+            chunk_size (int): chunk size used in webdataset creation
+            resume_flag (bool): If enabled, resumes from a specific iteration and epoch number.
+            verbose (bool): Prints some logs if true
+            is_infinite_loader (bool): If true, creates an infinite dataloader.
+                So, the dataset will be only one epoch and will not terminate.
+        """
+        super().__init__()
+
+        self.verbose = verbose
+        if self.verbose:
+            log.info("ShardListWithResumes init")
+        self.epoch = 0
+        self.start_index = 0
+        self.shuffle = shuffle
+        self.split_by_node = split_by_node
+        self.split_by_worker = split_by_worker
+        self.chunk_size = chunk_size
+        self.resume_flag = resume_flag
+        self.is_infinite_loader = is_infinite_loader
+
+    def set_urls(self, urls: list[TarSample]):
+        self.urls = urls
+        self._split_urls_by_aspect_ratio()
+
+    def set_chunk_size(self, chunk_size: int):
+        """Set chunk size
+
+        Args:
+            chunk_size (int): chunk size used in webdataset creation
+        """
+        self.chunk_size = chunk_size
+
+    def set_epoch(self, epoch: int, start_index: int):
+        r"""Set the current epoch. Used for per-node shuffling.
+        Args:
+            epoch (int): Epoch number
+            start_index (int): iteraton number
+        """
+        self.epoch = epoch
+        self.start_index = start_index
+
+    def _split_urls_by_aspect_ratio(self):
+        r"""Function for splitting urls by aspect ratio.
+        We assume that urls are grouped by dataset_id. That is, data belonging to
+        one dataset_id should have all data in the same aspect ratio.
+        """
+
+        url_aspect_split = defaultdict(list)
+
+        for url in self.urls:
+            dset_info = url.meta
+            if "aspect_ratio" not in dset_info.opts:
+                raise ValueError("aspect_ratio should be specified in dataset_info when using multi aspect distributor")
+            aspect_ratio = dset_info.opts["aspect_ratio"]
+            url_aspect_split[aspect_ratio].append(url)
+
+        aspect_ratio_with_most_elems = -1
+        aspect_ratio_with_least_elems = -1
+        max_aspect_ratio_count = -1
+        min_aspect_ratio_count = 1000000000
+
+        for aspect_ratio in url_aspect_split:
+            # Sort the url list
+            url_aspect_split[aspect_ratio] = sorted(
+                url_aspect_split[aspect_ratio], key=lambda tar: (tar.path, tar.root)
+            )
+
+            # Finding max and min tar counts per aspect ratio
+            if len(url_aspect_split[aspect_ratio]) > max_aspect_ratio_count:
+                aspect_ratio_with_most_elems = aspect_ratio
+                max_aspect_ratio_count = len(url_aspect_split[aspect_ratio])
+            if len(url_aspect_split[aspect_ratio]) < min_aspect_ratio_count:
+                aspect_ratio_with_least_elems = aspect_ratio
+                min_aspect_ratio_count = len(url_aspect_split[aspect_ratio])
+
+        self.url_aspect_split = url_aspect_split
+        self.aspect_ratio_with_most_elems = aspect_ratio_with_most_elems
+        self.aspect_ratio_with_least_elems = aspect_ratio_with_least_elems
+
+    def _ddp_equalize(
+        self, url_aspect_split: dict[str, list[TarSample]], nworkers_all: int
+    ) -> tuple[dict[str, list[TarSample]], int]:
+        r"""This function performs tar file equalization. That is, we repeat the number of tars in each aspect
+        ratio so that when the tars are split across workers, each worker recieves the same number of tars.
+        This function is important for ddp to terminate well at the end of each epoch.
+
+        Args:
+            url_aspect_split (dict[list[TarSample]]): TarSample split by aspect ratio
+            nworkers_all (int): Total number of dataloader workers
+
+        Returns:
+            url_aspect_split (dict[list[TarSample]]): TarSample split after DDP equalization
+            num_urls_per_worker (int): Number of tars in each worker
+        """
+        betas = []
+        n_total = sum([len(url_aspect_split[aspect_ratio]) for aspect_ratio in url_aspect_split])
+
+        # Initial assignment
+        aspect_ind_with_most_elems = 0
+        for i, aspect_ratio in enumerate(url_aspect_split):
+            betas.append(math.ceil((len(url_aspect_split[aspect_ratio]) / n_total) * nworkers_all))
+            if aspect_ratio == self.aspect_ratio_with_most_elems:
+                aspect_ind_with_most_elems = i
+
+        # Constraint that total number of workers is fixed
+        betas[aspect_ind_with_most_elems] += nworkers_all - sum(betas)
+
+        # Rebalance the number of urls
+        num_urls_per_worker = math.ceil(n_total / sum(betas))
+        for i, aspect_ratio in enumerate(url_aspect_split):
+            url_aspect_split[aspect_ratio] = repeat_list(url_aspect_split[aspect_ratio], betas[i] * num_urls_per_worker)
+
+        return url_aspect_split, num_urls_per_worker
+
+    def _obtain_node_worker_url_mapping(
+        self,
+        url_aspect_split: dict[str, list[TarSample]],
+        num_urls_per_worker: int,
+        rank: int,
+        world_size: int,
+        worker_id: int,
+        num_workers: int,
+    ):
+        r"""This function obtains the worker-URL mapping. It assigns the tar list seen by
+        each workers.
+
+        Args:
+            url_aspect_split (dict[list[TarSample]]: TarSample split by aspect ratio
+            num_urls_per_worker (int): Number of tar files seen by each worker
+            rank (int): Rank of the current GPU
+            world_size (int): Total number of GPUs
+            worker_id (int): ID for the current worker in the dataloader
+            num_workers (int): Total number of workers in the dataloader
+
+        Returns:
+            URL list for the current worker
+        """
+        assert self.split_by_node is True and self.split_by_worker is True
+
+        # First chunk the tars
+        chunk_mappings = []
+        for aspect_ratio in url_aspect_split:
+            samples_asp = url_aspect_split[aspect_ratio]
+            nchunks_asp = int(len(samples_asp) / num_urls_per_worker)
+            for chunk_id in range(nchunks_asp):
+                chunk_mappings.append((aspect_ratio, samples_asp[chunk_id::nchunks_asp]))
+
+        # Split by rank and workers
+        chunk_mappings = chunk_mappings[rank::world_size]
+        chunk_mappings = chunk_mappings[worker_id::num_workers]
+
+        assert len(chunk_mappings) == 1
+        return chunk_mappings[0][1]
+
+    def obtain_url_list(self):
+        r"""Return an iterator over the shards."""
+
+        rank, world_size, worker_id, num_workers = pytorch_worker_info()
+
+        # Setting epoch and start index
+        if self.resume_flag:
+            self.epoch = int(os.environ.get("WDS_EPOCH_NUM", 0))
+
+            # This tells us number of chunks that have been seen by one GPU
+            self.start_index = int(os.environ.get("WDS_START_INDEX", 0)) // self.chunk_size
+
+        urls = deepcopy(self.urls)
+        url_aspect_split = deepcopy(self.url_aspect_split)
+
+        # Splitting the shards by worker and node
+        if self.verbose:
+            log.info(f"PytorchShardList rank {rank} of {world_size}")
+            log.info(f"PytorchShardList worker {worker_id} of {num_workers}")
+
+        nworkers_all = world_size * num_workers
+
+        # Perform DDP equalization
+        url_aspect_split, num_urls_per_worker = self._ddp_equalize(url_aspect_split, nworkers_all)
+
+        # Form a mapping of url_aspect_split to node and workers
+        urls = self._obtain_node_worker_url_mapping(
+            url_aspect_split, num_urls_per_worker, rank, world_size, worker_id, num_workers
+        )
+
+        if self.verbose:
+            log.info("List of urls (before shuffle)")
+            log.info(urls[0:10])
+
+        if self.shuffle:
+            random.Random(rank * num_workers + worker_id).shuffle(urls)
+
+        # This tells us the number of chunks seen by one worker.
+        # Do not iterate over the seen chunks.
+        start_index_per_worker = self.start_index // num_workers
+        if not self.is_infinite_loader:
+            urls = urls[start_index_per_worker:]
+
+        if self.verbose:
+            log.info("List of urls (after shuffle)")
+            log.info(urls[0:10])
+            log.info(f"PytorchShardList got {len(urls)} urls")
+
+        return urls
+
+    def __iter__(self):
+        url_list = self.obtain_url_list()
+
+        if self.is_infinite_loader:
+            while True:
+                cur_time = time.time_ns()
+                random.Random(cur_time).shuffle(url_list)
+                for url in url_list:
+                    yield dict(url=url)
+        else:
+            for url in url_list:
+                yield dict(url=url)

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/multi_aspect_ratio_v2.py

@@ -0,0 +1,252 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script contains the code for multi-aspect ratio shard iterator
+
+import random
+import time
+from collections import defaultdict
+
+import numpy as np
+from webdataset.pytorch import IterableDataset
+from webdataset.utils import pytorch_worker_info
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import TarSample
+from cosmos_policy._src.imaginaire.utils import log
+
+
+class ShardlistMultiAspectRatioInfinite(IterableDataset):
+    r"""
+    An iterable dataset that parses and yields tar files.
+    This distributor handles the multi-aspect ratio case. For the dataloader to be successful,
+    each worker should load only one aspect ratio. Else, there can be a batch where two
+    aspect ratios would be present which would raise an error in collate function.
+    So, we design data distribution strategy so that each worker sees only one aspect ratio.
+
+    This version only supports infinite loader mode. This enables a simpler code that is faster to initialize
+    and produces samples better matching the dataset distribution.
+    """
+
+    def __init__(
+        self,
+        shuffle: bool = True,
+        split_by_node: bool = True,
+        split_by_worker: bool = True,
+        chunk_size: int = 1,
+        resume_flag: bool = True,
+        verbose: bool = False,
+        is_infinite_loader: bool = True,
+    ):
+        r"""Create a multi-aspect ratio ShardList.
+        Args:
+            urls (list[TarSample]): a list of tar files along with their metadata
+            epoch_shuffle (bool): Shuffles the whole epoch. If disabled, each node will see the same set of urls.
+            shuffle (bool): shuffle samples before iterating.
+            split_by_node (bool): split shards by node if True
+            split_by_worker (bool): split shards by worker if True
+            chunk_size (int): Ignored
+            resume_flag (bool): Ignored
+            verbose (bool): Prints some logs if true
+            is_infinite_loader (bool): If true, creates an infinite dataloader.
+                So, the dataset will be only one epoch and will not terminate.
+        """
+        super().__init__()
+
+        self.verbose = verbose
+        if self.verbose:
+            log.info("ShardlistMultiAspectRatioInfinite init")
+        self.shuffle = shuffle
+        self.split_by_node = split_by_node
+        self.split_by_worker = split_by_worker
+        self.chunk_size = chunk_size  # Ignored
+        self.resume_flag = resume_flag  # Ignored
+        assert is_infinite_loader is True
+
+    def set_urls(self, urls: list[TarSample]):
+        self.url_aspect_split = self._split_urls_by_aspect_ratio(urls)
+
+    def set_chunk_size(self, chunk_size: int):
+        """Set chunk size
+        For backward compatibility. Ignored.
+
+        Args:
+            chunk_size (int): chunk size used in webdataset creation
+        """
+        self.chunk_size = chunk_size
+
+    def set_epoch(self, epoch: int, start_index: int):
+        r"""Set the current epoch. Used for per-node shuffling.
+        For backward compatibility. Ignored.
+
+        Args:
+            epoch (int): Epoch number
+            start_index (int): iteraton number
+        """
+        self.epoch = epoch
+        self.start_index = start_index
+
+    def _split_urls_by_aspect_ratio(self, urls):
+        r"""Function for splitting urls by aspect ratio.
+        We assume that urls are grouped by dataset_id. That is, data belonging to
+        one dataset_id should have all data in the same aspect ratio.
+        """
+
+        url_aspect_split = defaultdict(list)
+
+        for url in urls:
+            dset_info = url.meta
+            if "aspect_ratio" not in dset_info.opts:
+                raise ValueError("aspect_ratio should be specified in dataset_info when using multi aspect distributor")
+            aspect_ratio = dset_info.opts["aspect_ratio"]
+            url_aspect_split[aspect_ratio].append(url)
+
+        for aspect_ratio in url_aspect_split:
+            # Sort the url list
+            url_aspect_split[aspect_ratio] = sorted(
+                url_aspect_split[aspect_ratio], key=lambda tar: (tar.path, tar.root)
+            )
+
+        return url_aspect_split
+
+    def _allocate_workers_to_aspects(
+        self, url_aspect_split: dict[str, list[TarSample]], num_workers_all: int
+    ) -> list[tuple[str, int]]:
+        r"""Allocate workers to each aspect ratio so that:
+        1. Each aspect ratio has at least one worker
+        2. All the workers have jobs to do
+
+        Args:
+            url_aspect_split (dict[list[TarSample]]): TarSample split by aspect ratio
+            num_workers_all (int): Total number of dataloader workers
+
+        Returns:
+            aspect_worker_allocation (list): List of tuple containing (aspect_key, num_workers)
+        """
+        if self.verbose:
+            log.info(
+                f"#URLs for each aspect ratio: {[len(url_aspect_split[aspect_ratio]) for aspect_ratio in url_aspect_split]}"
+            )
+
+        # Must have more global workers than the number of aspect ratios, as each global worker can only load a single
+        # aspect ratio.
+        num_aspects = len(url_aspect_split)
+        assert num_workers_all >= num_aspects
+
+        aspect_keys = list(url_aspect_split.keys())
+        # Allocate at least one worker per aspect ratios
+        target_ratio = np.array([len(url_aspect_split[key]) for key in aspect_keys])
+        target_ratio = target_ratio / target_ratio.sum()
+        aspect_worker_allocation = np.ones([num_aspects], dtype=np.int64)
+        for _i in range(num_workers_all - num_aspects):
+            current_ratio = aspect_worker_allocation / aspect_worker_allocation.sum()
+            aspect_worker_allocation[np.argmin(current_ratio - target_ratio)] += 1
+
+        if self.verbose:
+            log.info(f"Aspects: {aspect_keys}")
+            log.info(f"Target ratio: {target_ratio}")
+            log.info(f"Worker allocation: {aspect_worker_allocation}")
+            log.info(f"Discrepancy: {aspect_worker_allocation / aspect_worker_allocation.sum() / target_ratio}")
+        return [(k, v) for k, v in zip(aspect_keys, aspect_worker_allocation.tolist())]
+
+    def _obtain_node_worker_url_mapping(
+        self,
+        url_aspect_split: dict[str, list[TarSample]],
+        aspect_worker_allocation: list[tuple[str, int]],
+        rank: int,
+        world_size: int,
+        worker_id: int,
+        num_workers: int,
+    ):
+        r"""This function obtains the worker-URL mapping. It assigns the tar list seen by
+        each workers.
+
+        Args:
+            url_aspect_split (dict[list[TarSample]]: TarSample split by aspect ratio
+            aspect_worker_allocation (dict): Number of workers allocated to each aspect ratio
+            rank (int): Rank of the current GPU
+            world_size (int): Total number of GPUs
+            worker_id (int): ID for the current worker in the dataloader
+            num_workers (int): Total number of workers in the dataloader
+
+        Returns:
+            URL list for the current worker
+        """
+        assert self.split_by_node is True and self.split_by_worker is True
+
+        # First determine the aspect ratio for the current worker
+        global_worker_id = rank * num_workers + worker_id
+
+        cumulative = 0
+        for aspect_key, worker_count in aspect_worker_allocation:
+            cumulative += worker_count
+            if global_worker_id < cumulative:
+                chunk_id = global_worker_id - cumulative + worker_count
+                break
+
+        if self.verbose:
+            log.info(f"GID={global_worker_id}, aspect_key={aspect_key}, chunk_id={chunk_id}")
+        # chunk the urls for the target aspect ratio
+        urls_asp = url_aspect_split[aspect_key]
+        if len(urls_asp) >= worker_count:
+            url_chunk = urls_asp[chunk_id::worker_count]
+        else:
+            url_chunk = urls_asp[chunk_id % len(urls_asp) : chunk_id % len(urls_asp) + 1]
+
+        return url_chunk
+
+    def obtain_url_list(self):
+        r"""Return an iterator over the shards."""
+
+        rank, world_size, worker_id, num_workers = pytorch_worker_info()
+
+        # Splitting the shards by worker and node
+        if self.verbose:
+            log.info(f"PytorchShardList rank {rank} of {world_size}")
+            log.info(f"PytorchShardList worker {worker_id} of {num_workers}")
+
+        nworkers_all = world_size * num_workers
+
+        # Assigning workers to process each aspect ratio
+        aspect_worker_allocation = self._allocate_workers_to_aspects(self.url_aspect_split, nworkers_all)
+
+        # Form a mapping of url_aspect_split to node and workers
+        urls = self._obtain_node_worker_url_mapping(
+            self.url_aspect_split, aspect_worker_allocation, rank, world_size, worker_id, num_workers
+        )
+
+        if self.verbose:
+            log.info("List of urls (before shuffle)")
+            log.info(urls[0:10])
+
+        if self.shuffle:
+            global_worker_id = rank * num_workers + worker_id
+            random.Random(global_worker_id).shuffle(urls)
+
+        if self.verbose:
+            log.info("List of urls (after shuffle)")
+            log.info(urls[0:10])
+            log.info(f"PytorchShardList got {len(urls)} urls")
+
+        return urls
+
+    def __iter__(self):
+        url_list = self.obtain_url_list()
+        while True:
+            if self.shuffle:
+                cur_time = time.time_ns()
+                random.Random(cur_time).shuffle(url_list)
+            assert len(url_list) > 0, "No urls found"
+            for url in url_list:
+                yield dict(url=url)

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/multi_aspect_ratio_v2_test.py

@@ -0,0 +1,125 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Usage:
+    pytest --L1 -s cosmos_policy/_src/imaginaire/datasets/webdataset/distributors/multi_aspect_ratio_v2_test.py
+"""
+
+import os
+
+import pytest
+
+from cosmos_policy._src.imaginaire.config import ObjectStoreConfig
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import DatasetInfo, TarSample
+from cosmos_policy._src.imaginaire.datasets.webdataset.distributors.multi_aspect_ratio_v2 import (
+    ShardlistMultiAspectRatioInfinite,
+)
+from cosmos_policy._src.imaginaire.utils import log, misc
+
+
+@pytest.mark.skip(reason="not a test, it prepare test data")
+def generate_data(counts):
+    urls = []
+    for aspect_key, num_urls in zip(["1:1", "4:3", "3:4", "16:9", "9:16"], counts):
+        dataset_info = DatasetInfo(
+            object_store_config=ObjectStoreConfig(), wdinfo=[], opts={"aspect_ratio": aspect_key}
+        )
+        for i in range(num_urls):
+            urls.append(
+                TarSample(
+                    path=f"this_is_a_url_to_a_tar_file_{i:09d}",
+                    root="root/",
+                    keys=[],
+                    meta=dataset_info,
+                    dset_id="mock",
+                )
+            )
+    log.info(f"Generated a total of {len(urls)} urls")
+    return urls
+
+
+@pytest.fixture(autouse=True)
+def run_before_and_after_tests(tmpdir):
+    # Setup: run before the test
+    rank = os.environ.get("RANK", None)
+    world_size = os.environ.get("WORLD_SIZE", None)
+    worker = os.environ.get("WORKER", None)
+    num_workers = os.environ.get("NUM_WORKERS", None)
+
+    yield  # this is where the testing happens
+
+    # Teardown: run after the test
+    def restore_env(name, value):
+        if value is None:
+            os.environ.pop(name, None)
+        else:
+            os.environ.set(name, value)
+
+    restore_env("RANK", rank)
+    restore_env("WORLD_SIZE", world_size)
+    restore_env("WORKER", worker)
+    restore_env("NUM_WORKERS", num_workers)
+
+
+@misc.timer("test_shardlist_multi_aspect_ratio_infinite_mini")
+@pytest.mark.L1
+def test_shardlist_multi_aspect_ratio_infinite_mini():
+    urls = generate_data([100, 100, 100, 100, 100])
+
+    aspect_ratios = set()
+    for worker_id in range(16):
+        os.environ["RANK"] = "0"
+        os.environ["WORLD_SIZE"] = "1"
+        os.environ["WORKER"] = str(worker_id)
+        os.environ["NUM_WORKERS"] = "16"
+
+        distributor = ShardlistMultiAspectRatioInfinite(verbose=True, shuffle=False)
+        distributor.set_urls(urls)
+
+        distributor_iter = iter(distributor)
+
+        # Print first 10 URLs produced by the distributor
+        for i in range(2):
+            url = next(distributor_iter)
+            aspect_ratios.add(url["url"].meta.opts["aspect_ratio"])
+
+    assert len(aspect_ratios) == 5
+
+
+# Test on a large dataset. Takes 1 minute
+@misc.timer("test_shardlist_multi_aspect_ratio_infinite_large")
+@pytest.mark.L1
+def test_shardlist_multi_aspect_ratio_infinite_large():
+    urls = generate_data([123456, 234567, 10000, 500000, 500000])
+
+    aspect_ratios = set()
+    for worker_id in range(7):
+        os.environ["RANK"] = "0"
+        os.environ["WORLD_SIZE"] = "1"
+        os.environ["WORKER"] = str(worker_id)
+        os.environ["NUM_WORKERS"] = "7"
+
+        distributor = ShardlistMultiAspectRatioInfinite(verbose=True, shuffle=False)
+        distributor.set_urls(urls)
+
+        distributor_iter = iter(distributor)
+
+        # Print first 10 URLs produced by the distributor
+        for i in range(2):
+            url = next(distributor_iter)
+            aspect_ratios.add(url["url"].meta.opts["aspect_ratio"])
+
+    assert len(aspect_ratios) == 5

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/utils/iterators.py

@@ -0,0 +1,619 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import os
+import random
+import sys
+import time
+from typing import IO, Any, BinaryIO, Callable, Dict, Iterable, Iterator, Optional, Tuple, Union
+from urllib.parse import urlparse
+
+import botocore
+import botocore.exceptions
+import pandas as pd
+import webdataset.gopen as gopen_webdata
+import yaml
+from webdataset import cache, filters, shardlists
+from webdataset.compat import FluidInterface
+from webdataset.handlers import reraise_exception
+from webdataset.pipeline import DataPipeline
+from webdataset.pytorch import IterableDataset
+from webdataset.tariterators import group_by_keys, tar_file_iterator
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import TarSample
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.stream import RetryingStream
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.easy_io.backends import BaseStorageBackend
+
+# Number of attempts to read s3 objects.
+_NUM_OBJECT_STORE_READ_ATTEMPTS = 10
+
+
+def gopen(url: Tuple, mode: str = "rb", bufsize: int = 8192, **kw) -> Union[io.BytesIO, RetryingStream, BinaryIO, IO]:
+    r"""Open the URL.
+    This uses the `gopen_schemes` dispatch table to dispatch based
+    on scheme.
+    Support for the following schemes is built-in: pipe, file,
+    http, https, sftp, ftps, scp.
+    When no scheme is given the url is treated as a file.
+    You can use the OPEN_VERBOSE argument to get info about
+    files being opened.
+    Args:
+        url (tuple): (source URL, dataset id)
+        the source URL is join(TarSample.root, one of TarSample.keys, TarSample.path)
+        e.g. join("openx_short_cmu_playing_with_food_202505/v2.3/resolution_lt_720/aspect_ratio_4_3/duration_5_10/", "videos", "part_000000/000000.tar")
+        mode (str): the mode ("rb", "r")
+        bufsize (int): the buffer size
+    Returns:
+        Byte streams
+    """
+    global fallback_gopen
+    verbose = int(os.environ.get("GOPEN_VERBOSE", 0))
+    if verbose:
+        log.info("GOPEN", url, gopen_webdata.info, file=sys.stderr)
+
+    assert mode in ["rb", "wb"], mode
+    if url == "-":
+        if mode == "rb":
+            return sys.stdin.buffer
+        elif mode == "wb":
+            return sys.stdout.buffer
+        else:
+            raise ValueError(f"unknown mode {mode}")
+
+    # If we specify 'object_store' in keyword arguments,
+    # then we would load from s3.
+    if "object_store" in kw and kw["object_store"]:
+        assert isinstance(url, tuple)
+        return gopen_s3(
+            url,
+            easy_io_backends=kw["easy_io_backend"],
+            s3_bucket_name=kw["s3_bucket_name"],
+            streaming_download=kw["streaming_download"],
+        )
+
+    # For all other gopen schemes, use the native webdataset gopen functions.
+    # pr = gopen_webdata.urlparse(url)
+    # this should be a path to an existing file on local machine
+    url = url[0]
+    assert isinstance(url, str)
+    pr = urlparse(url)
+    if pr.scheme == "":
+        bufsize = int(os.environ.get("GOPEN_BUFFER", -1))
+        return open(url, mode, buffering=bufsize)
+    if pr.scheme == "file":
+        bufsize = int(os.environ.get("GOPEN_BUFFER", -1))
+        return open(pr.path, mode, buffering=bufsize)
+    handler = gopen_webdata.gopen_schemes["__default__"]
+    handler = gopen_webdata.gopen_schemes.get(pr.scheme, handler)
+    return handler(url, mode, bufsize, **kw)  # type: ignore
+
+
+def gopen_s3(
+    url: tuple,
+    easy_io_backends: Dict[str, BaseStorageBackend],
+    s3_bucket_name: Dict[str, str],
+    streaming_download=True,
+) -> Union[io.BytesIO, RetryingStream]:
+    r"""Gopen scheme for s3.
+    Function for reading urls from s3
+    Args:
+        url (list[TarSample]): the source URL
+        easy_io_backends: easy_io backends for downloading from object storage
+        s3_bucket_name (str): Bucket name for the S3 data
+    Returns:
+        Byte streams
+    """
+
+    attempt = 0
+
+    url_path = url[0]
+    dset_id = url[1]
+    easy_io_backend = easy_io_backends[dset_id]
+    bucket = s3_bucket_name[dset_id]
+
+    while attempt < _NUM_OBJECT_STORE_READ_ATTEMPTS:
+        try:
+            if streaming_download:
+                # Downloads in a streaming fashion
+                s3_stream = RetryingStream(easy_io_backend, bucket=bucket, key=url_path)
+                return s3_stream
+            else:
+                # Downloads the entire file
+                buffer = io.BytesIO()
+                buffer.write(easy_io_backend.get(filepath=f"s3://{bucket}/{url_path}"))
+                buffer.seek(0)
+                return buffer
+        except botocore.exceptions.ClientError as e:
+            # If there is an exception (usually connectivity error or protocol error), read again
+            attempt += 1
+            retry_interval = min(
+                0.1 * 2**attempt + random.uniform(0, 1), 30
+            )  # sleep workers randomly to avoid burst of requests
+            log.info(
+                f"Got an exception while downloading data {url_path}: attempt={attempt} - {e}. {type(e)}",
+                rank0_only=False,
+            )
+            log.info(f"Retrying tar file download after {retry_interval}s", rank0_only=False)
+            time.sleep(retry_interval)
+            continue
+    raise ConnectionError("Unable to read {} from PBSS. {} attempts tried.".format(url, attempt))
+
+
+def url_opener(data: Iterable, handler: Callable = reraise_exception, **kw) -> Iterator[dict]:
+    r"""Given a stream of url names (packaged in `dict(url=url)`), yield opened streams.
+
+    Args:
+        data (Iterable): Iterator of dictionaires containing url paths.
+        handler (Callable): Exception handler.
+
+    Yields:
+      Dictionaries with this structure:
+        {"url": ...
+         "stream": list[Union[io.BytesIO, RetryingStream]]}
+    """
+    for sample in data:
+        assert isinstance(sample, dict), sample
+        assert "url" in sample
+
+        url = sample["url"]
+        assert isinstance(url, TarSample), "URL should be of type TarSample"
+        try:
+            stream = []
+            for data_key in url.keys:
+                url_path_full = os.path.join(url.root, data_key, url.path)
+                url_key = (url_path_full, url.dset_id)
+                stream.append(gopen(url_key, **kw))
+
+            sample.update(stream=stream)
+            yield sample
+        except Exception as exn:
+            log.info(f"Got an exception while opening urls - {exn}", rank0_only=False)
+            exn.args = exn.args + (url,)
+            if handler(exn):
+                continue
+            else:
+                break
+
+
+def process_sample(sample, url, key_idx):
+    assert isinstance(sample, dict) and "data" in sample and "fname" in sample
+    # Edit the url entries
+    sample["__url__"] = url
+    # This is the folder name
+    data_key = url.keys[key_idx]
+    # Handle the case where data_key has "/"
+    data_key = data_key.replace("/", "_")
+    # Edit the fname to include the data_key
+    fname_splits = sample["fname"].split(".")
+    if len(fname_splits) == 2:
+        prefix, suffix = fname_splits  # {sample_key}.{suffix} e.g. "id_1410095.json"
+    else:  # if the fname here contains more than one dot, we replace all the dots except the last one with "-"
+        prefix = "-".join(fname_splits[:-1])
+        suffix = fname_splits[-1]
+
+    # e.g. "id_1410095.caption_ai_from_image.json"
+    sample["fname"] = f"{prefix}.{data_key}.{suffix}"
+
+    return sample
+
+
+def tar_file_expander(
+    data: Iterable[Dict[str, Any]],
+    handler: Callable[[Exception], bool] = reraise_exception,
+    select_files: Optional[Callable[[str], bool]] = None,
+    rename_files: Optional[Callable[[str], str]] = None,
+    easy_io_backend: Optional[Dict[str, BaseStorageBackend]] = None,
+    s3_bucket_name: Optional[Dict[str, str]] = None,
+) -> Iterator[Dict[str, Any]]:
+    """Expand tar files.
+
+    Args:
+        data (Iterable[Iterable[Dict[str, Any]]]): iterator over opened tar file streams.
+        handler (Callable[[Exception], bool]): exception handler.
+        select_files (Optional[Callable[[str], bool]]): select files from tarfiles by name (permits skipping files).
+        rename_files (Optional[Callable[[str], bool]]): Renaming tar files.
+
+        Optional args if reading sample_keys_full_list:
+        easy_io_backend: If loading from object store, specify easy_io backend. Keys is the dset_id, i.e. dataset id since different dataset could use different easy_io backend and bucket
+        s3_bucket_name (Dict[str, str]): If loading from object store, specify S3 bucket name.
+
+    Yields:
+        a stream of samples.
+    """
+    for source in data:
+        url = source["url"]
+        try:
+            assert isinstance(source, dict)
+            assert "stream" in source
+            tar_file_iterator_list = []
+            for stream_id in range(len(source["stream"])):
+                tar_file_iterator_list.append(
+                    tar_file_iterator(
+                        source["stream"][stream_id],
+                        handler=handler,
+                        select_files=select_files,
+                        rename_files=rename_files,
+                    )
+                )
+            if url.sample_keys_full_list is None:  # Original behavior
+                # tar_file_iterator_list is a list of iterator: [tar_file_iterator_0, tar_file_iterator_1, ... tar_file_iterator_N]
+                for sample in zip(*tar_file_iterator_list):
+                    # Merging data from all streams
+                    # sample is list of dictionaries, each dictionary contains data and fname
+                    # sample [tar_file_iterator_0[0], tar_file_iterator_1[0], ... tar_file_iterator_N[0]], length = num_of_data_key
+                    for key_idx, sample_key in enumerate(sample):
+                        sample_key = process_sample(sample_key, url, key_idx)
+                        yield sample_key
+            else:
+                # Read the index file from object storage
+                assert easy_io_backend is not None, "No easy_io backends"
+                assert s3_bucket_name is not None, "No S3 bucket names"
+                easy_io_backend_cur = easy_io_backend[url.dset_id]
+                bucket_cur = s3_bucket_name[url.dset_id]
+                sample_keys_full_list = read_sample_keys_full_list(
+                    url.sample_keys_full_list, easy_io_backend_cur, bucket_cur
+                )  # e.g. ["has_material_glb_from_obj_v4_1410095_0", "has_material_glb_from_obj_v4_1410095_1", ...]
+                sample_keys_full_to_index = {element: index for index, element in enumerate(sample_keys_full_list)}
+
+                # Start reading the tar files
+                target_index = 0
+                last_index = [-1] * len(tar_file_iterator_list)  # Keep track of the last index of each tar file
+                sample_list = []  # List of samples from each tar file
+                while True:  # Exit until target_index reach the max value
+                    skip_offset = False
+                    for key_idx, iterator in enumerate(tar_file_iterator_list):
+                        if last_index[key_idx] >= target_index:
+                            # This tar is moving faster than others, skip it and wait for others
+                            continue
+
+                        # Read the tar file until current_index >= target_index
+                        sample, current_index = run_iterator_to_index(
+                            iterator,
+                            target_index,
+                            sample_keys_full_to_index,
+                            name=f"{url.sample_keys_full_list}.{url.keys[key_idx]}",
+                        )
+                        if sample is None:  # Iterator {key_idx} already reached the end, exit the for loop
+                            if target_index < len(sample_keys_full_to_index):  # Missing keys
+                                missing_info = f"index_path={url.sample_keys_full_list} | id={target_index}, sample_key={sample_keys_full_list[target_index]};"
+                                log.info(
+                                    f"[missing keys] found in tar file: data_key={url.keys[key_idx]} | {missing_info}",
+                                    rank0_only=False,
+                                )
+                            sample_list = []  # Reset the sample_list
+                            break
+
+                        # Update the last_index
+                        last_index[key_idx] = current_index
+
+                        # Process sample dict
+                        sample = process_sample(sample, url=url, key_idx=key_idx)
+
+                        # Now check if the current index is matched or ahead
+                        if current_index == target_index:  # Nice!
+                            sample_list.append(sample)
+                        elif current_index > target_index:
+                            # This means there is missing keys in this tar, this tar is moving faster than others
+
+                            # Log the missing info
+                            missing_info = f"index_path={url.sample_keys_full_list} | "
+                            for missing_idx in range(target_index, current_index):
+                                missing_info += f" id={missing_idx}, sample_key={sample_keys_full_list[missing_idx]}; "
+                            log.info(
+                                f"[missing keys] found in tar file: data_key={url.keys[key_idx]} | {missing_info}",
+                                rank0_only=False,
+                            )
+
+                            # Update the target_index to current_index, skip index inbetween old target_index and current_index
+                            target_index = current_index
+
+                            # Reset sample_list, save the sample from this tar into sample_list and wait for others
+                            sample_list = [
+                                sample
+                            ]  # Attnetion: this will change the order of sample_list, we will put them in the right order later
+                            skip_offset = True  # Skip the offset of target_index, since we are waiting for others
+                            break
+                        elif current_index < target_index:
+                            # This should not happen
+                            raise ValueError(
+                                "Invalid output from run_iterator_to_index function. current_index should be equal or less than target_index"
+                            )
+
+                    # Decide where to yield the samples
+                    if len(sample_list) == len(tar_file_iterator_list):
+                        # Only yeild the samples if all the tars are preserved
+                        all_prefix = [sample["fname"].split(".")[0] for sample in sample_list]
+                        # Check all the prefix are the same
+                        assert all(prefix == all_prefix[0] for prefix in all_prefix), (
+                            f"prefixes are not the same: {all_prefix}"
+                        )
+                        # Correct the order of sample_list
+                        sample_list = correct_order(sample_list, url.keys)
+                        # Yield all the samples
+                        for sample in sample_list:
+                            assert isinstance(sample, dict) and "data" in sample and "fname" in sample
+                            yield sample
+                        sample_list = []  # Reset the sample_list
+                    elif len(sample_list) > 1:
+                        # Unexpected
+                        raise ValueError(f"Unexpected length of sample_list: {len(sample_list)}")
+                    elif len(sample_list) == 0 or len(sample_list) == 1:
+                        # If the sample_list is empty, it means the tar file is exhausted
+                        # If the sample_list has only one element, it means one tar file is moving faster than others
+                        pass  # Do nothing
+
+                    if not skip_offset:
+                        # If sample_list has one element, we stay at current target_index until others catch up
+                        target_index += 1  # Increase it by 1
+                    if target_index == len(sample_keys_full_to_index):
+                        break  # Reach the maximum index
+                # Make sure all the iterator are closed
+                for iterators in tar_file_iterator_list:
+                    try:
+                        next(iterators)
+                    except StopIteration:
+                        pass
+
+        except Exception as exn:
+            log.info(f"Got an exception while expanding tars - {exn}", rank0_only=False)
+            exn.args = exn.args + (source.get("stream"), source.get("url"))
+            if handler(exn):
+                continue
+            else:
+                break
+
+
+def correct_order(sample_list: list[Dict], expected_keys_order: list[str]) -> list[Dict]:
+    """Make sure the order of samples are the same as the url.keys order."""
+    data_keys_per_sample = [sample["fname"].split(".")[1] for sample in sample_list]
+    expected_keys_order = [key.replace("/", "_") for key in expected_keys_order]
+    if data_keys_per_sample == expected_keys_order:  # Correct order
+        return sample_list
+    # Order the sample_list based on the expected_keys_order
+    sample_list_ordered = [None] * len(expected_keys_order)
+    for data_key, sample in zip(data_keys_per_sample, sample_list):
+        idx = expected_keys_order.index(data_key)
+        sample_list_ordered[idx] = sample
+    return sample_list_ordered
+
+
+def load_func_parquet(buffer):
+    data_list = pd.read_parquet(buffer).values.tolist()
+    names = [data[0] for data in data_list]
+    return names
+
+
+def _read_sample_keys_full_list(key, easy_io_backend: BaseStorageBackend, s3_bucket_name: str):
+    with io.BytesIO() as buffer:
+        buffer.write(easy_io_backend.get(filepath=f"s3://{s3_bucket_name}/{key}"))
+        buffer.seek(0)
+        sample_keys_full_list = load_func_parquet(buffer)
+    sample_keys_full_list = [key.split(".")[0] for key in sample_keys_full_list]
+    return sample_keys_full_list
+
+
+def read_sample_keys_full_list(key: str, easy_io_backend: BaseStorageBackend, s3_bucket_name: str, max_attempts=10):
+    for attempt in range(max_attempts):
+        try:
+            return _read_sample_keys_full_list(key, easy_io_backend, s3_bucket_name)
+        except botocore.exceptions.ClientError as e:
+            retry_interval = min(
+                0.1 * 2**attempt + random.uniform(0, 1), 30
+            )  # sleep workers randomly to avoid burst of requests
+            log.exception(
+                f"Failed to read sample_keys_full_list {key}, attempt {attempt}. {e}. Retrying after {retry_interval}s."
+            )
+            if attempt < max_attempts - 1:
+                time.sleep(retry_interval)
+    raise ConnectionError(f"Unable to read sample_keys_full_list {key} after {max_attempts} attempts.")
+
+
+def run_iterator_to_index(iterator, target_index: int, sample_keys_full_to_index: dict, name: str = ""):
+    """
+    Iterates over samples from an iterator, checking against the index of current sample (current_index)
+    to target_index, until it finds
+    1) the sample key corresponds to the target index
+    or 2) the target index is passed (i,e, the target keys are missing)
+    or 3) until the iterator is exhausted.
+
+    This function is designed to handle cases where there are unexpected, duplicated, or missing
+    sample keys based on the index mapping provided.
+
+    Args:
+        iterator (iterator): An iterator yielding dictionaries that must include a key 'fname',
+            which contains the filename. The filename should be in the format 'prefix.suffix',
+            where 'prefix' will be used as the sample key.
+        target_index (int): The index of the sample to be retrieved according to the dictionary
+            mapping sample keys to indices.
+        sample_keys_full_to_index (dict): A dictionary mapping sample keys (extracted from the
+            'fname' prefix of the iterator's samples) to their respective indices. This mapping
+            dictates the order in which samples are considered valid and should be found.
+            e.g. {"name_0": 0, "name_1": 1, "name_2": 2}
+        name (str): Names of the tar file, used to log the progress.
+
+    Returns:
+        tuple: A tuple containing:
+            - sample (dict or None): The sample dictionary that matches the target index, or None
+              if no such sample is found by the time the iterator is exhausted.
+            - current_index (int or None): The index of the found sample according to the mapping,
+              or None if no sample is found.
+
+    Raises:
+        StopIteration: If the iterator is exhausted without finding a matching sample, though this
+        is caught internally and handled by returning None values.
+    """
+    sample, current_index = None, None
+    skip_count = 0
+    while True:
+        try:
+            sample = next(iterator)
+            prefix, suffix = sample["fname"].split(".")
+            sample_key = prefix
+
+            if sample_key not in sample_keys_full_to_index:  # extra sample_key
+                log.info(
+                    f"Skipping ({skip_count}) unexpected key {sample_key}; not found in the sample_keys_full_to_index {name} {sample_keys_full_to_index.keys()}"
+                )
+                skip_count += 1
+                continue
+            current_index = sample_keys_full_to_index[sample_key]  # can be <,=,> target_index
+            if current_index < target_index:
+                # Note: current_index < target_index happens when duplicated keys or it's under catching up process
+                # e.g.       [name_0, name_0, name_1] with target index = 1
+                # Pointer at             ^
+                # Current index is 0, which is less than target index 1
+                # In this case, we keep iterating
+                # log.info(f"[Skip] key {sample_key}; current_index={current_index} < target_index={target_index} {name}")
+                continue
+            elif current_index >= target_index:  # Note: current_index > targer_index happens when there is missing keys
+                # Note: current_index > targer_index happens when there is missing keys
+                # e.g.       [name_0, name_2, name_3] with target index 1
+                # Pointer at             ^
+                # Current index is 2, which is greater than target index 1
+                # In this case, we return the current_index, set the target_index to 2 and tell other tars to catch up.
+                # if current_index == target_index:  # Matched!
+                #     log.info(f"[Pass!] current_index={current_index} == target_index={target_index}")
+                # else:  # Missing keys
+                #     log.info(f"[Missing key detected!] current_index={current_index} > target_index={target_index} {name}")
+                break
+
+        except StopIteration:
+            sample = None
+            current_index = None
+            break
+    return sample, current_index
+
+
+def tarfile_samples(
+    src: Iterable,
+    handler: Callable = reraise_exception,
+    load_from_object_store: bool = False,
+    easy_io_backend: Optional[Dict[str, BaseStorageBackend]] = None,
+    s3_bucket_name: Optional[Dict[str, str]] = None,
+    streaming_download: bool = True,
+) -> Iterator[Dict]:
+    r"""
+    Given an iterator of filenames, this function opens the URL streams
+    and groups data by keys.
+
+    Args:
+        src (Iterable): Iterator of TarSample.
+        handler (Callable): Exception handler.
+        load_from_object_store (bool): A boolean flag to specify whether to load from
+            object store.
+        easy_io_backend: If loading from object store, specify easy_io backend.
+        s3_bucket_name (str): If loading from object store, specify S3 bucket name.
+        streaming_download(bool): If enabled, performs streaming download.
+    """
+    streams = url_opener(
+        src,
+        handler=handler,
+        object_store=load_from_object_store,
+        easy_io_backend=easy_io_backend,
+        s3_bucket_name=s3_bucket_name,
+        streaming_download=streaming_download,
+    )
+    files = tar_file_expander(streams, handler=handler, easy_io_backend=easy_io_backend, s3_bucket_name=s3_bucket_name)
+    samples = group_by_keys(files, handler=handler)
+    return samples
+
+
+tarfile_to_samples = filters.pipelinefilter(tarfile_samples)
+
+
+class WebDataset(DataPipeline, FluidInterface):
+    r"""Webdataset class modified to support loading from object store."""
+
+    def __init__(
+        self,
+        urls: list[TarSample],
+        handler: Callable = reraise_exception,
+        resampled: bool = False,
+        shardshuffle: Optional[bool] = None,
+        cache_size: int = -1,
+        cache_dir: Optional[str] = None,
+        detshuffle: bool = False,
+        nodesplitter: Callable = shardlists.single_node_only,
+        verbose: bool = False,
+        load_from_object_store: bool = False,
+        easy_io_backend: Optional[Dict[str, BaseStorageBackend]] = None,
+        s3_bucket_name: Optional[Dict[str, str]] = None,
+        streaming_download: bool = True,
+    ):
+        r"""
+        Args:
+            urls (list[TarSample]): An iterator containing a list of url names.
+            handler (Callable): Exception handler.
+            resampled (bool): If true, sample shards from shard list with replacement.
+            shardshuffle (bool): If true, shuffles the entire shard list.
+            cache_size (int): Size of cache.
+            cache_dir (str): Path to store cache.
+            detshuffle (bool): Whether to use deterministic shuffling when shardshuffle is True.
+            nodesplitter (Callable): Function for splitting urls among nodes.
+            verbose (bool): If True, prints logs.
+            load_from_object_store (bool): A boolean flag to specify whether to load from
+                object store.
+            easy_io_backend: If loading from object store, specify easy_io backend.
+            s3_bucket_name (str): If loading from object store, specify S3 bucket name.
+            streaming_download (bool): Whether to do streaming download or full object download.
+        """
+        super().__init__()
+        if isinstance(urls, IterableDataset):
+            assert not resampled
+            self.append(urls)
+        elif isinstance(urls, str) and (urls.endswith(".yaml") or urls.endswith(".yml")):
+            with open(urls) as stream:
+                spec = yaml.safe_load(stream)
+            assert "datasets" in spec
+            self.append(shardlists.MultiShardSample(spec))
+        elif isinstance(urls, dict):
+            assert "datasets" in urls
+            self.append(shardlists.MultiShardSample(urls))
+        elif resampled:
+            self.append(shardlists.ResampledShards(urls))
+        else:
+            self.append(shardlists.SimpleShardList(urls))
+            self.append(nodesplitter)
+            self.append(shardlists.split_by_worker)
+            if shardshuffle is True:
+                shardshuffle = 100  # type: ignore
+            if shardshuffle is not None:
+                if detshuffle:
+                    self.append(filters.detshuffle(shardshuffle))
+                else:
+                    self.append(filters.shuffle(shardshuffle))
+        if cache_dir is None or cache_size == 0:
+            self.append(
+                tarfile_to_samples(
+                    handler=handler,
+                    load_from_object_store=load_from_object_store,
+                    easy_io_backend=easy_io_backend,
+                    s3_bucket_name=s3_bucket_name,
+                    streaming_download=streaming_download,
+                )
+            )
+        else:
+            # We dont use cache.
+            assert cache_size == -1 or cache_size > 0
+            self.append(
+                cache.cached_tarfile_to_samples(
+                    handler=handler,
+                    verbose=verbose,
+                    cache_size=cache_size,
+                    cache_dir=cache_dir,
+                )
+            )

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/utils/misc.py

@@ -0,0 +1,90 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import Iterator
+
+
+def repeat_list(x: list, n: int) -> list:
+    r"""Function to repeat the list to a fixed shape.
+    n is the desired length of the extended list.
+    Args:
+        x (list): Input list
+        n (int): Desired length
+    Returns:
+        Extended list
+    """
+    if n == 0:
+        return []
+    assert len(x) > 0
+
+    x_extended = []
+    while len(x_extended) < n:
+        x_extended = x_extended + x
+    x_extended = x_extended[0:n]
+
+    return x_extended
+
+
+def remove_extensions_from_keys(data: Iterator[dict]) -> Iterator[dict]:
+    r"""Function to remove extension from keys
+    Args:
+        data (dict): Input data dict
+    Returns:
+        data dict with keys removed
+    """
+
+    for data_dict in data:
+        data_dict_remapped = dict()
+
+        for key in data_dict:
+            key_split = key.split(".")
+            if len(key_split) > 1:
+                key_new = ".".join(key_split[:-1])
+            else:
+                key_new = key
+            data_dict_remapped[key_new] = data_dict[key]
+
+        yield data_dict_remapped
+
+
+def update_url(data: Iterator[dict]) -> Iterator[dict]:
+    r"""Function to update the URLs so that the TarSample is removed from data.
+    Instead, we replace the URL with a string.
+    Args:
+        data (dict): Input data dict
+    Returns:
+        data dict with URL replaced with a string
+    """
+    for data_dict in data:
+        data_dict["__url__"] = os.path.join(data_dict["__url__"].root, data_dict["__url__"].path)
+        yield data_dict
+
+
+def skip_keys(data: Iterator[dict]) -> Iterator[dict]:
+    r"""
+    Function to skip keys
+    Args:
+        data (dict): Input data dict
+    Returns:
+        data_dict with keys skipped
+    """
+
+    for data_dict in data:
+        if ("keys_to_skip" in data_dict) and (int(data_dict["keys_to_skip"]) == 1):
+            # Skip this key if data_dict["skip_key"] is True
+            continue
+        else:
+            yield data_dict

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/utils/stream.py

@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# PBSS
+import time
+from typing import Optional
+
+from botocore.exceptions import EndpointConnectionError
+from multistorageclient.types import RetryableError
+from urllib3.exceptions import ProtocolError as URLLib3ProtocolError
+from urllib3.exceptions import ReadTimeoutError as URLLib3ReadTimeoutError
+from urllib3.exceptions import SSLError as URLLib3SSLError
+
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.easy_io.backends import BaseStorageBackend
+
+
+class RetryingStream:
+    def __init__(self, easy_io_backend: BaseStorageBackend, bucket: str, key: str, retries: int = 10):  # type: ignore
+        r"""Class for loading data in a streaming fashion from an object store.
+        Args:
+            easy_io_backend (BaseStorageBackend): easy_io backend, must support 's3://' URLs
+            bucket (str): Bucket where data is stored
+            key (str): Key to read
+            retries (int): Number of retries
+        """
+        self.easy_io_backend = easy_io_backend
+        self.filepath = f"s3://{bucket}/{key}"
+        self.retries = retries
+        self.content_size = self.easy_io_backend.size(filepath=self.filepath)
+        self._amount_read = 0
+
+        self.name = f"{bucket}/{key}"
+
+    def read(self, amt: Optional[int] = None) -> bytes:
+        r"""Read function for reading the data stream.
+        Args:
+            amt (int, optional): Amount of data to read
+        Returns:
+            chunk (bytes): Bytes read
+        """
+
+        chunk = b""
+        for cur_retry_idx in range(self.retries):
+            try:
+                chunk = self.easy_io_backend.get(
+                    filepath=self.filepath,
+                    offset=self._amount_read,
+                    size=amt or (self.content_size - self._amount_read),
+                )
+                if len(chunk) == 0 and self._amount_read != self.content_size:
+                    raise IOError
+                break
+            except URLLib3ReadTimeoutError as e:
+                log.warning(
+                    f"URLLib3ReadTimeoutError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            except URLLib3ProtocolError as e:
+                log.warning(
+                    f"URLLib3ProtocolError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            except URLLib3SSLError as e:
+                log.warning(
+                    f"URLLib3SSLError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}", rank0_only=False
+                )
+            except IOError as e:
+                log.warning(
+                    f"Premature end of stream. IOError {e}. Retrying...  {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            except RetryableError as e:
+                log.warning(
+                    f"RetryableError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            except RuntimeError as e:
+                log.warning(
+                    f"RuntimeError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            except EndpointConnectionError as e:
+                log.error(
+                    f"EndpointConnectionError: {e} {self.name} retry: {cur_retry_idx} / {self.retries}",
+                    rank0_only=False,
+                )
+            time.sleep(1)
+
+        if len(chunk) == 0 and self._amount_read != self.content_size:
+            log.warning(
+                f"After {self.retries} retries, chunk is empty and self._amount_read != self.content_size {self._amount_read} != {self.content_size} {self.name}",
+                rank0_only=False,
+            )
+            raise IOError
+
+        self._amount_read += len(chunk)
+        return chunk

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/webdataset.py

@@ -0,0 +1,286 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import time
+import warnings
+from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from functools import partial
+from typing import Callable
+
+import omegaconf
+import webdataset as wds
+from webdataset.handlers import reraise_exception
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import (
+    AugmentorConfig,
+    DatasetConfig,
+    DatasetInfo,
+    TarSample,
+    Wdinfo,
+)
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.iterators import WebDataset
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.misc import (
+    remove_extensions_from_keys,
+    skip_keys,
+    update_url,
+)
+from cosmos_policy._src.imaginaire.lazy_config import instantiate
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.distributed import get_world_size
+from cosmos_policy._src.imaginaire.utils.easy_io.backends import BaseStorageBackend
+from cosmos_policy._src.imaginaire.utils.object_store import ObjectStore
+
+
+def wrap_augmentor_func_as_generator(func: Callable, data: Iterable):
+    for data_dict in data:
+        data_dict_out = func(data_dict)
+        if data_dict_out is None:
+            # Skip "unhealthy" samples
+            continue
+        yield data_dict_out
+
+
+class Dataset:
+    def __init__(
+        self,
+        config: DatasetConfig,
+        handler: Callable = reraise_exception,
+    ):
+        r"""Webdataloader class
+
+        Args:
+            config: Dataset config
+            world_size: Total number of GPUs
+        """
+        super().__init__()
+
+        self.config = config
+
+        self.world_size = get_world_size()
+
+        dataset_info = config.dataset_info
+        self.streaming_download = config.streaming_download
+
+        self.use_object_store: bool = False
+        self.easy_io_backend: dict[str, BaseStorageBackend] = dict()
+        self.bucket: dict[str, str] = dict()
+        self.data_keys = config.keys
+
+        # Parse the metadata
+        self.wdinfo = Wdinfo([], 0, 0)
+        self.parse_dataset_info(dataset_info=dataset_info, use_multithread=True)
+        self.handler = handler
+        self.augmentors = dict()
+
+    def parse_dataset_info(self, dataset_info: list[DatasetInfo], use_multithread: bool = True):
+        r"""Parse metadata about the list of tar files.
+
+        Args:
+            dataset_info (list): List of dictionaries containing paths to metadata files.
+            use_multithread (bool): Whether to use multi-threaded parsing across datasets. Default: True.
+        """
+        log.info(f"Start parsing dataset info with {len(dataset_info)} entries, use multithread = {use_multithread}")
+        tic = time.time()
+
+        def process_single_dataset(dset_num: int, dset_info: DatasetInfo):
+            # For each dataset, we parse the file paths and store them as a list of TarSample.
+            # TarSample will then be used by each worker to load the data.
+            use_object_store = dset_info.object_store_config.enabled
+            self.use_object_store = use_object_store
+            dset_id = "dset: {}".format(dset_num)
+            if use_object_store:
+                object_store_reader = ObjectStore(config_object_storage=dset_info.object_store_config)
+
+                # Create object store config if data is loaded from object storage
+                easy_io_backend_dset = object_store_reader.easy_io_backend
+                bucket_dset = dset_info.object_store_config.bucket
+            else:
+                object_store_reader = None
+                easy_io_backend_dset = None
+                bucket_dset = None
+
+            tar_samples = []
+            total_key_count = 0
+            chunk_sizes = []
+
+            # Read all wdinfo files and obtain the DataSample list
+            for wdinfo_path in dset_info.wdinfo:
+                if use_object_store:
+                    if not object_store_reader.object_exists(wdinfo_path):
+                        raise FileNotFoundError(f"{wdinfo_path} not found")
+                    cur_dset_info = object_store_reader.load_object(key=wdinfo_path, type="json")  # type: ignore
+                else:
+                    with open(wdinfo_path, "r") as fp:
+                        cur_dset_info = json.load(fp)
+
+                data_root = cur_dset_info["root"]
+                # Strip s3://bucket/ prefix from root if present, as the bucket is specified separately
+                if data_root.startswith("s3://"):
+                    # Remove s3://bucket/ prefix (e.g., "s3://debug/path/" -> "path/")
+                    parts = data_root[5:].split("/", 1)  # Split after "s3://"
+                    if len(parts) > 1:
+                        data_root = parts[1]  # Take everything after bucket name
+                    else:
+                        data_root = ""
+                tar_files_list = cur_dset_info["data_list"]
+                local_tar_samples = [
+                    TarSample(
+                        path=tar_file,
+                        root=data_root,
+                        keys=(
+                            dset_info.per_dataset_keys if dset_info.per_dataset_keys else self.data_keys
+                        ),  # use per dataset keys if available
+                        meta=dset_info,
+                        dset_id=dset_id,
+                        sample_keys_full_list=None,
+                    )
+                    for tar_file in tar_files_list
+                ]
+                tar_samples.extend(local_tar_samples)
+                total_key_count += cur_dset_info["total_key_count"]
+                chunk_sizes.append(cur_dset_info["chunk_size"])
+
+            return {
+                "dset_id": dset_id,
+                "tar_samples": tar_samples,
+                "total_key_count": total_key_count,
+                "chunk_sizes": chunk_sizes,
+                "easy_io_backend": easy_io_backend_dset,
+                "bucket": bucket_dset,
+            }
+
+        dataset_results = []
+
+        if use_multithread:
+            num_workers = os.cpu_count()
+            with ThreadPoolExecutor(max_workers=num_workers) as executor:
+                futures = []
+                for i, dset_info in enumerate(dataset_info):
+                    if len(dset_info.wdinfo) == 0:
+                        log.warning(f"No wdinfo found for dataset {i}, skipping...")
+                        continue
+                    log.info(f"Adding: {dset_info.wdinfo}")
+                    futures.append(executor.submit(process_single_dataset, i, dset_info))
+                for future in as_completed(futures):
+                    dataset_results.append(future.result())
+        else:
+            for i, dset_info in enumerate(dataset_info):
+                log.info(f"Adding: {dset_info.wdinfo}")
+                dataset_results.append(process_single_dataset(i, dset_info))
+
+        # Merge results
+        for result in dataset_results:
+            dset_id = result["dset_id"]
+            self.wdinfo.tar_files.extend(result["tar_samples"])
+            self.wdinfo.total_key_count += result["total_key_count"]
+            if len(set(result["chunk_sizes"])) > 1:
+                warnings.warn(
+                    f"Multiple chunk_size values found in {dset_id}: {result['chunk_sizes']}. Using the first one."
+                )
+            self.wdinfo.chunk_size = result["chunk_sizes"][0]
+            if result["easy_io_backend"]:
+                self.easy_io_backend[dset_id] = result["easy_io_backend"]
+            if result["bucket"]:
+                self.bucket[dset_id] = result["bucket"]
+        toc = time.time()
+        log.info(
+            f"Parsed dataset info with {len(dataset_info)} wdinfos (num_keys = {self.wdinfo.total_key_count}, num_tars = {len(self.wdinfo.tar_files)}) and multithread = {use_multithread}, took {(toc - tic):.2f} seconds"
+        )
+
+    @staticmethod
+    # This is the function that calls each augmentor in sequence.
+    def augmentor_fn(data, augmentations):
+        # Build augmentor chain
+        for aug_fn in augmentations:
+            # Use generator function as augmentor
+            # (recommended, allows skipping or replicating samples inside the augmentor)
+            if getattr(aug_fn, "is_generator", False):
+                data = aug_fn(data)
+            else:  # Use regular function as augmentor (backward compatibility)
+                data = wrap_augmentor_func_as_generator(aug_fn, data)
+        yield from data
+
+    def build_data_augmentor(self, augmentor_cfg: dict[str, AugmentorConfig]) -> Callable:
+        r"""Function for building data augmentors from augmentor config."""
+        augmentations = []
+        for aug in augmentor_cfg.keys():
+            augmentations.append(instantiate(augmentor_cfg[aug]))
+
+        # This is the function that calls each augmentor in sequence.
+        return partial(Dataset.augmentor_fn, augmentations=augmentations)
+
+    def build_dataset(self, **kwargs) -> WebDataset:
+        tar_list = self.wdinfo.tar_files
+        num_tars = len(tar_list)
+        assert num_tars > 0, "Did not find any data."
+
+        shuffle_buffer_size = getattr(self.config, "buffer_size", self.wdinfo.chunk_size)
+
+        # update distributor urls and chunk size
+        distributor_fn = self.config.distributor
+
+        distributor_fn.set_urls(tar_list)
+        distributor_fn.set_chunk_size(self.wdinfo.chunk_size)
+
+        dataset = WebDataset(
+            distributor_fn,
+            load_from_object_store=self.use_object_store,
+            easy_io_backend=self.easy_io_backend,
+            s3_bucket_name=self.bucket,
+            streaming_download=self.streaming_download,
+            handler=self.handler,
+        )
+
+        # Creating a shuffle buffer
+        if shuffle_buffer_size > 0:
+            dataset.append(wds.shuffle(shuffle_buffer_size))
+
+        # Adding decoders
+        # Decoders are functions that decode the input IO stream
+        decoder_list = getattr(self.config, "decoders", [])
+        decoder_functions = []
+        for decoder in decoder_list:
+            # If the specified decoder is a string, use the webdataset decoder
+            # If its a callable function, use the defined function to decode data
+            assert isinstance(decoder, str) or callable(decoder), "Decoder should either be callable or a str"
+            decoder_functions.append(decoder)
+        dataset.append(wds.decode(*decoder_functions))
+
+        # After the decoders are added, remove extension from the keys
+        # Extensions in the data keys are needed for auto-detection of decoders in webdataset.
+        if self.config.remove_extension_from_keys:
+            dataset.append(remove_extensions_from_keys)
+
+        # Function to skip keys
+        dataset.append(skip_keys)
+        # Building augmentors
+        augmentor_cfg = getattr(self.config, "augmentation", None)
+        assert isinstance(augmentor_cfg, (dict, omegaconf.dictconfig.DictConfig)), (
+            f"getting type: {type(augmentor_cfg)}"
+        )
+        augmentation_fn = self.build_data_augmentor(augmentor_cfg)
+        dataset.append(augmentation_fn)
+
+        # Updates URL names so that the collate function can handle
+        dataset.append(update_url)
+
+        dataset.total_images = self.wdinfo.total_key_count  # type: ignore
+        log.info("Total number of training shards: %d" % num_tars)
+        log.info("Total training key count: %d" % dataset.total_images)  # type: ignore
+
+        return dataset

REGEN-main/cosmos_policy/_src/imaginaire/datasets/webdataset/webdataset_ext.py

@@ -0,0 +1,118 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Callable, Optional
+
+import omegaconf
+import webdataset as wds
+from webdataset import filters
+from webdataset.handlers import reraise_exception
+
+from cosmos_policy._src.imaginaire.datasets.webdataset.config.schema import DatasetConfig
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.iterators import WebDataset
+from cosmos_policy._src.imaginaire.datasets.webdataset.utils.misc import (
+    remove_extensions_from_keys,
+    skip_keys,
+    update_url,
+)
+from cosmos_policy._src.imaginaire.datasets.webdataset.webdataset import Dataset as BaseDataset
+from cosmos_policy._src.imaginaire.utils import log
+
+
+class Dataset(BaseDataset):
+    def __init__(
+        self,
+        config: DatasetConfig,
+        handler: Callable = reraise_exception,
+        decoder_handler: Optional[Callable] = None,
+        detshuffle: bool = False,
+    ):
+        r"""Webdataloader class
+
+        Args:
+            config: Dataset config
+            handler (Callable): Error handler for webdataset class
+            decoder_handler (Callable): Error handler during decoding
+        """
+        super().__init__(config=config, handler=handler)
+        self.decoder_handler = decoder_handler
+        self.detshuffle = detshuffle
+
+    def build_dataset(self, **kwargs) -> WebDataset:
+        r"""
+        Build the dataset object.
+        The function only diffs from BaseDataset.build_dataset by only adding the decoder_handler to the WebDataset object.
+        """
+        tar_list = self.wdinfo.tar_files
+        num_tars = len(tar_list)
+        assert num_tars > 0, "Did not find any data."
+
+        shuffle_buffer_size = getattr(self.config, "buffer_size", self.wdinfo.chunk_size)
+
+        # update distributor urls and chunk size
+        distributor_fn = self.config.distributor
+
+        distributor_fn.set_urls(tar_list)
+        distributor_fn.set_chunk_size(self.wdinfo.chunk_size)
+
+        dataset = WebDataset(
+            distributor_fn,
+            load_from_object_store=self.use_object_store,
+            easy_io_backend=self.easy_io_backend,
+            s3_bucket_name=self.bucket,
+            streaming_download=self.streaming_download,
+            handler=self.handler,
+        )
+
+        # Creating a shuffle buffer
+        if self.detshuffle:
+            dataset.append(filters.detshuffle(shuffle_buffer_size))
+        else:
+            dataset.append(wds.shuffle(shuffle_buffer_size))
+
+        # Adding decoders
+        # Decoders are functions that decode the input IO stream
+        decoder_list = getattr(self.config, "decoders", [])
+        decoder_functions = []
+        for decoder in decoder_list:
+            # If the specified decoder is a string, use the webdataset decoder
+            # If its a callable function, use the defined function to decode data
+            assert isinstance(decoder, str) or callable(decoder), "Decoder should either be callable or a str"
+            decoder_functions.append(decoder)
+        dataset.append(wds.decode(*decoder_functions, handler=self.decoder_handler))
+
+        # After the decoders are added, remove extension from the keys
+        # Extensions in the data keys are needed for auto-detection of decoders in webdataset.
+        if self.config.remove_extension_from_keys:
+            dataset.append(remove_extensions_from_keys)
+
+        # Function to skip keys
+        dataset.append(skip_keys)
+        # Building augmentors
+        augmentor_cfg = getattr(self.config, "augmentation", None)
+        assert isinstance(augmentor_cfg, (dict, omegaconf.dictconfig.DictConfig)), (
+            f"getting type: {type(augmentor_cfg)}"
+        )
+        augmentation_fn = self.build_data_augmentor(augmentor_cfg)
+        dataset.append(augmentation_fn)
+
+        # Updates URL names so that the collate function can handle
+        dataset.append(update_url)
+
+        dataset.total_images = self.wdinfo.total_key_count  # type: ignore
+        log.info("Total number of training shards: %d" % num_tars)
+        log.info("Total training key count: %d" % dataset.total_images)  # type: ignore
+
+        return dataset

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/__init__.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import BaseStorageBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.boto3_backend import Boto3Backend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.http_backend import HTTPBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.local_backend import LocalBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.msc_backend import MSCBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.registry_utils import (
+    backends,
+    prefix_to_backends,
+    register_backend,
+)
+
+__all__ = [
+    "BaseStorageBackend",
+    "LocalBackend",
+    "HTTPBackend",
+    "Boto3Backend",
+    "MSCBackend",
+    "register_backend",
+    "backends",
+    "prefix_to_backends",
+]

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/auto_auth.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import json
+from collections.abc import Generator
+from typing import IO, Any, Optional, Union
+
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.env_parsers.cred_env_parser import CRED_ENVS, CRED_ENVS_DICT
+
+DEPLOYMENT_ENVS = ["prod", "dev", "stg"]
+
+
+# context manger to open a file or read from env variable
+@contextlib.contextmanager
+def open_auth(s3_credential_path: Optional[Any], mode: str) -> Generator[Union[None, dict[str, Any], IO]]:
+    if not s3_credential_path:
+        log.info(f"No credential file provided {s3_credential_path}.")
+        yield None
+        return
+
+    name = s3_credential_path.split("/")[-1].split(".")[0]
+    if not name:
+        raise ValueError(f"Could not parse into env var: {s3_credential_path}")
+    cred_env_name = f"PROD_{name.upper()}"
+
+    if CRED_ENVS.APP_ENV in DEPLOYMENT_ENVS and cred_env_name in CRED_ENVS_DICT:
+        object_storage_config = get_creds_from_env(cred_env_name)
+        log.info(f"using ENV vars for {cred_env_name}")
+        yield object_storage_config
+    else:
+        log.info(f"using credential file: {s3_credential_path}")
+        with open(s3_credential_path, mode) as f:
+            yield f
+
+
+def get_creds_from_env(cred_env_name: str) -> dict[str, Any]:
+    try:
+        object_storage_config = CRED_ENVS_DICT[cred_env_name]
+    except KeyError:
+        raise ValueError(f"Could not find {cred_env_name} in CRED_ENVS")
+    empty_args = {key.upper() for key in object_storage_config if object_storage_config[key] == ""}
+    if empty_args:
+        raise ValueError(f"Some required environment variable(s) were not provided for {cred_env_name}", empty_args)
+    return object_storage_config
+
+
+def json_load_auth(f: Union[None, dict[str, Any], IO]) -> dict[str, Any]:
+    # None.
+    if f is None:
+        return {}
+    # dict[str, Any].
+    elif isinstance(f, dict):
+        return f
+    # IO.
+    else:
+        return json.load(f)

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/base_backend.py

@@ -0,0 +1,147 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import os
+import os.path as osp
+from abc import ABCMeta, abstractmethod
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional, Union
+
+
+def mkdir_or_exist(dir_name, mode=0o777):
+    if dir_name == "":
+        return
+    dir_name = osp.expanduser(dir_name)
+    os.makedirs(dir_name, mode=mode, exist_ok=True)
+
+
+def has_method(obj, method):
+    return hasattr(obj, method) and callable(getattr(obj, method))
+
+
+class BaseStorageBackend(metaclass=ABCMeta):
+    """Abstract class of storage backends."""
+
+    # a flag to indicate whether the backend can create a symlink for a file
+    # This attribute will be deprecated in future.
+    _allow_symlink: bool = False
+
+    @property
+    def allow_symlink(self) -> bool:
+        return self._allow_symlink
+
+    @property
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    @abstractmethod
+    def size(self, filepath: Union[str, Path]) -> int:
+        pass
+
+    @abstractmethod
+    def get(self, filepath: Union[str, Path], offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        pass
+
+    @abstractmethod
+    def get_text(self, filepath: Union[str, Path], encoding: str = "utf-8") -> str:
+        pass
+
+    @abstractmethod
+    def put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path]) -> None:
+        pass
+
+    @abstractmethod
+    def put_text(self, obj: str, filepath: Union[str, Path], encoding: str = "utf-8") -> None:
+        pass
+
+    @abstractmethod
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        pass
+
+    @abstractmethod
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        pass
+
+    @abstractmethod
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        pass
+
+    @abstractmethod
+    def join_path(self, filepath: Union[str, Path], *filepaths: Union[str, Path]) -> str:
+        pass
+
+    @abstractmethod
+    @contextmanager
+    def get_local_path(self, filepath: Union[str, Path]) -> Generator[Union[str, Path], None, None]:
+        pass
+
+    @abstractmethod
+    def copyfile(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        pass
+
+    @abstractmethod
+    def copytree(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        pass
+
+    @abstractmethod
+    def copyfile_from_local(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        pass
+
+    @abstractmethod
+    def copytree_from_local(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        pass
+
+    @abstractmethod
+    def copyfile_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+        dst_type: str,  # Choose from ["file", "dir"]
+    ) -> Union[str, Path]:
+        pass
+
+    @abstractmethod
+    def copytree_to_local(self, src: Union[str, Path], dst: Union[str, Path]) -> Union[str, Path]:
+        pass
+
+    @abstractmethod
+    def remove(self, filepath: Union[str, Path]) -> None:
+        pass
+
+    @abstractmethod
+    def rmtree(self, dir_path: Union[str, Path]) -> None:
+        pass
+
+    @abstractmethod
+    def copy_if_symlink_fails(self, src: Union[str, Path], dst: Union[str, Path]) -> bool:
+        pass
+
+    @abstractmethod
+    def list_dir(self, dir_path: Union[str, Path]) -> Generator[str, None, None]:
+        pass
+
+    @abstractmethod
+    def list_dir_or_file(  # pylint: disable=too-many-arguments
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        pass

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/boto3_backend.py

@@ -0,0 +1,866 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import os
+import re
+import tempfile
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from shutil import SameFileError
+from typing import Optional, Union
+
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import (
+    BaseStorageBackend,
+    has_method,
+    mkdir_or_exist,
+)
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.boto3_client import Boto3Client
+
+
+class Boto3Backend(BaseStorageBackend):
+    """boto3 storage backend (for internal usage).
+
+    **Deprecated**. Use the MSC backend instead.
+
+    Boto3Backend supports reading and writing data to multiple clusters.
+    If the file path contains the cluster name, Boto3Backend will read data
+    from specified cluster or write data to it. Otherwise, Boto3Backend will
+    access the default cluster.
+
+    Args:
+        path_mapping (dict, optional): Path mapping dict from local path to
+            Boto3 path. When ``path_mapping={'src': 'dst'}``, ``src`` in
+            ``filepath`` will be replaced by ``dst``. Defaults to None.
+        s3_credential_path (str, optional): Config path of Boto3 client. Default: None.
+            `New in version 0.3.3`.
+
+    Examples:
+        >>> backend = Boto3Backend()
+        >>> filepath1 = 's3://path/of/file'
+        >>> filepath2 = 'cluster-name:s3://path/of/file'
+        >>> backend.get(filepath1)  # get data from default cluster
+        >>> client.get(filepath2)  # get data from 'cluster-name' cluster
+    """
+
+    def __init__(
+        self,
+        s3_credential_path: str = "",
+        path_mapping: Optional[dict] = None,
+    ):
+        self._client = Boto3Client(s3_credential_path=s3_credential_path)
+        assert isinstance(path_mapping, dict) or path_mapping is None
+        self.path_mapping = path_mapping
+        if path_mapping:
+            for k, v in path_mapping.items():
+                log.critical(f"Path mapping: {k} -> {v}", rank0_only=False)
+
+    def _map_path(self, filepath: Union[str, Path]) -> str:
+        """Map ``filepath`` to a string path whose prefix will be replaced by
+        :attr:`self.path_mapping`.
+
+        Args:
+            filepath (str or Path): Path to be mapped.
+        """
+        filepath = str(filepath)
+        if self.path_mapping is not None:
+            for k, v in self.path_mapping.items():
+                filepath = filepath.replace(k, v, 1)
+        return filepath
+
+    def _format_path(self, filepath: str) -> str:
+        """Convert a ``filepath`` to standard format of s3 oss.
+
+        If the ``filepath`` is concatenated by ``os.path.join``, in a Windows
+        environment, the ``filepath`` will be the format of
+        's3://bucket_name\\image.jpg'. By invoking :meth:`_format_path`, the
+        above ``filepath`` will be converted to 's3://bucket_name/image.jpg'.
+
+        Args:
+            filepath (str): Path to be formatted.
+        """
+        return re.sub(r"\\+", "/", filepath)
+
+    def _replace_prefix(self, filepath: Union[str, Path]) -> str:
+        filepath = str(filepath)
+        return filepath
+        # return filepath.replace('s3://', 's3://')
+
+    def size(self, filepath: Union[str, Path]) -> int:
+        """Get the file size in bytes for a given ``filepath``.
+
+        Args:
+            filepath (str or Path): Path to get file size in bytes.
+
+        Returns:
+            int: File size in bytes for filepath.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.size(filepath)  # file containing 'hello world'
+            11
+        """
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        return self._client.size(filepath)
+
+    def get(self, filepath: Union[str, Path], offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        """Read bytes from a given ``filepath`` with 'rb' mode in range [offset, offset + size).
+
+        Args:
+            filepath (str or Path): Path to read data.
+            offset (int, optional): Read offset in bytes (0-index). Defaults to 0.
+            size (int, optional): Read size in bytes. Defaults to the file size.
+
+        Returns:
+            bytes: Return bytes read from filepath.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.get(filepath)
+            b'hello world'
+        """
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        value = self._client.get(filepath=filepath, offset=offset, size=size)
+        return value
+
+    def get_text(
+        self,
+        filepath: Union[str, Path],
+        encoding: str = "utf-8",
+    ) -> str:
+        """Read text from a given ``filepath`` with 'r' mode.
+
+        Args:
+            filepath (str or Path): Path to read data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Returns:
+            str: Expected text reading from ``filepath``.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.get_text(filepath)
+            'hello world'
+        """
+        return str(self.get(filepath), encoding=encoding)
+
+    def put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path]) -> None:
+        """Write bytes to a given ``filepath``.
+
+        Args:
+            obj (bytes): Data to be saved.
+            filepath (str or Path): Path to write data.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.put(b'hello world', filepath)
+        """
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        self._client.put(obj, filepath)
+
+    def fast_put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path], num_processes: int = 32) -> None:
+        """Write bytes to a given ``filepath`` with multiple processes and async"""
+        assert num_processes > 1
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        self._client.fast_put(obj, filepath, num_processes=num_processes)
+
+    def put_text(
+        self,
+        obj: str,
+        filepath: Union[str, Path],
+        encoding: str = "utf-8",
+    ) -> None:
+        """Write text to a given ``filepath``.
+
+        Args:
+            obj (str): Data to be written.
+            filepath (str or Path): Path to write data.
+            encoding (str): The encoding format used to encode the ``obj``.
+                Defaults to 'utf-8'.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.put_text('hello world', filepath)
+        """
+        self.put(bytes(obj, encoding=encoding), filepath)
+
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path exists.
+
+        Args:
+            filepath (str or Path): Path to be checked whether exists.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` exists, ``False`` otherwise.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.exists(filepath)
+            True
+        """
+        if not (has_method(self._client, "contains") and has_method(self._client, "isdir")):
+            raise NotImplementedError(
+                "Current version of Boto3 Python SDK has not supported "
+                "the `contains` and `isdir` methods, please use a higher"
+                "version or dev branch instead."
+            )
+
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        return self._client.contains(filepath) or self._client.isdir(filepath)
+
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a directory.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a
+                directory.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a directory,
+            ``False`` otherwise.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/dir'
+            >>> backend.isdir(filepath)
+            True
+        """
+        if not has_method(self._client, "isdir"):
+            raise NotImplementedError(
+                "Current version of Boto3 Python SDK has not supported "
+                "the `isdir` method, please use a higher version or dev"
+                " branch instead."
+            )
+
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        return self._client.isdir(filepath)
+
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a file.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a file.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a file, ``False``
+            otherwise.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.isfile(filepath)
+            True
+        """
+        if not has_method(self._client, "contains"):
+            raise NotImplementedError(
+                "Current version of Boto3 Python SDK has not supported "
+                "the `contains` method, please use a higher version or "
+                "dev branch instead."
+            )
+
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        return self._client.contains(filepath)
+
+    def join_path(
+        self,
+        filepath: Union[str, Path],
+        *filepaths: Union[str, Path],
+    ) -> str:
+        r"""Concatenate all file paths.
+
+        Join one or more filepath components intelligently. The return value
+        is the concatenation of filepath and any members of \*filepaths.
+
+        Args:
+            filepath (str or Path): Path to be concatenated.
+
+        Returns:
+            str: The result after concatenation.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.join_path(filepath, 'another/path')
+            's3://path/of/file/another/path'
+            >>> backend.join_path(filepath, '/another/path')
+            's3://path/of/file/another/path'
+        """
+        filepath = self._format_path(self._map_path(filepath))
+        if filepath.endswith("/"):
+            filepath = filepath[:-1]
+        formatted_paths = [filepath]
+        for path in filepaths:
+            formatted_path = self._format_path(self._map_path(path))
+            formatted_paths.append(formatted_path.lstrip("/"))
+
+        return "/".join(formatted_paths)
+
+    @contextmanager
+    def get_local_path(
+        self,
+        filepath: Union[str, Path],
+    ) -> Generator[Union[str, Path], None, None]:
+        """Download a file from ``filepath`` to a local temporary directory,
+        and return the temporary path.
+
+        ``get_local_path`` is decorated by :meth:`contxtlib.contextmanager`. It
+        can be called with ``with`` statement, and when exists from the
+        ``with`` statement, the temporary path will be released.
+
+        Args:
+            filepath (str or Path): Download a file from ``filepath``.
+
+        Yields:
+            Iterable[str]: Only yield one temporary path.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> # After existing from the ``with`` clause,
+            >>> # the path will be removed
+            >>> filepath = 's3://path/of/file'
+            >>> with backend.get_local_path(filepath) as path:
+            ...     # do something here
+        """
+        assert self.isfile(filepath)
+        try:
+            f = tempfile.NamedTemporaryFile(delete=False)
+            f.write(self.get(filepath))
+            f.close()
+            yield f.name
+        finally:
+            os.remove(f.name)
+
+    def copyfile(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Copy a file src to dst and return the destination file.
+
+        src and dst should have the same prefix. If dst specifies a directory,
+        the file will be copied into dst using the base filename from src. If
+        dst specifies a file that already exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to dst.
+
+        Returns:
+            str: The destination file.
+
+        Raises:
+            SameFileError: If src and dst are the same file, a SameFileError
+                will be raised.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> # dst is a file
+            >>> src = 's3://path/of/file'
+            >>> dst = 's3://path/of/file1'
+            >>> backend.copyfile(src, dst)
+            's3://path/of/file1'
+
+            >>> # dst is a directory
+            >>> dst = 's3://path/of/dir'
+            >>> backend.copyfile(src, dst)
+            's3://path/of/dir/file'
+        """
+        src = self._format_path(self._map_path(src))
+        dst = self._format_path(self._map_path(dst))
+        if self.isdir(dst):
+            dst = self.join_path(dst, src.split("/")[-1])
+
+        if src == dst:
+            raise SameFileError("src and dst should not be same")
+
+        self.put(self.get(src), dst)
+        return dst
+
+    def copytree(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory.
+
+        src and dst should have the same prefix.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to dst.
+            backend_args (dict, optional): Arguments to instantiate the
+                prefix of uri corresponding backend. Defaults to None.
+
+        Returns:
+            str: The destination directory.
+
+        Raises:
+            FileExistsError: If dst had already existed, a FileExistsError will
+                be raised.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> src = 's3://path/of/dir'
+            >>> dst = 's3://path/of/dir1'
+            >>> backend.copytree(src, dst)
+            's3://path/of/dir1'
+        """
+        src = self._format_path(self._map_path(src))
+        dst = self._format_path(self._map_path(dst))
+
+        if self.exists(dst):
+            raise FileExistsError("dst should not exist")
+
+        for path in self.list_dir_or_file(src, list_dir=False, recursive=True):
+            src_path = self.join_path(src, path)
+            dst_path = self.join_path(dst, path)
+            self.put(self.get(src_path), dst_path)
+
+        return dst
+
+    def copyfile_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Upload a local file src to dst and return the destination file.
+
+        Args:
+            src (str or Path): A local file to be copied.
+            dst (str or Path): Copy file to dst.
+            backend_args (dict, optional): Arguments to instantiate the
+                prefix of uri corresponding backend. Defaults to None.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> # dst is a file
+            >>> src = 'path/of/your/file'
+            >>> dst = 's3://path/of/file1'
+            >>> backend.copyfile_from_local(src, dst)
+            's3://path/of/file1'
+
+            >>> # dst is a directory
+            >>> dst = 's3://path/of/dir'
+            >>> backend.copyfile_from_local(src, dst)
+            's3://path/of/dir/file'
+        """
+        dst = self._format_path(self._map_path(dst))
+        if self.isdir(dst):
+            dst = self.join_path(dst, os.path.basename(src))
+
+        with open(src, "rb") as f:
+            self.put(f.read(), dst)
+
+        return dst
+
+    def copytree_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A local directory to be copied.
+            dst (str or Path): Copy directory to dst.
+
+        Returns:
+            str: The destination directory.
+
+        Raises:
+            FileExistsError: If dst had already existed, a FileExistsError will
+                be raised.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> src = 'path/of/your/dir'
+            >>> dst = 's3://path/of/dir1'
+            >>> backend.copytree_from_local(src, dst)
+            's3://path/of/dir1'
+        """
+        dst = self._format_path(self._map_path(dst))
+        if self.exists(dst):
+            raise FileExistsError("dst should not exist")
+
+        src = str(src)
+
+        for cur_dir, _, files in os.walk(src):
+            for f in files:
+                src_path = os.path.join(cur_dir, f)
+                dst_path = self.join_path(dst, src_path.replace(src, ""))
+                self.copyfile_from_local(src_path, dst_path)
+
+        return dst
+
+    def copyfile_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+        dst_type: str,  # Choose from ["file", "dir"]
+    ) -> Union[str, Path]:
+        """Copy the file src to local dst and return the destination file.
+
+        If dst specifies a directory, the file will be copied into dst using
+        the base filename from src. If dst specifies a file that already
+        exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to to local dst.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> # dst is a file
+            >>> src = 's3://path/of/file'
+            >>> dst = 'path/of/your/file'
+            >>> backend.copyfile_to_local(src, dst)
+            'path/of/your/file'
+
+            >>> # dst is a directory
+            >>> dst = 'path/of/your/dir'
+            >>> backend.copyfile_to_local(src, dst)
+            'path/of/your/dir/file'
+        """
+        assert dst_type in ["file", "dir"]
+        # There is no good way to detect whether dst is a directory or a file, so we make dst_type required
+        if dst_type == "dir":
+            basename = os.path.basename(src)
+            if isinstance(dst, str):
+                dst = os.path.join(dst, basename)
+            else:
+                assert isinstance(dst, Path)
+                dst = dst / basename
+
+        # Create parent directory if it doesn't exist
+        parent_dir = os.path.dirname(dst)
+        os.makedirs(parent_dir, exist_ok=True)
+
+        try:
+            with open(dst, "wb") as f:
+                data = self.get(src)
+                f.write(data)
+        except Exception as e:
+            log.error(f"Failed to write file: {e}")
+            raise
+
+        return dst
+
+    def copytree_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> Union[str, Path]:
+        """Recursively copy an entire directory tree rooted at src to a local
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to local dst.
+            backend_args (dict, optional): Arguments to instantiate the
+                prefix of uri corresponding backend. Defaults to None.
+
+        Returns:
+            str: The destination directory.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> src = 's3://path/of/dir'
+            >>> dst = 'path/of/your/dir'
+            >>> backend.copytree_to_local(src, dst)
+            'path/of/your/dir'
+        """
+        for path in self.list_dir_or_file(src, list_dir=False, recursive=True):
+            dst_path = os.path.join(dst, path)
+            mkdir_or_exist(os.path.dirname(dst_path))
+            with open(dst_path, "wb") as f:
+                f.write(self.get(self.join_path(src, path)))
+
+        return dst
+
+    def remove(self, filepath: Union[str, Path]) -> None:
+        """Remove a file.
+
+        Args:
+            filepath (str or Path): Path to be removed.
+
+        Raises:
+            FileNotFoundError: If filepath does not exist, an FileNotFoundError
+                will be raised.
+            IsADirectoryError: If filepath is a directory, an IsADirectoryError
+                will be raised.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> filepath = 's3://path/of/file'
+            >>> backend.remove(filepath)
+        """
+        if not has_method(self._client, "delete"):
+            raise NotImplementedError(
+                "Current version of Boto3 Python SDK has not supported "
+                "the `delete` method, please use a higher version or dev "
+                "branch instead."
+            )
+
+        if not self.exists(filepath):
+            raise FileNotFoundError(f"filepath {filepath} does not exist")
+
+        if self.isdir(filepath):
+            raise IsADirectoryError("filepath should be a file")
+
+        filepath = self._map_path(filepath)
+        filepath = self._format_path(filepath)
+        filepath = self._replace_prefix(filepath)
+        self._client.delete(filepath)
+
+    def rmtree(self, dir_path: Union[str, Path]) -> None:
+        """Recursively delete a directory tree.
+
+        Args:
+            dir_path (str or Path): A directory to be removed.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> dir_path = 's3://path/of/dir'
+            >>> backend.rmtree(dir_path)
+        """
+        for path in self.list_dir_or_file(dir_path, list_dir=False, recursive=True):
+            filepath = self.join_path(dir_path, path)
+            self.remove(filepath)
+
+    def copy_if_symlink_fails(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> bool:
+        """Create a symbolic link pointing to src named dst.
+
+        Directly copy src to dst because PetrelBacekend does not support create
+        a symbolic link.
+
+        Args:
+            src (str or Path): A file or directory to be copied.
+            dst (str or Path): Copy a file or directory to dst.
+            backend_args (dict, optional): Arguments to instantiate the
+                prefix of uri corresponding backend. Defaults to None.
+
+        Returns:
+            bool: Return False because Boto3Backend does not support create
+            a symbolic link.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> src = 's3://path/of/file'
+            >>> dst = 's3://path/of/your/file'
+            >>> backend.copy_if_symlink_fails(src, dst)
+            False
+            >>> src = 's3://path/of/dir'
+            >>> dst = 's3://path/of/your/dir'
+            >>> backend.copy_if_symlink_fails(src, dst)
+            False
+        """
+        if self.isfile(src):
+            self.copyfile(src, dst)
+        else:
+            self.copytree(src, dst)
+        return False
+
+    def list_dir(self, dir_path: Union[str, Path]):
+        """List all folders in an S3 bucket with a given prefix.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> dir_path = 's3://path/of/dir'
+            >>> backend.list_dir(dir_path)
+        """
+        dir_path = self._map_path(dir_path)
+        dir_path = self._format_path(dir_path)
+        dir_path = self._replace_prefix(dir_path)
+        return self._client.ls_dir(dir_path)
+
+    def list_dir_or_file(  # pylint: disable=too-many-arguments
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        """Scan a directory to find the interested directories or files in
+        arbitrary order.
+
+        Note:
+            Boto3 has no concept of directories but it simulates the directory
+            hierarchy in the filesystem through public prefixes. In addition,
+            if the returned path ends with '/', it means the path is a public
+            prefix which is a logical directory.
+
+        Note:
+            :meth:`list_dir_or_file` returns the path relative to ``dir_path``.
+            In addition, the returned path of directory will not contains the
+            suffix '/' which is consistent with other backends.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+            list_dir (bool): List the directories. Defaults to True.
+            list_file (bool): List the path of files. Defaults to True.
+            suffix (str or tuple[str], optional):  File suffix
+                that we are interested in. Defaults to None.
+            recursive (bool): If set to True, recursively scan the
+                directory. Defaults to False.
+
+        Yields:
+            Iterable[str]: A relative path to ``dir_path``.
+
+        Examples:
+            >>> backend = Boto3Backend()
+            >>> dir_path = 's3://path/of/dir'
+            >>> # list those files and directories in current directory
+            >>> for file_path in backend.list_dir_or_file(dir_path):
+            ...     print(file_path)
+            >>> # only list files
+            >>> for file_path in backend.list_dir_or_file(dir_path, list_dir=False):
+            ...     print(file_path)
+            >>> # only list directories
+            >>> for file_path in backend.list_dir_or_file(dir_path, list_file=False):
+            ...     print(file_path)
+            >>> # only list files ending with specified suffixes
+            >>> for file_path in backend.list_dir_or_file(dir_path, suffix='.txt'):
+            ...     print(file_path)
+            >>> # list all files and directory recursively
+            >>> for file_path in backend.list_dir_or_file(dir_path, recursive=True):
+            ...     print(file_path)
+        """  # noqa: E501
+        if not has_method(self._client, "list"):
+            raise NotImplementedError(
+                "Current version of Boto3 Python SDK has not supported "
+                "the `list` method, please use a higher version or dev"
+                " branch instead."
+            )
+
+        dir_path = self._map_path(dir_path)
+        dir_path = self._format_path(dir_path)
+        dir_path = self._replace_prefix(dir_path)
+        if list_dir and suffix is not None:
+            raise TypeError("`list_dir` should be False when `suffix` is not None")
+
+        if list_dir and not list_file and not recursive:
+            raise TypeError(
+                "Please use `list_dir` instead of `list_dir_or_file` when you only want to list the first level directories."
+            )
+
+        if (suffix is not None) and not isinstance(suffix, (str, tuple)):
+            raise TypeError("`suffix` must be a string or tuple of strings")
+
+        # Boto3's simulated directory hierarchy assumes that directory paths
+        # should end with `/`
+        if not dir_path.endswith("/"):
+            dir_path += "/"
+
+        root = dir_path
+
+        def _list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive):
+            # Keep track of directories we've already yielded to avoid duplicates
+            yielded_dirs = set() if list_dir else None
+
+            for path in self._client.list(dir_path):
+                # All paths returned by S3 list are file paths, never directory paths
+                absolute_path = self.join_path(dir_path, path)
+                rel_path = absolute_path[len(root) :]
+
+                # If we want directories, extract directory prefixes from file paths
+                # boto3 client actually never return dir, it only return file paths
+                if list_dir and "/" in rel_path:
+                    if not recursive:
+                        # Non-recursive: only yield immediate child directory (first level)
+                        first_slash_pos = rel_path.find("/")
+                        immediate_child_dir = rel_path[:first_slash_pos]
+
+                        if immediate_child_dir not in yielded_dirs:
+                            yielded_dirs.add(immediate_child_dir)
+                            yield immediate_child_dir
+                    else:
+                        # Recursive: yield all directory levels
+                        path_parts = rel_path.split("/")[:-1]  # Exclude filename
+                        current_dir = ""
+                        for part in path_parts:
+                            if current_dir:
+                                current_dir += "/" + part
+                            else:
+                                current_dir = part
+
+                            if current_dir not in yielded_dirs:
+                                yielded_dirs.add(current_dir)
+                                yield current_dir
+
+                # Handle file listing
+                if (suffix is None or rel_path.endswith(suffix)) and list_file:
+                    yield rel_path
+
+        return _list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive)
+
+    def generate_presigned_url(self, url: str, client_method: str = "get_object", expires_in: int = 3600) -> str:
+        """Generate the presigned url of video stream which can be passed to
+        mmcv.VideoReader. Now only work on Boto3 backend.
+
+        Note:
+            Now only work on Boto3 backend.
+
+        Args:
+            url (str): Url of video stream.
+            client_method (str): Method of client, 'get_object' or
+                'put_object'. Default: 'get_object'.
+            expires_in (int): expires, in seconds. Default: 3600.
+
+        Returns:
+            str: Generated presigned url.
+        """
+        raise NotImplementedError("generate_presigned_url is not supported in Boto3Backend")
+        return self._client.generate_presigned_url(url, client_method, expires_in)

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/boto3_client.py

@@ -0,0 +1,640 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import concurrent.futures
+import io
+import os
+import time
+from collections.abc import Generator
+from math import ceil
+from multiprocessing import shared_memory
+from typing import Any, Optional
+
+import boto3
+import numpy as np
+from botocore.config import Config as S3Config
+from botocore.exceptions import ClientError
+
+import cosmos_policy._src.imaginaire.utils.easy_io.backends.auto_auth as auto
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.env_parsers.cred_env_parser import CRED_ENVS
+
+try:
+    # pyrefly: ignore  # import-error
+    import aioboto3
+
+    # pyrefly: ignore  # import-error
+    import aioboto3.session
+
+    # pyrefly: ignore  # import-error
+    from aiobotocore.config import AioConfig
+
+    # pyrefly: ignore  # import-error
+    from aiobotocore.session import AioSession
+except ImportError:
+    aioboto3 = None
+    AioSession = None
+
+MAX_RETRIES = 5
+RETRY_DELAY = 1  # seconds
+
+
+async def upload_single_part_async(
+    s3: AioSession, bucket: str, key: str, part_number: int, data: bytes, upload_id: str
+) -> dict[str, Any]:
+    """
+    Uploads a single part of a file asynchronously to S3.
+
+    Args:
+        s3 (S3): The S3 client.
+        bucket (str): The S3 bucket name.
+        key (str): The S3 key (file path).
+        part_number (int): The part number of the upload.
+        data (bytes): The data to upload.
+        upload_id (str): The upload ID for the multipart upload.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the part number and ETag.
+    """
+    for attempt in range(MAX_RETRIES):
+        try:
+            response = await s3.upload_part(
+                Bucket=bucket, Key=key, PartNumber=part_number, UploadId=upload_id, Body=data
+            )
+            return {"PartNumber": part_number, "ETag": response["ETag"]}
+        except (ClientError, asyncio.TimeoutError, Exception) as e:
+            log.warning(f"Attempt {attempt + 1} failed for part {part_number}: {str(e)}", rank0_only=False)
+            if attempt < MAX_RETRIES - 1:
+                await asyncio.sleep(RETRY_DELAY * (2**attempt))  # Exponential backoff
+            else:
+                log.error(f"Failed to upload part {part_number} after {MAX_RETRIES} attempts", rank0_only=False)
+                raise
+
+
+async def upload_parts_async(
+    part_size: int,
+    part_numbers: range,
+    upload_id: str,
+    data: bytes,
+    bucket: str,
+    key: str,
+    client_config: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """
+    Uploads multiple parts of a file asynchronously to S3.
+
+    Args:
+        part_size (int): The size of each part in bytes.
+        part_numbers (range): The range of part numbers to upload.
+        upload_id (str): The upload ID for the multipart upload.
+        data (bytes): The data to upload.
+        bucket (str): The S3 bucket name.
+        key (str): The S3 key (file path).
+        client_config (dict[str, Any]): The S3 client configuration.
+
+    Returns:
+        list[dict[str, Any]]: A list of dictionaries containing part numbers and ETags.
+    """
+    session = aioboto3.Session()
+    config = AioConfig(retries={"max_attempts": 3, "mode": "adaptive"}, connect_timeout=5, read_timeout=10)
+    start_idx = part_numbers[0]
+    async with session.client("s3", config=config, **client_config) as s3:
+        tasks = []
+        for part_number in part_numbers:
+            start = (part_number - start_idx) * part_size
+            end = min(start + part_size, len(data))
+            part_data = data[start:end]
+            tasks.append(upload_single_part_async(s3, bucket, key, part_number + 1, part_data, upload_id))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        successful_parts = []
+        failed_parts = []
+        for part_number, result in enumerate(results, start=start_idx + 1):
+            if isinstance(result, Exception):
+                failed_parts.append(part_number)
+            else:
+                successful_parts.append(result)
+
+        if failed_parts:
+            log.error(f"Failed to upload parts: {failed_parts}", rank0_only=False)
+            raise Exception(f"Failed to upload {len(failed_parts)} parts")
+
+        successful_parts.sort(key=lambda part: part["PartNumber"])
+        return successful_parts
+
+
+def upload_parts_to_s3(args: tuple[range, str, int, bytes, str, str, dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    Uploads parts of a file to S3 using a new event loop.
+
+    Args:
+        args (tuple[range, str, int, bytes, str, str, dict[str, Any]]): The arguments for uploading parts, including:
+            part_numbers (range): The range of part numbers to upload.
+            upload_id (str): The upload ID for the multipart upload.
+            part_size (int): The size of each part in bytes.
+            data (bytes): The data to upload.
+            bucket (str): The S3 bucket name.
+            key (str): The S3 key (file path).
+            client_config (dict[str, Any]): The S3 client configuration.
+
+    Returns:
+        list[dict[str, Any]]: A list of dictionaries containing part numbers and ETags.
+    """
+    part_numbers, upload_id, part_size, data, bucket, key, client_config = args
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    parts = loop.run_until_complete(
+        upload_parts_async(part_size, part_numbers, upload_id, data, bucket, key, client_config)
+    )
+    loop.close()
+    return parts
+
+
+async def download_single_part_async(
+    s3, bucket: str, key: str, part_number: int, start: int, end: int, shm_name: str, part_size: int
+) -> None:
+    """
+    Downloads a single part of a file asynchronously and writes it to shared memory.
+
+    Args:
+        s3 (S3): The S3 client.
+        bucket (str): The S3 bucket name.
+        key (str): The S3 key (file path).
+        part_number (int): The part number.
+        start (int): The start byte of the part.
+        end (int): The end byte of the part.
+        shm_name (str): The name of the shared memory block.
+        part_size (int): The size of each part in bytes.
+    """
+    for attempt in range(MAX_RETRIES):
+        try:
+            range_header = f"bytes={start}-{end}"
+            response = await s3.get_object(Bucket=bucket, Key=key, Range=range_header)
+            data = await response["Body"].read()
+
+            shm = shared_memory.SharedMemory(name=shm_name)
+            offset = part_number * part_size
+            shm.buf[offset : offset + len(data)] = data
+            shm.close()
+            return
+        except (ClientError, asyncio.TimeoutError, Exception) as e:
+            log.warning(f"Attempt {attempt + 1} failed for part {part_number}: {str(e)}", rank0_only=False)
+            if attempt < MAX_RETRIES - 1:
+                await asyncio.sleep(RETRY_DELAY * (2**attempt))  # Exponential backoff
+            else:
+                log.error(f"Failed to download part {part_number} after {MAX_RETRIES} attempts", rank0_only=False)
+                raise
+
+
+async def download_parts_async(
+    part_size: int, part_numbers: range, bucket: str, key: str, client_config: dict[str, Any], shm_name: str
+) -> None:
+    """
+    Downloads multiple parts of a file asynchronously and writes them to shared memory.
+
+    Args:
+        part_size (int): The size of each part in bytes.
+        part_numbers (range): The range of part numbers to download.
+        bucket (str): The S3 bucket name.
+        key (str): The S3 key (file path).
+        client_config (dict[str, Any]): The S3 client configuration.
+        shm_name (str): The name of the shared memory block.
+    """
+    session = aioboto3.Session()
+    config = AioConfig(retries={"max_attempts": 5, "mode": "adaptive"}, connect_timeout=10, read_timeout=30)
+    async with session.client("s3", config=config, **client_config) as s3:
+        tasks = [
+            download_single_part_async(
+                s3,
+                bucket,
+                key,
+                part_number,
+                part_number * part_size,
+                (part_number + 1) * part_size - 1,
+                shm_name,
+                part_size,
+            )
+            for part_number in part_numbers
+        ]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        failed_parts = [part for part, result in zip(part_numbers, results) if isinstance(result, Exception)]
+
+        if failed_parts:
+            log.error(f"Failed to download parts: {failed_parts}", rank0_only=False)
+            raise Exception(f"Failed to download {len(failed_parts)} parts")
+
+
+def download_parts_to_s3(args: tuple[range, int, str, str, dict[str, Any], str]) -> bytes:
+    """
+    Downloads parts of a file using a new event loop.
+
+    Args:
+        args (tuple[range, int, str, str, dict[str, Any]]): The arguments for downloading parts, including:
+            part_numbers (range): The range of part numbers to download.
+            part_size (int): The size of each part in bytes.
+            bucket (str): The S3 bucket name.
+            key (str): The S3 key (file path).
+            client_config (dict[str, Any]): The S3 client configuration.
+
+    Returns:
+        bytes: The combined file data from all downloaded parts.
+    """
+    part_numbers, part_size, bucket, key, client_config, shm_name = args
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(download_parts_async(part_size, part_numbers, bucket, key, client_config, shm_name))
+    loop.close()
+
+
+class Boto3Client:
+    """
+    This class:
+
+    - Provides higher-level S3 operations.
+    - Serves as a wrapper around boto3.client in order to make boto3.client serializable.
+        - It's required to use spawn method of creating DataLoader workers,
+          which is in turn required to avoid segfaults when using Triton,
+          e.g. for torch.compile or custom kernels.
+    """
+
+    def __init__(
+        self,
+        s3_credential_path: str,
+        max_attempt: int = 3,
+    ):
+        self.max_attempt: int = max_attempt
+        assert s3_credential_path, "s3_credential_path is required"
+        assert os.path.exists(s3_credential_path) or CRED_ENVS.APP_ENV in [
+            "prod",
+            "dev",
+            "stg",
+        ], f"Credential file not found: {s3_credential_path}"
+
+        # Keep track of S3 client constructor parameters so it can be recreated when pickling.
+        with auto.open_auth(s3_credential_path, "r") as f:
+            self._s3_cred_info = auto.json_load_auth(f)
+        self._s3_config = S3Config(
+            signature_version="s3v4",
+            s3={"addressing_style": "virtual"},
+            response_checksum_validation="when_required",
+            request_checksum_calculation="when_required",
+        )
+        self._init_client()
+        self._mc_kv_store = None
+
+    def _init_client(self):
+        """Initialize the S3 client."""
+        self._client = boto3.client("s3", **self._s3_cred_info, config=self._s3_config)
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # S3 client isn't pickleable.
+        del state["_client"]
+        return state
+
+    def __setstate__(self, state: dict[str, Any]):
+        self.__dict__.update(state)
+        self._init_client()
+
+    def size(self, filepath: str) -> int:
+        filepath = self._check_path(filepath)
+
+        if self._mc_kv_store and self._mc_kv_store.available:
+            if self._mc_kv_store.has(filepath):
+                return len(self._mc_kv_store.get(filepath))
+
+        attempt: int = 0
+        while attempt < self.max_attempt:
+            try:
+                return self._client.head_object(
+                    Bucket=filepath.split("/")[0],
+                    Key="/".join(filepath.split("/")[1:]),
+                )["ContentLength"]
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "404":
+                    raise  # Object does not exist.
+                else:
+                    attempt += 1
+                    log.error(f"Attempt {attempt} failed for {filepath}: {e}", rank0_only=False)
+                    if attempt >= self.max_attempt:
+                        raise  # Re-raise the exception after max attempt
+                    time.sleep(2)  # Wait for 2 seconds before retrying
+            except Exception as e:
+                attempt += 1
+                log.error(f"Attempt {attempt} failed for {filepath}: due to an unexpected error: {e}", rank0_only=False)
+                if attempt >= self.max_attempt:
+                    raise  # Re-raise the exception after max attempt
+                time.sleep(2)  # Wait for 2 seconds before retrying
+
+        raise ConnectionError("Unable to head {} from. {} attempts tried.".format(filepath, attempt))
+
+    def get(self, filepath: str, offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        raw_filepath = filepath
+        filepath = self._check_path(filepath)
+
+        read_offset: Optional[int] = None
+        read_size: Optional[int] = None
+        byte_range: Optional[str] = None
+        if offset is not None or size is not None:
+            read_offset = offset or 0
+            assert read_offset >= 0, "Read offset must be ≥ 0"
+
+            # Try not to incur a remote call to get the file size. This can heavily slow down ranged reads.
+            #
+            # This means we won't always validate the read offset or read size against the file size.
+            read_size = size or (self.size(filepath=raw_filepath) - read_offset)
+            assert read_size >= 1, "Read size must be ≥ 1 or read offset must be < file size"
+
+            byte_range = f"bytes={read_offset}-{read_offset + read_size - 1}"
+
+        if self._mc_kv_store and self._mc_kv_store.available:
+            if self._mc_kv_store.has(filepath):
+                chunk: bytes = self._mc_kv_store.get(filepath)
+                if read_offset is not None and read_size is not None:
+                    return chunk[read_offset : read_offset + read_size]
+                else:
+                    return chunk
+
+        attempt = 0
+        while attempt < self.max_attempt:
+            try:
+                buffer = io.BytesIO()
+                if byte_range is None:
+                    self._client.download_fileobj(
+                        Bucket=filepath.split("/")[0],
+                        Key="/".join(filepath.split("/")[1:]),
+                        Fileobj=buffer,
+                    )
+                else:
+                    # The boto S3 Transfer Manager doesn't support ranged reads yet.
+                    #
+                    # https://github.com/boto/boto3/issues/1215
+                    # https://github.com/boto/s3transfer/issues/248
+                    resp = self._client.get_object(
+                        Bucket=filepath.split("/")[0],
+                        Key="/".join(filepath.split("/")[1:]),
+                        Range=byte_range,
+                    )
+                    buffer.write(resp["Body"].read())
+                buffer.seek(0)
+                # Only cache full reads.
+                if byte_range is None:
+                    if self._mc_kv_store and self._mc_kv_store.available:
+                        self._mc_kv_store.put(filepath, buffer.read())
+                        buffer.seek(0)
+
+                return buffer.read()
+            except Exception as e:
+                attempt += 1
+                log.error(f"Got an exception: attempt={attempt} - {e} - {filepath}", rank0_only=False)
+
+        raise ConnectionError("Unable to read {} from. {} attempts tried.".format(filepath, attempt))
+
+    def put(self, obj, filepath):
+        filepath = self._check_path(filepath)
+        bucket_name = filepath.split("/")[0]
+        key = "/".join(filepath.split("/")[1:])
+        attempt = 0
+        while attempt < self.max_attempt:
+            try:
+                # If obj is a string path to a local file, use upload_file instead
+                if isinstance(obj, str) and os.path.isfile(obj):
+                    self._client.upload_file(Filename=obj, Bucket=bucket_name, Key=key)
+                    return
+                if isinstance(obj, io.BytesIO):
+                    obj.seek(0)
+                    self._client.upload_fileobj(obj, Bucket=bucket_name, Key=key)
+                    return
+                if isinstance(obj, bytes):
+                    self._client.put_object(Body=obj, Bucket=bucket_name, Key=key)
+                    return
+                else:
+                    raise ValueError("Unsupported object type for upload")
+            except ClientError as e:
+                attempt += 1
+                log.error(f"Got an exception: attempt={attempt} - {e} - {filepath}", rank0_only=False)
+
+        raise ConnectionError("Unable to write {} to. {} attempts tried.".format(filepath, attempt))
+
+    def fast_put(self, obj, filepath, num_processes: int = 32):
+        assert aioboto3 is not None, "aioboto3 is required for fast_put"
+        original_filepath = filepath
+        filepath = self._check_path(filepath)
+        bucket = filepath.split("/")[0]
+        key = "/".join(filepath.split("/")[1:])
+        part_size = 16 * 1024 * 1024  # 16 MB part size
+
+        if isinstance(obj, bytes):
+            data = obj
+        elif isinstance(obj, str) and os.path.isfile(obj):
+            with open(obj, "rb") as f:
+                data = f.read()
+        elif isinstance(obj, io.BytesIO):
+            obj.seek(0)
+            data = obj.read()
+        else:
+            raise ValueError("Unsupported object type for upload")
+
+        file_size = len(data)
+        if file_size <= part_size * num_processes:
+            return self.put(data, original_filepath)
+        num_parts = ceil(file_size / part_size)
+        upload_id = self._client.create_multipart_upload(Bucket=bucket, Key=key)["UploadId"]
+
+        part_numbers = np.array_split(np.arange(num_parts), num_processes)
+
+        with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
+            args = []
+            for i in range(num_processes):
+                cur_parts = part_numbers[i].tolist()
+                cur_data = data[cur_parts[0] * part_size : min(cur_parts[-1] * part_size + part_size, file_size)]
+                args.append((cur_parts, upload_id, part_size, cur_data, bucket, key, self._s3_cred_info))
+            results = executor.map(upload_parts_to_s3, args)
+            parts = []
+            for result in results:
+                parts.extend(result)
+
+        parts = sorted(parts, key=lambda part: part["PartNumber"])
+        self._client.complete_multipart_upload(
+            Bucket=bucket, Key=key, UploadId=upload_id, MultipartUpload={"Parts": parts}
+        )
+
+    def contains(self, filepath: str, max_retries=10) -> bool:
+        """
+        Checks if the specified object exists in the S3 bucket with retry logic for errors.
+
+        Args:
+            filepath (str): The s3 path of the file to check, must start with "s3://".
+
+        Returns:
+            bool: True if the object exists in the S3 bucket, False otherwise.
+
+        Raises:
+            ClientError: If an error response other than "404 Not Found" is returned from the S3 service.
+        """
+        filepath = self._check_path(filepath)
+        bucket = filepath.split("/")[0]
+        key = "/".join(filepath.split("/")[1:])
+
+        retries = 0
+        while retries < max_retries:
+            try:
+                # Try to check if the object exists
+                self._client.head_object(Bucket=bucket, Key=key)
+                return True  # Object exists
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "404":
+                    return False  # Object does not exist
+                else:
+                    retries += 1
+                    print(f"Attempt {retries} failed with error: {e}")
+                    if retries >= max_retries:
+                        raise  # Re-raise the exception if max retries are reached
+                    time.sleep(2)  # Wait for 2 seconds before retrying
+            except Exception as e:
+                retries += 1
+                print(f"Attempt {retries} failed due to an unexpected error: {e}")
+                if retries >= max_retries:
+                    raise  # Re-raise the exception if max retries are reached
+                time.sleep(2)  # Wait for 2 seconds before retrying
+
+    def isdir(self, filepath: str, max_retries=10) -> bool:
+        """
+        Determines if the specified path corresponds to a directory in S3 with retry logic.
+
+        A directory in S3 is implied if there are any objects stored with the given prefix,
+        which means this function checks for the existence of any objects at or under the specified path.
+
+        Args:
+            filepath (str): The s3 path to check, must start with "s3://".
+
+        Returns:
+            bool: True if the specified path corresponds to a directory in S3, False otherwise.
+                Directories in S3 are not physical entities but are implied by object keys.
+
+        Raises:
+            ClientError: An error from the S3 API that isn't related to the absence of the directory
+                        (logged but not raised further).
+        """
+        filepath = self._check_path(filepath)
+        if not filepath.endswith("/"):
+            filepath += "/"
+
+        bucket = filepath.split("/")[0]
+        prefix = "/".join(filepath.split("/")[1:])
+
+        retries = 0
+        while retries < max_retries:
+            try:
+                # Try to check if any objects exist with the given prefix (i.e., directory in S3)
+                resp = self._client.list_objects_v2(Bucket=bucket, Prefix=prefix, Delimiter="/", MaxKeys=1)
+                # Check if any content or prefixes exist under the given path
+                return "CommonPrefixes" in resp or "Contents" in resp
+            except ClientError as e:
+                retries += 1
+                log.error(f"Attempt {retries} failed: {e}", rank0_only=False)
+                if retries >= max_retries:
+                    return False  # Return False if maximum retries are reached
+                time.sleep(2)  # Wait for 2 seconds before retrying
+            except Exception as e:
+                retries += 1
+                log.error(f"Attempt {retries} failed due to an unexpected error: {e}", rank0_only=False)
+                if retries >= max_retries:
+                    return False  # Return False if maximum retries are reached
+                time.sleep(2)  # Wait for 2 seconds before retrying
+
+    def delete(self, filepath):
+        filepath = self._check_path(filepath)
+        self._client.delete_object(Bucket=filepath.split("/")[0], Key="/".join(filepath.split("/")[1:]))
+
+    def ls_dir(self, filepath: str) -> Generator[str, None, None]:
+        """
+        List all folders in an S3 bucket with a given prefix.
+
+        Args:
+            filepath (str): The S3 path of the folder to list.
+
+        Yields:
+            str: The keys of the folders in the S3 bucket.
+        """
+        filepath = self._check_path(filepath)
+        bucket = filepath.split("/")[0]
+        prefix = "/".join(filepath.split("/")[1:])
+        continuation_token = None
+        if prefix and not prefix.endswith("/"):
+            prefix += "/"
+
+        while True:
+            if continuation_token:
+                resp = self._client.list_objects_v2(
+                    Bucket=bucket, Prefix=prefix, Delimiter="/", ContinuationToken=continuation_token
+                )
+            else:
+                resp = self._client.list_objects_v2(Bucket=bucket, Prefix=prefix, Delimiter="/")
+
+            if "CommonPrefixes" in resp:
+                for item in resp["CommonPrefixes"]:
+                    yield item["Prefix"][len(prefix) :]
+
+            # Check if there are more keys to retrieve
+            if resp.get("IsTruncated"):  # If IsTruncated is True, there are more keys
+                continuation_token = resp.get("NextContinuationToken")
+            else:
+                break
+
+    def list(self, filepath: str, exclude_prefix: Optional[str] = None) -> Generator[str, None, None]:
+        """
+        List all keys in an S3 bucket with a given prefix, excluding files that start with
+        specified prefix.
+
+        Args:
+            filepath (str): The S3 path of the file to list.
+            exclude_prefix (str): Files starting with this prefix will be excluded from results.
+                                Defaults to "real".
+
+        Yields:
+            str: The keys of the files in the S3 bucket that don't start with exclude_prefix.
+        """
+        filepath = self._check_path(filepath)
+        bucket = filepath.split("/")[0]
+        prefix = "/".join(filepath.split("/")[1:])
+
+        continuation_token = None
+
+        while True:
+            if continuation_token:
+                resp = self._client.list_objects_v2(Bucket=bucket, Prefix=prefix, ContinuationToken=continuation_token)
+            else:
+                resp = self._client.list_objects_v2(Bucket=bucket, Prefix=prefix)
+
+            if "Contents" in resp:
+                for item in resp["Contents"]:
+                    key = item["Key"][len(prefix) :]
+                    # Skip files that start with the excluded prefix
+                    if exclude_prefix is None or not key.startswith(exclude_prefix):
+                        yield key
+
+            # Check if there are more keys to retrieve
+            if resp.get("IsTruncated"):  # If IsTruncated is True, there are more keys
+                continuation_token = resp.get("NextContinuationToken")
+            else:
+                break
+
+    def _check_path(self, filepath: str):
+        assert filepath.startswith("s3://")
+        filepath = filepath[5:]
+        return filepath

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/http_backend.py

@@ -0,0 +1,198 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import os
+import tempfile
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional, Union
+from urllib.request import Request, urlopen
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import BaseStorageBackend
+
+
+class HTTPBackend(BaseStorageBackend):
+    """HTTP and HTTPS storage bachend."""
+
+    def size(self, filepath: Union[str, Path]) -> int:
+        """Get the file size in bytes for a given ``filepath``.
+
+        Args:
+            filepath (str or Path): Path to get file size in bytes.
+
+        Returns:
+            int: File size in bytes for filepath.
+
+        Examples:
+            >>> backend = HTTPBackend()
+            >>> filepath = 'http://path/of/file'
+            >>> backend.size(filepath)  # file containing 'hello world'
+            11
+        """
+        request = Request(url=str(filepath), method="HEAD")
+        with urlopen(request) as response:
+            if response.status == 200:
+                return int(response.headers["Content-Length"])
+            else:
+                raise RuntimeError(f"Unexpected response: {response}")
+
+    def get(self, filepath: Union[str, Path], offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        """Read bytes from a given ``filepath`` with 'rb' mode in range [offset, offset + size).
+
+        Args:
+            filepath (str): Path to read data.
+            offset (int, optional): Read offset in bytes (0-index). Defaults to 0.
+            size (int, optional): Read size in bytes. Defaults to the file size.
+
+        Returns:
+            bytes: Expected bytes object.
+
+        Examples:
+            >>> backend = HTTPBackend()
+            >>> backend.get('http://path/of/file')
+            b'hello world'
+        """
+        request = Request(url=str(filepath), method="GET")
+        if offset is not None or size is not None:
+            read_offset = offset or 0
+            assert read_offset >= 0, "Read offset must be ≥ 0"
+
+            # Try not to incur a remote call to get the file size. This can heavily slow down ranged reads.
+            #
+            # This means we won't always validate the read offset or read size against the file size.
+            read_size = size or (self.size(filepath=filepath) - read_offset)
+            assert read_size >= 1, "Read size must be ≥ 1 or read offset must be < file size"
+
+            request.add_header("Range", f"bytes={read_offset}-{read_offset + read_size - 1}")
+        with urlopen(request) as response:
+            if response.status in {200, 206}:
+                return response.read()
+            else:
+                raise RuntimeError(f"Unexpected response: {response}")
+
+    def get_text(self, filepath: Union[str, Path], encoding: str = "utf-8") -> str:
+        """Read text from a given ``filepath``.
+
+        Args:
+            filepath (str): Path to read data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Returns:
+            str: Expected text reading from ``filepath``.
+
+        Examples:
+            >>> backend = HTTPBackend()
+            >>> backend.get_text('http://path/of/file')
+            'hello world'
+        """
+        return self.get(filepath=filepath).decode(encoding)
+
+    def put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path]) -> None:
+        raise NotImplementedError(f"put not supported in {self.name}")
+
+    def put_text(self, obj: str, filepath: Union[str, Path], encoding: str = "utf-8") -> None:
+        raise NotImplementedError(f"put_text not supported in {self.name}")
+
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        request = Request(url=str(filepath), method="HEAD")
+        with urlopen(request) as response:
+            if response.status == 404:
+                return False
+            elif response.status == 200:
+                return True
+            else:
+                raise RuntimeError(f"Unexpected response: {response}")
+
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        raise NotImplementedError(f"isdir not supported in {self.name}")
+
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        raise NotImplementedError(f"isfile not supported in {self.name}")
+
+    def join_path(self, filepath: Union[str, Path], *filepaths: Union[str, Path]) -> str:
+        raise NotImplementedError(f"join_path not supported in {self.name}")
+
+    @contextmanager
+    def get_local_path(self, filepath: Union[str, Path]) -> Generator[Union[str, Path], None, None]:
+        """Download a file from ``filepath`` to a local temporary directory,
+        and return the temporary path.
+
+        ``get_local_path`` is decorated by :meth:`contxtlib.contextmanager`. It
+        can be called with ``with`` statement, and when exists from the
+        ``with`` statement, the temporary path will be released.
+
+        Args:
+            filepath (str): Download a file from ``filepath``.
+
+        Yields:
+            Iterable[str]: Only yield one temporary path.
+
+        Examples:
+            >>> backend = HTTPBackend()
+            >>> # After existing from the ``with`` clause,
+            >>> # the path will be removed
+            >>> with backend.get_local_path('http://path/of/file') as path:
+            ...     # do something here
+        """
+        try:
+            f = tempfile.NamedTemporaryFile(delete=False)
+            f.write(self.get(filepath))
+            f.close()
+            yield f.name
+        finally:
+            os.remove(f.name)
+
+    def copyfile(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        raise NotImplementedError(f"copyfile not supported in {self.name}")
+
+    def copytree(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        raise NotImplementedError(f"copytree not supported in {self.name}")
+
+    def copyfile_from_local(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        raise NotImplementedError(f"copyfile_from_local not supported in {self.name}")
+
+    def copytree_from_local(self, src: Union[str, Path], dst: Union[str, Path]) -> str:
+        raise NotImplementedError(f"copytree_from_local not supported in {self.name}")
+
+    def copyfile_to_local(self, src: Union[str, Path], dst: Union[str, Path], dst_type: str) -> Union[str, Path]:
+        raise NotImplementedError(f"copyfile_to_local not supported in {self.name}")
+
+    def copytree_to_local(self, src: Union[str, Path], dst: Union[str, Path]) -> Union[str, Path]:
+        raise NotImplementedError(f"copytree_to_local not supported in {self.name}")
+
+    def remove(self, filepath: Union[str, Path]) -> None:
+        raise NotImplementedError(f"remove not supported in {self.name}")
+
+    def rmtree(self, dir_path: Union[str, Path]) -> None:
+        raise NotImplementedError(f"rmtree not supported in {self.name}")
+
+    def copy_if_symlink_fails(self, src: Union[str, Path], dst: Union[str, Path]) -> bool:
+        raise NotImplementedError(f"copy_if_symlink_fails not supported in {self.name}")
+
+    def list_dir(self, dir_path: Union[str, Path]) -> Generator[str, None, None]:
+        raise NotImplementedError(f"list_dir not supported in {self.name}")
+
+    def list_dir_or_file(  # pylint: disable=too-many-arguments
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        raise NotImplementedError(f"list_dir_or_file not supported in {self.name}")

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/local_backend.py

@@ -0,0 +1,599 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import os
+import os.path as osp
+import shutil
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional, Union
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import BaseStorageBackend, mkdir_or_exist
+
+
+class LocalBackend(BaseStorageBackend):
+    """Raw local storage backend."""
+
+    _allow_symlink = True
+
+    def size(self, filepath: Union[str, Path]) -> int:
+        """Get the file size in bytes for a given ``filepath``.
+
+        Args:
+            filepath (str or Path): Path to get file size in bytes.
+
+        Returns:
+            int: File size in bytes for filepath.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.size(filepath)  # file containing 'hello world'
+            11
+        """
+        return osp.getsize(filepath)
+
+    def get(self, filepath: Union[str, Path], offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        """Read bytes from a given ``filepath`` with 'rb' mode.
+
+        Args:
+            filepath (str or Path): Path to read data.
+            offset (int, optional): Read offset in bytes (0-index). Defaults to 0.
+            size (int, optional): Read size in bytes. Defaults to the file size.
+
+        Returns:
+            bytes: Expected bytes object.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.get(filepath)
+            b'hello world'
+        """
+        read_offset: Optional[int] = None
+        read_size: Optional[int] = None
+        if offset is not None or size is not None:
+            read_offset = offset or 0
+            assert read_offset >= 0, "Read offset must be ≥ 0"
+
+            read_size = size or (self.size(filepath=filepath) - read_offset)
+            assert read_size >= 1, "Read size must be ≥ 1 or read offset must be < file size"
+
+        with open(filepath, "rb") as f:
+            if read_offset is not None:
+                f.seek(read_offset)
+            value = f.read(read_size)
+        return value
+
+    def get_text(self, filepath: Union[str, Path], encoding: str = "utf-8") -> str:
+        """Read text from a given ``filepath`` with 'r' mode.
+
+        Args:
+            filepath (str or Path): Path to read data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Returns:
+            str: Expected text reading from ``filepath``.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.get_text(filepath)
+            'hello world'
+        """
+        with open(filepath, encoding=encoding) as f:
+            text = f.read()
+        return text
+
+    def put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path]) -> None:
+        """Write bytes to a given ``filepath`` with 'wb' mode.
+
+        Note:
+            ``put`` will create a directory if the directory of
+            ``filepath`` does not exist.
+
+        Args:
+            obj (bytes): Data to be written.
+            filepath (str or Path): Path to write data.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.put(b'hello world', filepath)
+        """
+        mkdir_or_exist(osp.dirname(filepath))
+        if isinstance(obj, io.BytesIO):
+            obj.seek(0)
+            obj = obj.getvalue()
+        with open(filepath, "wb") as f:
+            f.write(obj)
+
+    def put_text(self, obj: str, filepath: Union[str, Path], encoding: str = "utf-8") -> None:
+        """Write text to a given ``filepath`` with 'w' mode.
+
+        Note:
+            ``put_text`` will create a directory if the directory of
+            ``filepath`` does not exist.
+
+        Args:
+            obj (str): Data to be written.
+            filepath (str or Path): Path to write data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.put_text('hello world', filepath)
+        """
+        mkdir_or_exist(osp.dirname(filepath))
+        with open(filepath, "w", encoding=encoding) as f:
+            f.write(obj)
+
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path exists.
+
+        Args:
+            filepath (str or Path): Path to be checked whether exists.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` exists, ``False`` otherwise.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.exists(filepath)
+            True
+        """
+        return osp.exists(filepath)
+
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a directory.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a
+                directory.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a directory,
+            ``False`` otherwise.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/dir'
+            >>> backend.isdir(filepath)
+            True
+        """
+        return osp.isdir(filepath)
+
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a file.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a file.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a file, ``False``
+            otherwise.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.isfile(filepath)
+            True
+        """
+        return osp.isfile(filepath)
+
+    def join_path(self, filepath: Union[str, Path], *filepaths: Union[str, Path]) -> str:
+        r"""Concatenate all file paths.
+
+        Join one or more filepath components intelligently. The return value
+        is the concatenation of filepath and any members of \*filepaths.
+
+        Args:
+            filepath (str or Path): Path to be concatenated.
+
+        Returns:
+            str: The result of concatenation.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath1 = '/path/of/dir1'
+            >>> filepath2 = 'dir2'
+            >>> filepath3 = 'path/of/file'
+            >>> backend.join_path(filepath1, filepath2, filepath3)
+            '/path/of/dir/dir2/path/of/file'
+        """
+        # TODO, if filepath or filepaths are Path, should return Path
+        return osp.join(filepath, *filepaths)
+
+    @contextmanager
+    def get_local_path(
+        self,
+        filepath: Union[str, Path],
+    ) -> Generator[Union[str, Path], None, None]:
+        """Only for unified API and do nothing.
+
+        Args:
+            filepath (str or Path): Path to be read data.
+            backend_args (dict, optional): Arguments to instantiate the
+                corresponding backend. Defaults to None.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> with backend.get_local_path('s3://bucket/abc.jpg') as path:
+            ...     # do something here
+        """
+        yield filepath
+
+    def copyfile(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Copy a file src to dst and return the destination file.
+
+        src and dst should have the same prefix. If dst specifies a directory,
+        the file will be copied into dst using the base filename from src. If
+        dst specifies a file that already exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to dst.
+
+        Returns:
+            str: The destination file.
+
+        Raises:
+            SameFileError: If src and dst are the same file, a SameFileError
+                will be raised.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> # dst is a file
+            >>> src = '/path/of/file'
+            >>> dst = '/path1/of/file1'
+            >>> # src will be copied to '/path1/of/file1'
+            >>> backend.copyfile(src, dst)
+            '/path1/of/file1'
+
+            >>> # dst is a directory
+            >>> dst = '/path1/of/dir'
+            >>> # src will be copied to '/path1/of/dir/file'
+            >>> backend.copyfile(src, dst)
+            '/path1/of/dir/file'
+        """
+        return shutil.copy(src, dst)
+
+    def copytree(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory.
+
+        src and dst should have the same prefix and dst must not already exist.
+
+        TODO: Whether to support dirs_exist_ok parameter.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to dst.
+
+        Returns:
+            str: The destination directory.
+
+        Raises:
+            FileExistsError: If dst had already existed, a FileExistsError will
+                be raised.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> src = '/path/of/dir1'
+            >>> dst = '/path/of/dir2'
+            >>> backend.copytree(src, dst)
+            '/path/of/dir2'
+        """
+        return shutil.copytree(src, dst)
+
+    def copyfile_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Copy a local file src to dst and return the destination file. Same
+        as :meth:`copyfile`.
+
+        Args:
+            src (str or Path): A local file to be copied.
+            dst (str or Path): Copy file to dst.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Raises:
+            SameFileError: If src and dst are the same file, a SameFileError
+                will be raised.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> # dst is a file
+            >>> src = '/path/of/file'
+            >>> dst = '/path1/of/file1'
+            >>> # src will be copied to '/path1/of/file1'
+            >>> backend.copyfile_from_local(src, dst)
+            '/path1/of/file1'
+
+            >>> # dst is a directory
+            >>> dst = '/path1/of/dir'
+            >>> # src will be copied to
+            >>> backend.copyfile_from_local(src, dst)
+            '/path1/of/dir/file'
+        """
+        return self.copyfile(src, dst)
+
+    def copytree_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory. Same as
+        :meth:`copytree`.
+
+        Args:
+            src (str or Path): A local directory to be copied.
+            dst (str or Path): Copy directory to dst.
+
+        Returns:
+            str: The destination directory.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> src = '/path/of/dir1'
+            >>> dst = '/path/of/dir2'
+            >>> backend.copytree_from_local(src, dst)
+            '/path/of/dir2'
+        """
+        return self.copytree(src, dst)
+
+    def copyfile_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+        dst_type: Optional[str] = None,
+    ) -> str:
+        """Copy the file src to local dst and return the destination file. Same
+        as :meth:`copyfile`.
+
+        If dst specifies a directory, the file will be copied into dst using
+        the base filename from src. If dst specifies a file that already
+        exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to to local dst.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> # dst is a file
+            >>> src = '/path/of/file'
+            >>> dst = '/path1/of/file1'
+            >>> # src will be copied to '/path1/of/file1'
+            >>> backend.copyfile_to_local(src, dst)
+            '/path1/of/file1'
+
+            >>> # dst is a directory
+            >>> dst = '/path1/of/dir'
+            >>> # src will be copied to
+            >>> backend.copyfile_to_local(src, dst)
+            '/path1/of/dir/file'
+        """
+        return self.copyfile(src, dst)
+
+    def copytree_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a local
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to local dst.
+            backend_args (dict, optional): Arguments to instantiate the
+                prefix of uri corresponding backend. Defaults to None.
+
+        Returns:
+            str: The destination directory.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> src = '/path/of/dir1'
+            >>> dst = '/path/of/dir2'
+            >>> backend.copytree_from_local(src, dst)
+            '/path/of/dir2'
+        """
+        return self.copytree(src, dst)
+
+    def remove(self, filepath: Union[str, Path]) -> None:
+        """Remove a file.
+
+        Args:
+            filepath (str or Path): Path to be removed.
+
+        Raises:
+            IsADirectoryError: If filepath is a directory, an IsADirectoryError
+                will be raised.
+            FileNotFoundError: If filepath does not exist, an FileNotFoundError
+                will be raised.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> filepath = '/path/of/file'
+            >>> backend.remove(filepath)
+        """
+        if not self.exists(filepath):
+            raise FileNotFoundError(f"filepath {filepath} does not exist")
+
+        if self.isdir(filepath):
+            raise IsADirectoryError("filepath should be a file")
+
+        os.remove(filepath)
+
+    def rmtree(self, dir_path: Union[str, Path]) -> None:
+        """Recursively delete a directory tree.
+
+        Args:
+            dir_path (str or Path): A directory to be removed.
+
+        Examples:
+            >>> dir_path = '/path/of/dir'
+            >>> backend.rmtree(dir_path)
+        """
+        shutil.rmtree(dir_path)
+
+    def copy_if_symlink_fails(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> bool:
+        """Create a symbolic link pointing to src named dst.
+
+        If failed to create a symbolic link pointing to src, directly copy src
+        to dst instead.
+
+        Args:
+            src (str or Path): Create a symbolic link pointing to src.
+            dst (str or Path): Create a symbolic link named dst.
+
+        Returns:
+            bool: Return True if successfully create a symbolic link pointing
+            to src. Otherwise, return False.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> src = '/path/of/file'
+            >>> dst = '/path1/of/file1'
+            >>> backend.copy_if_symlink_fails(src, dst)
+            True
+            >>> src = '/path/of/dir'
+            >>> dst = '/path1/of/dir1'
+            >>> backend.copy_if_symlink_fails(src, dst)
+            True
+        """
+        try:
+            os.symlink(src, dst)
+            return True
+        except Exception:
+            if self.isfile(src):
+                self.copyfile(src, dst)
+            else:
+                self.copytree(src, dst)
+            return False
+
+    def list_dir(self, dir_path: Union[str, Path]) -> Generator[str, None, None]:
+        """List all folders in a storage location with a given prefix.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> dir_path = 'path/of/dir'
+            >>> list(backend.list_dir(dir_path))
+            ['subdir1/', 'subdir2/']
+        """
+        for entry in os.scandir(dir_path):
+            if entry.is_dir():
+                yield f"{entry.name}/"
+
+    def list_dir_or_file(
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        """Scan a directory to find the interested directories or files in
+        arbitrary order.
+
+        Note:
+            :meth:`list_dir_or_file` returns the path relative to ``dir_path``.
+
+        Args:
+            dir_path (str or Path): Path of the directory.
+            list_dir (bool): List the directories. Defaults to True.
+            list_file (bool): List the path of files. Defaults to True.
+            suffix (str or tuple[str], optional): File suffix that we are
+                interested in. Defaults to None.
+            recursive (bool): If set to True, recursively scan the directory.
+                Defaults to False.
+
+        Yields:
+            Iterable[str]: A relative path to ``dir_path``.
+
+        Examples:
+            >>> backend = LocalBackend()
+            >>> dir_path = '/path/of/dir'
+            >>> # list those files and directories in current directory
+            >>> for file_path in backend.list_dir_or_file(dir_path):
+            ...     print(file_path)
+            >>> # only list files
+            >>> for file_path in backend.list_dir_or_file(dir_path, list_dir=False):
+            ...     print(file_path)
+            >>> # only list directories
+            >>> for file_path in backend.list_dir_or_file(dir_path, list_file=False):
+            ...     print(file_path)
+            >>> # only list files ending with specified suffixes
+            >>> for file_path in backend.list_dir_or_file(dir_path, suffix='.txt'):
+            ...     print(file_path)
+            >>> # list all files and directory recursively
+            >>> for file_path in backend.list_dir_or_file(dir_path, recursive=True):
+            ...     print(file_path)
+        """  # noqa: E501
+        if list_dir and suffix is not None:
+            raise TypeError("`suffix` should be None when `list_dir` is True")
+
+        if (suffix is not None) and not isinstance(suffix, (str, tuple)):
+            raise TypeError("`suffix` must be a string or tuple of strings")
+
+        root = dir_path
+
+        def _list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive):
+            for entry in os.scandir(dir_path):
+                if not entry.name.startswith(".") and entry.is_file():
+                    rel_path = osp.relpath(entry.path, root)
+                    if (suffix is None or rel_path.endswith(suffix)) and list_file:
+                        yield rel_path
+                elif osp.isdir(entry.path):
+                    if list_dir:
+                        rel_dir = osp.relpath(entry.path, root)
+                        yield rel_dir
+                    if recursive:
+                        yield from _list_dir_or_file(entry.path, list_dir, list_file, suffix, recursive)
+
+        return _list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive)

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/msc_backend.py

@@ -0,0 +1,911 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import io
+import os
+import re
+import tempfile
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from shutil import SameFileError
+from typing import Any, Optional, Union
+from urllib.parse import urlparse
+
+from multistorageclient import StorageClient, StorageClientConfig
+from multistorageclient.types import Range
+
+import cosmos_policy._src.imaginaire.utils.easy_io.backends.auto_auth as auto
+from cosmos_policy._src.imaginaire.utils import log
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import BaseStorageBackend, mkdir_or_exist
+
+# {scheme}://
+_URL_PREFIX_REGEX = r"[a-zA-Z0-9+.-]*:\/\/"
+
+
+class MSCBackend(BaseStorageBackend):
+    """Multi-Storage Client (MSC) backend.
+
+    Uses MSC storage clients instead of MSC shortcuts.
+
+    URL file paths (e.g. 's3://path/of/file') are handled transparently. Using URL file paths
+    as input will return URL file path outputs when appropriate to match Boto3Backend behavior.
+
+    **If using URL file paths, the storage provider's base path option must be empty!**
+
+    Get/put concurrency can be set for certain providers in the MSC configuration file.
+
+    Examples:
+        >>> backend = MSCBackend()
+        >>> filepath = "path/of/file"  # or "s3://path/of/file"
+        >>> backend.get(filepath)
+    """
+
+    _storage_client: StorageClient
+    _path_mapping: dict[str, str]
+
+    def __init__(
+        self,
+        config_path: Optional[str] = "credentials/msc_config.yaml",
+        profile: Optional[str] = None,
+        s3_credential_path: Optional[str] = None,
+        path_mapping: Optional[dict[str, str]] = None,
+    ):
+        """Initialize a backend.
+
+        Args:
+            config_path (str, optional): MSC config path (e.g. ``credentials/msc_config.yaml``).
+            profile (str, optional): MSC profile from the MSC config to use.
+                Mutually exclusive with ``s3_credential_path``.
+            s3_credential_path (str, optional): Legacy Boto3 config path (e.g. ``credentials/s3_training.secret``).
+                Translated into an MSC profile that's merged with the MSC config at ``config_path`` with:
+
+                - The profile name set to ``s3_credential_path`` verbatim.
+                - The storage and credentials provider types determined by the file contents.
+
+                Mutually exclusive with ``profile``.
+            path_mapping (dict, optional): Path mapping dict from src path to dst path.
+                When ``path_mapping={'src': 'dst'}``, ``src`` in ``filepath`` will be replaced by ``dst``.
+                Doesn't apply to the local path in ``copy{file,tree}_{from,to}_local`` methods.
+        """
+        if all(_ is None for _ in (profile, s3_credential_path)) or all(
+            _ is not None for _ in (profile, s3_credential_path)
+        ):
+            raise ValueError("Must specify exactly one of profile or s3_credential_path")
+
+        msc_config_dict: dict[str, Any] = {}
+
+        # Use an existing MSC config file as the base MSC config.
+        if config_path is not None:
+            config_dict, _ = StorageClientConfig.read_msc_config(config_file_paths=[config_path])
+            if config_dict is None:
+                log.info(f"No MSC config at {config_path}, using empty base MSC config", rank0_only=False)
+            else:
+                msc_config_dict = config_dict
+
+        # Create an MSC profile from the legacy Boto3 config.
+        if s3_credential_path is not None:
+            with auto.open_auth(s3_credential_path, "r") as unloaded_legacy_boto3_config:
+                legacy_boto3_config = auto.json_load_auth(unloaded_legacy_boto3_config)
+                if len(legacy_boto3_config) > 0:
+                    profile = s3_credential_path
+
+                    # Merge with any existing profiles.
+                    msc_config_dict["profiles"] = msc_config_dict.get("profiles", {})
+                    # Merge with the existing profile, replacing `storage_provider` and `credentials_provider` completely.
+                    msc_config_dict["profiles"][profile] = msc_config_dict["profiles"].get(profile, {})
+
+                    storage_provider_type: str = "s3"
+                    parsed_endpoint_url = urlparse(legacy_boto3_config["endpoint_url"])
+                    # Handle regional SwiftStack endpoints.
+                    if parsed_endpoint_url.hostname.endswith(".s8k.io"):
+                        storage_provider_type = "s8k"
+                    # Handle global and regional GCS endpoints.
+                    elif parsed_endpoint_url.hostname.startswith("storage.") and parsed_endpoint_url.hostname.endswith(
+                        ".googleapis.com"
+                    ):
+                        storage_provider_type = "gcs_s3"
+
+                    msc_config_dict["profiles"][profile]["storage_provider"] = {
+                        "type": storage_provider_type,
+                        "options": {
+                            "base_path": "",
+                            "endpoint_url": legacy_boto3_config["endpoint_url"],
+                            "region_name": legacy_boto3_config["region_name"],
+                        },
+                    }
+
+                    if all(_ in legacy_boto3_config for _ in ("aws_access_key_id", "aws_secret_access_key")):
+                        msc_config_dict["profiles"][profile]["credentials_provider"] = {
+                            "type": "S3Credentials",
+                            "options": {
+                                "access_key": legacy_boto3_config["aws_access_key_id"],
+                                "secret_key": legacy_boto3_config["aws_secret_access_key"],
+                            },
+                        }
+                else:
+                    raise ValueError("Cannot create profile from empty legacy Boto3 config")
+
+        assert profile is not None, "Failed to resolve MSC profile"
+
+        # easy_io needs backend args to be JSON-serializable for backend instance cache keys.
+        #
+        # StorageClientConfig isn't, so we need to construct it here instead of receiving one.
+        self._storage_client = StorageClient(
+            config=StorageClientConfig.from_dict(config_dict=msc_config_dict, profile=profile)
+        )
+
+        assert isinstance(path_mapping, dict) or path_mapping is None
+        # Make a deep copy of the path mapping to prevent external mutation.
+        self._path_mapping = {} if path_mapping is None else copy.deepcopy(path_mapping)
+        for src, dst in self._path_mapping.items():
+            log.info(f"Path mapping: {src} -> {dst}", rank0_only=False)
+
+    def _translate_filepath(self, filepath: Union[str, Path], translate_url: bool = True) -> str:
+        """Translate a `filepath` to a string.
+
+        Paths are of the form 'path/to/file' (path form) or '{protocol}://path/to/file' (URL form).
+
+        Args:
+            filepath (str): File path to be translated.
+            translate_url (bool): Strip '{scheme}://' prefixes. Needed for paths passed directly to MSC storage clients.
+        """
+        assert isinstance(filepath, (str, Path))
+
+        # Change to a POSIX path string.
+        if isinstance(filepath, str):
+            # If the ``filepath`` is concatenated by ``os.path.join`` in a Windows
+            # environment, the ``filepath`` will be the format of 'prefix\file.txt'.
+            filepath = re.sub(r"\\+", "/", filepath)
+        elif isinstance(filepath, Path):
+            # These should only be filesystem paths (e.g. '/path/of/file').
+            # URL paths (e.g. ``Path('s3://profile/path/of/file')``) collapse '://' to ':/'.
+            filepath = filepath.as_posix()
+        else:
+            raise ValueError(f"Unhandled filepath type: {type(filepath)}")
+
+        # Remap path.
+        #
+        # If there's multiple matching srcs, use the longest src (i.e. the most specific).
+        longest_src: str = ""
+        for src in self._path_mapping.keys():
+            if filepath.startswith(src) and len(src) > len(longest_src):
+                longest_src = src
+        if len(longest_src) > 0:
+            filepath = filepath.replace(longest_src, self._path_mapping[longest_src], 1)
+
+        # Optionally strip URL prefix then return.
+        #
+        # Don't use urlparse in case filepath is an invalid URL.
+        return re.sub(rf"^{_URL_PREFIX_REGEX}", "", filepath) if translate_url else filepath
+
+    def size(self, filepath: Union[str, Path]) -> int:
+        """Get the file size in bytes for a given ``filepath``.
+
+        Args:
+            filepath (str or Path): Path to get file size in bytes.
+
+        Returns:
+            int: File size in bytes for filepath.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.size(filepath)  # file containing "hello world"
+            11
+        """
+        path = self._translate_filepath(filepath=filepath)
+        return self._storage_client.info(path=path, strict=False).content_length
+
+    def get(self, filepath: Union[str, Path], offset: Optional[int] = None, size: Optional[int] = None) -> bytes:
+        """Read bytes from a given ``filepath`` with 'rb' mode in range [offset, offset + size).
+
+        Args:
+            filepath (str or Path): Path to read data.
+            offset (int, optional): Read offset in bytes (0-index). Defaults to 0.
+            size (int, optional): Read size in bytes. Defaults to the file size.
+
+        Returns:
+            bytes: Return bytes read from filepath.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.get(filepath)
+            b'hello world'
+        """
+        path = self._translate_filepath(filepath=filepath)
+        byte_range: Optional[Range] = None
+        if offset is not None or size is not None:
+            read_offset = offset or 0
+            assert read_offset >= 0, "Read offset must be ≥ 0"
+
+            # Try not to incur a remote call to get the file size. This can heavily slow down ranged reads.
+            #
+            # This means we won't always validate the read offset or read size against the file size.
+            read_size = size or (self.size(filepath=filepath) - read_offset)
+            assert read_size >= 1, "Read size must be ≥ 1 or read offset must be < file size"
+
+            byte_range = Range(offset=read_offset, size=read_size)
+
+        if byte_range is None:
+            buffer = io.BytesIO()
+            # `StorageClient.read()` defers to `StorageProvider.get_object()` while
+            # `StorageClient.download_file()` defers to `StorageProvider.download_file()`.
+            #
+            # Currently, only `StorageProvider.download_file()` supports parallel downloads
+            # in some storage providers (e.g. boto S3 transfer manager for S3 storage providers)
+            # so it's often much faster.
+            self._storage_client.download_file(remote_path=path, local_path=buffer)
+            buffer.seek(0)
+            return buffer.read()
+        else:
+            return self._storage_client.read(path=path, byte_range=byte_range)
+
+    def get_text(
+        self,
+        filepath: Union[str, Path],
+        encoding: str = "utf-8",
+    ) -> str:
+        """Read text from a given ``filepath`` with 'r' mode.
+
+        Args:
+            filepath (str or Path): Path to read data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Returns:
+            str: Expected text reading from ``filepath``.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.get_text(filepath)
+            'hello world'
+        """
+        return str(self.get(filepath=filepath), encoding=encoding)
+
+    def put(self, obj: Union[bytes, io.BytesIO], filepath: Union[str, Path]) -> None:
+        """Write bytes to a given ``filepath``.
+
+        Args:
+            obj (bytes): Data to be saved.
+            filepath (str or Path): Path to write data.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.put(b"hello world", filepath)
+        """
+        path = self._translate_filepath(filepath=filepath)
+        buffer = io.BytesIO()
+        if isinstance(obj, bytes):
+            buffer.write(obj)
+            buffer.seek(0)
+        elif isinstance(obj, io.BytesIO):
+            buffer = obj
+        else:
+            raise ValueError(f"Unhandled obj type: {type(obj)}")
+        # `StorageClient.write()` defers to `StorageProvider.put_object()` while
+        # `StorageClient.upload_file()` defers to `StorageProvider.upload_file()`.
+        #
+        # Currently, only `StorageProvider.upload_file()` supports parallel uploads
+        # in some storage providers (e.g. boto S3 transfer manager for S3 storage providers)
+        # so it's often much faster.
+        self._storage_client.upload_file(remote_path=path, local_path=buffer)
+
+    def put_text(
+        self,
+        obj: str,
+        filepath: Union[str, Path],
+        encoding: str = "utf-8",
+    ) -> None:
+        """Write text to a given ``filepath``.
+
+        Args:
+            obj (str): Data to be written.
+            filepath (str or Path): Path to write data.
+            encoding (str): The encoding format used to encode the ``obj``.
+                Defaults to 'utf-8'.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.put_text("hello world", filepath)
+        """
+        self.put(obj=bytes(obj, encoding=encoding), filepath=filepath)
+
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path exists.
+
+        Args:
+            filepath (str or Path): Path to be checked whether exists.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` exists, ``False`` otherwise.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.exists(filepath)
+            True
+        """
+        path = self._translate_filepath(filepath=filepath)
+        try:
+            # Include directories and files.
+            self._storage_client.info(path=path, strict=True)
+            return True
+        except FileNotFoundError:
+            return False
+
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a directory.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a
+                directory.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a directory,
+            ``False`` otherwise.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/dir"  # or "s3://path/of/file"
+            >>> backend.isdir(filepath)
+            True
+        """
+        path = self._translate_filepath(filepath=filepath)
+        try:
+            # Include directories and files.
+            metadata = self._storage_client.info(path=path, strict=True)
+            return metadata.type == "directory"
+        except FileNotFoundError:
+            return False
+
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a file.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a file.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a file, ``False``
+            otherwise.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.isfile(filepath)
+            True
+        """
+        path = self._translate_filepath(filepath=filepath)
+        try:
+            return self._storage_client.is_file(path=path)
+        except FileNotFoundError:
+            return False
+
+    def join_path(
+        self,
+        filepath: Union[str, Path],
+        *filepaths: Union[str, Path],
+    ) -> str:
+        r"""Concatenate all file paths.
+
+        Join one or more filepath components intelligently. The return value
+        is the concatenation of filepath and any members of \*filepaths.
+
+        Args:
+            filepath (str or Path): Path to be concatenated.
+
+        Returns:
+            str: The result after concatenation.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.join_path(filepath, "another/path")
+            'path/of/file/another/path'  # or "s3://path/of/file/another/path"
+            >>> backend.join_path(filepath, "/another/path")
+            'path/of/file/another/path'  # or "s3://path/of/file/another/path"
+        """
+        filepath = self._translate_filepath(filepath=filepath, translate_url=False)
+        if filepath.endswith("/") and not filepath.endswith("://"):
+            filepath = filepath[:-1]
+        formatted_paths = [filepath]
+        for path in filepaths:
+            formatted_path = self._translate_filepath(filepath=path)
+            formatted_paths.append(formatted_path.lstrip("/"))
+
+        return "/".join(formatted_paths)
+
+    @contextmanager
+    def get_local_path(
+        self,
+        filepath: Union[str, Path],
+    ) -> Generator[Union[str, Path], None, None]:
+        """Download a file from ``filepath`` to a local temporary directory,
+        and return the temporary path.
+
+        ``get_local_path`` is decorated by :meth:`contxtlib.contextmanager`. It
+        can be called with ``with`` statement, and when exists from the
+        ``with`` statement, the temporary path will be released.
+
+        Args:
+            filepath (str or Path): Download a file from ``filepath``.
+
+        Yields:
+            Iterable[str]: Only yield one temporary path.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> # After existing from the ``with`` clause,
+            >>> # the path will be removed
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> with backend.get_local_path(filepath) as path:
+            ...     # do something here
+        """
+        assert self.isfile(filepath=filepath)
+        try:
+            f = tempfile.NamedTemporaryFile(delete=False)
+            f.write(self.get(filepath=filepath))
+            f.close()
+            yield f.name
+        finally:
+            os.remove(f.name)
+
+    def copyfile(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Copy a file src to dst and return the destination file.
+
+        If dst specifies a file that already exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to dst.
+
+        Returns:
+            str: The destination file.
+
+        Raises:
+            SameFileError: If src and dst are the same file, a SameFileError
+                will be raised.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> # dst is a file
+            >>> src = "path/of/file"  # or "s3://path/of/file"
+            >>> dst = "path/of/file1"  # or "s3://path/of/file1"
+            >>> backend.copyfile(src, dst)
+            'path/of/file1'  # or "s3://path/of/file1"
+
+            >>> # dst is a directory
+            >>> dst = "path/of/dir"  # or "s3://path/of/dir"
+            >>> backend.copyfile(src, dst)
+            'path/of/dir/file'  # or "s3://path/of/dir/file"
+        """
+        if not self.isfile(filepath=src):
+            raise FileNotFoundError("src does not exist or is not a file")
+        if self.isdir(filepath=dst):
+            dst = self.join_path(dst, self._translate_filepath(filepath=src).split("/")[-1])
+        if self._translate_filepath(filepath=src) == self._translate_filepath(filepath=dst):
+            raise SameFileError("src and dst should not be same")
+
+        self.put(obj=self.get(filepath=src), filepath=dst)
+
+        return self._translate_filepath(filepath=dst, translate_url=False)
+
+    def copytree(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to dst.
+
+        Returns:
+            str: The destination directory.
+
+        Raises:
+            FileExistsError: If dst had already existed, a FileExistsError will
+                be raised.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> src = "path/of/dir"  # or "s3://path/of/dir"
+            >>> dst = "path/of/dir1"  # or "s3://path/of/dir1"
+            >>> backend.copytree(src, dst)
+            'path/of/dir1'  # or "s3://path/of/dir1"
+        """
+        if not self.isdir(filepath=src):
+            raise FileNotFoundError("src does not exist or is not a directory")
+        if self.exists(filepath=dst):
+            raise FileExistsError("dst should not exist")
+
+        for path in self.list_dir_or_file(src, list_dir=False, recursive=True):
+            src_path = self.join_path(src, path)
+            dst_path = self.join_path(dst, path)
+            self.put(obj=self.get(filepath=src_path), filepath=dst_path)
+
+        return self._translate_filepath(filepath=dst, translate_url=False)
+
+    def copyfile_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Upload a local file src to dst and return the destination file.
+
+        Args:
+            src (str or Path): A local file to be copied.
+            dst (str or Path): Copy file to dst.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> # dst is a file
+            >>> src = "path/of/your/file"
+            >>> dst = "path/of/file1"  # or "s3://path/of/file1"
+            >>> backend.copyfile_from_local(src, dst)
+            'path/of/file1'  # or "s3://path/of/file1"
+
+            >>> # dst is a directory
+            >>> dst = "path/of/dir"
+            >>> backend.copyfile_from_local(src, dst)
+            'path/of/dir/file'  # or "s3://path/of/dir/file"
+        """
+        if self.isdir(filepath=dst):
+            dst = self.join_path(dst, os.path.basename(src))
+
+        with open(src, "rb") as f:
+            self.put(obj=f.read(), filepath=dst)
+
+        return self._translate_filepath(filepath=dst, translate_url=False)
+
+    def copytree_from_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> str:
+        """Recursively copy an entire directory tree rooted at src to a
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A local directory to be copied.
+            dst (str or Path): Copy directory to dst.
+
+        Returns:
+            str: The destination directory.
+
+        Raises:
+            FileExistsError: If dst had already existed, a FileExistsError will
+                be raised.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> src = "path/of/your/dir"
+            >>> dst = "path/of/dir1"  # or "s3://path/of/dir1"
+            >>> backend.copytree_from_local(src, dst)
+            'path/of/dir1'  # or "s3://path/of/dir1"
+        """
+        if self.exists(filepath=dst):
+            raise FileExistsError("dst should not exist")
+
+        src = str(src)
+
+        for cur_dir, _, files in os.walk(src):
+            for f in files:
+                src_path = os.path.join(cur_dir, f)
+                dst_path = self.join_path(dst, src_path.replace(src, ""))
+                self.copyfile_from_local(src=src_path, dst=dst_path)
+
+        return self._translate_filepath(filepath=dst, translate_url=False)
+
+    def copyfile_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+        dst_type: str,  # Choose from ["file", "dir"]
+    ) -> Union[str, Path]:
+        """Copy the file src to local dst and return the destination file.
+
+        If dst specifies a directory, the file will be copied into dst using
+        the base filename from src. If dst specifies a file that already
+        exists, it will be replaced.
+
+        Args:
+            src (str or Path): A file to be copied.
+            dst (str or Path): Copy file to to local dst.
+
+        Returns:
+            str: If dst specifies a directory, the file will be copied into dst
+            using the base filename from src.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> # dst is a file
+            >>> src = "path/of/file"  # or "s3://path/of/file"
+            >>> dst = "path/of/your/file"
+            >>> backend.copyfile_to_local(src, dst)
+            'path/of/your/file'
+
+            >>> # dst is a directory
+            >>> dst = "path/of/your/dir"
+            >>> backend.copyfile_to_local(src, dst)
+            'path/of/your/dir/file'
+        """
+        assert dst_type in ["file", "dir"]
+        # There is no good way to detect whether dst is a directory or a file, so we make dst_type required
+        if dst_type == "dir":
+            basename = os.path.basename(self._translate_filepath(filepath=src))
+            if isinstance(dst, str):
+                dst = os.path.join(dst, basename)
+            else:
+                assert isinstance(dst, Path)
+                dst = dst / basename
+
+        # Create parent directory if it doesn't exist
+        parent_dir = os.path.dirname(dst)
+        os.makedirs(parent_dir, exist_ok=True)
+
+        try:
+            with open(dst, "wb") as f:
+                data = self.get(filepath=src)
+                f.write(data)
+        except Exception as e:
+            log.error(f"Failed to write file: {e}")
+            raise
+
+        return dst
+
+    def copytree_to_local(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> Union[str, Path]:
+        """Recursively copy an entire directory tree rooted at src to a local
+        directory named dst and return the destination directory.
+
+        Args:
+            src (str or Path): A directory to be copied.
+            dst (str or Path): Copy directory to local dst.
+
+        Returns:
+            str: The destination directory.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> src = "path/of/dir"  # or "s3://path/of/dir"
+            >>> dst = "path/of/your/dir"
+            >>> backend.copytree_to_local(src, dst)
+            'path/of/your/dir'
+        """
+        for path in self.list_dir_or_file(dir_path=src, list_dir=False, recursive=True):
+            dst_path = os.path.join(dst, path)
+            mkdir_or_exist(os.path.dirname(dst_path))
+            with open(dst_path, "wb") as f:
+                f.write(self.get(filepath=self.join_path(src, path)))
+
+        return dst
+
+    def remove(self, filepath: Union[str, Path]) -> None:
+        """Remove a file.
+
+        Args:
+            filepath (str or Path): Path to be removed.
+
+        Raises:
+            FileNotFoundError: If filepath does not exist, an FileNotFoundError
+                will be raised.
+            IsADirectoryError: If filepath is a directory, an IsADirectoryError
+                will be raised.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> filepath = "path/of/file"  # or "s3://path/of/file"
+            >>> backend.remove(filepath)
+        """
+        if not self.exists(filepath=filepath):
+            raise FileNotFoundError(f"filepath {filepath} does not exist")
+
+        if self.isdir(filepath=filepath):
+            raise IsADirectoryError("filepath should be a file")
+
+        self._storage_client.delete(path=self._translate_filepath(filepath=filepath), recursive=False)
+
+    def rmtree(self, dir_path: Union[str, Path]) -> None:
+        """Recursively delete a directory tree.
+
+        Args:
+            dir_path (str or Path): A directory to be removed.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> dir_path = "path/of/dir"  # or "s3://path/of/dir"
+            >>> backend.rmtree(dir_path)
+        """
+        self._storage_client.delete(path=self._translate_filepath(filepath=dir_path), recursive=True)
+
+    def copy_if_symlink_fails(
+        self,
+        src: Union[str, Path],
+        dst: Union[str, Path],
+    ) -> bool:
+        """Create a symbolic link pointing to src named dst.
+
+        Directly copy src to dst because MSCBackend does not support creating
+        a symbolic link.
+
+        Args:
+            src (str or Path): A file or directory to be copied.
+            dst (str or Path): Copy a file or directory to dst.
+
+        Returns:
+            bool: Return False because MSCBackend does not support create
+            a symbolic link.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> src = "path/of/file"  # or "s3://path/of/file"
+            >>> dst = "path/of/your/file"  # or "s3://path/of/your/file"
+            >>> backend.copy_if_symlink_fails(src, dst)
+            False
+            >>> src = "path/of/dir"  # or "s3://path/of/dir"
+            >>> dst = "path/of/your/dir"  # or "s3://path/of/your/dir"
+            >>> backend.copy_if_symlink_fails(src, dst)
+            False
+        """
+        if self.isfile(filepath=src):
+            self.copyfile(src=src, dst=dst)
+        else:
+            self.copytree(src=src, dst=dst)
+        return False
+
+    def list_dir(self, dir_path: Union[str, Path]) -> Generator[str, None, None]:
+        """List all folders in a storage location with a given prefix.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> dir_path = "path/of/dir"  # or "s3://path/of/dir"
+            >>> list(backend.list_dir(dir_path))
+            ["subdir1/", "subdir2/"]
+        """
+        path = self._translate_filepath(filepath=dir_path).removesuffix("/") + "/"
+        for metadata in self._storage_client.list(path=path, include_directories=True, include_url_prefix=False):
+            if metadata.type == "directory":
+                yield metadata.key.removeprefix(path).removesuffix("/") + "/"
+
+    def list_dir_or_file(  # pylint: disable=too-many-arguments
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        """Scan a directory to find the interested directories or files in
+        arbitrary order.
+
+        Note:
+            Most object stores have no concept of directories but it simulates
+            the directory hierarchy in the filesystem through public prefixes.
+            In addition, if the returned path ends with '/', it means the path
+            is a public prefix which is a logical directory.
+
+        Note:
+            :meth:`list_dir_or_file` returns the path relative to ``dir_path``.
+            In addition, the returned path of directory will not contains the
+            suffix '/' which is consistent with other backends.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+            list_dir (bool): List the directories. Defaults to True.
+            list_file (bool): List the path of files. Defaults to True.
+            suffix (str or tuple[str], optional):  File suffix
+                that we are interested in. Defaults to None.
+            recursive (bool): If set to True, recursively scan the
+                directory. Defaults to False.
+
+        Yields:
+            Iterable[str]: A relative path to ``dir_path``.
+
+        Examples:
+            >>> backend = MSCBackend()
+            >>> dir_path = "path/of/dir"  # or "s3://path/of/dir"
+            >>> # list those files and directories in current directory
+            >>> list(backend.list_dir_or_file(dir_path))
+            ["file.txt", "subdir", "subdir/cat.png", "subdir/subsubdir/dog.jpg"]
+            >>> # only list files
+            >>> list(backend.list_dir_or_file(dir_path, list_dir=False))
+            ["file.txt", "subdir/cat.png", "subdir/subsubdir/dog.jpg"]
+            >>> # only list directories
+            >>> list(backend.list_dir_or_file(dir_path, list_file=False))
+            ["subdir"]
+            >>> # only list files ending with specified suffixes
+            >>> list(backend.list_dir_or_file(dir_path, suffix=".txt"))
+            ["file.txt"]
+            >>> # list all files and directory recursively
+            >>> list(backend.list_dir_or_file(dir_path, recursive=True))
+            ["file.txt", "subdir", "subdir/cat.png", "subdir/subsubdir", "subdir/subsubdir/dog.png"]
+        """
+        dir_path = self._translate_filepath(filepath=dir_path).removesuffix("/") + "/"
+
+        if list_dir and suffix is not None:
+            raise TypeError("`list_dir` should be False when `suffix` is not None")
+
+        if list_dir and not list_file and not recursive:
+            raise TypeError(
+                "Please use `list_dir` instead of `list_dir_or_file` "
+                "when you only want to list the first level directories."
+            )
+
+        if (suffix is not None) and not isinstance(suffix, (str, tuple)):
+            raise TypeError("`suffix` must be a string or tuple of strings")
+
+        yielded_subdir_paths: set[str] = set()
+        # In the MSC, the `include_directories` option switches between flat and hierarchical for both files and "directories".
+        #
+        # In the Boto3Backend, however, the `recursive` option only applies to "directories" (seems like a bug).
+        #
+        # Construct directories from file paths to match the Boto3Backend behavior.
+        #
+        # If this behavior needs to be fixed, switch to `include_directories=(not recursive)` and adjust metadata processing.
+        for metadata in self._storage_client.list(path=dir_path, include_directories=False, include_url_prefix=False):
+            # Only files should be returned with `include_directories=False`, but just in case.
+            if metadata.type == "file":
+                rel_path: str = metadata.key.removeprefix(dir_path)
+                if list_dir:
+                    rel_path_fragments = rel_path.split("/")
+                    if len(rel_path_fragments) > 1:
+                        for i in range(len(rel_path_fragments) - 1 if recursive else 1):
+                            subdir_path = "/".join(rel_path_fragments[: i + 1])
+                            if subdir_path not in yielded_subdir_paths:
+                                yielded_subdir_paths.add(subdir_path)
+                                yield subdir_path
+                if list_file:
+                    if suffix is None or rel_path.endswith(suffix):
+                        yield rel_path
+
+    def generate_presigned_url(self, url: str, client_method: str = "get_object", expires_in: int = 3600) -> str:
+        """Generate the presigned url of video stream which can be passed to
+        mmcv.VideoReader. Now only work on Boto3 backend.
+
+        Note:
+            Now only work on Boto3 backend.
+
+        Args:
+            url (str): Url of video stream.
+            client_method (str): Method of client, 'get_object' or
+                'put_object'. Default: 'get_object'.
+            expires_in (int): expires, in seconds. Default: 3600.
+
+        Returns:
+            str: Generated presigned url.
+        """
+        raise NotImplementedError("generate_presigned_url is not supported in MSCBackend")

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/backends/registry_utils.py

@@ -0,0 +1,130 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+from typing import Optional, Type, Union
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.base_backend import BaseStorageBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.http_backend import HTTPBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.local_backend import LocalBackend
+from cosmos_policy._src.imaginaire.utils.easy_io.backends.msc_backend import MSCBackend
+
+backends: dict = {}
+prefix_to_backends: dict = {}
+
+
+def _register_backend(
+    name: str,
+    backend: Type[BaseStorageBackend],
+    force: bool = False,
+    prefixes: Union[str, list, tuple, None] = None,
+):
+    """Register a backend.
+
+    Args:
+        name (str): The name of the registered backend.
+        backend (BaseStorageBackend): The backend class to be registered,
+            which must be a subclass of :class:`BaseStorageBackend`.
+        force (bool): Whether to override the backend if the name has already
+            been registered. Defaults to False.
+        prefixes (str or list[str] or tuple[str], optional): The prefix
+            of the registered storage backend. Defaults to None.
+    """
+    global backends, prefix_to_backends
+
+    if not isinstance(name, str):
+        raise TypeError(f"the backend name should be a string, but got {type(name)}")
+
+    if not inspect.isclass(backend):
+        raise TypeError(f"backend should be a class, but got {type(backend)}")
+    if not issubclass(backend, BaseStorageBackend):
+        raise TypeError(f"backend {backend} is not a subclass of BaseStorageBackend")
+
+    if name in backends and not force:
+        raise ValueError(
+            f'{name} is already registered as a storage backend, add "force=True" if you want to override it'
+        )
+    backends[name] = backend
+
+    if prefixes is not None:
+        if isinstance(prefixes, str):
+            prefixes = [prefixes]
+        else:
+            assert isinstance(prefixes, (list, tuple))
+
+        for prefix in prefixes:
+            if prefix in prefix_to_backends and not force:
+                raise ValueError(
+                    f'{prefix} is already registered as a storage backend, add "force=True" if you want to override it'
+                )
+
+            prefix_to_backends[prefix] = backend
+
+
+def register_backend(
+    name: str,
+    backend: Optional[Type[BaseStorageBackend]] = None,
+    force: bool = False,
+    prefixes: Union[str, list, tuple, None] = None,
+):
+    """Register a backend.
+
+    Args:
+        name (str): The name of the registered backend.
+        backend (class, optional): The backend class to be registered,
+            which must be a subclass of :class:`BaseStorageBackend`.
+            When this method is used as a decorator, backend is None.
+            Defaults to None.
+        force (bool): Whether to override the backend if the name has already
+            been registered. Defaults to False.
+        prefixes (str or list[str] or tuple[str], optional): The prefix
+            of the registered storage backend. Defaults to None.
+
+    This method can be used as a normal method or a decorator.
+
+    Examples:
+
+        >>> class NewBackend(BaseStorageBackend):
+        ...     def get(self, filepath):
+        ...         return filepath
+        ...
+        ...     def get_text(self, filepath):
+        ...         return filepath
+        >>> register_backend('new', NewBackend)
+
+        >>> @register_backend('new')
+        ... class NewBackend(BaseStorageBackend):
+        ...     def get(self, filepath):
+        ...         return filepath
+        ...
+        ...     def get_text(self, filepath):
+        ...         return filepath
+    """
+    if backend is not None:
+        _register_backend(name, backend, force=force, prefixes=prefixes)
+        return
+
+    def _register(backend_cls):
+        _register_backend(name, backend_cls, force=force, prefixes=prefixes)
+        return backend_cls
+
+    return _register
+
+
+register_backend("local", LocalBackend, prefixes="")
+# To avoid breaking backward Compatibility, 's3' is also used as a
+# prefix for MSCBackend
+register_backend("s3", MSCBackend, prefixes=["s3"])
+register_backend("http", HTTPBackend, prefixes=["http", "https"])

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/easy_io.py

@@ -0,0 +1,1116 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import warnings
+from contextlib import contextmanager
+from io import BytesIO, StringIO
+from pathlib import Path
+from typing import IO, Any, Generator, Iterator, Optional, Tuple, Union
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends import backends, prefix_to_backends
+from cosmos_policy._src.imaginaire.utils.easy_io.file_client import FileClient
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers import file_handlers
+
+backend_instances: dict = {}
+
+
+def is_filepath(filepath):
+    return isinstance(filepath, (str, Path))
+
+
+def _parse_uri_prefix(uri: Union[str, Path]) -> str:
+    """Parse the prefix of uri.
+
+    Args:
+        uri (str or Path): Uri to be parsed that contains the file prefix.
+
+    Examples:
+        >>> _parse_uri_prefix('/home/path/of/your/file')
+        ''
+        >>> _parse_uri_prefix('s3://path/of/your/file')
+        's3'
+        >>> _parse_uri_prefix('clusterName:s3://path/of/your/file')
+        's3'
+
+    Returns:
+        str: Return the prefix of uri if the uri contains '://'. Otherwise,
+        return ''.
+    """
+    assert is_filepath(uri)
+    uri = str(uri)
+    # if uri does not contains '://', the uri will be handled by
+    # LocalBackend by default
+    if "://" not in uri:
+        return ""
+    else:
+        prefix, _ = uri.split("://")
+        # In the case of Boto3Backend, the prefix may contain the cluster
+        # name like clusterName:s3://path/of/your/file
+        if ":" in prefix:
+            _, prefix = prefix.split(":")
+        return prefix
+
+
+def _get_file_backend(prefix: str, backend_args: dict):
+    """Return a file backend based on the prefix or backend_args.
+
+    Args:
+        prefix (str): Prefix of uri.
+        backend_args (dict): Arguments to instantiate the corresponding
+            backend.
+    """
+    # backend name has a higher priority
+    if "backend" in backend_args:
+        # backend_args should not be modified
+        backend_args_bak = backend_args.copy()
+        backend_name = backend_args_bak.pop("backend")
+        backend = backends[backend_name](**backend_args_bak)
+    else:
+        backend = prefix_to_backends[prefix](**backend_args)
+    return backend
+
+
+def set_s3_backend(
+    key: str = "s3:{}",
+    backend_args: Optional[dict] = None,
+):
+    """register s3 backend.
+
+    Args:
+        key str: The key to register the s3 backend. Defaults to s3.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+    global backend_instances
+    if backend_args is None:
+        backend_args = {}
+    backend = _get_file_backend(key, backend_args)
+    backend_instances[key] = backend
+    return backend
+
+
+def get_file_backend(
+    uri: Union[str, Path, None] = None,
+    *,
+    backend_args: Optional[dict] = None,
+    enable_singleton: bool = False,
+    backend_key: Optional[str] = None,
+):
+    """Return a file backend based on the prefix of uri or backend_args.
+
+    Args:
+        uri (str or Path): Uri to be parsed that contains the file prefix.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        enable_singleton (bool): Whether to enable the singleton pattern.
+            If it is True, the backend created will be reused if the
+            signature is same with the previous one. Defaults to False.
+        backend_key: str: The key to register the backend. Defaults to None.
+
+    Returns:
+        BaseStorageBackend: Instantiated Backend object.
+
+    Examples:
+        >>> # get file backend based on the prefix of uri
+        >>> uri = 's3://path/of/your/file'
+        >>> backend = get_file_backend(uri)
+        >>> # get file backend based on the backend_args
+        >>> backend = get_file_backend(backend_args={'backend': 's3'})
+        >>> # backend name has a higher priority if 'backend' in backend_args
+        >>> backend = get_file_backend(uri, backend_args={'backend': 's3'})
+    """
+    global backend_instances
+    if backend_key is not None:
+        if backend_key in backend_instances:
+            return backend_instances[backend_key]
+
+    if backend_args is None:
+        backend_args = {}
+
+    if uri is None and "backend" not in backend_args and backend_key is None:
+        raise ValueError('uri should not be None when "backend" does not exist in backend_args and backend_key is None')
+
+    if uri is not None:
+        prefix = _parse_uri_prefix(uri)
+    else:
+        prefix = ""
+
+    if enable_singleton:
+        unique_key = f"{prefix}:{json.dumps(backend_args)}"
+        if unique_key in backend_instances:
+            return backend_instances[unique_key]
+
+        backend = _get_file_backend(prefix, backend_args)
+        backend_instances[unique_key] = backend
+        if backend_key is not None:
+            backend_instances[backend_key] = backend
+        return backend
+    else:
+        backend = _get_file_backend(prefix, backend_args)
+        return backend
+
+
+def size(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> int:
+    """Get the file size in bytes for a given ``filepath``.
+
+    Args:
+        filepath (str or Path): Path to get file size in bytes.
+
+    Returns:
+        int: File size in bytes for filepath.
+
+    Examples:
+        >>> filepath = 'path/of/file'
+        >>> size(filepath)  # file containing 'hello world'
+        11
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.size(filepath)
+
+
+def get(
+    filepath: Union[str, Path],
+    offset: Optional[int] = None,
+    size: Optional[int] = None,
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> bytes:
+    """Read bytes from a given ``filepath`` with 'rb' mode in range [offset, offset + size).
+
+    Args:
+        filepath (str or Path): Path to read data.
+        offset (int, optional): Read offset in bytes (0-index). Defaults to 0.
+        size (int, optional): Read size in bytes. Defaults to the file size.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        bytes: Expected bytes object.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> get(filepath)
+        b'hello world'
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.get(filepath, offset=offset, size=size)
+
+
+def get_text(
+    filepath: Union[str, Path],
+    encoding="utf-8",
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> str:
+    """Read text from a given ``filepath`` with 'r' mode.
+
+    Args:
+        filepath (str or Path): Path to read data.
+        encoding (str): The encoding format used to open the ``filepath``.
+            Defaults to 'utf-8'.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        str: Expected text reading from ``filepath``.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> get_text(filepath)
+        'hello world'
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.get_text(filepath, encoding)
+
+
+def put(
+    obj: bytes,
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> None:
+    """Write bytes to a given ``filepath`` with 'wb' mode.
+
+    Note:
+        ``put`` should create a directory if the directory of
+        ``filepath`` does not exist.
+
+    Args:
+        obj (bytes): Data to be written.
+        filepath (str or Path): Path to write data.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> put(b'hello world', filepath)
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    backend.put(obj, filepath)
+
+
+def put_text(
+    obj: str,
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> None:
+    """Write text to a given ``filepath`` with 'w' mode.
+
+    Note:
+        ``put_text`` should create a directory if the directory of
+        ``filepath`` does not exist.
+
+    Args:
+        obj (str): Data to be written.
+        filepath (str or Path): Path to write data.
+        encoding (str, optional): The encoding format used to open the
+            ``filepath``. Defaults to 'utf-8'.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> put_text('hello world', filepath)
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    backend.put_text(obj, filepath)
+
+
+def exists(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> bool:
+    """Check whether a file path exists.
+
+    Args:
+        filepath (str or Path): Path to be checked whether exists.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        bool: Return ``True`` if ``filepath`` exists, ``False`` otherwise.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> exists(filepath)
+        True
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.exists(filepath)
+
+
+def isdir(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> bool:
+    """Check whether a file path is a directory.
+
+    Args:
+        filepath (str or Path): Path to be checked whether it is a
+            directory.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        bool: Return ``True`` if ``filepath`` points to a directory,
+        ``False`` otherwise.
+
+    Examples:
+        >>> filepath = '/path/of/dir'
+        >>> isdir(filepath)
+        True
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.isdir(filepath)
+
+
+def isfile(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> bool:
+    """Check whether a file path is a file.
+
+    Args:
+        filepath (str or Path): Path to be checked whether it is a file.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        bool: Return ``True`` if ``filepath`` points to a file, ``False``
+        otherwise.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> isfile(filepath)
+        True
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.isfile(filepath)
+
+
+def join_path(
+    filepath: Union[str, Path],
+    *filepaths: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    r"""Concatenate all file paths.
+
+    Join one or more filepath components intelligently. The return value
+    is the concatenation of filepath and any members of \*filepaths.
+
+    Args:
+        filepath (str or Path): Path to be concatenated.
+        *filepaths (str or Path): Other paths to be concatenated.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        str: The result of concatenation.
+
+    Examples:
+        >>> filepath1 = '/path/of/dir1'
+        >>> filepath2 = 'dir2'
+        >>> filepath3 = 'path/of/file'
+        >>> join_path(filepath1, filepath2, filepath3)
+        '/path/of/dir/dir2/path/of/file'
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    return backend.join_path(filepath, *filepaths)
+
+
+@contextmanager
+def get_local_path(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Generator[Union[str, Path], None, None]:
+    """Download data from ``filepath`` and write the data to local path.
+
+    ``get_local_path`` is decorated by :meth:`contxtlib.contextmanager`. It
+    can be called with ``with`` statement, and when exists from the
+    ``with`` statement, the temporary path will be released.
+
+    Note:
+        If the ``filepath`` is a local path, just return itself and it will
+        not be released (removed).
+
+    Args:
+        filepath (str or Path): Path to be read data.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Yields:
+        Iterable[str]: Only yield one path.
+
+    Examples:
+        >>> with get_local_path('s3://bucket/abc.jpg') as path:
+        ...     # do something here
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    with backend.get_local_path(str(filepath)) as local_path:
+        yield local_path
+
+
+def copyfile(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Copy a file src to dst and return the destination file.
+
+    src and dst should have the same prefix. If dst specifies a directory,
+    the file will be copied into dst using the base filename from src. If
+    dst specifies a file that already exists, it will be replaced.
+
+    Args:
+        src (str or Path): A file to be copied.
+        dst (str or Path): Copy file to dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: The destination file.
+
+    Raises:
+        SameFileError: If src and dst are the same file, a SameFileError will
+            be raised.
+
+    Examples:
+        >>> # dst is a file
+        >>> src = '/path/of/file'
+        >>> dst = '/path1/of/file1'
+        >>> # src will be copied to '/path1/of/file1'
+        >>> copyfile(src, dst)
+        '/path1/of/file1'
+
+        >>> # dst is a directory
+        >>> dst = '/path1/of/dir'
+        >>> # src will be copied to '/path1/of/dir/file'
+        >>> copyfile(src, dst)
+        '/path1/of/dir/file'
+    """
+    backend = get_file_backend(src, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copyfile(src, dst)
+
+
+def copytree(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Recursively copy an entire directory tree rooted at src to a directory
+    named dst and return the destination directory.
+
+    src and dst should have the same prefix and dst must not already exist.
+
+    Args:
+        src (str or Path): A directory to be copied.
+        dst (str or Path): Copy directory to dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        backend_key (str, optional): The key to get the backend from register.
+
+    Returns:
+        str: The destination directory.
+
+    Raises:
+        FileExistsError: If dst had already existed, a FileExistsError will be
+            raised.
+
+    Examples:
+        >>> src = '/path/of/dir1'
+        >>> dst = '/path/of/dir2'
+        >>> copytree(src, dst)
+        '/path/of/dir2'
+    """
+    backend = get_file_backend(src, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copytree(src, dst)
+
+
+def copyfile_from_local(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Copy a local file src to dst and return the destination file.
+
+    Note:
+        If the backend is the instance of LocalBackend, it does the same
+        thing with :func:`copyfile`.
+
+    Args:
+        src (str or Path): A local file to be copied.
+        dst (str or Path): Copy file to dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: If dst specifies a directory, the file will be copied into dst
+        using the base filename from src.
+
+    Examples:
+        >>> # dst is a file
+        >>> src = '/path/of/file'
+        >>> dst = 's3://openmmlab/mmengine/file1'
+        >>> # src will be copied to 's3://openmmlab/mmengine/file1'
+        >>> copyfile_from_local(src, dst)
+        s3://openmmlab/mmengine/file1
+
+        >>> # dst is a directory
+        >>> dst = 's3://openmmlab/mmengine'
+        >>> # src will be copied to 's3://openmmlab/mmengine/file''
+        >>> copyfile_from_local(src, dst)
+        's3://openmmlab/mmengine/file'
+    """
+    backend = get_file_backend(dst, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copyfile_from_local(src, dst)
+
+
+def copytree_from_local(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Recursively copy an entire directory tree rooted at src to a directory
+    named dst and return the destination directory.
+
+    Note:
+        If the backend is the instance of LocalBackend, it does the same
+        thing with :func:`copytree`.
+
+    Args:
+        src (str or Path): A local directory to be copied.
+        dst (str or Path): Copy directory to dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: The destination directory.
+
+    Examples:
+        >>> src = '/path/of/dir'
+        >>> dst = 's3://openmmlab/mmengine/dir'
+        >>> copyfile_from_local(src, dst)
+        's3://openmmlab/mmengine/dir'
+    """
+    backend = get_file_backend(dst, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copytree_from_local(src, dst)
+
+
+def copyfile_to_local(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    dst_type: str,  # Choose from ["file", "dir"]
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Copy the file src to local dst and return the destination file.
+
+    If dst specifies a directory, the file will be copied into dst using
+    the base filename from src. If dst specifies a file that already
+    exists, it will be replaced.
+
+    Note:
+        If the backend is the instance of LocalBackend, it does the same
+        thing with :func:`copyfile`.
+
+    Args:
+        src (str or Path): A file to be copied.
+        dst (str or Path): Copy file to to local dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: If dst specifies a directory, the file will be copied into dst
+        using the base filename from src.
+
+    Examples:
+        >>> # dst is a file
+        >>> src = 's3://openmmlab/mmengine/file'
+        >>> dst = '/path/of/file'
+        >>> # src will be copied to '/path/of/file'
+        >>> copyfile_to_local(src, dst)
+        '/path/of/file'
+
+        >>> # dst is a directory
+        >>> dst = '/path/of/dir'
+        >>> # src will be copied to '/path/of/dir/file'
+        >>> copyfile_to_local(src, dst)
+        '/path/of/dir/file'
+    """
+    assert dst_type in ["file", "dir"]
+    Path(dst).parent.mkdir(parents=True, exist_ok=True)
+    backend = get_file_backend(src, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copyfile_to_local(src, dst, dst_type=dst_type)
+
+
+def copytree_to_local(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Union[str, Path]:
+    """Recursively copy an entire directory tree rooted at src to a local
+    directory named dst and return the destination directory.
+
+    Note:
+        If the backend is the instance of LocalBackend, it does the same
+        thing with :func:`copytree`.
+
+    Args:
+        src (str or Path): A directory to be copied.
+        dst (str or Path): Copy directory to local dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: The destination directory.
+
+    Examples:
+        >>> src = 's3://openmmlab/mmengine/dir'
+        >>> dst = '/path/of/dir'
+        >>> copytree_to_local(src, dst)
+        '/path/of/dir'
+    """
+    Path(dst).parent.mkdir(parents=True, exist_ok=True)
+    backend = get_file_backend(dst, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copytree_to_local(src, dst)
+
+
+def remove(
+    filepath: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> None:
+    """Remove a file.
+
+    Args:
+        filepath (str, Path): Path to be removed.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Raises:
+        FileNotFoundError: If filepath does not exist, an FileNotFoundError
+            will be raised.
+        IsADirectoryError: If filepath is a directory, an IsADirectoryError
+            will be raised.
+
+    Examples:
+        >>> filepath = '/path/of/file'
+        >>> remove(filepath)
+    """
+    backend = get_file_backend(
+        filepath,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    backend.remove(filepath)
+
+
+def rmtree(
+    dir_path: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> None:
+    """Recursively delete a directory tree.
+
+    Args:
+        dir_path (str or Path): A directory to be removed.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Examples:
+        >>> dir_path = '/path/of/dir'
+        >>> rmtree(dir_path)
+    """
+    backend = get_file_backend(
+        dir_path,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    backend.rmtree(dir_path)
+
+
+def copy_if_symlink_fails(
+    src: Union[str, Path],
+    dst: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> bool:
+    """Create a symbolic link pointing to src named dst.
+
+    If failed to create a symbolic link pointing to src, directory copy src to
+    dst instead.
+
+    Args:
+        src (str or Path): Create a symbolic link pointing to src.
+        dst (str or Path): Create a symbolic link named dst.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        bool: Return True if successfully create a symbolic link pointing to
+        src. Otherwise, return False.
+
+    Examples:
+        >>> src = '/path/of/file'
+        >>> dst = '/path1/of/file1'
+        >>> copy_if_symlink_fails(src, dst)
+        True
+        >>> src = '/path/of/dir'
+        >>> dst = '/path1/of/dir1'
+        >>> copy_if_symlink_fails(src, dst)
+        True
+    """
+    backend = get_file_backend(src, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.copy_if_symlink_fails(src, dst)
+
+
+def list_dir(
+    dir_path: Union[str, Path],
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+):
+    """List all folders in an S3 bucket with a given prefix.
+
+    Args:
+        dir_path (str | Path): Path of the directory.
+
+    Examples:
+        >>> dir_path = '/path/of/dir'
+        >>> for file_path in list_dir(dir_path):
+        ...     print(file_path)
+    """
+    if not dir_path.endswith("/"):
+        dir_path += "/"
+    backend = get_file_backend(
+        dir_path,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+
+    return backend.list_dir(dir_path)
+
+
+def list_dir_or_file(
+    dir_path: Union[str, Path],
+    list_dir: bool = True,
+    list_file: bool = True,
+    suffix: Optional[Union[str, Tuple[str]]] = None,
+    recursive: bool = False,
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> Iterator[str]:
+    """Scan a directory to find the interested directories or files in
+    arbitrary order.
+
+    Note:
+        :meth:`list_dir_or_file` returns the path relative to ``dir_path``.
+
+    Args:
+        dir_path (str or Path): Path of the directory.
+        list_dir (bool): List the directories. Defaults to True.
+        list_file (bool): List the path of files. Defaults to True.
+        suffix (str or tuple[str], optional): File suffix that we are
+            interested in. Defaults to None.
+        recursive (bool): If set to True, recursively scan the directory.
+            Defaults to False.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Yields:
+        Iterable[str]: A relative path to ``dir_path``.
+
+    Examples:
+        >>> dir_path = '/path/of/dir'
+        >>> for file_path in list_dir_or_file(dir_path):
+        ...     print(file_path)
+        >>> # list those files and directories in current directory
+        >>> for file_path in list_dir_or_file(dir_path):
+        ...     print(file_path)
+        >>> # only list files
+        >>> for file_path in list_dir_or_file(dir_path, list_dir=False):
+        ...     print(file_path)
+        >>> # only list directories
+        >>> for file_path in list_dir_or_file(dir_path, list_file=False):
+        ...     print(file_path)
+        >>> # only list files ending with specified suffixes
+        >>> for file_path in list_dir_or_file(dir_path, suffix='.txt'):
+        ...     print(file_path)
+        >>> # list all files and directory recursively
+        >>> for file_path in list_dir_or_file(dir_path, recursive=True):
+        ...     print(file_path)
+    """
+    backend = get_file_backend(
+        dir_path,
+        backend_args=backend_args,
+        enable_singleton=True,
+        backend_key=backend_key,
+    )
+    yield from backend.list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive)
+
+
+def generate_presigned_url(
+    url: str,
+    client_method: str = "get_object",
+    expires_in: int = 3600,
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+) -> str:
+    """Generate the presigned url of video stream which can be passed to
+    mmcv.VideoReader. Now only work on s3 backend.
+
+    Note:
+        Now only work on s3 backend.
+
+    Args:
+        url (str): Url of video stream.
+        client_method (str): Method of client, 'get_object' or
+            'put_object'. Defaults to 'get_object'.
+        expires_in (int): expires, in seconds. Defaults to 3600.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+
+    Returns:
+        str: Generated presigned url.
+    """
+    backend = get_file_backend(url, backend_args=backend_args, enable_singleton=True, backend_key=backend_key)
+    return backend.generate_presigned_url(url, client_method, expires_in)
+
+
+def load(
+    file: Union[str, Path, IO[Any]],
+    file_format: Optional[str] = None,
+    file_client_args: Optional[dict] = None,
+    fast_backend: bool = False,
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+    **kwargs,
+):
+    """Load data from json/yaml/pickle files.
+
+    This method provides a unified api for loading data from serialized files.
+
+    ``load`` supports loading data from serialized files those can be storaged
+    in different backends.
+
+    Args:
+        file (str or :obj:`Path` or file-like object): Filename or a file-like
+            object.
+        file_format (str, optional): If not specified, the file format will be
+            inferred from the file extension, otherwise use the specified one.
+            Currently supported formats include "json", "yaml/yml" and
+            "pickle/pkl".
+        file_client_args (dict, optional): Arguments to instantiate a
+            FileClient. See :class:`mmengine.fileio.FileClient` for details.
+            Defaults to None. It will be deprecated in future. Please use
+            ``backend_args`` instead.
+        fast_backend: bool: Whether to use multiprocess. Defaults to False.
+        backend_args (dict, optional): Arguments to instantiate the
+            prefix of uri corresponding backend. Defaults to None.
+            New in v0.2.0.
+
+    Examples:
+        >>> load('/path/of/your/file')  # file is storaged in disk
+        >>> load('https://path/of/your/file')  # file is storaged in Internet
+        >>> load('s3://path/of/your/file')  # file is storaged in s3
+
+    Returns:
+        The content from the file.
+    """
+    if isinstance(file, Path):
+        file = str(file)
+    if file_format is None and isinstance(file, str):
+        file_format = file.split(".")[-1]
+    # convert file_format to lower case
+    file_format = file_format.lower()
+    if file_format not in file_handlers:
+        raise TypeError(f"Unsupported format: {file_format}")
+
+    if file_client_args is not None:
+        warnings.warn(
+            '"file_client_args" will be deprecated in future. Please use "backend_args" instead',
+            DeprecationWarning,
+        )
+        if backend_args is not None:
+            raise ValueError('"file_client_args and "backend_args" cannot be set at the same time.')
+
+    handler = file_handlers[file_format]
+    if isinstance(file, str):
+        if file_client_args is not None:
+            file_client = FileClient.infer_client(file_client_args, file)
+            file_backend = file_client
+        else:
+            file_backend = get_file_backend(
+                file,
+                backend_args=backend_args,
+                backend_key=backend_key,
+                enable_singleton=True,
+            )
+
+        if handler.str_like:
+            with StringIO(file_backend.get_text(file)) as f:
+                obj = handler.load_from_fileobj(f, **kwargs)
+        else:
+            if fast_backend:
+                if hasattr(file_backend, "fast_get"):
+                    with BytesIO(file_backend.fast_get(file)) as f:
+                        obj = handler.load_from_fileobj(f, **kwargs)
+                else:
+                    warnings.warn(
+                        f"fast_backend is not supported by the backend, type {type(file_backend)} fallback to normal get"
+                    )
+                    with BytesIO(file_backend.get(file)) as f:
+                        obj = handler.load_from_fileobj(f, **kwargs)
+            else:
+                with BytesIO(file_backend.get(file)) as f:
+                    obj = handler.load_from_fileobj(f, **kwargs)
+    elif hasattr(file, "read"):
+        obj = handler.load_from_fileobj(file, **kwargs)
+    else:
+        raise TypeError('"file" must be a filepath str or a file-object')
+    return obj
+
+
+def dump(
+    obj: Any,
+    file: Union[str, Path, IO[Any], None] = None,
+    file_format: Optional[str] = None,
+    file_client_args: Optional[dict] = None,
+    fast_backend: bool = False,
+    backend_args: Optional[dict] = None,
+    backend_key: Optional[str] = None,
+    **kwargs,
+):
+    """Dump data to json/yaml/pickle strings or files.
+
+    This method provides a unified api for dumping data as strings or to files,
+    and also supports custom arguments for each file format.
+
+    ``dump`` supports dumping data as strings or to files which is saved to
+    different backends.
+
+    Args:
+        obj (any): The python object to be dumped.
+        file (str or :obj:`Path` or file-like object, optional): If not
+            specified, then the object is dumped to a str, otherwise to a file
+            specified by the filename or file-like object.
+        file_format (str, optional): Same as :func:`load`.
+        file_client_args (dict, optional): Arguments to instantiate a
+            FileClient. See :class:`mmengine.fileio.FileClient` for details.
+            Defaults to None. It will be deprecated in future. Please use
+            ``backend_args`` instead.
+        fast_backend: bool: Whether to use multiprocess. Defaults to False.
+        backend_args (dict, optional): Arguments to instantiate the
+            prefix of uri corresponding backend. Defaults to None.
+            New in v0.2.0.
+        backend_key: str: The key to register the backend. Defaults to None.
+
+    Examples:
+        >>> dump('hello world', '/path/of/your/file')  # disk
+        >>> dump('hello world', 's3://path/of/your/file')  # ceph or s3
+
+    Returns:
+        bool: True for success, False otherwise.
+    """
+    if isinstance(file, Path):
+        file = str(file)
+    if file_format is None:
+        if isinstance(file, str):
+            file_format = file.split(".")[-1]
+        elif file is None:
+            raise ValueError("file_format must be specified since file is None")
+    # convert file_format to lower case
+    file_format = file_format.lower()
+    if file_format not in file_handlers:
+        raise TypeError(f"Unsupported format: {file_format}")
+
+    if file_client_args is not None:
+        warnings.warn(
+            '"file_client_args" will be deprecated in future. Please use "backend_args" instead',
+            DeprecationWarning,
+        )
+        if backend_args is not None:
+            raise ValueError('"file_client_args" and "backend_args" cannot be set at the same time.')
+
+    handler = file_handlers[file_format]
+    if file is None:
+        return handler.dump_to_str(obj, **kwargs)
+    elif isinstance(file, str):
+        if file_client_args is not None:
+            file_client = FileClient.infer_client(file_client_args, file)
+            file_backend = file_client
+        else:
+            file_backend = get_file_backend(
+                file,
+                backend_args=backend_args,
+                backend_key=backend_key,
+                enable_singleton=True,
+            )
+
+        if handler.str_like:
+            with StringIO() as f:
+                handler.dump_to_fileobj(obj, f, **kwargs)
+                file_backend.put_text(f.getvalue(), file)
+        else:
+            with BytesIO() as f:
+                handler.dump_to_fileobj(obj, f, **kwargs)
+                if fast_backend:
+                    if hasattr(file_backend, "fast_put"):
+                        file_backend.fast_put(f, file)
+                    else:
+                        warnings.warn("fast_backend is not supported by the backend, fallback to normal put")
+                        file_backend.put(f, file)
+                else:
+                    file_backend.put(f, file)
+    elif hasattr(file, "write"):
+        handler.dump_to_fileobj(obj, file, **kwargs)
+    else:
+        raise TypeError('"file" must be a filename str or a file-object')

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/file_client.py

@@ -0,0 +1,459 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Generator, Iterator, Optional, Tuple, Union
+
+from cosmos_policy._src.imaginaire.utils.easy_io.backends import (
+    BaseStorageBackend,
+    HTTPBackend,
+    LocalBackend,
+    MSCBackend,
+)
+
+
+def is_filepath(filepath):
+    return isinstance(filepath, (str, Path))
+
+
+class HardDiskBackend(LocalBackend):
+    """Raw hard disks storage backend."""
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+
+class FileClient:
+    """A general file client to access files in different backends.
+
+    The client loads a file or text in a specified backend from its path
+    and returns it as a binary or text file. There are two ways to choose a
+    backend, the name of backend and the prefix of path. Although both of them
+    can be used to choose a storage backend, ``backend`` has a higher priority
+    that is if they are all set, the storage backend will be chosen by the
+    backend argument. If they are all `None`, the disk backend will be chosen.
+    Note that It can also register other backend accessor with a given name,
+    prefixes, and backend class. In addition, We use the singleton pattern to
+    avoid repeated object creation. If the arguments are the same, the same
+    object will be returned.
+
+    Warning:
+        `FileClient` will be deprecated in future. Please use io functions
+        in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io
+
+    Args:
+        backend (str, optional): The storage backend type. Options are "disk",
+            "memcached", "lmdb", "http" and "s3". Defaults to None.
+        prefix (str, optional): The prefix of the registered storage backend.
+            Options are "s3", "http", "https". Defaults to None.
+
+    Examples:
+        >>> # only set backend
+        >>> file_client = FileClient(backend='s3')
+        >>> # only set prefix
+        >>> file_client = FileClient(prefix='s3')
+        >>> # set both backend and prefix but use backend to choose client
+        >>> file_client = FileClient(backend='s3', prefix='s3')
+        >>> # if the arguments are the same, the same object is returned
+        >>> file_client1 = FileClient(backend='s3')
+        >>> file_client1 is file_client
+        True
+
+    Attributes:
+        client (:obj:`BaseStorageBackend`): The backend object.
+    """
+
+    _backends = {
+        "disk": HardDiskBackend,
+        "s3": MSCBackend,
+        "http": HTTPBackend,
+        "msc": MSCBackend,
+    }
+
+    _prefix_to_backends: dict = {
+        "s3": MSCBackend,
+        "http": HTTPBackend,
+        "https": HTTPBackend,
+    }
+
+    _instances: dict = {}
+
+    client: Any
+
+    def __new__(cls, backend=None, prefix=None, **kwargs):
+        if backend is None and prefix is None:
+            backend = "disk"
+        if backend is not None and backend not in cls._backends:
+            raise ValueError(
+                f"Backend {backend} is not supported. Currently supported ones are {list(cls._backends.keys())}"
+            )
+        if prefix is not None and prefix not in cls._prefix_to_backends:
+            raise ValueError(
+                f"prefix {prefix} is not supported. Currently supported ones are {list(cls._prefix_to_backends.keys())}"
+            )
+
+        # concatenate the arguments to a unique key for determining whether
+        # objects with the same arguments were created
+        arg_key = f"{backend}:{prefix}"
+        for key, value in kwargs.items():
+            arg_key += f":{key}:{value}"
+
+        # if a backend was overridden, it will create a new object
+        if arg_key in cls._instances:
+            _instance = cls._instances[arg_key]
+        else:
+            # create a new object and put it to _instance
+            _instance = super().__new__(cls)
+            if backend is not None:
+                _instance.client = cls._backends[backend](**kwargs)
+            else:
+                _instance.client = cls._prefix_to_backends[prefix](**kwargs)
+
+            cls._instances[arg_key] = _instance
+
+        return _instance
+
+    @property
+    def name(self):
+        return self.client.name
+
+    @property
+    def allow_symlink(self):
+        return self.client.allow_symlink
+
+    @staticmethod
+    def parse_uri_prefix(uri: Union[str, Path]) -> Optional[str]:
+        """Parse the prefix of a uri.
+
+        Args:
+            uri (str | Path): Uri to be parsed that contains the file prefix.
+
+        Examples:
+            >>> FileClient.parse_uri_prefix('s3://path/of/your/file')
+            's3'
+
+        Returns:
+            str | None: Return the prefix of uri if the uri contains '://' else
+            ``None``.
+        """
+        assert is_filepath(uri)
+        uri = str(uri)
+        if "://" not in uri:
+            return None
+        else:
+            prefix, _ = uri.split("://")
+            # In the case of MSCBackend, the prefix may contains the cluster
+            # name like clusterName:s3
+            if ":" in prefix:
+                _, prefix = prefix.split(":")
+            return prefix
+
+    @classmethod
+    def infer_client(
+        cls,
+        file_client_args: Optional[dict] = None,
+        uri: Optional[Union[str, Path]] = None,
+    ) -> "FileClient":
+        """Infer a suitable file client based on the URI and arguments.
+
+        Args:
+            file_client_args (dict, optional): Arguments to instantiate a
+                FileClient. Defaults to None.
+            uri (str | Path, optional): Uri to be parsed that contains the file
+                prefix. Defaults to None.
+
+        Examples:
+            >>> uri = 's3://path/of/your/file'
+            >>> file_client = FileClient.infer_client(uri=uri)
+            >>> file_client_args = {'backend': 's3'}
+            >>> file_client = FileClient.infer_client(file_client_args)
+
+        Returns:
+            FileClient: Instantiated FileClient object.
+        """
+        assert file_client_args is not None or uri is not None
+        if file_client_args is None:
+            file_prefix = cls.parse_uri_prefix(uri)  # type: ignore
+            return cls(prefix=file_prefix)
+        else:
+            return cls(**file_client_args)
+
+    @classmethod
+    def _register_backend(cls, name, backend, force=False, prefixes=None):
+        if not isinstance(name, str):
+            raise TypeError(f"the backend name should be a string, but got {type(name)}")
+        if not inspect.isclass(backend):
+            raise TypeError(f"backend should be a class but got {type(backend)}")
+        if not issubclass(backend, BaseStorageBackend):
+            raise TypeError(f"backend {backend} is not a subclass of BaseStorageBackend")
+        if not force and name in cls._backends:
+            raise KeyError(
+                f'{name} is already registered as a storage backend, add "force=True" if you want to override it'
+            )
+
+        if name in cls._backends and force:
+            for arg_key, instance in list(cls._instances.items()):
+                if isinstance(instance.client, cls._backends[name]):
+                    cls._instances.pop(arg_key)
+        cls._backends[name] = backend
+
+        if prefixes is not None:
+            if isinstance(prefixes, str):
+                prefixes = [prefixes]
+            else:
+                assert isinstance(prefixes, (list, tuple))
+            for prefix in prefixes:
+                if prefix not in cls._prefix_to_backends:
+                    cls._prefix_to_backends[prefix] = backend
+                elif (prefix in cls._prefix_to_backends) and force:
+                    overridden_backend = cls._prefix_to_backends[prefix]
+                    for arg_key, instance in list(cls._instances.items()):
+                        if isinstance(instance.client, overridden_backend):
+                            cls._instances.pop(arg_key)
+                else:
+                    raise KeyError(
+                        f"{prefix} is already registered as a storage backend,"
+                        ' add "force=True" if you want to override it'
+                    )
+
+    @classmethod
+    def register_backend(cls, name, backend=None, force=False, prefixes=None):
+        """Register a backend to FileClient.
+
+        This method can be used as a normal class method or a decorator.
+
+        .. code-block:: python
+
+            class NewBackend(BaseStorageBackend):
+
+                def get(self, filepath):
+                    return filepath
+
+                def get_text(self, filepath):
+                    return filepath
+
+            FileClient.register_backend('new', NewBackend)
+
+        or
+
+        .. code-block:: python
+
+            @FileClient.register_backend('new')
+            class NewBackend(BaseStorageBackend):
+
+                def get(self, filepath):
+                    return filepath
+
+                def get_text(self, filepath):
+                    return filepath
+
+        Args:
+            name (str): The name of the registered backend.
+            backend (class, optional): The backend class to be registered,
+                which must be a subclass of :class:`BaseStorageBackend`.
+                When this method is used as a decorator, backend is None.
+                Defaults to None.
+            force (bool, optional): Whether to override the backend if the name
+                has already been registered. Defaults to False.
+            prefixes (str or list[str] or tuple[str], optional): The prefixes
+                of the registered storage backend. Defaults to None.
+                `New in version 1.3.15.`
+        """
+        if backend is not None:
+            cls._register_backend(name, backend, force=force, prefixes=prefixes)
+            return
+
+        def _register(backend_cls):
+            cls._register_backend(name, backend_cls, force=force, prefixes=prefixes)
+            return backend_cls
+
+        return _register
+
+    def get(self, filepath: Union[str, Path]) -> Union[bytes, memoryview]:
+        """Read data from a given ``filepath`` with 'rb' mode.
+
+        Note:
+            There are two types of return values for ``get``, one is ``bytes``
+            and the other is ``memoryview``. The advantage of using memoryview
+            is that you can avoid copying, and if you want to convert it to
+            ``bytes``, you can use ``.tobytes()``.
+
+        Args:
+            filepath (str or Path): Path to read data.
+
+        Returns:
+            bytes | memoryview: Expected bytes object or a memory view of the
+            bytes object.
+        """
+        return self.client.get(filepath)
+
+    def get_text(self, filepath: Union[str, Path], encoding="utf-8") -> str:
+        """Read data from a given ``filepath`` with 'r' mode.
+
+        Args:
+            filepath (str or Path): Path to read data.
+            encoding (str): The encoding format used to open the ``filepath``.
+                Defaults to 'utf-8'.
+
+        Returns:
+            str: Expected text reading from ``filepath``.
+        """
+        return self.client.get_text(filepath, encoding)
+
+    def put(self, obj: bytes, filepath: Union[str, Path]) -> None:
+        """Write data to a given ``filepath`` with 'wb' mode.
+
+        Note:
+            ``put`` should create a directory if the directory of ``filepath``
+            does not exist.
+
+        Args:
+            obj (bytes): Data to be written.
+            filepath (str or Path): Path to write data.
+        """
+        self.client.put(obj, filepath)
+
+    def put_text(self, obj: str, filepath: Union[str, Path]) -> None:
+        """Write data to a given ``filepath`` with 'w' mode.
+
+        Note:
+            ``put_text`` should create a directory if the directory of
+            ``filepath`` does not exist.
+
+        Args:
+            obj (str): Data to be written.
+            filepath (str or Path): Path to write data.
+            encoding (str, optional): The encoding format used to open the
+                `filepath`. Defaults to 'utf-8'.
+        """
+        self.client.put_text(obj, filepath)
+
+    def remove(self, filepath: Union[str, Path]) -> None:
+        """Remove a file.
+
+        Args:
+            filepath (str, Path): Path to be removed.
+        """
+        self.client.remove(filepath)
+
+    def exists(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path exists.
+
+        Args:
+            filepath (str or Path): Path to be checked whether exists.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` exists, ``False`` otherwise.
+        """
+        return self.client.exists(filepath)
+
+    def isdir(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a directory.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a
+                directory.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a directory,
+            ``False`` otherwise.
+        """
+        return self.client.isdir(filepath)
+
+    def isfile(self, filepath: Union[str, Path]) -> bool:
+        """Check whether a file path is a file.
+
+        Args:
+            filepath (str or Path): Path to be checked whether it is a file.
+
+        Returns:
+            bool: Return ``True`` if ``filepath`` points to a file, ``False``
+            otherwise.
+        """
+        return self.client.isfile(filepath)
+
+    def join_path(self, filepath: Union[str, Path], *filepaths: Union[str, Path]) -> str:
+        r"""Concatenate all file paths.
+
+        Join one or more filepath components intelligently. The return value
+        is the concatenation of filepath and any members of \*filepaths.
+
+        Args:
+            filepath (str or Path): Path to be concatenated.
+
+        Returns:
+            str: The result of concatenation.
+        """
+        return self.client.join_path(filepath, *filepaths)
+
+    @contextmanager
+    def get_local_path(self, filepath: Union[str, Path]) -> Generator[Union[str, Path], None, None]:
+        """Download data from ``filepath`` and write the data to local path.
+
+        ``get_local_path`` is decorated by :meth:`contxtlib.contextmanager`. It
+        can be called with ``with`` statement, and when exists from the
+        ``with`` statement, the temporary path will be released.
+
+        Note:
+            If the ``filepath`` is a local path, just return itself.
+
+        .. warning::
+            ``get_local_path`` is an experimental interface that may change in
+            the future.
+
+        Args:
+            filepath (str or Path): Path to be read data.
+
+        Examples:
+            >>> file_client = FileClient(prefix='s3')
+            >>> with file_client.get_local_path('s3://bucket/abc.jpg') as path:
+            ...     # do something here
+
+        Yields:
+            Iterable[str]: Only yield one path.
+        """
+        with self.client.get_local_path(str(filepath)) as local_path:
+            yield local_path
+
+    def list_dir_or_file(  # pylint: disable=too-many-arguments
+        self,
+        dir_path: Union[str, Path],
+        list_dir: bool = True,
+        list_file: bool = True,
+        suffix: Optional[Union[str, Tuple[str]]] = None,
+        recursive: bool = False,
+    ) -> Iterator[str]:
+        """Scan a directory to find the interested directories or files in
+        arbitrary order.
+
+        Note:
+            :meth:`list_dir_or_file` returns the path relative to ``dir_path``.
+
+        Args:
+            dir_path (str | Path): Path of the directory.
+            list_dir (bool): List the directories. Defaults to True.
+            list_file (bool): List the path of files. Defaults to True.
+            suffix (str or tuple[str], optional):  File suffix
+                that we are interested in. Defaults to None.
+            recursive (bool): If set to True, recursively scan the
+                directory. Defaults to False.
+
+        Yields:
+            Iterable[str]: A relative path to ``dir_path``.
+        """
+        yield from self.client.list_dir_or_file(dir_path, list_dir, list_file, suffix, recursive)

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/handlers/__init__.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.base import BaseFileHandler
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.json_handler import JsonHandler
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.pickle_handler import PickleHandler
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.registry_utils import file_handlers, register_handler
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.yaml_handler import YamlHandler
+
+__all__ = [
+    "BaseFileHandler",
+    "JsonHandler",
+    "PickleHandler",
+    "YamlHandler",
+    "register_handler",
+    "file_handlers",
+]

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/handlers/base.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABCMeta, abstractmethod
+
+
+class BaseFileHandler(metaclass=ABCMeta):
+    # `str_like` is a flag to indicate whether the type of file object is
+    # str-like object or bytes-like object. Pickle only processes bytes-like
+    # objects but json only processes str-like object. If it is str-like
+    # object, `StringIO` will be used to process the buffer.
+    str_like = True
+
+    @abstractmethod
+    def load_from_fileobj(self, file, **kwargs):
+        pass
+
+    @abstractmethod
+    def dump_to_fileobj(self, obj, file, **kwargs):
+        pass
+
+    @abstractmethod
+    def dump_to_str(self, obj, **kwargs):
+        pass
+
+    def load_from_path(self, filepath, mode="r", **kwargs):
+        with open(filepath, mode) as f:
+            return self.load_from_fileobj(f, **kwargs)
+
+    def dump_to_path(self, obj, filepath, mode="w", **kwargs):
+        with open(filepath, mode) as f:
+            self.dump_to_fileobj(obj, f, **kwargs)

REGEN-main/cosmos_policy/_src/imaginaire/utils/easy_io/handlers/byte_handler.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import IO
+
+from cosmos_policy._src.imaginaire.utils.easy_io.handlers.base import BaseFileHandler
+
+
+class ByteHandler(BaseFileHandler):
+    str_like = False
+
+    def load_from_fileobj(self, file: IO[bytes], **kwargs):
+        file.seek(0)
+        # extra all bytes and return
+        return file.read()
+
+    def dump_to_fileobj(
+        self,
+        obj: bytes,
+        file: IO[bytes],
+        **kwargs,
+    ):
+        # write all bytes to file
+        file.write(obj)
+
+    def dump_to_str(self, obj, **kwargs):
+        raise NotImplementedError