From fcb7de37b317b50cdb8110671709844b5419012d Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:11:52 +0000 Subject: [PATCH 01/62] Add multimodal MINT1T reader/writer pipeline and scoped benchmarks Signed-off-by: Vibhu Jawa --- benchmarking/nightly-benchmark.yaml | 54 +++++ .../scripts/multimodal_mint1t_benchmark.py | 192 ++++++++++++++++++ nemo_curator/core/utils.py | 46 +++++ nemo_curator/stages/base.py | 18 +- nemo_curator/stages/multimodal/__init__.py | 17 ++ nemo_curator/stages/multimodal/io/__init__.py | 18 ++ nemo_curator/stages/multimodal/io/reader.py | 57 ++++++ .../stages/multimodal/io/readers/__init__.py | 17 ++ .../stages/multimodal/io/readers/base.py | 33 +++ .../multimodal/io/readers/webdataset.py | 176 ++++++++++++++++ nemo_curator/stages/multimodal/io/writer.py | 28 +++ .../stages/multimodal/io/writers/__init__.py | 20 ++ .../stages/multimodal/io/writers/base.py | 73 +++++++ .../multimodal/io/writers/multimodal.py | 154 ++++++++++++++ nemo_curator/stages/multimodal/stages.py | 55 +++++ nemo_curator/tasks/__init__.py | 2 + nemo_curator/tasks/multimodal.py | 139 +++++++++++++ tests/stages/multimodal/__init__.py | 1 + .../stages/multimodal/test_multimodal_core.py | 90 ++++++++ .../multimodal/test_multimodal_reader.py | 68 +++++++ .../multimodal/test_multimodal_writer.py | 110 ++++++++++ tutorials/multimodal/mint1t_mvp_pipeline.py | 81 ++++++++ 22 files changed, 1444 insertions(+), 5 deletions(-) create mode 100644 benchmarking/scripts/multimodal_mint1t_benchmark.py create mode 100644 nemo_curator/stages/multimodal/__init__.py create mode 100644 nemo_curator/stages/multimodal/io/__init__.py create mode 100644 nemo_curator/stages/multimodal/io/reader.py create mode 100644 nemo_curator/stages/multimodal/io/readers/__init__.py create mode 100644 nemo_curator/stages/multimodal/io/readers/base.py create mode 100644 nemo_curator/stages/multimodal/io/readers/webdataset.py create mode 100644 nemo_curator/stages/multimodal/io/writer.py create mode 100644 nemo_curator/stages/multimodal/io/writers/__init__.py create mode 100644 nemo_curator/stages/multimodal/io/writers/base.py create mode 100644 nemo_curator/stages/multimodal/io/writers/multimodal.py create mode 100644 nemo_curator/stages/multimodal/stages.py create mode 100644 nemo_curator/tasks/multimodal.py create mode 100644 tests/stages/multimodal/__init__.py create mode 100644 tests/stages/multimodal/test_multimodal_core.py create mode 100644 tests/stages/multimodal/test_multimodal_reader.py create mode 100644 tests/stages/multimodal/test_multimodal_writer.py create mode 100644 tutorials/multimodal/mint1t_mvp_pipeline.py diff --git a/benchmarking/nightly-benchmark.yaml b/benchmarking/nightly-benchmark.yaml index 434c84436f..76cec0122b 100644 --- a/benchmarking/nightly-benchmark.yaml +++ b/benchmarking/nightly-benchmark.yaml @@ -69,6 +69,10 @@ datasets: formats: - type: "jsonl" path: "{datasets_path}/gretel_symptoms" + - name: "multimodal_mint1t" + formats: + - type: "wds_tar_dir" + path: "{datasets_path}/multimodal/mint1t" default_timeout_s: 7200 # Optional sinks @@ -715,3 +719,53 @@ entries: exact_value: 113 - metric: throughput_clips_per_sec min_value: 0.25 + + - name: multimodal_mint1t_xenna + enabled: false + script: multimodal_mint1t_benchmark.py + args: >- + --benchmark-results-path={session_entry_dir} + --executor=xenna + --input-path={dataset:multimodal_mint1t,wds_tar_dir} + --output-path={session_entry_dir}/scratch/output + --files-per-partition=2 + --mode=overwrite + --no-materialize-on-write + --output-max-batch-bytes=2000000 + timeout_s: 1800 + sink_data: + - name: slack + additional_metrics: + - throughput_rows_per_sec + - num_rows + - num_output_files + - materialize_error_count + ray: + num_cpus: 64 + num_gpus: 0 + enable_object_spilling: false + + - name: multimodal_mint1t_xenna_materialize + enabled: false + script: multimodal_mint1t_benchmark.py + args: >- + --benchmark-results-path={session_entry_dir} + --executor=xenna + --input-path={dataset:multimodal_mint1t,wds_tar_dir} + --output-path={session_entry_dir}/scratch/output + --files-per-partition=2 + --mode=overwrite + --materialize-on-write + --output-max-batch-bytes=2000000 + timeout_s: 1800 + sink_data: + - name: slack + additional_metrics: + - throughput_rows_per_sec + - num_rows + - num_output_files + - materialize_error_count + ray: + num_cpus: 64 + num_gpus: 0 + enable_object_spilling: false diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py new file mode 100644 index 0000000000..04f880eeab --- /dev/null +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -0,0 +1,192 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +"""Benchmark for multimodal MINT1T workflow: WebDataset -> filter -> parquet.""" + +import argparse +import time +import traceback +from pathlib import Path +from typing import Any + +import pandas as pd +from loguru import logger +from utils import setup_executor, write_benchmark_results + +from nemo_curator.core.client import RayClient +from nemo_curator.pipeline import Pipeline +from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader +from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage +from nemo_curator.tasks.utils import TaskPerfUtils +from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under, get_all_file_paths_under + + +def create_pipeline(args: argparse.Namespace) -> Pipeline: + read_kwargs = {} + write_kwargs = {} + if args.parquet_row_group_size is not None: + write_kwargs["row_group_size"] = args.parquet_row_group_size + if args.parquet_compression is not None: + write_kwargs["compression"] = args.parquet_compression + write_kwargs["writer_backend"] = args.parquet_write_backend + pipeline = Pipeline( + name="multimodal_mint1t_benchmark", + description="Benchmark: WebDataset MINT1T to multimodal parquet", + ) + pipeline.add_stage( + WebdatasetReader( + file_paths=args.input_path, + files_per_partition=args.files_per_partition, + blocksize=args.input_blocksize, + max_batch_bytes=args.output_max_batch_bytes, + read_kwargs=read_kwargs, + load_binary=False, + ) + ) + pipeline.add_stage(BasicMultimodalFilterStage(drop_invalid_rows=True)) + pipeline.add_stage( + MultimodalParquetWriter( + path=args.output_path, + materialize_on_write=args.materialize_on_write, + write_kwargs=write_kwargs, + mode=args.mode, + ) + ) + return pipeline + + +def _collect_output_metrics(output_path: Path) -> dict[str, Any]: + parquet_files = get_all_file_paths_under( + str(output_path), + recurse_subdirectories=True, + keep_extensions=[".parquet"], + ) + output_files_with_size = get_all_file_paths_and_size_under( + str(output_path), + recurse_subdirectories=True, + keep_extensions=[".parquet"], + ) + num_files = len(parquet_files) + total_size_bytes = int(sum(size for _, size in output_files_with_size)) + num_rows = 0 + modality_counts: dict[str, int] = {} + materialize_error_count = 0 + for path in parquet_files: + df = pd.read_parquet(path) + num_rows += len(df) + if "modality" in df.columns: + vc = df["modality"].value_counts(dropna=False).to_dict() + for k, v in vc.items(): + key = str(k) + modality_counts[key] = modality_counts.get(key, 0) + int(v) + if "materialize_error" in df.columns: + materialize_error_count += int(df["materialize_error"].notna().sum()) + return { + "num_output_files": num_files, + "output_total_bytes": total_size_bytes, + "output_total_mb": total_size_bytes / (1024 * 1024), + "num_rows": num_rows, + "modality_counts": modality_counts, + "materialize_error_count": materialize_error_count, + } + + +def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: + executor = setup_executor(args.executor) + input_path = str(Path(args.input_path).absolute()) + output_path = Path(args.output_path).absolute() + output_path.mkdir(parents=True, exist_ok=True) + + start = time.perf_counter() + output_tasks = [] + success = False + try: + pipeline = create_pipeline(args) + logger.info("Pipeline:\n{}", pipeline.describe()) + output_tasks = pipeline.run(executor) + success = True + except Exception as e: # noqa: BLE001 + logger.error("Benchmark failed: {}", e) + logger.debug(traceback.format_exc()) + + elapsed = time.perf_counter() - start + output_metrics = _collect_output_metrics(output_path) + task_metrics = TaskPerfUtils.aggregate_task_metrics(output_tasks, prefix="task") + writer_stats = {k: v for k, v in task_metrics.items() if "multimodal_" in k and "_writer" in k} + logger.info("Writer stage stats: {}", writer_stats) + rows = output_metrics["num_rows"] + return { + "params": { + "executor": args.executor, + "input_path": input_path, + "output_path": str(output_path), + "files_per_partition": args.files_per_partition, + "input_blocksize": args.input_blocksize, + "output_max_batch_bytes": args.output_max_batch_bytes, + "materialize_on_write": args.materialize_on_write, + "parquet_row_group_size": args.parquet_row_group_size, + "parquet_compression": args.parquet_compression, + "parquet_write_backend": args.parquet_write_backend, + "mode": args.mode, + }, + "metrics": { + "is_success": success, + "time_taken_s": elapsed, + "throughput_rows_per_sec": (rows / elapsed) if elapsed > 0 else 0.0, + **task_metrics, + **output_metrics, + }, + "tasks": output_tasks, + } + + +def main() -> int: + parser = argparse.ArgumentParser(description="Multimodal MINT1T benchmark") + parser.add_argument("--benchmark-results-path", type=Path, required=True) + parser.add_argument("--executor", default="xenna", choices=["xenna", "ray_data"]) + parser.add_argument("--input-path", type=str, required=True) + parser.add_argument("--output-path", type=str, required=True) + parser.add_argument("--files-per-partition", type=int, default=1) + parser.add_argument("--input-blocksize", type=str, default=None) + parser.add_argument("--output-max-batch-bytes", type=int, default=None) + parser.add_argument("--parquet-row-group-size", type=int, default=None) + parser.add_argument("--parquet-compression", type=str, default=None) + parser.add_argument("--parquet-write-backend", type=str, default="pandas", choices=["pandas", "pyarrow"]) + parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") + parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") + parser.add_argument("--mode", type=str, default="overwrite", choices=["ignore", "overwrite", "append", "error"]) + parser.set_defaults(materialize_on_write=False) + args = parser.parse_args() + + ray_client = RayClient() + ray_client.start() + try: + results = run_benchmark(args) + except Exception as e: # noqa: BLE001 + logger.error("Benchmark crashed: {}", e) + logger.debug(traceback.format_exc()) + results = { + "params": vars(args), + "metrics": {"is_success": False}, + "tasks": [], + } + finally: + write_benchmark_results(results, args.benchmark_results_path) + ray_client.stop() + + return 0 if results["metrics"]["is_success"] else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index 5fb4024394..acb33b9988 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -18,6 +18,8 @@ import time from typing import TYPE_CHECKING +import pyarrow as pa +import pyarrow.compute as pc import ray from loguru import logger @@ -185,3 +187,47 @@ def init_cluster( # noqa: PLR0913 logger.info(f"Ray start command: {' '.join(ray_command)}") return proc + + +def split_table_by_group_max_bytes( + table: pa.Table, + group_column: str, + max_batch_bytes: int | None, +) -> list[pa.Table]: + """Split an Arrow table by approximate byte size without splitting group rows. + + Each unique value in ``group_column`` is kept in a single output table. + If a single group exceeds ``max_batch_bytes``, it is still emitted as one chunk. + """ + if max_batch_bytes is None or table.num_rows == 0: + return [table] + if max_batch_bytes <= 0: + msg = f"max_batch_bytes must be > 0, got {max_batch_bytes}" + raise ValueError(msg) + if group_column not in table.column_names: + msg = f"Group column '{group_column}' not found in table" + raise ValueError(msg) + + group_values = [str(v) for v in pc.unique(table[group_column]).to_pylist()] + group_tables: list[pa.Table] = [] + for group_value in group_values: + group_tables.append(table.filter(pc.equal(table[group_column], group_value))) + + chunks: list[list[pa.Table]] = [] + chunk_tables: list[pa.Table] = [] + chunk_bytes = 0 + for group_table in group_tables: + group_bytes = int(group_table.nbytes) + if chunk_tables and (chunk_bytes + group_bytes > max_batch_bytes): + chunks.append(chunk_tables) + chunk_tables = [] + chunk_bytes = 0 + chunk_tables.append(group_table) + chunk_bytes += group_bytes + if chunk_tables: + chunks.append(chunk_tables) + + out_tables: list[pa.Table] = [] + for chunk in chunks: + out_tables.append(pa.concat_tables(chunk) if len(chunk) > 1 else chunk[0]) + return out_tables diff --git a/nemo_curator/stages/base.py b/nemo_curator/stages/base.py index 3c55f15c98..cf11008895 100644 --- a/nemo_curator/stages/base.py +++ b/nemo_curator/stages/base.py @@ -14,7 +14,11 @@ from __future__ import annotations +import contextlib +import copy +import time from abc import ABC, ABCMeta, abstractmethod +from inspect import isabstract from typing import TYPE_CHECKING, Any, Generic, TypeVar, final from loguru import logger @@ -48,8 +52,6 @@ def __new__(mcls, name, bases, namespace, **kwargs): # noqa: ANN001 # Only register subclasses that ultimately derive from ProcessingStage # but are not abstract. - from inspect import isabstract # local import to avoid cycle during class creation - if "ProcessingStage" in [base.__name__ for base in cls.mro()[1:]] and not isabstract(cls): # Ensure no duplicate class names (helps when reloading in notebooks) _STAGE_REGISTRY[cls.__name__] = cls # type: ignore[assignment] @@ -268,9 +270,6 @@ def with_( resources: Override the resources property batch_size: Override the batch_size property """ - # Create a copy of the current instance - import copy - new_instance = copy.deepcopy(self) # Override the instance attributes directly @@ -320,6 +319,15 @@ def _log_metrics(self, metrics: dict[str, float]) -> None: def _log_metric(self, name: str, value: float) -> None: return self._log_metrics({name: value}) + @contextlib.contextmanager + def _time_metric(self, name: str) -> contextlib.AbstractContextManager[None]: + """Record elapsed time for a code block as a custom stage metric.""" + start = time.perf_counter() + try: + yield + finally: + self._log_metric(name, time.perf_counter() - start) + def _consume_custom_metrics(self) -> dict[str, float]: """Return and clear metrics recorded during the last process call.""" if not hasattr(self, "_custom_metrics") or self._custom_metrics is None: diff --git a/nemo_curator/stages/multimodal/__init__.py b/nemo_curator/stages/multimodal/__init__.py new file mode 100644 index 0000000000..95aa04df92 --- /dev/null +++ b/nemo_curator/stages/multimodal/__init__.py @@ -0,0 +1,17 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage + +__all__ = ["BasicMultimodalFilterStage"] diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/multimodal/io/__init__.py new file mode 100644 index 0000000000..b539c2f4ae --- /dev/null +++ b/nemo_curator/stages/multimodal/io/__init__.py @@ -0,0 +1,18 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 nemo_curator.stages.multimodal.io.reader import WebdatasetReader +from nemo_curator.stages.multimodal.io.writer import MultimodalParquetWriter + +__all__ = ["MultimodalParquetWriter", "WebdatasetReader"] diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py new file mode 100644 index 0000000000..a1598b7d95 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -0,0 +1,57 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 dataclasses import dataclass, field +from typing import Any + +from nemo_curator.stages.base import CompositeStage +from nemo_curator.stages.file_partitioning import FilePartitioningStage +from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.tasks import MultiBatchTask, _EmptyTask + +_DEFAULT_WEBDATASET_EXTENSIONS = [".tar", ".tar.gz", ".tgz", ".tar.zst"] + + +@dataclass +class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): + """Composite stage for reading WebDataset shards.""" + + file_paths: str | list[str] + files_per_partition: int | None = None + blocksize: int | str | None = None + max_batch_bytes: int | None = None + read_kwargs: dict[str, Any] = field(default_factory=dict) + load_binary: bool = False + file_extensions: list[str] = field(default_factory=lambda: _DEFAULT_WEBDATASET_EXTENSIONS) + name: str = "webdataset_reader" + + def __post_init__(self): + super().__init__() + self.storage_options = self.read_kwargs.get("storage_options", {}) + + def decompose(self) -> list: + return [ + FilePartitioningStage( + file_paths=self.file_paths, + files_per_partition=self.files_per_partition, + blocksize=self.blocksize, + file_extensions=self.file_extensions, + storage_options=self.storage_options, + ), + WebdatasetReaderStage( + read_kwargs=self.read_kwargs, + load_binary=self.load_binary, + max_batch_bytes=self.max_batch_bytes, + ), + ] diff --git a/nemo_curator/stages/multimodal/io/readers/__init__.py b/nemo_curator/stages/multimodal/io/readers/__init__.py new file mode 100644 index 0000000000..570244039b --- /dev/null +++ b/nemo_curator/stages/multimodal/io/readers/__init__.py @@ -0,0 +1,17 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage + +__all__ = ["WebdatasetReaderStage"] diff --git a/nemo_curator/stages/multimodal/io/readers/base.py b/nemo_curator/stages/multimodal/io/readers/base.py new file mode 100644 index 0000000000..844981a4f7 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/readers/base.py @@ -0,0 +1,33 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 dataclasses import dataclass, field +from typing import Any + +from nemo_curator.stages.base import ProcessingStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + + +@dataclass +class BaseMultimodalReader(ProcessingStage[FileGroupTask, MultiBatchTask]): + """Base contract for multimodal readers.""" + + read_kwargs: dict[str, Any] = field(default_factory=dict) + name: str = "" + + def inputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def outputs(self) -> tuple[list[str], list[str]]: + return ["data"], ["sample_id", "position", "modality"] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py new file mode 100644 index 0000000000..927484f292 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -0,0 +1,176 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import json +import mimetypes +import tarfile +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import fsspec +import pyarrow as pa + +from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + +from .base import BaseMultimodalReader + +_IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif") + + +@dataclass +class WebdatasetReaderStage(BaseMultimodalReader): + """Read MINT1T-style WebDataset shards into a row-wise multimodal task.""" + + load_binary: bool = False + max_batch_bytes: int | None = None + name: str = "webdataset_reader" + + def _rows_from_sample( + self, + sample_id: str, + sample: dict[str, Any], + source_shard: str, + tar_path: str, + json_member_name: str, + image_member_name: str | None, + ) -> list[dict[str, Any]]: + source_id = sample.get("pdf_name") + rows: list[dict[str, Any]] = [] + + rows.append( + { + "sample_id": sample_id, + "position": -1, + "modality": "metadata", + "content_type": "application/json", + "text_content": None, + "binary_content": None, + "metadata_source": MultiBatchTask.build_metadata_source( + source_id=source_id, + source_shard=source_shard, + content_path=tar_path, + content_key=json_member_name, + ), + "metadata_json": json.dumps(sample, ensure_ascii=True), + "materialize_error": None, + } + ) + + texts = sample.get("texts") + if isinstance(texts, list): + for idx, text_value in enumerate(texts): + rows.append( + { + "sample_id": sample_id, + "position": idx, + "modality": "text", + "content_type": "text/plain", + "text_content": text_value if isinstance(text_value, str) else None, + "binary_content": None, + "metadata_source": MultiBatchTask.build_metadata_source( + source_id=source_id, + source_shard=source_shard, + content_path=tar_path, + content_key=json_member_name, + ), + "metadata_json": None, + "materialize_error": None, + } + ) + + images = sample.get("images") + if isinstance(images, list): + for idx, image_token in enumerate(images): + content_key = image_member_name if image_token is not None else None + content_type, _ = mimetypes.guess_type(image_member_name or "") + rows.append( + { + "sample_id": sample_id, + "position": idx, + "modality": "image", + "content_type": content_type or ("application/octet-stream" if image_member_name else None), + "text_content": None, + "binary_content": None, + "metadata_source": MultiBatchTask.build_metadata_source( + source_id=source_id, + source_shard=source_shard, + content_path=tar_path, + content_key=content_key, + ), + "metadata_json": None, + "materialize_error": None, + } + ) + + return rows + + def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: + rows: list[dict[str, Any]] = [] + storage_options = (self.read_kwargs or {}).get("storage_options", {}) + + for tar_path in task.data: + source_shard = Path(tar_path).name + with fsspec.open(tar_path, mode="rb", **storage_options) as fobj: + with tarfile.open(fileobj=fobj, mode="r:*") as tf: + members = [m for m in tf.getmembers() if m.isfile()] + member_names = {m.name for m in members} + for member in members: + if not member.name.endswith(".json"): + continue + extracted = tf.extractfile(member) + if extracted is None: + continue + payload = json.load(extracted) + sample_id = Path(member.name).stem + image_member_name = next( + (f"{sample_id}{ext}" for ext in _IMAGE_EXTENSIONS if f"{sample_id}{ext}" in member_names), + None, + ) + sample_rows = self._rows_from_sample( + sample_id=sample_id, + sample=payload, + source_shard=source_shard, + tar_path=tar_path, + json_member_name=member.name, + image_member_name=image_member_name, + ) + if self.load_binary and image_member_name is not None: + img = tf.extractfile(image_member_name) + if img is not None: + image_bytes = img.read() + for row in sample_rows: + if row["modality"] == "image" and row["position"] >= 0: + row["binary_content"] = image_bytes + rows.extend(sample_rows) + + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) + batches: list[MultiBatchTask] = [] + for idx, split in enumerate(splits): + task_id = f"{task.task_id}_processed" if len(splits) == 1 else f"{task.task_id}_processed_{idx:05d}" + batches.append( + MultiBatchTask( + task_id=task_id, + dataset_name=task.dataset_name, + data=split, + _metadata=task._metadata, + _stage_perf=task._stage_perf, + ) + ) + return batches if len(batches) > 1 else batches[0] diff --git a/nemo_curator/stages/multimodal/io/writer.py b/nemo_curator/stages/multimodal/io/writer.py new file mode 100644 index 0000000000..84c22bbe8d --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writer.py @@ -0,0 +1,28 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 dataclasses import dataclass, field +from typing import Any + +from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage + + +@dataclass +class MultimodalParquetWriter(MultimodalParquetWriterStage): + """User-facing multimodal parquet writer alias.""" + + path: str = "" + write_kwargs: dict[str, Any] = field(default_factory=dict) + materialize_on_write: bool = True + name: str = "multimodal_parquet_writer" diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py new file mode 100644 index 0000000000..d2d6a5a1fb --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 nemo_curator.stages.multimodal.io.writers.multimodal import ( + BaseMultimodalTabularWriter, + MultimodalParquetWriterStage, +) + +__all__ = ["BaseMultimodalTabularWriter", "MultimodalParquetWriterStage"] diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/multimodal/io/writers/base.py new file mode 100644 index 0000000000..775414251d --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/base.py @@ -0,0 +1,73 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 uuid +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import Any, Literal + +from fsspec.core import url_to_fs +from loguru import logger + +import nemo_curator.stages.text.io.writer.utils as writer_utils +from nemo_curator.stages.base import ProcessingStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.utils.client_utils import is_remote_url +from nemo_curator.utils.file_utils import check_output_mode + + +@dataclass +class BaseMultimodalWriter(ProcessingStage[MultiBatchTask, FileGroupTask], ABC): + """Base class for multimodal writers.""" + + path: str + file_extension: str + write_kwargs: dict[str, Any] = field(default_factory=dict) + name: str = "base_multimodal_writer" + mode: Literal["ignore", "overwrite", "append", "error"] = "ignore" + append_mode_implemented: bool = False + + def __post_init__(self): + self.storage_options = (self.write_kwargs or {}).get("storage_options", {}) + self.fs, self._fs_path = url_to_fs(self.path, **self.storage_options) + check_output_mode(self.mode, self.fs, self._fs_path, append_mode_implemented=self.append_mode_implemented) + + def inputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def outputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + @abstractmethod + def write_data(self, task: MultiBatchTask, file_path: str) -> None: + """Format-specific write implementation.""" + + def process(self, task: MultiBatchTask) -> FileGroupTask: + if source_files := task._metadata.get("source_files"): + filename = writer_utils.get_deterministic_hash(source_files, task.task_id) + else: + logger.warning("The task does not have source_files in metadata, using UUID for base filename") + filename = uuid.uuid4().hex + + file_path = self.fs.sep.join([self._fs_path, f"{filename}.{self.file_extension}"]) + file_path_with_protocol = self.fs.unstrip_protocol(file_path) if is_remote_url(self.path) else file_path + + self.write_data(task, file_path_with_protocol) + return FileGroupTask( + task_id=task.task_id, + dataset_name=task.dataset_name, + data=[file_path_with_protocol], + _metadata={**task._metadata, "format": self.file_extension}, + _stage_perf=task._stage_perf, + ) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py new file mode 100644 index 0000000000..e551e5f6c7 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -0,0 +1,154 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import tarfile +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import Any + +import fsspec +import pandas as pd +import pyarrow as pa +import pyarrow.parquet as pq + +from nemo_curator.tasks import MultiBatchTask + +from .base import BaseMultimodalWriter + + +@dataclass +class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): + """Shared multimodal tabular writer with optional image materialization.""" + + write_kwargs: dict[str, Any] = field(default_factory=dict) + materialize_on_write: bool = True + name: str = "base_multimodal_tabular_writer" + + def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: + if not self.materialize_on_write: + with self._time_metric("to_pandas_s"): + out = task.to_pandas() + self._log_metric("rows_out", float(len(out))) + return out + + with self._time_metric("parse_source_columns_s"): + out = task.with_parsed_source_columns(prefix="_src_").reset_index(drop=True) + if "materialize_error" in out.columns: + error_values = out["materialize_error"].astype("object").tolist() + else: + error_values = [None] * len(out) + binary_values = out["binary_content"].astype("object").tolist() + + image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) + self._log_metrics( + { + "rows_out": float(len(out)), + "image_rows": float((out["modality"] == "image").sum()), + "image_rows_missing_binary": float(image_mask.sum()), + } + ) + if not image_mask.any(): + return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") + + storage_options = (self.write_kwargs or {}).get("storage_options", {}) + pending = out[image_mask] + with self._time_metric("materialize_fetch_binary_s"): + for content_path, idxs in pending.groupby("_src_content_path").groups.items(): + if not content_path: + for idx in idxs: + error_values[idx] = "missing content_path" + continue + + keyed_idxs = [idx for idx in idxs if out.at[idx, "_src_content_key"]] + direct_idxs = [idx for idx in idxs if not out.at[idx, "_src_content_key"]] + try: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: + if keyed_idxs: + key_to_indices: dict[str, list[int]] = {} + for idx in keyed_idxs: + key = str(out.at[idx, "_src_content_key"]) + key_to_indices.setdefault(key, []).append(idx) + + with tarfile.open(fileobj=fobj, mode="r:*") as tf: + for key, key_indices in key_to_indices.items(): + try: + extracted = tf.extractfile(key) + except KeyError: + extracted = None + if extracted is None: + for idx in key_indices: + error_values[idx] = f"missing content_key '{key}'" + continue + payload = extracted.read() + for idx in key_indices: + binary_values[idx] = payload + error_values[idx] = None + if direct_idxs: + if keyed_idxs: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fresh: + payload = fresh.read() + else: + payload = fobj.read() + for idx in direct_idxs: + binary_values[idx] = payload + error_values[idx] = None + elif not keyed_idxs: + payload = fobj.read() + for idx in idxs: + binary_values[idx] = payload + error_values[idx] = None + except Exception as e: # noqa: BLE001 + for idx in idxs: + error_values[idx] = str(e) + + out["binary_content"] = pd.Series(binary_values, dtype="object") + out["materialize_error"] = pd.Series(error_values, dtype="object") + self._log_metric("materialize_errors", float(sum(v is not None for v in error_values))) + return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") + + @abstractmethod + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + """Format-specific writer implementation.""" + + def write_data(self, task: MultiBatchTask, file_path: str) -> None: + with self._time_metric("materialize_dataframe_total_s"): + df = self._materialize_dataframe(task) + write_kwargs = {"index": None} + write_kwargs.update(self.write_kwargs) + self._write_dataframe(df, file_path, write_kwargs) + + +@dataclass +class MultimodalParquetWriterStage(BaseMultimodalTabularWriter): + """Thin parquet writer on top of the tabular multimodal base.""" + + file_extension: str = "parquet" + name: str = "multimodal_parquet_writer" + + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + # Empirically best default from current benchmark sweep. + write_kwargs.setdefault("compression", "snappy") + write_kwargs.setdefault("row_group_size", 128) + writer_backend = str(write_kwargs.pop("writer_backend", "pandas")).lower() + if writer_backend == "pyarrow": + write_kwargs.pop("index", None) + write_kwargs.pop("storage_options", None) + with self._time_metric("parquet_write_s"): + table = pa.Table.from_pandas(df, preserve_index=False) + pq.write_table(table, file_path, **write_kwargs) + return + with self._time_metric("parquet_write_s"): + df.to_parquet(file_path, **write_kwargs) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py new file mode 100644 index 0000000000..eac73338d3 --- /dev/null +++ b/nemo_curator/stages/multimodal/stages.py @@ -0,0 +1,55 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 dataclasses import dataclass + +import pandas as pd + +from nemo_curator.stages.base import ProcessingStage +from nemo_curator.tasks import MultiBatchTask + + +@dataclass +class BasicMultimodalFilterStage(ProcessingStage[MultiBatchTask, MultiBatchTask]): + """Minimal validation/filter stage for multimodal rows.""" + + drop_invalid_rows: bool = True + name: str = "basic_multimodal_filter" + + def inputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def outputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def process(self, task: MultiBatchTask) -> MultiBatchTask: + df = task.to_pandas().copy() + if df.empty: + return task + + if self.drop_invalid_rows: + allowed = {"text", "image", "metadata"} + df = df[df["modality"].isin(allowed)] + # Keep metadata rows at sentinel position -1; content rows should be non-negative. + valid_pos = (df["modality"] == "metadata") & (df["position"] == -1) + valid_pos = valid_pos | ((df["modality"] != "metadata") & (df["position"] >= 0)) + df = df[valid_pos] + + return MultiBatchTask( + task_id=f"{task.task_id}_{self.name}", + dataset_name=task.dataset_name, + data=df.reset_index(drop=True), + _metadata=task._metadata, + _stage_perf=task._stage_perf, + ) diff --git a/nemo_curator/tasks/__init__.py b/nemo_curator/tasks/__init__.py index 4bd3f05d40..368e3043a9 100644 --- a/nemo_curator/tasks/__init__.py +++ b/nemo_curator/tasks/__init__.py @@ -16,6 +16,7 @@ from .document import DocumentBatch from .file_group import FileGroupTask from .image import ImageBatch, ImageObject +from .multimodal import MultiBatchTask from .tasks import EmptyTask, Task, _EmptyTask __all__ = [ @@ -25,6 +26,7 @@ "FileGroupTask", "ImageBatch", "ImageObject", + "MultiBatchTask", "Task", "_EmptyTask", ] diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py new file mode 100644 index 0000000000..d0c9c3002d --- /dev/null +++ b/nemo_curator/tasks/multimodal.py @@ -0,0 +1,139 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 +from dataclasses import dataclass, field + +import pandas as pd +import pyarrow as pa +from loguru import logger + +from .tasks import Task + +MULTIMODAL_SCHEMA = pa.schema( + [ + pa.field("sample_id", pa.string(), nullable=False), + pa.field("position", pa.int32(), nullable=False), + pa.field("modality", pa.string(), nullable=False), + pa.field("content_type", pa.string(), nullable=True), + pa.field("text_content", pa.string(), nullable=True), + pa.field("binary_content", pa.large_binary(), nullable=True), + pa.field("metadata_source", pa.string(), nullable=True), + pa.field("metadata_json", pa.string(), nullable=True), + pa.field("materialize_error", pa.string(), nullable=True), + ] +) + + +@dataclass +class MultiBatchTask(Task[pa.Table | pd.DataFrame]): + """Task carrying row-wise multimodal records.""" + + data: pa.Table | pd.DataFrame = field(default_factory=pa.Table) + + def to_pyarrow(self) -> pa.Table: + if isinstance(self.data, pa.Table): + return self.data + if isinstance(self.data, pd.DataFrame): + return pa.Table.from_pandas(self.data, preserve_index=False) + msg = f"Cannot convert {type(self.data)} to PyArrow table" + raise TypeError(msg) + + def to_pandas(self) -> pd.DataFrame: + if isinstance(self.data, pd.DataFrame): + return self.data + if isinstance(self.data, pa.Table): + # Strict mode: preserve Arrow-backed nullable/native types in pandas. + return self.data.to_pandas(types_mapper=pd.ArrowDtype) + msg = f"Cannot convert {type(self.data)} to Pandas DataFrame" + raise TypeError(msg) + + @property + def num_items(self) -> int: + return len(self.data) + + def get_columns(self) -> list[str]: + if isinstance(self.data, pd.DataFrame): + return list(self.data.columns) + if isinstance(self.data, pa.Table): + return self.data.column_names + msg = f"Unsupported data type: {type(self.data)}" + raise TypeError(msg) + + def validate(self) -> bool: + if self.num_items <= 0: + logger.warning(f"Task {self.task_id} has no items") + return False + required = {"sample_id", "position", "modality"} + columns = set(self.get_columns()) + missing = sorted(required - columns) + if missing: + logger.warning(f"Task {self.task_id} missing required columns: {missing}") + return False + return True + + @staticmethod + def build_metadata_source( + source_id: str | None, + source_shard: str | None, + content_path: str | None, + content_key: str | None, + ) -> str: + return json.dumps( + { + "source_id": source_id, + "source_shard": source_shard, + "content_path": content_path, + "content_key": content_key, + }, + ensure_ascii=True, + ) + + @staticmethod + def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: + """Parse one metadata_source JSON string into a source locator dict.""" + if source_value is None or source_value == "": + return { + "source_id": None, + "source_shard": None, + "content_path": None, + "content_key": None, + } + parsed = json.loads(source_value) + if not isinstance(parsed, dict): + msg = "metadata_source must decode to a JSON object" + raise TypeError(msg) + return { + "source_id": parsed.get("source_id"), + "source_shard": parsed.get("source_shard"), + "content_path": parsed.get("content_path"), + "content_key": parsed.get("content_key"), + } + + def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: + """Return a pandas view with parsed metadata source columns added. + + Added columns: + - {prefix}source_id + - {prefix}source_shard + - {prefix}content_path + - {prefix}content_key + """ + df = self.to_pandas().copy() + parsed = df["metadata_source"].apply(self.parse_metadata_source) + df[f"{prefix}source_id"] = parsed.apply(lambda d: d["source_id"]) + df[f"{prefix}source_shard"] = parsed.apply(lambda d: d["source_shard"]) + df[f"{prefix}content_path"] = parsed.apply(lambda d: d["content_path"]) + df[f"{prefix}content_key"] = parsed.apply(lambda d: d["content_key"]) + return df diff --git a/tests/stages/multimodal/__init__.py b/tests/stages/multimodal/__init__.py new file mode 100644 index 0000000000..2f2d917f6e --- /dev/null +++ b/tests/stages/multimodal/__init__.py @@ -0,0 +1 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py new file mode 100644 index 0000000000..fd163644fe --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -0,0 +1,90 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 pandas as pd +import pyarrow as pa +import pytest + +from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + + +@pytest.fixture +def single_row_table() -> pa.Table: + return pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "metadata_source": json.dumps( + { + "source_id": "doc.pdf", + "source_shard": "shard-00000.tar", + "content_path": "/tmp/shard-00000.tar", + "content_key": "s1.json", + } + ), + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + + +@pytest.fixture +def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: + return MultiBatchTask(task_id="t1", dataset_name="d1", data=single_row_table) + + +def test_to_pandas_keeps_arrow_dtypes(single_row_task: MultiBatchTask) -> None: + df = single_row_task.to_pandas() + assert isinstance(df, pd.DataFrame) + assert str(df.dtypes["sample_id"]).endswith("[pyarrow]") + assert str(df.dtypes["position"]).endswith("[pyarrow]") + + +def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: + df = single_row_task.with_parsed_source_columns() + assert df.loc[0, "_src_source_id"] == "doc.pdf" + assert df.loc[0, "_src_source_shard"] == "shard-00000.tar" + assert df.loc[0, "_src_content_path"] == "/tmp/shard-00000.tar" + assert df.loc[0, "_src_content_key"] == "s1.json" + + +def test_split_table_keeps_group_intact() -> None: + table = pa.Table.from_pylist( + [ + {"sample_id": "a", "position": 0, "value": "x" * 20}, + {"sample_id": "a", "position": 1, "value": "y" * 20}, + {"sample_id": "b", "position": 0, "value": "z" * 20}, + {"sample_id": "b", "position": 1, "value": "w" * 20}, + ] + ) + + splits = split_table_by_group_max_bytes(table, "sample_id", max_batch_bytes=120) + assert len(splits) == 2 + + first_groups = set(splits[0]["sample_id"].to_pylist()) + second_groups = set(splits[1]["sample_id"].to_pylist()) + assert len(first_groups) == 1 + assert len(second_groups) == 1 + assert first_groups != second_groups diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py new file mode 100644 index 0000000000..9bc9634511 --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -0,0 +1,68 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 tarfile +from io import BytesIO + +import pytest + +from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + + +@pytest.fixture +def mint_like_tar(tmp_path): + tar_path = tmp_path / "shard-00000.tar" + sample_id = "abc123" + payload = { + "pdf_name": "doc.pdf", + "url": "https://example.com/doc.pdf", + "texts": ["hello", None, "world"], + "images": ["page_0_image_1", None, "page_2_image_9"], + "image_metadata": [{"page": 0}, {"page": 2}], + } + image_bytes = b"fake-image-bytes" + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name=f"{sample_id}.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + + img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + return str(tar_path), sample_id, image_bytes + + +@pytest.fixture +def input_task(mint_like_tar): + tar_path, _, _ = mint_like_tar + return FileGroupTask( + task_id="file_group_0", + dataset_name="mint_test", + data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) + + +def test_reader_emits_metadata_text_image_rows(input_task: FileGroupTask, mint_like_tar) -> None: + _, sample_id, _ = mint_like_tar + reader = WebdatasetReaderStage() + output = reader.process(input_task) + assert isinstance(output, MultiBatchTask) + + df = output.to_pandas() + assert set(df["modality"].unique()) == {"metadata", "text", "image"} + assert ((df["sample_id"] == sample_id) & (df["modality"] == "metadata") & (df["position"] == -1)).any() diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py new file mode 100644 index 0000000000..6c239af662 --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -0,0 +1,110 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 tarfile +from io import BytesIO + +import pandas as pd +import pytest + +from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + + +@pytest.fixture +def mint_like_tar(tmp_path): + tar_path = tmp_path / "shard-00000.tar" + sample_id = "abc123" + payload = { + "pdf_name": "doc.pdf", + "url": "https://example.com/doc.pdf", + "texts": ["hello", None, "world"], + "images": ["page_0_image_1", None, "page_2_image_9"], + "image_metadata": [{"page": 0}, {"page": 2}], + } + image_bytes = b"fake-image-bytes" + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name=f"{sample_id}.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + + img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + return str(tar_path), image_bytes + + +@pytest.fixture +def input_task(mint_like_tar): + tar_path, _ = mint_like_tar + return FileGroupTask( + task_id="file_group_0", + dataset_name="mint_test", + data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) + + +def test_writer_materializes_and_marks_errors(tmp_path, input_task: FileGroupTask, mint_like_tar) -> None: + _, image_bytes = mint_like_tar + reader = WebdatasetReaderStage() + batch = reader.process(input_task) + assert isinstance(batch, MultiBatchTask) + + writer = MultimodalParquetWriterStage(path=str(tmp_path / "out"), materialize_on_write=True, mode="overwrite") + write_task = writer.process(batch) + out_file = write_task.data[0] + + written = pd.read_parquet(out_file) + image_rows = written[written["modality"] == "image"] + assert len(image_rows) > 0 + assert (image_rows["binary_content"].apply(lambda x: x == image_bytes).any()) + assert (image_rows["materialize_error"].isna().any()) + + +def test_writer_marks_materialize_error_on_bad_source_path(tmp_path, input_task: FileGroupTask) -> None: + reader = WebdatasetReaderStage() + batch = reader.process(input_task) + assert isinstance(batch, MultiBatchTask) + + df = batch.to_pandas().copy() + image_mask = df["modality"] == "image" + assert image_mask.any() + first_image_idx = df[image_mask].index[0] + df.at[first_image_idx, "metadata_source"] = json.dumps( + { + "source_id": "doc.pdf", + "source_shard": "shard-00000.tar", + "content_path": "/definitely/missing/path.tar", + "content_key": "abc123.tiff", + } + ) + bad_batch = MultiBatchTask( + task_id=batch.task_id, + dataset_name=batch.dataset_name, + data=df, + _metadata=batch._metadata, + _stage_perf=batch._stage_perf, + ) + + writer = MultimodalParquetWriterStage(path=str(tmp_path / "out_bad"), materialize_on_write=True, mode="overwrite") + write_task = writer.process(bad_batch) + written = pd.read_parquet(write_task.data[0]) + + target = written.loc[first_image_idx] + assert pd.isna(target["binary_content"]) + assert isinstance(target["materialize_error"], str) diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py new file mode 100644 index 0000000000..5492804b0b --- /dev/null +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -0,0 +1,81 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# 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 argparse +import json + +from nemo_curator.core.client import RayClient +from nemo_curator.pipeline import Pipeline +from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader +from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage + + +def build_pipeline(args: argparse.Namespace) -> Pipeline: + read_kwargs = {} + write_kwargs = {} + if args.storage_options_json: + storage_options = json.loads(args.storage_options_json) + read_kwargs["storage_options"] = storage_options + write_kwargs["storage_options"] = storage_options + + pipe = Pipeline(name="mint1t_mvp_multimodal", description="WebDataset MINT1T -> multimodal rows -> parquet") + pipe.add_stage( + WebdatasetReader( + file_paths=args.input_path, + files_per_partition=args.files_per_partition, + blocksize=args.input_blocksize, + max_batch_bytes=args.output_max_batch_bytes, + read_kwargs=read_kwargs, + load_binary=False, + ) + ) + pipe.add_stage(BasicMultimodalFilterStage(drop_invalid_rows=True)) + pipe.add_stage( + MultimodalParquetWriter( + path=args.output_path, + materialize_on_write=args.materialize_on_write, + write_kwargs=write_kwargs, + mode=args.mode, + ) + ) + return pipe + + +def main(args: argparse.Namespace) -> None: + ray_client = RayClient() + ray_client.start() + pipeline = build_pipeline(args) + print(pipeline.describe()) + pipeline.run() + ray_client.stop() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="MINT1T multimodal MVP pipeline") + parser.add_argument("--input-path", type=str, required=True, help="Input tar shard path or directory") + parser.add_argument("--output-path", type=str, required=True, help="Output directory for parquet") + parser.add_argument("--files-per-partition", type=int, default=1) + parser.add_argument("--input-blocksize", type=str, default=None) + parser.add_argument("--output-max-batch-bytes", type=int, default=None) + parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") + parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") + parser.set_defaults(materialize_on_write=True) + parser.add_argument("--mode", type=str, default="ignore", choices=["ignore", "overwrite", "append", "error"]) + parser.add_argument( + "--storage-options-json", + type=str, + default=None, + help="JSON-encoded fsspec storage options for cloud paths", + ) + main(parser.parse_args()) From 9dbe24ac8112cb9339b69b20a666a4cd8c9e6151 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:16:39 +0000 Subject: [PATCH 02/62] Move parquet output metrics helper to benchmark utils and update 2026 headers Signed-off-by: Vibhu Jawa --- .../scripts/multimodal_mint1t_benchmark.py | 42 +------------------ benchmarking/scripts/utils.py | 41 +++++++++++++++++- nemo_curator/core/utils.py | 2 +- nemo_curator/stages/base.py | 2 +- nemo_curator/stages/multimodal/__init__.py | 2 +- nemo_curator/stages/multimodal/io/__init__.py | 2 +- nemo_curator/stages/multimodal/io/reader.py | 2 +- .../stages/multimodal/io/readers/__init__.py | 2 +- .../stages/multimodal/io/readers/base.py | 2 +- .../multimodal/io/readers/webdataset.py | 2 +- nemo_curator/stages/multimodal/io/writer.py | 2 +- .../stages/multimodal/io/writers/__init__.py | 2 +- .../stages/multimodal/io/writers/base.py | 2 +- .../multimodal/io/writers/multimodal.py | 2 +- nemo_curator/stages/multimodal/stages.py | 4 +- nemo_curator/tasks/__init__.py | 2 +- nemo_curator/tasks/multimodal.py | 2 +- tests/stages/multimodal/__init__.py | 2 +- tutorials/multimodal/mint1t_mvp_pipeline.py | 2 +- 19 files changed, 59 insertions(+), 60 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 04f880eeab..718f75a4bb 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -20,16 +20,14 @@ from pathlib import Path from typing import Any -import pandas as pd from loguru import logger -from utils import setup_executor, write_benchmark_results +from utils import collect_parquet_output_metrics, setup_executor, write_benchmark_results from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage from nemo_curator.tasks.utils import TaskPerfUtils -from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under, get_all_file_paths_under def create_pipeline(args: argparse.Namespace) -> Pipeline: @@ -66,42 +64,6 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: return pipeline -def _collect_output_metrics(output_path: Path) -> dict[str, Any]: - parquet_files = get_all_file_paths_under( - str(output_path), - recurse_subdirectories=True, - keep_extensions=[".parquet"], - ) - output_files_with_size = get_all_file_paths_and_size_under( - str(output_path), - recurse_subdirectories=True, - keep_extensions=[".parquet"], - ) - num_files = len(parquet_files) - total_size_bytes = int(sum(size for _, size in output_files_with_size)) - num_rows = 0 - modality_counts: dict[str, int] = {} - materialize_error_count = 0 - for path in parquet_files: - df = pd.read_parquet(path) - num_rows += len(df) - if "modality" in df.columns: - vc = df["modality"].value_counts(dropna=False).to_dict() - for k, v in vc.items(): - key = str(k) - modality_counts[key] = modality_counts.get(key, 0) + int(v) - if "materialize_error" in df.columns: - materialize_error_count += int(df["materialize_error"].notna().sum()) - return { - "num_output_files": num_files, - "output_total_bytes": total_size_bytes, - "output_total_mb": total_size_bytes / (1024 * 1024), - "num_rows": num_rows, - "modality_counts": modality_counts, - "materialize_error_count": materialize_error_count, - } - - def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: executor = setup_executor(args.executor) input_path = str(Path(args.input_path).absolute()) @@ -121,7 +83,7 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: logger.debug(traceback.format_exc()) elapsed = time.perf_counter() - start - output_metrics = _collect_output_metrics(output_path) + output_metrics = collect_parquet_output_metrics(output_path) task_metrics = TaskPerfUtils.aggregate_task_metrics(output_tasks, prefix="task") writer_stats = {k: v for k, v in task_metrics.items() if "multimodal_" in k and "_writer" in k} logger.info("Writer stage stats: {}", writer_stats) diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index bf55ac16fe..b8cc45fdc1 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -15,11 +15,14 @@ import json import pickle from pathlib import Path +from typing import Any + +import pandas as pd from nemo_curator.backends.experimental.ray_actor_pool.executor import RayActorPoolExecutor from nemo_curator.backends.experimental.ray_data import RayDataExecutor from nemo_curator.backends.xenna import XennaExecutor -from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under +from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under, get_all_file_paths_under _executor_map = {"ray_data": RayDataExecutor, "xenna": XennaExecutor, "ray_actors": RayActorPoolExecutor} @@ -94,6 +97,42 @@ def write_benchmark_results(results: dict, output_path: str | Path) -> None: (output_path / "tasks.pkl").write_bytes(pickle.dumps(results["tasks"])) +def collect_parquet_output_metrics(output_path: Path) -> dict[str, Any]: + parquet_files = get_all_file_paths_under( + str(output_path), + recurse_subdirectories=True, + keep_extensions=[".parquet"], + ) + output_files_with_size = get_all_file_paths_and_size_under( + str(output_path), + recurse_subdirectories=True, + keep_extensions=[".parquet"], + ) + num_files = len(parquet_files) + total_size_bytes = int(sum(size for _, size in output_files_with_size)) + num_rows = 0 + modality_counts: dict[str, int] = {} + materialize_error_count = 0 + for path in parquet_files: + df = pd.read_parquet(path) + num_rows += len(df) + if "modality" in df.columns: + vc = df["modality"].value_counts(dropna=False).to_dict() + for k, v in vc.items(): + key = str(k) + modality_counts[key] = modality_counts.get(key, 0) + int(v) + if "materialize_error" in df.columns: + materialize_error_count += int(df["materialize_error"].notna().sum()) + return { + "num_output_files": num_files, + "output_total_bytes": total_size_bytes, + "output_total_mb": total_size_bytes / (1024 * 1024), + "num_rows": num_rows, + "modality_counts": modality_counts, + "materialize_error_count": materialize_error_count, + } + + def convert_paths_to_strings(obj: object) -> object: """ Convert Path objects to strings, support conversions in container types in a recursive manner. diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index acb33b9988..2f0ca2db66 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/base.py b/nemo_curator/stages/base.py index cf11008895..cbf7652ac0 100644 --- a/nemo_curator/stages/base.py +++ b/nemo_curator/stages/base.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/__init__.py b/nemo_curator/stages/multimodal/__init__.py index 95aa04df92..a865850479 100644 --- a/nemo_curator/stages/multimodal/__init__.py +++ b/nemo_curator/stages/multimodal/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/multimodal/io/__init__.py index b539c2f4ae..d7b3898f91 100644 --- a/nemo_curator/stages/multimodal/io/__init__.py +++ b/nemo_curator/stages/multimodal/io/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index a1598b7d95..760628c673 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/readers/__init__.py b/nemo_curator/stages/multimodal/io/readers/__init__.py index 570244039b..1734a25f29 100644 --- a/nemo_curator/stages/multimodal/io/readers/__init__.py +++ b/nemo_curator/stages/multimodal/io/readers/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/readers/base.py b/nemo_curator/stages/multimodal/io/readers/base.py index 844981a4f7..eab4bb0e62 100644 --- a/nemo_curator/stages/multimodal/io/readers/base.py +++ b/nemo_curator/stages/multimodal/io/readers/base.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 927484f292..a01c6612ed 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/writer.py b/nemo_curator/stages/multimodal/io/writer.py index 84c22bbe8d..f2e7d1f4c4 100644 --- a/nemo_curator/stages/multimodal/io/writer.py +++ b/nemo_curator/stages/multimodal/io/writer.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py index d2d6a5a1fb..361dd7633f 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/multimodal/io/writers/base.py index 775414251d..3b145a9072 100644 --- a/nemo_curator/stages/multimodal/io/writers/base.py +++ b/nemo_curator/stages/multimodal/io/writers/base.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index e551e5f6c7..3cef1df634 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index eac73338d3..40f395ba7f 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -14,8 +14,6 @@ from dataclasses import dataclass -import pandas as pd - from nemo_curator.stages.base import ProcessingStage from nemo_curator.tasks import MultiBatchTask diff --git a/nemo_curator/tasks/__init__.py b/nemo_curator/tasks/__init__.py index 368e3043a9..b9c986444d 100644 --- a/nemo_curator/tasks/__init__.py +++ b/nemo_curator/tasks/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index d0c9c3002d..f41058a6be 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/tests/stages/multimodal/__init__.py b/tests/stages/multimodal/__init__.py index 2f2d917f6e..3e4afde2e2 100644 --- a/tests/stages/multimodal/__init__.py +++ b/tests/stages/multimodal/__init__.py @@ -1 +1 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 5492804b0b..5be5ea14e9 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -1,4 +1,4 @@ -# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. From 4b6f3e0d6cbf5b149a2b1a6287af5259c822ff4a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:28:31 +0000 Subject: [PATCH 03/62] Clean up multimodal reader/writer config and cloud materialization path Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/io/reader.py | 16 ++ .../multimodal/io/readers/webdataset.py | 168 +++++++++++++----- .../multimodal/io/writers/multimodal.py | 130 ++++++++------ .../multimodal/test_multimodal_reader.py | 62 ++++++- .../multimodal/test_multimodal_writer.py | 17 +- 5 files changed, 284 insertions(+), 109 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index 760628c673..64ef2ec150 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -21,6 +21,8 @@ from nemo_curator.tasks import MultiBatchTask, _EmptyTask _DEFAULT_WEBDATASET_EXTENSIONS = [".tar", ".tar.gz", ".tgz", ".tar.zst"] +_DEFAULT_JSON_EXTENSIONS = [".json"] +_DEFAULT_IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif"] @dataclass @@ -34,6 +36,13 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): read_kwargs: dict[str, Any] = field(default_factory=dict) load_binary: bool = False file_extensions: list[str] = field(default_factory=lambda: _DEFAULT_WEBDATASET_EXTENSIONS) + json_extensions: list[str] = field(default_factory=lambda: _DEFAULT_JSON_EXTENSIONS) + image_extensions: list[str] = field(default_factory=lambda: _DEFAULT_IMAGE_EXTENSIONS) + source_id_field: str | None = "pdf_name" + sample_id_field: str | None = None + texts_field: str = "texts" + images_field: str = "images" + image_member_field: str | None = None name: str = "webdataset_reader" def __post_init__(self): @@ -53,5 +62,12 @@ def decompose(self) -> list: read_kwargs=self.read_kwargs, load_binary=self.load_binary, max_batch_bytes=self.max_batch_bytes, + json_extensions=tuple(self.json_extensions), + image_extensions=tuple(self.image_extensions), + source_id_field=self.source_id_field, + sample_id_field=self.sample_id_field, + texts_field=self.texts_field, + images_field=self.images_field, + image_member_field=self.image_member_field, ), ] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index a01c6612ed..9e0313da76 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -17,7 +17,7 @@ import json import mimetypes import tarfile -from dataclasses import dataclass +from dataclasses import dataclass, field from pathlib import Path from typing import Any @@ -39,19 +39,26 @@ class WebdatasetReaderStage(BaseMultimodalReader): load_binary: bool = False max_batch_bytes: int | None = None + json_extensions: tuple[str, ...] = (".json",) + image_extensions: tuple[str, ...] = field(default_factory=lambda: _IMAGE_EXTENSIONS) + source_id_field: str | None = "pdf_name" + sample_id_field: str | None = None + texts_field: str = "texts" + images_field: str = "images" + image_member_field: str | None = None name: str = "webdataset_reader" def _rows_from_sample( self, sample_id: str, sample: dict[str, Any], - source_shard: str, - tar_path: str, - json_member_name: str, - image_member_name: str | None, + source: dict[str, str], + member_names: set[str], ) -> list[dict[str, Any]]: - source_id = sample.get("pdf_name") + source_id = sample.get(self.source_id_field) if self.source_id_field else None rows: list[dict[str, Any]] = [] + images = sample.get(self.images_field) + image_member_name = self._resolve_default_image_member_name(sample_id, sample, images, member_names) rows.append( { @@ -63,16 +70,16 @@ def _rows_from_sample( "binary_content": None, "metadata_source": MultiBatchTask.build_metadata_source( source_id=source_id, - source_shard=source_shard, - content_path=tar_path, - content_key=json_member_name, + source_shard=source["source_shard"], + content_path=source["tar_path"], + content_key=source["json_member_name"], ), "metadata_json": json.dumps(sample, ensure_ascii=True), "materialize_error": None, } ) - texts = sample.get("texts") + texts = sample.get(self.texts_field) if isinstance(texts, list): for idx, text_value in enumerate(texts): rows.append( @@ -85,19 +92,18 @@ def _rows_from_sample( "binary_content": None, "metadata_source": MultiBatchTask.build_metadata_source( source_id=source_id, - source_shard=source_shard, - content_path=tar_path, - content_key=json_member_name, + source_shard=source["source_shard"], + content_path=source["tar_path"], + content_key=source["json_member_name"], ), "metadata_json": None, "materialize_error": None, } ) - images = sample.get("images") if isinstance(images, list): for idx, image_token in enumerate(images): - content_key = image_member_name if image_token is not None else None + content_key = self._resolve_image_content_key(image_token, image_member_name, member_names) content_type, _ = mimetypes.guess_type(image_member_name or "") rows.append( { @@ -109,8 +115,8 @@ def _rows_from_sample( "binary_content": None, "metadata_source": MultiBatchTask.build_metadata_source( source_id=source_id, - source_shard=source_shard, - content_path=tar_path, + source_shard=source["source_shard"], + content_path=source["tar_path"], content_key=content_key, ), "metadata_json": None, @@ -120,56 +126,120 @@ def _rows_from_sample( return rows + def _resolve_default_image_member_name( + self, + sample_id: str, + sample: dict[str, Any], + images: list[object] | None, + member_names: set[str], + ) -> str | None: + if self.image_member_field: + image_member_name = sample.get(self.image_member_field) + if isinstance(image_member_name, str) and image_member_name in member_names: + return image_member_name + if isinstance(images, list): + for image_token in images: + if isinstance(image_token, str) and image_token in member_names: + return image_token + return next( + (f"{sample_id}{ext}" for ext in self.image_extensions if f"{sample_id}{ext}" in member_names), None + ) + + @staticmethod + def _resolve_image_content_key( + image_token: object, + default_image_member_name: str | None, + member_names: set[str], + ) -> str | None: + if image_token is None: + return None + if isinstance(image_token, str) and image_token in member_names: + return image_token + return default_image_member_name + + def _rows_from_member( + self, + tf: tarfile.TarFile, + member: tarfile.TarInfo, + member_names: set[str], + source_info: dict[str, str], + binary_cache: dict[str, bytes | None], + ) -> list[dict[str, Any]]: + extracted = tf.extractfile(member) + if extracted is None: + return [] + payload = json.load(extracted) + sample_id = ( + str(payload.get(self.sample_id_field)) + if self.sample_id_field and payload.get(self.sample_id_field) is not None + else Path(member.name).stem + ) + source = { + "source_shard": source_info["source_shard"], + "tar_path": source_info["tar_path"], + "json_member_name": member.name, + } + sample_rows = self._rows_from_sample( + sample_id=sample_id, + sample=payload, + source=source, + member_names=member_names, + ) + if self.load_binary: + for row in sample_rows: + if row["modality"] != "image" or row["position"] < 0: + continue + source_meta = MultiBatchTask.parse_metadata_source(row["metadata_source"]) + content_key = source_meta.get("content_key") + if not content_key: + continue + if content_key not in binary_cache: + img = tf.extractfile(content_key) + binary_cache[content_key] = img.read() if img is not None else None + row["binary_content"] = binary_cache[content_key] + return sample_rows + def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: rows: list[dict[str, Any]] = [] storage_options = (self.read_kwargs or {}).get("storage_options", {}) for tar_path in task.data: source_shard = Path(tar_path).name - with fsspec.open(tar_path, mode="rb", **storage_options) as fobj: - with tarfile.open(fileobj=fobj, mode="r:*") as tf: - members = [m for m in tf.getmembers() if m.isfile()] - member_names = {m.name for m in members} - for member in members: - if not member.name.endswith(".json"): - continue - extracted = tf.extractfile(member) - if extracted is None: - continue - payload = json.load(extracted) - sample_id = Path(member.name).stem - image_member_name = next( - (f"{sample_id}{ext}" for ext in _IMAGE_EXTENSIONS if f"{sample_id}{ext}" in member_names), - None, - ) - sample_rows = self._rows_from_sample( - sample_id=sample_id, - sample=payload, - source_shard=source_shard, - tar_path=tar_path, - json_member_name=member.name, - image_member_name=image_member_name, + with ( + fsspec.open(tar_path, mode="rb", **storage_options) as fobj, + tarfile.open(fileobj=fobj, mode="r:*") as tf, + ): + members = [m for m in tf.getmembers() if m.isfile()] + member_names = {m.name for m in members} + binary_cache: dict[str, bytes | None] = {} + source = {"source_shard": source_shard, "tar_path": tar_path} + for member in members: + if not member.name.endswith(self.json_extensions): + continue + rows.extend( + self._rows_from_member( + tf=tf, + member=member, + member_names=member_names, + source_info=source, + binary_cache=binary_cache, ) - if self.load_binary and image_member_name is not None: - img = tf.extractfile(image_member_name) - if img is not None: - image_bytes = img.read() - for row in sample_rows: - if row["modality"] == "image" and row["position"] >= 0: - row["binary_content"] = image_bytes - rows.extend(sample_rows) + ) table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) batches: list[MultiBatchTask] = [] for idx, split in enumerate(splits): task_id = f"{task.task_id}_processed" if len(splits) == 1 else f"{task.task_id}_processed_{idx:05d}" + metadata = dict(task._metadata) + if storage_options: + metadata["source_storage_options"] = storage_options batches.append( MultiBatchTask( task_id=task_id, dataset_name=task.dataset_name, data=split, - _metadata=task._metadata, + _metadata=metadata, _stage_perf=task._stage_perf, ) ) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 3cef1df634..12b47c9fe1 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -17,17 +17,18 @@ import tarfile from abc import ABC, abstractmethod from dataclasses import dataclass, field -from typing import Any +from typing import TYPE_CHECKING, Any import fsspec import pandas as pd import pyarrow as pa import pyarrow.parquet as pq -from nemo_curator.tasks import MultiBatchTask - from .base import BaseMultimodalWriter +if TYPE_CHECKING: + from nemo_curator.tasks import MultiBatchTask + @dataclass class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): @@ -37,6 +38,69 @@ class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): materialize_on_write: bool = True name: str = "base_multimodal_tabular_writer" + @staticmethod + def _set_errors(error_values: list[str | None], indices: list[int], error: str | None) -> None: + for idx in indices: + error_values[idx] = error + + @staticmethod + def _set_payload( + binary_values: list[object], error_values: list[str | None], indices: list[int], payload: bytes + ) -> None: + for idx in indices: + binary_values[idx] = payload + error_values[idx] = None + + @staticmethod + def _key_to_indices(df: pd.DataFrame, keyed_idxs: list[int]) -> dict[str, list[int]]: + key_to_indices: dict[str, list[int]] = {} + for idx in keyed_idxs: + key = str(df.loc[idx, "_src_content_key"]) + key_to_indices.setdefault(key, []).append(idx) + return key_to_indices + + def _materialize_group( + self, + df: pd.DataFrame, + content_path: object, + idxs: list[int], + storage_options: dict[str, Any], + materialized_state: dict[str, list[object] | list[str | None]], + ) -> None: + binary_values = materialized_state["binary_values"] + error_values = materialized_state["error_values"] + if not content_path: + self._set_errors(error_values, idxs, "missing content_path") + return + + keyed_idxs = [idx for idx in idxs if df.loc[idx, "_src_content_key"]] + direct_idxs = [idx for idx in idxs if not df.loc[idx, "_src_content_key"]] + try: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: + if keyed_idxs: + key_to_indices = self._key_to_indices(df, keyed_idxs) + with tarfile.open(fileobj=fobj, mode="r:*") as tf: + for key, key_indices in key_to_indices.items(): + try: + extracted = tf.extractfile(key) + except KeyError: + extracted = None + if extracted is None: + self._set_errors(error_values, key_indices, f"missing content_key '{key}'") + continue + self._set_payload(binary_values, error_values, key_indices, extracted.read()) + if direct_idxs: + if keyed_idxs: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fresh: + payload = fresh.read() + else: + payload = fobj.read() + self._set_payload(binary_values, error_values, direct_idxs, payload) + elif not keyed_idxs: + self._set_payload(binary_values, error_values, idxs, fobj.read()) + except Exception as e: # noqa: BLE001 + self._set_errors(error_values, idxs, str(e)) + def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: if not self.materialize_on_write: with self._time_metric("to_pandas_s"): @@ -63,56 +127,22 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: if not image_mask.any(): return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") - storage_options = (self.write_kwargs or {}).get("storage_options", {}) + source_storage_options = task._metadata.get("source_storage_options", {}) + if isinstance(source_storage_options, dict): + storage_options = source_storage_options or (self.write_kwargs or {}).get("storage_options", {}) + else: + storage_options = (self.write_kwargs or {}).get("storage_options", {}) pending = out[image_mask] + materialized_state = {"binary_values": binary_values, "error_values": error_values} with self._time_metric("materialize_fetch_binary_s"): for content_path, idxs in pending.groupby("_src_content_path").groups.items(): - if not content_path: - for idx in idxs: - error_values[idx] = "missing content_path" - continue - - keyed_idxs = [idx for idx in idxs if out.at[idx, "_src_content_key"]] - direct_idxs = [idx for idx in idxs if not out.at[idx, "_src_content_key"]] - try: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: - if keyed_idxs: - key_to_indices: dict[str, list[int]] = {} - for idx in keyed_idxs: - key = str(out.at[idx, "_src_content_key"]) - key_to_indices.setdefault(key, []).append(idx) - - with tarfile.open(fileobj=fobj, mode="r:*") as tf: - for key, key_indices in key_to_indices.items(): - try: - extracted = tf.extractfile(key) - except KeyError: - extracted = None - if extracted is None: - for idx in key_indices: - error_values[idx] = f"missing content_key '{key}'" - continue - payload = extracted.read() - for idx in key_indices: - binary_values[idx] = payload - error_values[idx] = None - if direct_idxs: - if keyed_idxs: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fresh: - payload = fresh.read() - else: - payload = fobj.read() - for idx in direct_idxs: - binary_values[idx] = payload - error_values[idx] = None - elif not keyed_idxs: - payload = fobj.read() - for idx in idxs: - binary_values[idx] = payload - error_values[idx] = None - except Exception as e: # noqa: BLE001 - for idx in idxs: - error_values[idx] = str(e) + self._materialize_group( + df=out, + content_path=content_path, + idxs=list(idxs), + storage_options=storage_options, + materialized_state=materialized_state, + ) out["binary_content"] = pd.Series(binary_values, dtype="object") out["materialize_error"] = pd.Series(error_values, dtype="object") diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 9bc9634511..87a2762a7d 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -15,6 +15,7 @@ import json import tarfile from io import BytesIO +from pathlib import Path import pytest @@ -23,7 +24,7 @@ @pytest.fixture -def mint_like_tar(tmp_path): +def mint_like_tar(tmp_path: Path) -> tuple[str, str, bytes]: tar_path = tmp_path / "shard-00000.tar" sample_id = "abc123" payload = { @@ -47,7 +48,7 @@ def mint_like_tar(tmp_path): @pytest.fixture -def input_task(mint_like_tar): +def input_task(mint_like_tar: tuple[str, str, bytes]) -> FileGroupTask: tar_path, _, _ = mint_like_tar return FileGroupTask( task_id="file_group_0", @@ -57,7 +58,9 @@ def input_task(mint_like_tar): ) -def test_reader_emits_metadata_text_image_rows(input_task: FileGroupTask, mint_like_tar) -> None: +def test_reader_emits_metadata_text_image_rows( + input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] +) -> None: _, sample_id, _ = mint_like_tar reader = WebdatasetReaderStage() output = reader.process(input_task) @@ -66,3 +69,56 @@ def test_reader_emits_metadata_text_image_rows(input_task: FileGroupTask, mint_l df = output.to_pandas() assert set(df["modality"].unique()) == {"metadata", "text", "image"} assert ((df["sample_id"] == sample_id) & (df["modality"] == "metadata") & (df["position"] == -1)).any() + + +def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: + tar_path = tmp_path / "alt-shard-00000.tar" + payload = { + "doc_id": "doc-custom", + "source_doc": "custom.pdf", + "captions": ["a", "b"], + "frames": ["custom-image.jpg"], + "primary_image": "custom-image.jpg", + } + image_bytes = b"custom-image-bytes" + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name="sample-xyz.meta.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + + img_info = tarfile.TarInfo(name="custom-image.jpg") + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + + task = FileGroupTask( + task_id="file_group_custom", + dataset_name="custom_dataset", + data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) + reader = WebdatasetReaderStage( + sample_id_field="doc_id", + source_id_field="source_doc", + texts_field="captions", + images_field="frames", + image_member_field="primary_image", + json_extensions=(".meta.json",), + load_binary=True, + ) + output = reader.process(task) + assert isinstance(output, MultiBatchTask) + df = output.to_pandas() + assert ((df["sample_id"] == "doc-custom") & (df["modality"] == "metadata")).any() + text_rows = df[df["modality"] == "text"] + assert text_rows["text_content"].tolist() == ["a", "b"] + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 1 + assert image_rows.iloc[0]["binary_content"] == image_bytes + + +def test_reader_propagates_source_storage_options(input_task: FileGroupTask) -> None: + reader = WebdatasetReaderStage(read_kwargs={"storage_options": {"anon": False}}) + output = reader.process(input_task) + assert isinstance(output, MultiBatchTask) + assert output._metadata.get("source_storage_options") == {"anon": False} diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 6c239af662..7d33d921a8 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -15,6 +15,7 @@ import json import tarfile from io import BytesIO +from pathlib import Path import pandas as pd import pytest @@ -25,7 +26,7 @@ @pytest.fixture -def mint_like_tar(tmp_path): +def mint_like_tar(tmp_path: Path) -> tuple[str, bytes]: tar_path = tmp_path / "shard-00000.tar" sample_id = "abc123" payload = { @@ -49,7 +50,7 @@ def mint_like_tar(tmp_path): @pytest.fixture -def input_task(mint_like_tar): +def input_task(mint_like_tar: tuple[str, bytes]) -> FileGroupTask: tar_path, _ = mint_like_tar return FileGroupTask( task_id="file_group_0", @@ -59,7 +60,9 @@ def input_task(mint_like_tar): ) -def test_writer_materializes_and_marks_errors(tmp_path, input_task: FileGroupTask, mint_like_tar) -> None: +def test_writer_materializes_and_marks_errors( + tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, bytes] +) -> None: _, image_bytes = mint_like_tar reader = WebdatasetReaderStage() batch = reader.process(input_task) @@ -72,11 +75,11 @@ def test_writer_materializes_and_marks_errors(tmp_path, input_task: FileGroupTas written = pd.read_parquet(out_file) image_rows = written[written["modality"] == "image"] assert len(image_rows) > 0 - assert (image_rows["binary_content"].apply(lambda x: x == image_bytes).any()) - assert (image_rows["materialize_error"].isna().any()) + assert image_rows["binary_content"].apply(lambda x: x == image_bytes).any() + assert image_rows["materialize_error"].isna().any() -def test_writer_marks_materialize_error_on_bad_source_path(tmp_path, input_task: FileGroupTask) -> None: +def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input_task: FileGroupTask) -> None: reader = WebdatasetReaderStage() batch = reader.process(input_task) assert isinstance(batch, MultiBatchTask) @@ -85,7 +88,7 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path, input_task: image_mask = df["modality"] == "image" assert image_mask.any() first_image_idx = df[image_mask].index[0] - df.at[first_image_idx, "metadata_source"] = json.dumps( + df.loc[first_image_idx, "metadata_source"] = json.dumps( { "source_id": "doc.pdf", "source_shard": "shard-00000.tar", From c42bacfc7f01f7b49a80d86f3278da813508c4b1 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:37:29 +0000 Subject: [PATCH 04/62] Clean up multimodal stage readability and consolidate test fixtures Signed-off-by: Vibhu Jawa --- .../multimodal/io/writers/multimodal.py | 16 ++- nemo_curator/stages/multimodal/stages.py | 103 +++++++++++++++++- tests/stages/multimodal/conftest.py | 57 ++++++++++ .../stages/multimodal/test_multimodal_core.py | 91 +++++++++++++++- .../multimodal/test_multimodal_reader.py | 37 ------- .../multimodal/test_multimodal_writer.py | 42 +------ 6 files changed, 260 insertions(+), 86 deletions(-) create mode 100644 tests/stages/multimodal/conftest.py diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 12b47c9fe1..9c267838d9 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -30,6 +30,12 @@ from nemo_curator.tasks import MultiBatchTask +@dataclass +class _MaterializationBuffers: + binary_values: list[object] + error_values: list[str | None] + + @dataclass class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): """Shared multimodal tabular writer with optional image materialization.""" @@ -65,10 +71,10 @@ def _materialize_group( content_path: object, idxs: list[int], storage_options: dict[str, Any], - materialized_state: dict[str, list[object] | list[str | None]], + buffers: _MaterializationBuffers, ) -> None: - binary_values = materialized_state["binary_values"] - error_values = materialized_state["error_values"] + binary_values = buffers.binary_values + error_values = buffers.error_values if not content_path: self._set_errors(error_values, idxs, "missing content_path") return @@ -133,7 +139,7 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: else: storage_options = (self.write_kwargs or {}).get("storage_options", {}) pending = out[image_mask] - materialized_state = {"binary_values": binary_values, "error_values": error_values} + buffers = _MaterializationBuffers(binary_values=binary_values, error_values=error_values) with self._time_metric("materialize_fetch_binary_s"): for content_path, idxs in pending.groupby("_src_content_path").groups.items(): self._materialize_group( @@ -141,7 +147,7 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: content_path=content_path, idxs=list(idxs), storage_options=storage_options, - materialized_state=materialized_state, + buffers=buffers, ) out["binary_content"] = pd.Series(binary_values, dtype="object") diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 40f395ba7f..6b1a7e0140 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -12,7 +12,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -from dataclasses import dataclass +from __future__ import annotations + +import io +import tarfile +from dataclasses import dataclass, field +from typing import Any + +import fsspec +import pandas as pd +from PIL import Image # type: ignore[import-not-found] from nemo_curator.stages.base import ProcessingStage from nemo_curator.tasks import MultiBatchTask @@ -20,9 +29,14 @@ @dataclass class BasicMultimodalFilterStage(ProcessingStage[MultiBatchTask, MultiBatchTask]): - """Minimal validation/filter stage for multimodal rows.""" + """Validation/filter stage for multimodal rows with optional JPEG aspect-ratio checks.""" drop_invalid_rows: bool = True + validate_jpeg_aspect_ratio: bool = False + min_aspect_ratio: float = 0.2 + max_aspect_ratio: float = 5.0 + jpeg_content_types: tuple[str, ...] = ("image/jpeg", "image/jpg") + read_kwargs: dict[str, Any] = field(default_factory=dict) name: str = "basic_multimodal_filter" def inputs(self) -> tuple[list[str], list[str]]: @@ -31,6 +45,88 @@ def inputs(self) -> tuple[list[str], list[str]]: def outputs(self) -> tuple[list[str], list[str]]: return ["data"], [] + @staticmethod + def _image_aspect_ratio(image_bytes: bytes) -> float | None: + try: + with Image.open(io.BytesIO(image_bytes)) as image: + width, height = image.size + except Exception: # noqa: BLE001 + return None + if height <= 0: + return None + return float(width) / float(height) + + @staticmethod + def _load_image_bytes_from_source( + source_value: str | None, + storage_options: dict[str, Any], + byte_cache: dict[tuple[str, str], bytes | None], + ) -> bytes | None: + source = MultiBatchTask.parse_metadata_source(source_value) + content_path = source.get("content_path") + content_key = source.get("content_key") + if not content_path: + return None + + cache_key = (str(content_path), str(content_key or "")) + if cache_key in byte_cache: + return byte_cache[cache_key] + + try: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: + if content_key: + with tarfile.open(fileobj=fobj, mode="r:*") as tf: + try: + extracted = tf.extractfile(content_key) + except KeyError: + extracted = None + payload = extracted.read() if extracted is not None else None + byte_cache[cache_key] = payload + return payload + payload = fobj.read() + byte_cache[cache_key] = payload + return payload + except Exception: # noqa: BLE001 + byte_cache[cache_key] = None + return None + + def _filter_jpeg_aspect_ratio(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: + if df.empty: + return df + if "modality" not in df.columns or "content_type" not in df.columns: + return df + + jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) + if not jpeg_mask.any(): + return df + + storage_options = task._metadata.get("source_storage_options") + if not isinstance(storage_options, dict): + storage_options = (self.read_kwargs or {}).get("storage_options", {}) + + byte_cache: dict[tuple[str, str], bytes | None] = {} + keep_mask = pd.Series(True, index=df.index) + + for idx in df[jpeg_mask].index.tolist(): + image_bytes = df.loc[idx, "binary_content"] + if not isinstance(image_bytes, (bytes, bytearray)): + image_bytes = self._load_image_bytes_from_source( + source_value=df.loc[idx, "metadata_source"] if "metadata_source" in df.columns else None, + storage_options=storage_options, + byte_cache=byte_cache, + ) + if not isinstance(image_bytes, (bytes, bytearray)): + keep_mask.loc[idx] = False + continue + aspect_ratio = self._image_aspect_ratio(bytes(image_bytes)) + if aspect_ratio is None: + keep_mask.loc[idx] = False + continue + if aspect_ratio < self.min_aspect_ratio or aspect_ratio > self.max_aspect_ratio: + keep_mask.loc[idx] = False + + return df[keep_mask] + def process(self, task: MultiBatchTask) -> MultiBatchTask: df = task.to_pandas().copy() if df.empty: @@ -44,6 +140,9 @@ def process(self, task: MultiBatchTask) -> MultiBatchTask: valid_pos = valid_pos | ((df["modality"] != "metadata") & (df["position"] >= 0)) df = df[valid_pos] + if self.validate_jpeg_aspect_ratio: + df = self._filter_jpeg_aspect_ratio(task, df) + return MultiBatchTask( task_id=f"{task.task_id}_{self.name}", dataset_name=task.dataset_name, diff --git a/tests/stages/multimodal/conftest.py b/tests/stages/multimodal/conftest.py new file mode 100644 index 0000000000..0a27fa2e28 --- /dev/null +++ b/tests/stages/multimodal/conftest.py @@ -0,0 +1,57 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 tarfile +from io import BytesIO +from pathlib import Path + +import pytest + +from nemo_curator.tasks import FileGroupTask + + +@pytest.fixture +def mint_like_tar(tmp_path: Path) -> tuple[str, str, bytes]: + tar_path = tmp_path / "shard-00000.tar" + sample_id = "abc123" + payload = { + "pdf_name": "doc.pdf", + "url": "https://example.com/doc.pdf", + "texts": ["hello", None, "world"], + "images": ["page_0_image_1", None, "page_2_image_9"], + "image_metadata": [{"page": 0}, {"page": 2}], + } + image_bytes = b"fake-image-bytes" + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name=f"{sample_id}.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + + img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + return str(tar_path), sample_id, image_bytes + + +@pytest.fixture +def input_task(mint_like_tar: tuple[str, str, bytes]) -> FileGroupTask: + tar_path, _, _ = mint_like_tar + return FileGroupTask( + task_id="file_group_0", + dataset_name="mint_test", + data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index fd163644fe..c71ff9a844 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -13,12 +13,17 @@ # limitations under the License. import json +import tarfile +from io import BytesIO +from pathlib import Path import pandas as pd import pyarrow as pa import pytest +from PIL import Image from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -38,7 +43,7 @@ def single_row_table() -> pa.Table: { "source_id": "doc.pdf", "source_shard": "shard-00000.tar", - "content_path": "/tmp/shard-00000.tar", + "content_path": "/dataset/shard-00000.tar", "content_key": "s1.json", } ), @@ -66,7 +71,7 @@ def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: df = single_row_task.with_parsed_source_columns() assert df.loc[0, "_src_source_id"] == "doc.pdf" assert df.loc[0, "_src_source_shard"] == "shard-00000.tar" - assert df.loc[0, "_src_content_path"] == "/tmp/shard-00000.tar" + assert df.loc[0, "_src_content_path"] == "/dataset/shard-00000.tar" assert df.loc[0, "_src_content_key"] == "s1.json" @@ -88,3 +93,85 @@ def test_split_table_keeps_group_intact() -> None: assert len(first_groups) == 1 assert len(second_groups) == 1 assert first_groups != second_groups + + +def _make_jpeg_bytes(width: int, height: int) -> bytes: + image = Image.new("RGB", (width, height), color=(255, 0, 0)) + buffer = BytesIO() + image.save(buffer, format="JPEG") + return buffer.getvalue() + + +def test_basic_multimodal_filter_stage_jpeg_ratio_from_binary() -> None: + square_bytes = _make_jpeg_bytes(100, 100) + wide_bytes = _make_jpeg_bytes(1000, 100) + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": square_bytes, + "metadata_source": None, + "metadata_json": None, + "materialize_error": None, + }, + { + "sample_id": "s2", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": wide_bytes, + "metadata_source": None, + "metadata_json": None, + "materialize_error": None, + }, + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="ratio_binary", dataset_name="d1", data=table) + stage = BasicMultimodalFilterStage(validate_jpeg_aspect_ratio=True, min_aspect_ratio=0.8, max_aspect_ratio=1.2) + out = stage.process(task) + out_df = out.to_pandas() + assert len(out_df) == 1 + assert out_df.iloc[0]["sample_id"] == "s1" + + +def test_basic_multimodal_filter_stage_jpeg_ratio_from_source(tmp_path: Path) -> None: + tar_path = tmp_path / "images.tar" + wide_bytes = _make_jpeg_bytes(900, 100) + with tarfile.open(tar_path, "w") as tf: + info = tarfile.TarInfo(name="wide.jpg") + info.size = len(wide_bytes) + tf.addfile(info, BytesIO(wide_bytes)) + + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": None, + "metadata_source": json.dumps( + { + "source_id": "doc.pdf", + "source_shard": "images.tar", + "content_path": str(tar_path), + "content_key": "wide.jpg", + } + ), + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="ratio_source", dataset_name="d1", data=table) + stage = BasicMultimodalFilterStage(validate_jpeg_aspect_ratio=True, min_aspect_ratio=0.8, max_aspect_ratio=1.2) + out = stage.process(task) + assert out.to_pandas().empty diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 87a2762a7d..9127be8302 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -17,47 +17,10 @@ from io import BytesIO from pathlib import Path -import pytest - from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask -@pytest.fixture -def mint_like_tar(tmp_path: Path) -> tuple[str, str, bytes]: - tar_path = tmp_path / "shard-00000.tar" - sample_id = "abc123" - payload = { - "pdf_name": "doc.pdf", - "url": "https://example.com/doc.pdf", - "texts": ["hello", None, "world"], - "images": ["page_0_image_1", None, "page_2_image_9"], - "image_metadata": [{"page": 0}, {"page": 2}], - } - image_bytes = b"fake-image-bytes" - with tarfile.open(tar_path, "w") as tf: - json_blob = json.dumps(payload).encode("utf-8") - json_info = tarfile.TarInfo(name=f"{sample_id}.json") - json_info.size = len(json_blob) - tf.addfile(json_info, BytesIO(json_blob)) - - img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") - img_info.size = len(image_bytes) - tf.addfile(img_info, BytesIO(image_bytes)) - return str(tar_path), sample_id, image_bytes - - -@pytest.fixture -def input_task(mint_like_tar: tuple[str, str, bytes]) -> FileGroupTask: - tar_path, _, _ = mint_like_tar - return FileGroupTask( - task_id="file_group_0", - dataset_name="mint_test", - data=[tar_path], - _metadata={"source_files": [tar_path]}, - ) - - def test_reader_emits_metadata_text_image_rows( input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 7d33d921a8..bf897210c7 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -13,57 +13,19 @@ # limitations under the License. import json -import tarfile -from io import BytesIO from pathlib import Path import pandas as pd -import pytest from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask -@pytest.fixture -def mint_like_tar(tmp_path: Path) -> tuple[str, bytes]: - tar_path = tmp_path / "shard-00000.tar" - sample_id = "abc123" - payload = { - "pdf_name": "doc.pdf", - "url": "https://example.com/doc.pdf", - "texts": ["hello", None, "world"], - "images": ["page_0_image_1", None, "page_2_image_9"], - "image_metadata": [{"page": 0}, {"page": 2}], - } - image_bytes = b"fake-image-bytes" - with tarfile.open(tar_path, "w") as tf: - json_blob = json.dumps(payload).encode("utf-8") - json_info = tarfile.TarInfo(name=f"{sample_id}.json") - json_info.size = len(json_blob) - tf.addfile(json_info, BytesIO(json_blob)) - - img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") - img_info.size = len(image_bytes) - tf.addfile(img_info, BytesIO(image_bytes)) - return str(tar_path), image_bytes - - -@pytest.fixture -def input_task(mint_like_tar: tuple[str, bytes]) -> FileGroupTask: - tar_path, _ = mint_like_tar - return FileGroupTask( - task_id="file_group_0", - dataset_name="mint_test", - data=[tar_path], - _metadata={"source_files": [tar_path]}, - ) - - def test_writer_materializes_and_marks_errors( - tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, bytes] + tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: - _, image_bytes = mint_like_tar + _, _, image_bytes = mint_like_tar reader = WebdatasetReaderStage() batch = reader.process(input_task) assert isinstance(batch, MultiBatchTask) From 73a66d377cff63d046fdd5baf2306c4c38decb88 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:48:32 +0000 Subject: [PATCH 05/62] Refine multimodal JPEG filter abstractions and naming Signed-off-by: Vibhu Jawa --- .../scripts/multimodal_mint1t_benchmark.py | 4 +- nemo_curator/stages/multimodal/__init__.py | 8 +- nemo_curator/stages/multimodal/stages.py | 119 +++++++++++------- .../stages/multimodal/test_multimodal_core.py | 6 +- tutorials/multimodal/mint1t_mvp_pipeline.py | 4 +- 5 files changed, 84 insertions(+), 57 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 718f75a4bb..d403520e68 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -26,7 +26,7 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader -from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage from nemo_curator.tasks.utils import TaskPerfUtils @@ -52,7 +52,7 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: load_binary=False, ) ) - pipeline.add_stage(BasicMultimodalFilterStage(drop_invalid_rows=True)) + pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) pipeline.add_stage( MultimodalParquetWriter( path=args.output_path, diff --git a/nemo_curator/stages/multimodal/__init__.py b/nemo_curator/stages/multimodal/__init__.py index a865850479..9b1a32cfbb 100644 --- a/nemo_curator/stages/multimodal/__init__.py +++ b/nemo_curator/stages/multimodal/__init__.py @@ -12,6 +12,10 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage +from nemo_curator.stages.multimodal.stages import ( + BaseMultimodalAnnotatorStage, + BaseMultimodalFilterStage, + MultimodalJpegAspectRatioFilterStage, +) -__all__ = ["BasicMultimodalFilterStage"] +__all__ = ["BaseMultimodalAnnotatorStage", "BaseMultimodalFilterStage", "MultimodalJpegAspectRatioFilterStage"] diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 6b1a7e0140..d150afaddf 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -16,8 +16,8 @@ import io import tarfile -from dataclasses import dataclass, field -from typing import Any +from abc import ABC, abstractmethod +from dataclasses import dataclass import fsspec import pandas as pd @@ -28,16 +28,10 @@ @dataclass -class BasicMultimodalFilterStage(ProcessingStage[MultiBatchTask, MultiBatchTask]): - """Validation/filter stage for multimodal rows with optional JPEG aspect-ratio checks.""" +class BaseMultimodalAnnotatorStage(ProcessingStage[MultiBatchTask, MultiBatchTask], ABC): + """Base stage for row-wise multimodal annotation/filter transforms.""" - drop_invalid_rows: bool = True - validate_jpeg_aspect_ratio: bool = False - min_aspect_ratio: float = 0.2 - max_aspect_ratio: float = 5.0 - jpeg_content_types: tuple[str, ...] = ("image/jpeg", "image/jpg") - read_kwargs: dict[str, Any] = field(default_factory=dict) - name: str = "basic_multimodal_filter" + name: str = "base_multimodal_annotator" def inputs(self) -> tuple[list[str], list[str]]: return ["data"], [] @@ -45,6 +39,48 @@ def inputs(self) -> tuple[list[str], list[str]]: def outputs(self) -> tuple[list[str], list[str]]: return ["data"], [] + @abstractmethod + def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: + """Apply annotation/filter logic and return transformed dataframe.""" + + def process(self, task: MultiBatchTask) -> MultiBatchTask: + df = task.to_pandas().copy() + if df.empty: + return task + out_df = self.annotate(task, df) + return MultiBatchTask( + task_id=f"{task.task_id}_{self.name}", + dataset_name=task.dataset_name, + data=out_df.reset_index(drop=True), + _metadata=task._metadata, + _stage_perf=task._stage_perf, + ) + + +@dataclass +class BaseMultimodalFilterStage(BaseMultimodalAnnotatorStage, ABC): + """Base stage for multimodal filtering based on a keep-mask.""" + + name: str = "base_multimodal_filter" + + @abstractmethod + def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + """Return boolean keep-mask aligned to dataframe index.""" + + def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: + return df[self.keep_mask(task, df)] + + +@dataclass +class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): + """Filter multimodal rows and enforce JPEG aspect-ratio bounds.""" + + drop_invalid_rows: bool = True + min_aspect_ratio: float = 0.2 + max_aspect_ratio: float = 5.0 + jpeg_content_types: tuple[str, ...] = ("image/jpeg", "image/jpg") + name: str = "multimodal_jpeg_aspect_ratio_filter" + @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: try: @@ -59,7 +95,7 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: @staticmethod def _load_image_bytes_from_source( source_value: str | None, - storage_options: dict[str, Any], + storage_options: dict[str, object], byte_cache: dict[tuple[str, str], bytes | None], ) -> bytes | None: source = MultiBatchTask.parse_metadata_source(source_value) @@ -90,28 +126,23 @@ def _load_image_bytes_from_source( byte_cache[cache_key] = None return None - def _filter_jpeg_aspect_ratio(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: - if df.empty: - return df + def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + keep_mask = pd.Series(True, index=df.index, dtype=bool) if "modality" not in df.columns or "content_type" not in df.columns: - return df - + return keep_mask jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) if not jpeg_mask.any(): - return df - + return keep_mask storage_options = task._metadata.get("source_storage_options") if not isinstance(storage_options, dict): - storage_options = (self.read_kwargs or {}).get("storage_options", {}) - + storage_options = {} byte_cache: dict[tuple[str, str], bytes | None] = {} - keep_mask = pd.Series(True, index=df.index) - for idx in df[jpeg_mask].index.tolist(): image_bytes = df.loc[idx, "binary_content"] if not isinstance(image_bytes, (bytes, bytearray)): + source_value = df.loc[idx, "metadata_source"] if "metadata_source" in df.columns else None image_bytes = self._load_image_bytes_from_source( - source_value=df.loc[idx, "metadata_source"] if "metadata_source" in df.columns else None, + source_value=source_value, storage_options=storage_options, byte_cache=byte_cache, ) @@ -124,29 +155,21 @@ def _filter_jpeg_aspect_ratio(self, task: MultiBatchTask, df: pd.DataFrame) -> p continue if aspect_ratio < self.min_aspect_ratio or aspect_ratio > self.max_aspect_ratio: keep_mask.loc[idx] = False + return keep_mask - return df[keep_mask] - - def process(self, task: MultiBatchTask) -> MultiBatchTask: - df = task.to_pandas().copy() - if df.empty: - return task - + @staticmethod + def _basic_row_validity_mask(df: pd.DataFrame) -> pd.Series: + keep_mask = pd.Series(True, index=df.index, dtype=bool) + allowed = {"text", "image", "metadata"} + keep_mask &= df["modality"].isin(allowed) + metadata_pos = (df["modality"] == "metadata") & (df["position"] == -1) + content_pos = (df["modality"] != "metadata") & (df["position"] >= 0) + keep_mask &= metadata_pos | content_pos + return keep_mask + + def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + keep_mask = pd.Series(True, index=df.index, dtype=bool) if self.drop_invalid_rows: - allowed = {"text", "image", "metadata"} - df = df[df["modality"].isin(allowed)] - # Keep metadata rows at sentinel position -1; content rows should be non-negative. - valid_pos = (df["modality"] == "metadata") & (df["position"] == -1) - valid_pos = valid_pos | ((df["modality"] != "metadata") & (df["position"] >= 0)) - df = df[valid_pos] - - if self.validate_jpeg_aspect_ratio: - df = self._filter_jpeg_aspect_ratio(task, df) - - return MultiBatchTask( - task_id=f"{task.task_id}_{self.name}", - dataset_name=task.dataset_name, - data=df.reset_index(drop=True), - _metadata=task._metadata, - _stage_perf=task._stage_perf, - ) + keep_mask &= self._basic_row_validity_mask(df) + keep_mask &= self._jpeg_keep_mask(task, df) + return keep_mask diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index c71ff9a844..3a4feed6bb 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -23,7 +23,7 @@ from PIL import Image from nemo_curator.core.utils import split_table_by_group_max_bytes -from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -133,7 +133,7 @@ def test_basic_multimodal_filter_stage_jpeg_ratio_from_binary() -> None: schema=MULTIMODAL_SCHEMA, ) task = MultiBatchTask(task_id="ratio_binary", dataset_name="d1", data=table) - stage = BasicMultimodalFilterStage(validate_jpeg_aspect_ratio=True, min_aspect_ratio=0.8, max_aspect_ratio=1.2) + stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) out = stage.process(task) out_df = out.to_pandas() assert len(out_df) == 1 @@ -172,6 +172,6 @@ def test_basic_multimodal_filter_stage_jpeg_ratio_from_source(tmp_path: Path) -> schema=MULTIMODAL_SCHEMA, ) task = MultiBatchTask(task_id="ratio_source", dataset_name="d1", data=table) - stage = BasicMultimodalFilterStage(validate_jpeg_aspect_ratio=True, min_aspect_ratio=0.8, max_aspect_ratio=1.2) + stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) out = stage.process(task) assert out.to_pandas().empty diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 5be5ea14e9..1504dfb4da 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -18,7 +18,7 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader -from nemo_curator.stages.multimodal.stages import BasicMultimodalFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage def build_pipeline(args: argparse.Namespace) -> Pipeline: @@ -40,7 +40,7 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: load_binary=False, ) ) - pipe.add_stage(BasicMultimodalFilterStage(drop_invalid_rows=True)) + pipe.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) pipe.add_stage( MultimodalParquetWriter( path=args.output_path, From 5d3547fba3b0aa8ede76bcd8ce8acd1b826dd794 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:53:27 +0000 Subject: [PATCH 06/62] Require explicit source_id_field in multimodal webdataset reader Signed-off-by: Vibhu Jawa --- benchmarking/scripts/multimodal_mint1t_benchmark.py | 1 + nemo_curator/stages/multimodal/io/reader.py | 5 ++++- nemo_curator/stages/multimodal/io/readers/webdataset.py | 7 ++++++- tests/stages/multimodal/test_multimodal_reader.py | 4 ++-- tests/stages/multimodal/test_multimodal_writer.py | 4 ++-- tutorials/multimodal/mint1t_mvp_pipeline.py | 1 + 6 files changed, 16 insertions(+), 6 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index d403520e68..3799b9183d 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -44,6 +44,7 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: ) pipeline.add_stage( WebdatasetReader( + source_id_field="pdf_name", file_paths=args.input_path, files_per_partition=args.files_per_partition, blocksize=args.input_blocksize, diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index 64ef2ec150..e43bd58017 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -38,7 +38,7 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): file_extensions: list[str] = field(default_factory=lambda: _DEFAULT_WEBDATASET_EXTENSIONS) json_extensions: list[str] = field(default_factory=lambda: _DEFAULT_JSON_EXTENSIONS) image_extensions: list[str] = field(default_factory=lambda: _DEFAULT_IMAGE_EXTENSIONS) - source_id_field: str | None = "pdf_name" + source_id_field: str | None = None sample_id_field: str | None = None texts_field: str = "texts" images_field: str = "images" @@ -47,6 +47,9 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): def __post_init__(self): super().__init__() + if not self.source_id_field: + msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" + raise ValueError(msg) self.storage_options = self.read_kwargs.get("storage_options", {}) def decompose(self) -> list: diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 9e0313da76..c733338907 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -41,13 +41,18 @@ class WebdatasetReaderStage(BaseMultimodalReader): max_batch_bytes: int | None = None json_extensions: tuple[str, ...] = (".json",) image_extensions: tuple[str, ...] = field(default_factory=lambda: _IMAGE_EXTENSIONS) - source_id_field: str | None = "pdf_name" + source_id_field: str | None = None sample_id_field: str | None = None texts_field: str = "texts" images_field: str = "images" image_member_field: str | None = None name: str = "webdataset_reader" + def __post_init__(self) -> None: + if not self.source_id_field: + msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" + raise ValueError(msg) + def _rows_from_sample( self, sample_id: str, diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 9127be8302..538f777204 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -25,7 +25,7 @@ def test_reader_emits_metadata_text_image_rows( input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: _, sample_id, _ = mint_like_tar - reader = WebdatasetReaderStage() + reader = WebdatasetReaderStage(source_id_field="pdf_name") output = reader.process(input_task) assert isinstance(output, MultiBatchTask) @@ -81,7 +81,7 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: def test_reader_propagates_source_storage_options(input_task: FileGroupTask) -> None: - reader = WebdatasetReaderStage(read_kwargs={"storage_options": {"anon": False}}) + reader = WebdatasetReaderStage(source_id_field="pdf_name", read_kwargs={"storage_options": {"anon": False}}) output = reader.process(input_task) assert isinstance(output, MultiBatchTask) assert output._metadata.get("source_storage_options") == {"anon": False} diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index bf897210c7..f4b32e57de 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -26,7 +26,7 @@ def test_writer_materializes_and_marks_errors( tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: _, _, image_bytes = mint_like_tar - reader = WebdatasetReaderStage() + reader = WebdatasetReaderStage(source_id_field="pdf_name") batch = reader.process(input_task) assert isinstance(batch, MultiBatchTask) @@ -42,7 +42,7 @@ def test_writer_materializes_and_marks_errors( def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input_task: FileGroupTask) -> None: - reader = WebdatasetReaderStage() + reader = WebdatasetReaderStage(source_id_field="pdf_name") batch = reader.process(input_task) assert isinstance(batch, MultiBatchTask) diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 1504dfb4da..bc0c50dc65 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -32,6 +32,7 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: pipe = Pipeline(name="mint1t_mvp_multimodal", description="WebDataset MINT1T -> multimodal rows -> parquet") pipe.add_stage( WebdatasetReader( + source_id_field="pdf_name", file_paths=args.input_path, files_per_partition=args.files_per_partition, blocksize=args.input_blocksize, From 21908bf82dfac74e10a109cba97ca616e45cc1f9 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 07:58:40 +0000 Subject: [PATCH 07/62] Optimize parsed source column extraction for multimodal task Signed-off-by: Vibhu Jawa --- nemo_curator/tasks/multimodal.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index f41058a6be..a0304022af 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -131,9 +131,11 @@ def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: - {prefix}content_key """ df = self.to_pandas().copy() - parsed = df["metadata_source"].apply(self.parse_metadata_source) - df[f"{prefix}source_id"] = parsed.apply(lambda d: d["source_id"]) - df[f"{prefix}source_shard"] = parsed.apply(lambda d: d["source_shard"]) - df[f"{prefix}content_path"] = parsed.apply(lambda d: d["content_path"]) - df[f"{prefix}content_key"] = parsed.apply(lambda d: d["content_key"]) + parsed = [self.parse_metadata_source(value) for value in df["metadata_source"].tolist()] + parsed_df = pd.DataFrame.from_records( + parsed, + columns=["source_id", "source_shard", "content_path", "content_key"], + ) + for col in parsed_df.columns: + df[f"{prefix}{col}"] = parsed_df[col].to_numpy(copy=False) return df From ed901bec97c15780356a801e3f7fc87651f0faf2 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 08:01:02 +0000 Subject: [PATCH 08/62] Remove redundant direct materialization branch and add regression test Signed-off-by: Vibhu Jawa --- .../multimodal/io/writers/multimodal.py | 2 - .../multimodal/test_multimodal_writer.py | 46 +++++++++++++++++++ 2 files changed, 46 insertions(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 9c267838d9..3889d33056 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -102,8 +102,6 @@ def _materialize_group( else: payload = fobj.read() self._set_payload(binary_values, error_values, direct_idxs, payload) - elif not keyed_idxs: - self._set_payload(binary_values, error_values, idxs, fobj.read()) except Exception as e: # noqa: BLE001 self._set_errors(error_values, idxs, str(e)) diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index f4b32e57de..16a7e4b7e8 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -16,10 +16,12 @@ from pathlib import Path import pandas as pd +import pyarrow as pa from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA def test_writer_materializes_and_marks_errors( @@ -73,3 +75,47 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input target = written.loc[first_image_idx] assert pd.isna(target["binary_content"]) assert isinstance(target["materialize_error"], str) + + +def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> None: + image_bytes = b"raw-image-bytes" + raw_path = tmp_path / "raw_image.jpg" + raw_path.write_bytes(image_bytes) + + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": None, + "metadata_source": json.dumps( + { + "source_id": "doc.pdf", + "source_shard": "raw_image.jpg", + "content_path": str(raw_path), + "content_key": None, + } + ), + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask( + task_id="direct_content_path", + dataset_name="mint_test", + data=table, + _metadata={"source_files": [str(raw_path)]}, + ) + + writer = MultimodalParquetWriterStage( + path=str(tmp_path / "out_direct"), materialize_on_write=True, mode="overwrite" + ) + write_task = writer.process(task) + written = pd.read_parquet(write_task.data[0]) + assert written.loc[0, "binary_content"] == image_bytes + assert pd.isna(written.loc[0, "materialize_error"]) From 4e90268660ce98b69241ab92f82123cde1bfeb8a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 08:17:46 +0000 Subject: [PATCH 09/62] Refactor multimodal materialization and shared IO defaults Signed-off-by: Vibhu Jawa --- .../scripts/multimodal_mint1t_benchmark.py | 7 +- nemo_curator/stages/multimodal/io/reader.py | 29 ++--- .../multimodal/io/readers/webdataset.py | 102 +++++++++--------- .../multimodal/io/writers/multimodal.py | 63 ++++------- nemo_curator/stages/multimodal/stages.py | 43 +------- .../stages/multimodal/utils/__init__.py | 35 ++++++ .../stages/multimodal/utils/constants.py | 17 +++ .../multimodal/utils/materialization.py | 86 +++++++++++++++ .../stages/multimodal/test_multimodal_core.py | 42 ++++++++ .../multimodal/test_multimodal_reader.py | 12 ++- tutorials/multimodal/mint1t_mvp_pipeline.py | 6 +- 11 files changed, 294 insertions(+), 148 deletions(-) create mode 100644 nemo_curator/stages/multimodal/utils/__init__.py create mode 100644 nemo_curator/stages/multimodal/utils/constants.py create mode 100644 nemo_curator/stages/multimodal/utils/materialization.py diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 3799b9183d..288dae8099 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -50,7 +50,7 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: blocksize=args.input_blocksize, max_batch_bytes=args.output_max_batch_bytes, read_kwargs=read_kwargs, - load_binary=False, + materialize_on_read=args.materialize_on_read, ) ) pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) @@ -97,6 +97,7 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: "files_per_partition": args.files_per_partition, "input_blocksize": args.input_blocksize, "output_max_batch_bytes": args.output_max_batch_bytes, + "materialize_on_read": args.materialize_on_read, "materialize_on_write": args.materialize_on_write, "parquet_row_group_size": args.parquet_row_group_size, "parquet_compression": args.parquet_compression, @@ -123,13 +124,15 @@ def main() -> int: parser.add_argument("--files-per-partition", type=int, default=1) parser.add_argument("--input-blocksize", type=str, default=None) parser.add_argument("--output-max-batch-bytes", type=int, default=None) + parser.add_argument("--materialize-on-read", action="store_true", dest="materialize_on_read") + parser.add_argument("--no-materialize-on-read", action="store_false", dest="materialize_on_read") parser.add_argument("--parquet-row-group-size", type=int, default=None) parser.add_argument("--parquet-compression", type=str, default=None) parser.add_argument("--parquet-write-backend", type=str, default="pandas", choices=["pandas", "pyarrow"]) parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") parser.add_argument("--mode", type=str, default="overwrite", choices=["ignore", "overwrite", "append", "error"]) - parser.set_defaults(materialize_on_write=False) + parser.set_defaults(materialize_on_write=False, materialize_on_read=False) args = parser.parse_args() ray_client = RayClient() diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index e43bd58017..b5735638e4 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -18,12 +18,15 @@ from nemo_curator.stages.base import CompositeStage from nemo_curator.stages.file_partitioning import FilePartitioningStage from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.multimodal.utils import ( + DEFAULT_IMAGE_EXTENSIONS, + DEFAULT_JSON_EXTENSIONS, + DEFAULT_WEBDATASET_EXTENSIONS, + require_source_id_field, + resolve_storage_options, +) from nemo_curator.tasks import MultiBatchTask, _EmptyTask -_DEFAULT_WEBDATASET_EXTENSIONS = [".tar", ".tar.gz", ".tgz", ".tar.zst"] -_DEFAULT_JSON_EXTENSIONS = [".json"] -_DEFAULT_IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif"] - @dataclass class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): @@ -34,11 +37,11 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): blocksize: int | str | None = None max_batch_bytes: int | None = None read_kwargs: dict[str, Any] = field(default_factory=dict) - load_binary: bool = False - file_extensions: list[str] = field(default_factory=lambda: _DEFAULT_WEBDATASET_EXTENSIONS) - json_extensions: list[str] = field(default_factory=lambda: _DEFAULT_JSON_EXTENSIONS) - image_extensions: list[str] = field(default_factory=lambda: _DEFAULT_IMAGE_EXTENSIONS) - source_id_field: str | None = None + materialize_on_read: bool = False + file_extensions: list[str] = field(default_factory=lambda: list(DEFAULT_WEBDATASET_EXTENSIONS)) + json_extensions: list[str] = field(default_factory=lambda: list(DEFAULT_JSON_EXTENSIONS)) + image_extensions: list[str] = field(default_factory=lambda: list(DEFAULT_IMAGE_EXTENSIONS)) + source_id_field: str = "" sample_id_field: str | None = None texts_field: str = "texts" images_field: str = "images" @@ -47,10 +50,8 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): def __post_init__(self): super().__init__() - if not self.source_id_field: - msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" - raise ValueError(msg) - self.storage_options = self.read_kwargs.get("storage_options", {}) + self.source_id_field = require_source_id_field(self.source_id_field) + self.storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) def decompose(self) -> list: return [ @@ -63,7 +64,7 @@ def decompose(self) -> list: ), WebdatasetReaderStage( read_kwargs=self.read_kwargs, - load_binary=self.load_binary, + materialize_on_read=self.materialize_on_read, max_batch_bytes=self.max_batch_bytes, json_extensions=tuple(self.json_extensions), image_extensions=tuple(self.image_extensions), diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index c733338907..b66f55581e 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -25,23 +25,37 @@ import pyarrow as pa from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.stages.multimodal.utils import ( + DEFAULT_IMAGE_EXTENSIONS, + DEFAULT_JSON_EXTENSIONS, + load_bytes_from_metadata_source, + require_source_id_field, + resolve_storage_options, +) from nemo_curator.tasks import FileGroupTask, MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA from .base import BaseMultimodalReader -_IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif") + +@dataclass +class _ReadContext: + source_shard: str + tar_path: str + member_names: set[str] + storage_options: dict[str, object] + byte_cache: dict[tuple[str, str], bytes | None] @dataclass class WebdatasetReaderStage(BaseMultimodalReader): """Read MINT1T-style WebDataset shards into a row-wise multimodal task.""" - load_binary: bool = False + materialize_on_read: bool = False max_batch_bytes: int | None = None - json_extensions: tuple[str, ...] = (".json",) - image_extensions: tuple[str, ...] = field(default_factory=lambda: _IMAGE_EXTENSIONS) - source_id_field: str | None = None + json_extensions: tuple[str, ...] = DEFAULT_JSON_EXTENSIONS + image_extensions: tuple[str, ...] = field(default_factory=lambda: DEFAULT_IMAGE_EXTENSIONS) + source_id_field: str = "" sample_id_field: str | None = None texts_field: str = "texts" images_field: str = "images" @@ -49,9 +63,7 @@ class WebdatasetReaderStage(BaseMultimodalReader): name: str = "webdataset_reader" def __post_init__(self) -> None: - if not self.source_id_field: - msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" - raise ValueError(msg) + self.source_id_field = require_source_id_field(self.source_id_field) def _rows_from_sample( self, @@ -60,10 +72,21 @@ def _rows_from_sample( source: dict[str, str], member_names: set[str], ) -> list[dict[str, Any]]: - source_id = sample.get(self.source_id_field) if self.source_id_field else None + source_id = sample.get(self.source_id_field) rows: list[dict[str, Any]] = [] images = sample.get(self.images_field) image_member_name = self._resolve_default_image_member_name(sample_id, sample, images, member_names) + source_shard = source["source_shard"] + tar_path = source["tar_path"] + json_member_name = source["json_member_name"] + + def build_metadata_source(content_key: str | None) -> str: + return MultiBatchTask.build_metadata_source( + source_id=source_id, + source_shard=source_shard, + content_path=tar_path, + content_key=content_key, + ) rows.append( { @@ -73,12 +96,7 @@ def _rows_from_sample( "content_type": "application/json", "text_content": None, "binary_content": None, - "metadata_source": MultiBatchTask.build_metadata_source( - source_id=source_id, - source_shard=source["source_shard"], - content_path=source["tar_path"], - content_key=source["json_member_name"], - ), + "metadata_source": build_metadata_source(json_member_name), "metadata_json": json.dumps(sample, ensure_ascii=True), "materialize_error": None, } @@ -95,12 +113,7 @@ def _rows_from_sample( "content_type": "text/plain", "text_content": text_value if isinstance(text_value, str) else None, "binary_content": None, - "metadata_source": MultiBatchTask.build_metadata_source( - source_id=source_id, - source_shard=source["source_shard"], - content_path=source["tar_path"], - content_key=source["json_member_name"], - ), + "metadata_source": build_metadata_source(json_member_name), "metadata_json": None, "materialize_error": None, } @@ -118,12 +131,7 @@ def _rows_from_sample( "content_type": content_type or ("application/octet-stream" if image_member_name else None), "text_content": None, "binary_content": None, - "metadata_source": MultiBatchTask.build_metadata_source( - source_id=source_id, - source_shard=source["source_shard"], - content_path=source["tar_path"], - content_key=content_key, - ), + "metadata_source": build_metadata_source(content_key), "metadata_json": None, "materialize_error": None, } @@ -166,9 +174,7 @@ def _rows_from_member( self, tf: tarfile.TarFile, member: tarfile.TarInfo, - member_names: set[str], - source_info: dict[str, str], - binary_cache: dict[str, bytes | None], + context: _ReadContext, ) -> list[dict[str, Any]]: extracted = tf.extractfile(member) if extracted is None: @@ -180,33 +186,30 @@ def _rows_from_member( else Path(member.name).stem ) source = { - "source_shard": source_info["source_shard"], - "tar_path": source_info["tar_path"], + "source_shard": context.source_shard, + "tar_path": context.tar_path, "json_member_name": member.name, } sample_rows = self._rows_from_sample( sample_id=sample_id, sample=payload, source=source, - member_names=member_names, + member_names=context.member_names, ) - if self.load_binary: + if self.materialize_on_read: for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue - source_meta = MultiBatchTask.parse_metadata_source(row["metadata_source"]) - content_key = source_meta.get("content_key") - if not content_key: - continue - if content_key not in binary_cache: - img = tf.extractfile(content_key) - binary_cache[content_key] = img.read() if img is not None else None - row["binary_content"] = binary_cache[content_key] + row["binary_content"] = load_bytes_from_metadata_source( + source_value=row["metadata_source"], + storage_options=context.storage_options, + byte_cache=context.byte_cache, + ) return sample_rows def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: rows: list[dict[str, Any]] = [] - storage_options = (self.read_kwargs or {}).get("storage_options", {}) + storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) for tar_path in task.data: source_shard = Path(tar_path).name @@ -216,8 +219,13 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: ): members = [m for m in tf.getmembers() if m.isfile()] member_names = {m.name for m in members} - binary_cache: dict[str, bytes | None] = {} - source = {"source_shard": source_shard, "tar_path": tar_path} + context = _ReadContext( + source_shard=source_shard, + tar_path=tar_path, + member_names=member_names, + storage_options=storage_options, + byte_cache={}, + ) for member in members: if not member.name.endswith(self.json_extensions): continue @@ -225,9 +233,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: self._rows_from_member( tf=tf, member=member, - member_names=member_names, - source_info=source, - binary_cache=binary_cache, + context=context, ) ) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 3889d33056..2080f6155b 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -14,16 +14,16 @@ from __future__ import annotations -import tarfile from abc import ABC, abstractmethod from dataclasses import dataclass, field from typing import TYPE_CHECKING, Any -import fsspec import pandas as pd import pyarrow as pa import pyarrow.parquet as pq +from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference, resolve_storage_options + from .base import BaseMultimodalWriter if TYPE_CHECKING: @@ -34,6 +34,7 @@ class _MaterializationBuffers: binary_values: list[object] error_values: list[str | None] + byte_cache: dict[tuple[str, str], bytes | None] @dataclass @@ -57,14 +58,6 @@ def _set_payload( binary_values[idx] = payload error_values[idx] = None - @staticmethod - def _key_to_indices(df: pd.DataFrame, keyed_idxs: list[int]) -> dict[str, list[int]]: - key_to_indices: dict[str, list[int]] = {} - for idx in keyed_idxs: - key = str(df.loc[idx, "_src_content_key"]) - key_to_indices.setdefault(key, []).append(idx) - return key_to_indices - def _materialize_group( self, df: pd.DataFrame, @@ -79,31 +72,23 @@ def _materialize_group( self._set_errors(error_values, idxs, "missing content_path") return - keyed_idxs = [idx for idx in idxs if df.loc[idx, "_src_content_key"]] - direct_idxs = [idx for idx in idxs if not df.loc[idx, "_src_content_key"]] - try: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: - if keyed_idxs: - key_to_indices = self._key_to_indices(df, keyed_idxs) - with tarfile.open(fileobj=fobj, mode="r:*") as tf: - for key, key_indices in key_to_indices.items(): - try: - extracted = tf.extractfile(key) - except KeyError: - extracted = None - if extracted is None: - self._set_errors(error_values, key_indices, f"missing content_key '{key}'") - continue - self._set_payload(binary_values, error_values, key_indices, extracted.read()) - if direct_idxs: - if keyed_idxs: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fresh: - payload = fresh.read() - else: - payload = fobj.read() - self._set_payload(binary_values, error_values, direct_idxs, payload) - except Exception as e: # noqa: BLE001 - self._set_errors(error_values, idxs, str(e)) + for idx in idxs: + raw_key = df.loc[idx, "_src_content_key"] + content_key = str(raw_key) if raw_key else None + payload = load_bytes_from_content_reference( + content_path=str(content_path), + content_key=content_key, + storage_options=storage_options, + byte_cache=buffers.byte_cache, + ) + if payload is None: + if content_key: + error_values[idx] = f"missing content_key '{content_key}'" + else: + error_values[idx] = "failed to read content_path" + continue + binary_values[idx] = payload + error_values[idx] = None def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: if not self.materialize_on_write: @@ -131,13 +116,9 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: if not image_mask.any(): return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") - source_storage_options = task._metadata.get("source_storage_options", {}) - if isinstance(source_storage_options, dict): - storage_options = source_storage_options or (self.write_kwargs or {}).get("storage_options", {}) - else: - storage_options = (self.write_kwargs or {}).get("storage_options", {}) + storage_options = resolve_storage_options(task=task, io_kwargs=self.write_kwargs) pending = out[image_mask] - buffers = _MaterializationBuffers(binary_values=binary_values, error_values=error_values) + buffers = _MaterializationBuffers(binary_values=binary_values, error_values=error_values, byte_cache={}) with self._time_metric("materialize_fetch_binary_s"): for content_path, idxs in pending.groupby("_src_content_path").groups.items(): self._materialize_group( diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index d150afaddf..3c7b3260d5 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -15,15 +15,14 @@ from __future__ import annotations import io -import tarfile from abc import ABC, abstractmethod from dataclasses import dataclass -import fsspec import pandas as pd from PIL import Image # type: ignore[import-not-found] from nemo_curator.stages.base import ProcessingStage +from nemo_curator.stages.multimodal.utils import load_bytes_from_metadata_source, resolve_storage_options from nemo_curator.tasks import MultiBatchTask @@ -92,40 +91,6 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: return None return float(width) / float(height) - @staticmethod - def _load_image_bytes_from_source( - source_value: str | None, - storage_options: dict[str, object], - byte_cache: dict[tuple[str, str], bytes | None], - ) -> bytes | None: - source = MultiBatchTask.parse_metadata_source(source_value) - content_path = source.get("content_path") - content_key = source.get("content_key") - if not content_path: - return None - - cache_key = (str(content_path), str(content_key or "")) - if cache_key in byte_cache: - return byte_cache[cache_key] - - try: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: - if content_key: - with tarfile.open(fileobj=fobj, mode="r:*") as tf: - try: - extracted = tf.extractfile(content_key) - except KeyError: - extracted = None - payload = extracted.read() if extracted is not None else None - byte_cache[cache_key] = payload - return payload - payload = fobj.read() - byte_cache[cache_key] = payload - return payload - except Exception: # noqa: BLE001 - byte_cache[cache_key] = None - return None - def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: keep_mask = pd.Series(True, index=df.index, dtype=bool) if "modality" not in df.columns or "content_type" not in df.columns: @@ -133,15 +98,13 @@ def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) if not jpeg_mask.any(): return keep_mask - storage_options = task._metadata.get("source_storage_options") - if not isinstance(storage_options, dict): - storage_options = {} + storage_options = resolve_storage_options(task=task) byte_cache: dict[tuple[str, str], bytes | None] = {} for idx in df[jpeg_mask].index.tolist(): image_bytes = df.loc[idx, "binary_content"] if not isinstance(image_bytes, (bytes, bytearray)): source_value = df.loc[idx, "metadata_source"] if "metadata_source" in df.columns else None - image_bytes = self._load_image_bytes_from_source( + image_bytes = load_bytes_from_metadata_source( source_value=source_value, storage_options=storage_options, byte_cache=byte_cache, diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py new file mode 100644 index 0000000000..4c7e03309c --- /dev/null +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -0,0 +1,35 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 nemo_curator.stages.multimodal.utils.constants import ( + DEFAULT_IMAGE_EXTENSIONS, + DEFAULT_JSON_EXTENSIONS, + DEFAULT_WEBDATASET_EXTENSIONS, +) +from nemo_curator.stages.multimodal.utils.materialization import ( + load_bytes_from_content_reference, + load_bytes_from_metadata_source, + require_source_id_field, + resolve_storage_options, +) + +__all__ = [ + "DEFAULT_IMAGE_EXTENSIONS", + "DEFAULT_JSON_EXTENSIONS", + "DEFAULT_WEBDATASET_EXTENSIONS", + "load_bytes_from_content_reference", + "load_bytes_from_metadata_source", + "require_source_id_field", + "resolve_storage_options", +] diff --git a/nemo_curator/stages/multimodal/utils/constants.py b/nemo_curator/stages/multimodal/utils/constants.py new file mode 100644 index 0000000000..94f97d6d0a --- /dev/null +++ b/nemo_curator/stages/multimodal/utils/constants.py @@ -0,0 +1,17 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +DEFAULT_WEBDATASET_EXTENSIONS = (".tar", ".tar.gz", ".tgz", ".tar.zst") +DEFAULT_JSON_EXTENSIONS = (".json",) +DEFAULT_IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif") diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py new file mode 100644 index 0000000000..ff2d87a9a8 --- /dev/null +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import tarfile +from typing import Any + +import fsspec + +from nemo_curator.tasks import MultiBatchTask, Task + + +def require_source_id_field(source_id_field: str) -> str: + if source_id_field: + return source_id_field + msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" + raise ValueError(msg) + + +def resolve_storage_options( + task: Task[Any] | None = None, + io_kwargs: dict[str, object] | None = None, +) -> dict[str, object]: + source_storage_options = task._metadata.get("source_storage_options") if task is not None else None + if isinstance(source_storage_options, dict) and source_storage_options: + return source_storage_options + storage_options = (io_kwargs or {}).get("storage_options") + return storage_options if isinstance(storage_options, dict) else {} + + +def load_bytes_from_content_reference( + content_path: str | None, + content_key: str | None, + storage_options: dict[str, object], + byte_cache: dict[tuple[str, str], bytes | None], +) -> bytes | None: + if not content_path: + return None + + cache_key = (str(content_path), str(content_key or "")) + if cache_key in byte_cache: + return byte_cache[cache_key] + + try: + with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: + if content_key: + with tarfile.open(fileobj=fobj, mode="r:*") as tf: + try: + extracted = tf.extractfile(content_key) + except KeyError: + extracted = None + payload = extracted.read() if extracted is not None else None + byte_cache[cache_key] = payload + return payload + payload = fobj.read() + byte_cache[cache_key] = payload + return payload + except Exception: # noqa: BLE001 + byte_cache[cache_key] = None + return None + + +def load_bytes_from_metadata_source( + source_value: str | None, + storage_options: dict[str, object], + byte_cache: dict[tuple[str, str], bytes | None], +) -> bytes | None: + source = MultiBatchTask.parse_metadata_source(source_value) + return load_bytes_from_content_reference( + content_path=source.get("content_path"), + content_key=source.get("content_key"), + storage_options=storage_options, + byte_cache=byte_cache, + ) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 3a4feed6bb..7bd7ab4667 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -24,6 +24,11 @@ from nemo_curator.core.utils import split_table_by_group_max_bytes from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage +from nemo_curator.stages.multimodal.utils import ( + load_bytes_from_content_reference, + require_source_id_field, + resolve_storage_options, +) from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -175,3 +180,40 @@ def test_basic_multimodal_filter_stage_jpeg_ratio_from_source(tmp_path: Path) -> stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) out = stage.process(task) assert out.to_pandas().empty + + +def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> None: + direct_path = tmp_path / "direct.bin" + direct_payload = b"direct-bytes" + direct_path.write_bytes(direct_payload) + + tar_path = tmp_path / "blob.tar" + tar_payload = b"tar-bytes" + with tarfile.open(tar_path, "w") as tf: + info = tarfile.TarInfo(name="x.bin") + info.size = len(tar_payload) + tf.addfile(info, BytesIO(tar_payload)) + + cache: dict[tuple[str, str], bytes | None] = {} + out_direct = load_bytes_from_content_reference(str(direct_path), None, {}, cache) + out_keyed = load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) + assert out_direct == direct_payload + assert out_keyed == tar_payload + + +def test_require_source_id_field() -> None: + assert require_source_id_field("pdf_name") == "pdf_name" + with pytest.raises(ValueError, match="source_id_field must be provided explicitly"): + require_source_id_field("") + + +def test_resolve_storage_options_prefers_task_metadata() -> None: + task = MultiBatchTask( + task_id="t1", + dataset_name="d1", + data=pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA), + _metadata={"source_storage_options": {"anon": False}}, + ) + assert resolve_storage_options(task=task, io_kwargs={"storage_options": {"anon": True}}) == {"anon": False} + assert resolve_storage_options(task=task, io_kwargs={}) == {"anon": False} + assert resolve_storage_options(io_kwargs={"storage_options": {"anon": True}}) == {"anon": True} diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 538f777204..f3e7fb715d 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -67,7 +67,7 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: images_field="frames", image_member_field="primary_image", json_extensions=(".meta.json",), - load_binary=True, + materialize_on_read=True, ) output = reader.process(task) assert isinstance(output, MultiBatchTask) @@ -85,3 +85,13 @@ def test_reader_propagates_source_storage_options(input_task: FileGroupTask) -> output = reader.process(input_task) assert isinstance(output, MultiBatchTask) assert output._metadata.get("source_storage_options") == {"anon": False} + + +def test_reader_materialize_on_read_flag(input_task: FileGroupTask) -> None: + reader = WebdatasetReaderStage(source_id_field="pdf_name", materialize_on_read=True) + output = reader.process(input_task) + assert isinstance(output, MultiBatchTask) + df = output.to_pandas() + image_rows = df[df["modality"] == "image"] + assert len(image_rows) > 0 + assert image_rows["binary_content"].notna().any() diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index bc0c50dc65..e577b2bc17 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -38,7 +38,7 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: blocksize=args.input_blocksize, max_batch_bytes=args.output_max_batch_bytes, read_kwargs=read_kwargs, - load_binary=False, + materialize_on_read=args.materialize_on_read, ) ) pipe.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) @@ -69,9 +69,11 @@ def main(args: argparse.Namespace) -> None: parser.add_argument("--files-per-partition", type=int, default=1) parser.add_argument("--input-blocksize", type=str, default=None) parser.add_argument("--output-max-batch-bytes", type=int, default=None) + parser.add_argument("--materialize-on-read", action="store_true", dest="materialize_on_read") + parser.add_argument("--no-materialize-on-read", action="store_false", dest="materialize_on_read") parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") - parser.set_defaults(materialize_on_write=True) + parser.set_defaults(materialize_on_write=True, materialize_on_read=False) parser.add_argument("--mode", type=str, default="ignore", choices=["ignore", "overwrite", "append", "error"]) parser.add_argument( "--storage-options-json", From 47a147bc734837059206ff0d3864262f6d341cb0 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 08:39:48 +0000 Subject: [PATCH 10/62] Unify multimodal reader field projection and tighten validation Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/io/reader.py | 2 + .../multimodal/io/readers/webdataset.py | 77 +++++++++--- .../multimodal/io/writers/multimodal.py | 16 +-- .../stages/multimodal/test_multimodal_core.py | 116 +++++++----------- .../multimodal/test_multimodal_reader.py | 111 +++++++++++++++-- .../multimodal/test_multimodal_writer.py | 15 +-- 6 files changed, 216 insertions(+), 121 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index b5735638e4..b450e530f8 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -46,6 +46,7 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): texts_field: str = "texts" images_field: str = "images" image_member_field: str | None = None + fields: tuple[str, ...] | None = None name: str = "webdataset_reader" def __post_init__(self): @@ -73,5 +74,6 @@ def decompose(self) -> list: texts_field=self.texts_field, images_field=self.images_field, image_member_field=self.image_member_field, + fields=self.fields, ), ] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index b66f55581e..7eb4723893 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -60,6 +60,7 @@ class WebdatasetReaderStage(BaseMultimodalReader): texts_field: str = "texts" images_field: str = "images" image_member_field: str | None = None + fields: tuple[str, ...] | None = None name: str = "webdataset_reader" def __post_init__(self) -> None: @@ -79,6 +80,7 @@ def _rows_from_sample( source_shard = source["source_shard"] tar_path = source["tar_path"] json_member_name = source["json_member_name"] + passthrough_row = self._build_passthrough_row(sample) def build_metadata_source(content_key: str | None) -> str: return MultiBatchTask.build_metadata_source( @@ -88,34 +90,42 @@ def build_metadata_source(content_key: str | None) -> str: content_key=content_key, ) - rows.append( + def append_row(row: dict[str, Any]) -> None: + rows.append( + { + "sample_id": sample_id, + "position": row["position"], + "modality": row["modality"], + "content_type": row.get("content_type"), + "text_content": row.get("text_content"), + "binary_content": row.get("binary_content"), + "metadata_source": row.get("metadata_source"), + "metadata_json": row.get("metadata_json"), + "materialize_error": None, + **passthrough_row, + } + ) + + append_row( { - "sample_id": sample_id, "position": -1, "modality": "metadata", "content_type": "application/json", - "text_content": None, - "binary_content": None, "metadata_source": build_metadata_source(json_member_name), "metadata_json": json.dumps(sample, ensure_ascii=True), - "materialize_error": None, } ) texts = sample.get(self.texts_field) if isinstance(texts, list): for idx, text_value in enumerate(texts): - rows.append( + append_row( { - "sample_id": sample_id, "position": idx, "modality": "text", "content_type": "text/plain", "text_content": text_value if isinstance(text_value, str) else None, - "binary_content": None, "metadata_source": build_metadata_source(json_member_name), - "metadata_json": None, - "materialize_error": None, } ) @@ -123,22 +133,55 @@ def build_metadata_source(content_key: str | None) -> str: for idx, image_token in enumerate(images): content_key = self._resolve_image_content_key(image_token, image_member_name, member_names) content_type, _ = mimetypes.guess_type(image_member_name or "") - rows.append( + append_row( { - "sample_id": sample_id, "position": idx, "modality": "image", "content_type": content_type or ("application/octet-stream" if image_member_name else None), - "text_content": None, - "binary_content": None, "metadata_source": build_metadata_source(content_key), - "metadata_json": None, - "materialize_error": None, } ) return rows + def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: + excluded = { + self.source_id_field, + self.sample_id_field, + self.texts_field, + self.images_field, + self.image_member_field, + "sample_id", + "position", + "modality", + "content_type", + "text_content", + "binary_content", + "metadata_source", + "metadata_json", + "materialize_error", + } + if self.fields is None: + fields = [key for key in sample if key not in excluded] + else: + fields = list(self.fields) + reserved = sorted(field for field in fields if field in excluded) + if reserved: + msg = f"fields contains reserved keys: {reserved}" + raise ValueError(msg) + missing = sorted(field for field in fields if field not in sample) + if missing: + msg = f"fields not found in source sample: {missing}" + raise ValueError(msg) + return { + field: ( + json.dumps(sample.get(field), ensure_ascii=True) + if isinstance(sample.get(field), (dict, list)) + else sample.get(field) + ) + for field in fields + } + def _resolve_default_image_member_name( self, sample_id: str, @@ -237,7 +280,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: ) ) - table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + table = pa.Table.from_pylist(rows) if rows else pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) batches: list[MultiBatchTask] = [] for idx, split in enumerate(splits): diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 2080f6155b..6a376503c0 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -45,19 +45,6 @@ class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): materialize_on_write: bool = True name: str = "base_multimodal_tabular_writer" - @staticmethod - def _set_errors(error_values: list[str | None], indices: list[int], error: str | None) -> None: - for idx in indices: - error_values[idx] = error - - @staticmethod - def _set_payload( - binary_values: list[object], error_values: list[str | None], indices: list[int], payload: bytes - ) -> None: - for idx in indices: - binary_values[idx] = payload - error_values[idx] = None - def _materialize_group( self, df: pd.DataFrame, @@ -69,7 +56,8 @@ def _materialize_group( binary_values = buffers.binary_values error_values = buffers.error_values if not content_path: - self._set_errors(error_values, idxs, "missing content_path") + for idx in idxs: + error_values[idx] = "missing content_path" return for idx in idxs: diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 7bd7ab4667..1553188b2f 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -68,8 +68,7 @@ def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: def test_to_pandas_keeps_arrow_dtypes(single_row_task: MultiBatchTask) -> None: df = single_row_task.to_pandas() assert isinstance(df, pd.DataFrame) - assert str(df.dtypes["sample_id"]).endswith("[pyarrow]") - assert str(df.dtypes["position"]).endswith("[pyarrow]") + assert all(str(df.dtypes[col]).endswith("[pyarrow]") for col in ("sample_id", "position")) def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: @@ -81,23 +80,18 @@ def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: def test_split_table_keeps_group_intact() -> None: - table = pa.Table.from_pylist( - [ - {"sample_id": "a", "position": 0, "value": "x" * 20}, - {"sample_id": "a", "position": 1, "value": "y" * 20}, - {"sample_id": "b", "position": 0, "value": "z" * 20}, - {"sample_id": "b", "position": 1, "value": "w" * 20}, - ] - ) - + table = pa.Table.from_pylist([ + {"sample_id": "a", "position": 0, "value": "x" * 20}, + {"sample_id": "a", "position": 1, "value": "y" * 20}, + {"sample_id": "b", "position": 0, "value": "z" * 20}, + {"sample_id": "b", "position": 1, "value": "w" * 20}, + ]) splits = split_table_by_group_max_bytes(table, "sample_id", max_batch_bytes=120) assert len(splits) == 2 - - first_groups = set(splits[0]["sample_id"].to_pylist()) - second_groups = set(splits[1]["sample_id"].to_pylist()) - assert len(first_groups) == 1 - assert len(second_groups) == 1 - assert first_groups != second_groups + groups = [set(split["sample_id"].to_pylist()) for split in splits] + assert len(groups[0]) == 1 + assert len(groups[1]) == 1 + assert groups[0] != groups[1] def _make_jpeg_bytes(width: int, height: int) -> bytes: @@ -107,34 +101,28 @@ def _make_jpeg_bytes(width: int, height: int) -> bytes: return buffer.getvalue() +def _image_row( + sample_id: str, + *, + binary_content: bytes | None = None, + metadata_source: str | None = None, +) -> dict[str, object]: + return { + "sample_id": sample_id, + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": binary_content, + "metadata_source": metadata_source, + "metadata_json": None, + "materialize_error": None, + } + + def test_basic_multimodal_filter_stage_jpeg_ratio_from_binary() -> None: - square_bytes = _make_jpeg_bytes(100, 100) - wide_bytes = _make_jpeg_bytes(1000, 100) table = pa.Table.from_pylist( - [ - { - "sample_id": "s1", - "position": 0, - "modality": "image", - "content_type": "image/jpeg", - "text_content": None, - "binary_content": square_bytes, - "metadata_source": None, - "metadata_json": None, - "materialize_error": None, - }, - { - "sample_id": "s2", - "position": 0, - "modality": "image", - "content_type": "image/jpeg", - "text_content": None, - "binary_content": wide_bytes, - "metadata_source": None, - "metadata_json": None, - "materialize_error": None, - }, - ], + [_image_row("s1", binary_content=_make_jpeg_bytes(100, 100)), _image_row("s2", binary_content=_make_jpeg_bytes(1000, 100))], schema=MULTIMODAL_SCHEMA, ) task = MultiBatchTask(task_id="ratio_binary", dataset_name="d1", data=table) @@ -147,35 +135,22 @@ def test_basic_multimodal_filter_stage_jpeg_ratio_from_binary() -> None: def test_basic_multimodal_filter_stage_jpeg_ratio_from_source(tmp_path: Path) -> None: tar_path = tmp_path / "images.tar" + image_key = "wide.jpg" + metadata_source = json.dumps( + { + "source_id": "doc.pdf", + "source_shard": "images.tar", + "content_path": str(tar_path), + "content_key": image_key, + } + ) wide_bytes = _make_jpeg_bytes(900, 100) with tarfile.open(tar_path, "w") as tf: - info = tarfile.TarInfo(name="wide.jpg") + info = tarfile.TarInfo(name=image_key) info.size = len(wide_bytes) tf.addfile(info, BytesIO(wide_bytes)) - table = pa.Table.from_pylist( - [ - { - "sample_id": "s1", - "position": 0, - "modality": "image", - "content_type": "image/jpeg", - "text_content": None, - "binary_content": None, - "metadata_source": json.dumps( - { - "source_id": "doc.pdf", - "source_shard": "images.tar", - "content_path": str(tar_path), - "content_key": "wide.jpg", - } - ), - "metadata_json": None, - "materialize_error": None, - } - ], - schema=MULTIMODAL_SCHEMA, - ) + table = pa.Table.from_pylist([_image_row("s1", metadata_source=metadata_source)], schema=MULTIMODAL_SCHEMA) task = MultiBatchTask(task_id="ratio_source", dataset_name="d1", data=table) stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) out = stage.process(task) @@ -186,7 +161,6 @@ def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> N direct_path = tmp_path / "direct.bin" direct_payload = b"direct-bytes" direct_path.write_bytes(direct_payload) - tar_path = tmp_path / "blob.tar" tar_payload = b"tar-bytes" with tarfile.open(tar_path, "w") as tf: @@ -195,10 +169,8 @@ def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> N tf.addfile(info, BytesIO(tar_payload)) cache: dict[tuple[str, str], bytes | None] = {} - out_direct = load_bytes_from_content_reference(str(direct_path), None, {}, cache) - out_keyed = load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) - assert out_direct == direct_payload - assert out_keyed == tar_payload + assert load_bytes_from_content_reference(str(direct_path), None, {}, cache) == direct_payload + assert load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) == tar_payload def test_require_source_id_field() -> None: diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index f3e7fb715d..4e0dd1a945 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -17,19 +17,24 @@ from io import BytesIO from pathlib import Path +import pandas as pd +import pytest + from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask +def _as_df(task_or_tasks: MultiBatchTask | list[MultiBatchTask]) -> pd.DataFrame: + task = task_or_tasks[0] if isinstance(task_or_tasks, list) else task_or_tasks + return task.to_pandas() + + def test_reader_emits_metadata_text_image_rows( input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: _, sample_id, _ = mint_like_tar reader = WebdatasetReaderStage(source_id_field="pdf_name") - output = reader.process(input_task) - assert isinstance(output, MultiBatchTask) - - df = output.to_pandas() + df = _as_df(reader.process(input_task)) assert set(df["modality"].unique()) == {"metadata", "text", "image"} assert ((df["sample_id"] == sample_id) & (df["modality"] == "metadata") & (df["position"] == -1)).any() @@ -42,6 +47,7 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: "captions": ["a", "b"], "frames": ["custom-image.jpg"], "primary_image": "custom-image.jpg", + "p_hash": "abc123", } image_bytes = b"custom-image-bytes" with tarfile.open(tar_path, "w") as tf: @@ -68,30 +74,113 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: image_member_field="primary_image", json_extensions=(".meta.json",), materialize_on_read=True, + fields=("p_hash",), ) - output = reader.process(task) - assert isinstance(output, MultiBatchTask) - df = output.to_pandas() + df = _as_df(reader.process(task)) assert ((df["sample_id"] == "doc-custom") & (df["modality"] == "metadata")).any() text_rows = df[df["modality"] == "text"] assert text_rows["text_content"].tolist() == ["a", "b"] image_rows = df[df["modality"] == "image"] assert len(image_rows) == 1 assert image_rows.iloc[0]["binary_content"] == image_bytes + assert "p_hash" in df.columns + assert image_rows.iloc[0]["p_hash"] == "abc123" def test_reader_propagates_source_storage_options(input_task: FileGroupTask) -> None: reader = WebdatasetReaderStage(source_id_field="pdf_name", read_kwargs={"storage_options": {"anon": False}}) output = reader.process(input_task) - assert isinstance(output, MultiBatchTask) + assert isinstance(output, MultiBatchTask) # metadata lives on task, not dataframe assert output._metadata.get("source_storage_options") == {"anon": False} def test_reader_materialize_on_read_flag(input_task: FileGroupTask) -> None: reader = WebdatasetReaderStage(source_id_field="pdf_name", materialize_on_read=True) - output = reader.process(input_task) - assert isinstance(output, MultiBatchTask) - df = output.to_pandas() + df = _as_df(reader.process(input_task)) image_rows = df[df["modality"] == "image"] assert len(image_rows) > 0 assert image_rows["binary_content"].notna().any() + + +def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: + tar_path = tmp_path / "all-fields.tar" + payload = { + "doc_id": "doc-all", + "source_doc": "all.pdf", + "captions": ["hello"], + "frames": ["image.jpg"], + "primary_image": "image.jpg", + "p_hash": "phash-1", + "score": 0.91, + "aux": {"page": 3}, + } + with tarfile.open(tar_path, "w") as tf: + blob = json.dumps(payload).encode("utf-8") + info = tarfile.TarInfo(name="sample.meta.json") + info.size = len(blob) + tf.addfile(info, BytesIO(blob)) + img = tarfile.TarInfo(name="image.jpg") + img.size = 3 + tf.addfile(img, BytesIO(b"abc")) + + task = FileGroupTask( + task_id="all_fields", + dataset_name="custom_dataset", + data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) + reader = WebdatasetReaderStage( + sample_id_field="doc_id", + source_id_field="source_doc", + texts_field="captions", + images_field="frames", + image_member_field="primary_image", + json_extensions=(".meta.json",), + ) + df = _as_df(reader.process(task)) + image_row = df[df["modality"] == "image"].iloc[0] + assert image_row["p_hash"] == "phash-1" + assert image_row["score"] == 0.91 + assert image_row["aux"] == json.dumps({"page": 3}, ensure_ascii=True) + assert "captions" not in df.columns + assert "frames" not in df.columns + + +def test_reader_fields_raises_for_missing_key(tmp_path: Path) -> None: + tar_path = tmp_path / "missing-key.tar" + payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} + with tarfile.open(tar_path, "w") as tf: + blob = json.dumps(payload).encode("utf-8") + info = tarfile.TarInfo(name="sample.json") + info.size = len(blob) + tf.addfile(info, BytesIO(blob)) + + task = FileGroupTask( + task_id="missing_key", + dataset_name="custom_dataset", + data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("p_hash",)) + with pytest.raises(ValueError, match="fields not found in source sample"): + _ = reader.process(task) + + +def test_reader_fields_raises_for_reserved_key(tmp_path: Path) -> None: + tar_path = tmp_path / "reserved-key.tar" + payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} + with tarfile.open(tar_path, "w") as tf: + blob = json.dumps(payload).encode("utf-8") + info = tarfile.TarInfo(name="sample.json") + info.size = len(blob) + tf.addfile(info, BytesIO(blob)) + + task = FileGroupTask( + task_id="reserved_key", + dataset_name="custom_dataset", + data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("sample_id",)) + with pytest.raises(ValueError, match="fields contains reserved keys"): + _ = reader.process(task) diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 16a7e4b7e8..8e8b370ee3 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -24,13 +24,17 @@ from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA +def _read_batch(input_task: FileGroupTask) -> MultiBatchTask: + batch = WebdatasetReaderStage(source_id_field="pdf_name").process(input_task) + assert isinstance(batch, MultiBatchTask) + return batch + + def test_writer_materializes_and_marks_errors( tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] ) -> None: _, _, image_bytes = mint_like_tar - reader = WebdatasetReaderStage(source_id_field="pdf_name") - batch = reader.process(input_task) - assert isinstance(batch, MultiBatchTask) + batch = _read_batch(input_task) writer = MultimodalParquetWriterStage(path=str(tmp_path / "out"), materialize_on_write=True, mode="overwrite") write_task = writer.process(batch) @@ -44,10 +48,7 @@ def test_writer_materializes_and_marks_errors( def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input_task: FileGroupTask) -> None: - reader = WebdatasetReaderStage(source_id_field="pdf_name") - batch = reader.process(input_task) - assert isinstance(batch, MultiBatchTask) - + batch = _read_batch(input_task) df = batch.to_pandas().copy() image_mask = df["modality"] == "image" assert image_mask.any() From fb2999105a74e1c13e8c1789999073f78883bbce Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 08:51:11 +0000 Subject: [PATCH 11/62] Extract source field validation util and reduce multimodal LOC Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 26 +--- .../stages/multimodal/utils/__init__.py | 2 + .../multimodal/utils/validation_utils.py | 44 ++++++ .../stages/multimodal/test_multimodal_core.py | 101 ------------- .../multimodal/test_multimodal_reader.py | 136 +++++++----------- .../multimodal/test_multimodal_writer.py | 42 ++---- 6 files changed, 109 insertions(+), 242 deletions(-) create mode 100644 nemo_curator/stages/multimodal/utils/validation_utils.py diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 7eb4723893..665ea03fb7 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -31,6 +31,7 @@ load_bytes_from_metadata_source, require_source_id_field, resolve_storage_options, + validate_and_project_source_fields, ) from nemo_curator.tasks import FileGroupTask, MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -147,10 +148,10 @@ def append_row(row: dict[str, Any]) -> None: def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = { self.source_id_field, - self.sample_id_field, + *( [self.sample_id_field] if self.sample_id_field else [] ), self.texts_field, self.images_field, - self.image_member_field, + *( [self.image_member_field] if self.image_member_field else [] ), "sample_id", "position", "modality", @@ -161,26 +162,7 @@ def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: "metadata_json", "materialize_error", } - if self.fields is None: - fields = [key for key in sample if key not in excluded] - else: - fields = list(self.fields) - reserved = sorted(field for field in fields if field in excluded) - if reserved: - msg = f"fields contains reserved keys: {reserved}" - raise ValueError(msg) - missing = sorted(field for field in fields if field not in sample) - if missing: - msg = f"fields not found in source sample: {missing}" - raise ValueError(msg) - return { - field: ( - json.dumps(sample.get(field), ensure_ascii=True) - if isinstance(sample.get(field), (dict, list)) - else sample.get(field) - ) - for field in fields - } + return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) def _resolve_default_image_member_name( self, diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py index 4c7e03309c..069790c4ca 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -23,6 +23,7 @@ require_source_id_field, resolve_storage_options, ) +from nemo_curator.stages.multimodal.utils.validation_utils import validate_and_project_source_fields __all__ = [ "DEFAULT_IMAGE_EXTENSIONS", @@ -32,4 +33,5 @@ "load_bytes_from_metadata_source", "require_source_id_field", "resolve_storage_options", + "validate_and_project_source_fields", ] diff --git a/nemo_curator/stages/multimodal/utils/validation_utils.py b/nemo_curator/stages/multimodal/utils/validation_utils.py new file mode 100644 index 0000000000..5d750255c2 --- /dev/null +++ b/nemo_curator/stages/multimodal/utils/validation_utils.py @@ -0,0 +1,44 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import json +from typing import Any + + +def validate_and_project_source_fields( + sample: dict[str, Any], + fields: tuple[str, ...] | None, + excluded_fields: set[str], +) -> dict[str, Any]: + """Validate requested source `fields` and normalize selected values for tabular output.""" + selected = [key for key in sample if key not in excluded_fields] if fields is None else list(fields) + if fields is not None: + reserved = sorted(field for field in selected if field in excluded_fields) + if reserved: + msg = f"fields contains reserved keys: {reserved}" + raise ValueError(msg) + missing = sorted(field for field in selected if field not in sample) + if missing: + msg = f"fields not found in source sample: {missing}" + raise ValueError(msg) + return { + field: ( + json.dumps(sample[field], ensure_ascii=True) + if isinstance(sample[field], (dict, list)) + else sample[field] + ) + for field in selected + } diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 1553188b2f..4de171076a 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -17,17 +17,12 @@ from io import BytesIO from pathlib import Path -import pandas as pd import pyarrow as pa import pytest -from PIL import Image -from nemo_curator.core.utils import split_table_by_group_max_bytes -from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage from nemo_curator.stages.multimodal.utils import ( load_bytes_from_content_reference, require_source_id_field, - resolve_storage_options, ) from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -65,12 +60,6 @@ def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: return MultiBatchTask(task_id="t1", dataset_name="d1", data=single_row_table) -def test_to_pandas_keeps_arrow_dtypes(single_row_task: MultiBatchTask) -> None: - df = single_row_task.to_pandas() - assert isinstance(df, pd.DataFrame) - assert all(str(df.dtypes[col]).endswith("[pyarrow]") for col in ("sample_id", "position")) - - def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: df = single_row_task.with_parsed_source_columns() assert df.loc[0, "_src_source_id"] == "doc.pdf" @@ -79,84 +68,6 @@ def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: assert df.loc[0, "_src_content_key"] == "s1.json" -def test_split_table_keeps_group_intact() -> None: - table = pa.Table.from_pylist([ - {"sample_id": "a", "position": 0, "value": "x" * 20}, - {"sample_id": "a", "position": 1, "value": "y" * 20}, - {"sample_id": "b", "position": 0, "value": "z" * 20}, - {"sample_id": "b", "position": 1, "value": "w" * 20}, - ]) - splits = split_table_by_group_max_bytes(table, "sample_id", max_batch_bytes=120) - assert len(splits) == 2 - groups = [set(split["sample_id"].to_pylist()) for split in splits] - assert len(groups[0]) == 1 - assert len(groups[1]) == 1 - assert groups[0] != groups[1] - - -def _make_jpeg_bytes(width: int, height: int) -> bytes: - image = Image.new("RGB", (width, height), color=(255, 0, 0)) - buffer = BytesIO() - image.save(buffer, format="JPEG") - return buffer.getvalue() - - -def _image_row( - sample_id: str, - *, - binary_content: bytes | None = None, - metadata_source: str | None = None, -) -> dict[str, object]: - return { - "sample_id": sample_id, - "position": 0, - "modality": "image", - "content_type": "image/jpeg", - "text_content": None, - "binary_content": binary_content, - "metadata_source": metadata_source, - "metadata_json": None, - "materialize_error": None, - } - - -def test_basic_multimodal_filter_stage_jpeg_ratio_from_binary() -> None: - table = pa.Table.from_pylist( - [_image_row("s1", binary_content=_make_jpeg_bytes(100, 100)), _image_row("s2", binary_content=_make_jpeg_bytes(1000, 100))], - schema=MULTIMODAL_SCHEMA, - ) - task = MultiBatchTask(task_id="ratio_binary", dataset_name="d1", data=table) - stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) - out = stage.process(task) - out_df = out.to_pandas() - assert len(out_df) == 1 - assert out_df.iloc[0]["sample_id"] == "s1" - - -def test_basic_multimodal_filter_stage_jpeg_ratio_from_source(tmp_path: Path) -> None: - tar_path = tmp_path / "images.tar" - image_key = "wide.jpg" - metadata_source = json.dumps( - { - "source_id": "doc.pdf", - "source_shard": "images.tar", - "content_path": str(tar_path), - "content_key": image_key, - } - ) - wide_bytes = _make_jpeg_bytes(900, 100) - with tarfile.open(tar_path, "w") as tf: - info = tarfile.TarInfo(name=image_key) - info.size = len(wide_bytes) - tf.addfile(info, BytesIO(wide_bytes)) - - table = pa.Table.from_pylist([_image_row("s1", metadata_source=metadata_source)], schema=MULTIMODAL_SCHEMA) - task = MultiBatchTask(task_id="ratio_source", dataset_name="d1", data=table) - stage = MultimodalJpegAspectRatioFilterStage(min_aspect_ratio=0.8, max_aspect_ratio=1.2) - out = stage.process(task) - assert out.to_pandas().empty - - def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> None: direct_path = tmp_path / "direct.bin" direct_payload = b"direct-bytes" @@ -177,15 +88,3 @@ def test_require_source_id_field() -> None: assert require_source_id_field("pdf_name") == "pdf_name" with pytest.raises(ValueError, match="source_id_field must be provided explicitly"): require_source_id_field("") - - -def test_resolve_storage_options_prefers_task_metadata() -> None: - task = MultiBatchTask( - task_id="t1", - dataset_name="d1", - data=pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA), - _metadata={"source_storage_options": {"anon": False}}, - ) - assert resolve_storage_options(task=task, io_kwargs={"storage_options": {"anon": True}}) == {"anon": False} - assert resolve_storage_options(task=task, io_kwargs={}) == {"anon": False} - assert resolve_storage_options(io_kwargs={"storage_options": {"anon": True}}) == {"anon": True} diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 4e0dd1a945..d841de3987 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -29,14 +29,31 @@ def _as_df(task_or_tasks: MultiBatchTask | list[MultiBatchTask]) -> pd.DataFrame return task.to_pandas() -def test_reader_emits_metadata_text_image_rows( - input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] +def _write_tar_sample( + tar_path: Path, + payload: dict[str, object], + *, + json_name: str = "sample.json", + image_name: str = "image.jpg", + image_bytes: bytes = b"abc", ) -> None: - _, sample_id, _ = mint_like_tar - reader = WebdatasetReaderStage(source_id_field="pdf_name") - df = _as_df(reader.process(input_task)) - assert set(df["modality"].unique()) == {"metadata", "text", "image"} - assert ((df["sample_id"] == sample_id) & (df["modality"] == "metadata") & (df["position"] == -1)).any() + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name=json_name) + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + img_info = tarfile.TarInfo(name=image_name) + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + + +def _task_for_tar(tar_path: Path, task_id: str) -> FileGroupTask: + return FileGroupTask( + task_id=task_id, + dataset_name="custom_dataset", + data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: @@ -50,22 +67,14 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: "p_hash": "abc123", } image_bytes = b"custom-image-bytes" - with tarfile.open(tar_path, "w") as tf: - json_blob = json.dumps(payload).encode("utf-8") - json_info = tarfile.TarInfo(name="sample-xyz.meta.json") - json_info.size = len(json_blob) - tf.addfile(json_info, BytesIO(json_blob)) - - img_info = tarfile.TarInfo(name="custom-image.jpg") - img_info.size = len(image_bytes) - tf.addfile(img_info, BytesIO(image_bytes)) - - task = FileGroupTask( - task_id="file_group_custom", - dataset_name="custom_dataset", - data=[str(tar_path)], - _metadata={"source_files": [str(tar_path)]}, + _write_tar_sample( + tar_path, + payload, + json_name="sample-xyz.meta.json", + image_name="custom-image.jpg", + image_bytes=image_bytes, ) + task = _task_for_tar(tar_path, "file_group_custom") reader = WebdatasetReaderStage( sample_id_field="doc_id", source_id_field="source_doc", @@ -87,21 +96,6 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: assert image_rows.iloc[0]["p_hash"] == "abc123" -def test_reader_propagates_source_storage_options(input_task: FileGroupTask) -> None: - reader = WebdatasetReaderStage(source_id_field="pdf_name", read_kwargs={"storage_options": {"anon": False}}) - output = reader.process(input_task) - assert isinstance(output, MultiBatchTask) # metadata lives on task, not dataframe - assert output._metadata.get("source_storage_options") == {"anon": False} - - -def test_reader_materialize_on_read_flag(input_task: FileGroupTask) -> None: - reader = WebdatasetReaderStage(source_id_field="pdf_name", materialize_on_read=True) - df = _as_df(reader.process(input_task)) - image_rows = df[df["modality"] == "image"] - assert len(image_rows) > 0 - assert image_rows["binary_content"].notna().any() - - def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: tar_path = tmp_path / "all-fields.tar" payload = { @@ -114,21 +108,8 @@ def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: "score": 0.91, "aux": {"page": 3}, } - with tarfile.open(tar_path, "w") as tf: - blob = json.dumps(payload).encode("utf-8") - info = tarfile.TarInfo(name="sample.meta.json") - info.size = len(blob) - tf.addfile(info, BytesIO(blob)) - img = tarfile.TarInfo(name="image.jpg") - img.size = 3 - tf.addfile(img, BytesIO(b"abc")) - - task = FileGroupTask( - task_id="all_fields", - dataset_name="custom_dataset", - data=[str(tar_path)], - _metadata={"source_files": [str(tar_path)]}, - ) + _write_tar_sample(tar_path, payload, json_name="sample.meta.json") + task = _task_for_tar(tar_path, "all_fields") reader = WebdatasetReaderStage( sample_id_field="doc_id", source_id_field="source_doc", @@ -146,41 +127,20 @@ def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: assert "frames" not in df.columns -def test_reader_fields_raises_for_missing_key(tmp_path: Path) -> None: - tar_path = tmp_path / "missing-key.tar" - payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} - with tarfile.open(tar_path, "w") as tf: - blob = json.dumps(payload).encode("utf-8") - info = tarfile.TarInfo(name="sample.json") - info.size = len(blob) - tf.addfile(info, BytesIO(blob)) - - task = FileGroupTask( - task_id="missing_key", - dataset_name="custom_dataset", - data=[str(tar_path)], - _metadata={"source_files": [str(tar_path)]}, - ) - reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("p_hash",)) - with pytest.raises(ValueError, match="fields not found in source sample"): - _ = reader.process(task) - - -def test_reader_fields_raises_for_reserved_key(tmp_path: Path) -> None: - tar_path = tmp_path / "reserved-key.tar" +@pytest.mark.parametrize( + ("task_id", "fields", "error_pattern"), + [ + ("missing_key", ("p_hash",), "fields not found in source sample"), + ("reserved_key", ("sample_id",), "fields contains reserved keys"), + ], +) +def test_reader_fields_validation_errors( + tmp_path: Path, task_id: str, fields: tuple[str, ...], error_pattern: str +) -> None: + tar_path = tmp_path / f"{task_id}.tar" payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} - with tarfile.open(tar_path, "w") as tf: - blob = json.dumps(payload).encode("utf-8") - info = tarfile.TarInfo(name="sample.json") - info.size = len(blob) - tf.addfile(info, BytesIO(blob)) - - task = FileGroupTask( - task_id="reserved_key", - dataset_name="custom_dataset", - data=[str(tar_path)], - _metadata={"source_files": [str(tar_path)]}, - ) - reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("sample_id",)) - with pytest.raises(ValueError, match="fields contains reserved keys"): + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, task_id) + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=fields) + with pytest.raises(ValueError, match=error_pattern): _ = reader.process(task) diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 8e8b370ee3..50a0c73e6d 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -30,21 +30,15 @@ def _read_batch(input_task: FileGroupTask) -> MultiBatchTask: return batch -def test_writer_materializes_and_marks_errors( - tmp_path: Path, input_task: FileGroupTask, mint_like_tar: tuple[str, str, bytes] -) -> None: - _, _, image_bytes = mint_like_tar - batch = _read_batch(input_task) - - writer = MultimodalParquetWriterStage(path=str(tmp_path / "out"), materialize_on_write=True, mode="overwrite") - write_task = writer.process(batch) - out_file = write_task.data[0] - - written = pd.read_parquet(out_file) - image_rows = written[written["modality"] == "image"] - assert len(image_rows) > 0 - assert image_rows["binary_content"].apply(lambda x: x == image_bytes).any() - assert image_rows["materialize_error"].isna().any() +def _metadata_source(content_path: str, content_key: str | None, source_shard: str = "shard-00000.tar") -> str: + return json.dumps( + { + "source_id": "doc.pdf", + "source_shard": source_shard, + "content_path": content_path, + "content_key": content_key, + } + ) def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input_task: FileGroupTask) -> None: @@ -53,14 +47,7 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input image_mask = df["modality"] == "image" assert image_mask.any() first_image_idx = df[image_mask].index[0] - df.loc[first_image_idx, "metadata_source"] = json.dumps( - { - "source_id": "doc.pdf", - "source_shard": "shard-00000.tar", - "content_path": "/definitely/missing/path.tar", - "content_key": "abc123.tiff", - } - ) + df.loc[first_image_idx, "metadata_source"] = _metadata_source("/definitely/missing/path.tar", "abc123.tiff") bad_batch = MultiBatchTask( task_id=batch.task_id, dataset_name=batch.dataset_name, @@ -92,14 +79,7 @@ def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> "content_type": "image/jpeg", "text_content": None, "binary_content": None, - "metadata_source": json.dumps( - { - "source_id": "doc.pdf", - "source_shard": "raw_image.jpg", - "content_path": str(raw_path), - "content_key": None, - } - ), + "metadata_source": _metadata_source(str(raw_path), None, source_shard="raw_image.jpg"), "metadata_json": None, "materialize_error": None, } From ba3ccdc822dc365e7e02ff5ccbf55e029bf1b180 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 08:59:06 +0000 Subject: [PATCH 12/62] Require multimodal writer path and add Pillow image dependency Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/io/writer.py | 2 +- pyproject.toml | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/nemo_curator/stages/multimodal/io/writer.py b/nemo_curator/stages/multimodal/io/writer.py index f2e7d1f4c4..ad0878fc17 100644 --- a/nemo_curator/stages/multimodal/io/writer.py +++ b/nemo_curator/stages/multimodal/io/writer.py @@ -22,7 +22,7 @@ class MultimodalParquetWriter(MultimodalParquetWriterStage): """User-facing multimodal parquet writer alias.""" - path: str = "" + path: str write_kwargs: dict[str, Any] = field(default_factory=dict) materialize_on_write: bool = True name: str = "multimodal_parquet_writer" diff --git a/pyproject.toml b/pyproject.toml index fe498d38cf..7981b60471 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -92,6 +92,7 @@ audio_cuda12 = [ ] image_cpu = [ + "Pillow", "torchvision" ] From 545f2246262c52a143e15b36a63ba323e5394f5b Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:02:18 +0000 Subject: [PATCH 13/62] Move multimodal validation helpers and harden metadata source parsing Signed-off-by: Vibhu Jawa --- .../stages/multimodal/utils/__init__.py | 4 +++- .../multimodal/utils/materialization.py | 21 +---------------- .../multimodal/utils/validation_utils.py | 23 ++++++++++++++++++- nemo_curator/tasks/multimodal.py | 9 +++++++- 4 files changed, 34 insertions(+), 23 deletions(-) diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py index 069790c4ca..f5d2c12a7d 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -20,10 +20,12 @@ from nemo_curator.stages.multimodal.utils.materialization import ( load_bytes_from_content_reference, load_bytes_from_metadata_source, +) +from nemo_curator.stages.multimodal.utils.validation_utils import ( require_source_id_field, resolve_storage_options, + validate_and_project_source_fields, ) -from nemo_curator.stages.multimodal.utils.validation_utils import validate_and_project_source_fields __all__ = [ "DEFAULT_IMAGE_EXTENSIONS", diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index ff2d87a9a8..eae81f8d78 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -15,29 +15,10 @@ from __future__ import annotations import tarfile -from typing import Any import fsspec -from nemo_curator.tasks import MultiBatchTask, Task - - -def require_source_id_field(source_id_field: str) -> str: - if source_id_field: - return source_id_field - msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" - raise ValueError(msg) - - -def resolve_storage_options( - task: Task[Any] | None = None, - io_kwargs: dict[str, object] | None = None, -) -> dict[str, object]: - source_storage_options = task._metadata.get("source_storage_options") if task is not None else None - if isinstance(source_storage_options, dict) and source_storage_options: - return source_storage_options - storage_options = (io_kwargs or {}).get("storage_options") - return storage_options if isinstance(storage_options, dict) else {} +from nemo_curator.tasks import MultiBatchTask def load_bytes_from_content_reference( diff --git a/nemo_curator/stages/multimodal/utils/validation_utils.py b/nemo_curator/stages/multimodal/utils/validation_utils.py index 5d750255c2..d024a23629 100644 --- a/nemo_curator/stages/multimodal/utils/validation_utils.py +++ b/nemo_curator/stages/multimodal/utils/validation_utils.py @@ -15,7 +15,28 @@ from __future__ import annotations import json -from typing import Any +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from nemo_curator.tasks import Task + + +def require_source_id_field(source_id_field: str) -> str: + if source_id_field: + return source_id_field + msg = "source_id_field must be provided explicitly (e.g., 'pdf_name')" + raise ValueError(msg) + + +def resolve_storage_options( + task: Task[Any] | None = None, + io_kwargs: dict[str, object] | None = None, +) -> dict[str, object]: + source_storage_options = task._metadata.get("source_storage_options") if task is not None else None + if isinstance(source_storage_options, dict) and source_storage_options: + return source_storage_options + storage_options = (io_kwargs or {}).get("storage_options") + return storage_options if isinstance(storage_options, dict) else {} def validate_and_project_source_fields( diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index a0304022af..c3b1d81e92 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -103,7 +103,14 @@ def build_metadata_source( @staticmethod def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: """Parse one metadata_source JSON string into a source locator dict.""" - if source_value is None or source_value == "": + if source_value is None or pd.isna(source_value): + return { + "source_id": None, + "source_shard": None, + "content_path": None, + "content_key": None, + } + if source_value == "": return { "source_id": None, "source_shard": None, From 25e3bd8c1525cbcc9b47d9364c38d8112f5bae3b Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:05:26 +0000 Subject: [PATCH 14/62] Avoid tar reopen in multimodal materialize-on-read path Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 29 +++++++++++++++---- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 665ea03fb7..c03be8f980 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -28,7 +28,6 @@ from nemo_curator.stages.multimodal.utils import ( DEFAULT_IMAGE_EXTENSIONS, DEFAULT_JSON_EXTENSIONS, - load_bytes_from_metadata_source, require_source_id_field, resolve_storage_options, validate_and_project_source_fields, @@ -195,6 +194,25 @@ def _resolve_image_content_key( return image_token return default_image_member_name + @staticmethod + def _load_image_bytes_from_tar( + tf: tarfile.TarFile, + content_key: str | None, + context: _ReadContext, + ) -> bytes | None: + if not content_key: + return None + cache_key = (context.tar_path, content_key) + if cache_key in context.byte_cache: + return context.byte_cache[cache_key] + try: + extracted = tf.extractfile(content_key) + except KeyError: + extracted = None + payload = extracted.read() if extracted is not None else None + context.byte_cache[cache_key] = payload + return payload + def _rows_from_member( self, tf: tarfile.TarFile, @@ -225,10 +243,11 @@ def _rows_from_member( for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue - row["binary_content"] = load_bytes_from_metadata_source( - source_value=row["metadata_source"], - storage_options=context.storage_options, - byte_cache=context.byte_cache, + source = MultiBatchTask.parse_metadata_source(row["metadata_source"]) + row["binary_content"] = self._load_image_bytes_from_tar( + tf=tf, + content_key=source.get("content_key"), + context=context, ) return sample_rows From 279858cc4d64d19b3dd6df28dc8e9bf3b4fe3377 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:06:34 +0000 Subject: [PATCH 15/62] Make PIL import lazy in multimodal aspect ratio filter Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/stages.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 3c7b3260d5..55a1f85cf3 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -19,7 +19,6 @@ from dataclasses import dataclass import pandas as pd -from PIL import Image # type: ignore[import-not-found] from nemo_curator.stages.base import ProcessingStage from nemo_curator.stages.multimodal.utils import load_bytes_from_metadata_source, resolve_storage_options @@ -82,6 +81,8 @@ class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: + from PIL import Image # type: ignore[import-not-found] # noqa: PLC0415 + try: with Image.open(io.BytesIO(image_bytes)) as image: width, height = image.size From 0a99dcea51b53496c1bdc1b1db091ddff8978d1f Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:07:51 +0000 Subject: [PATCH 16/62] Fix multimodal defaults for tar formats and empty task table Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/utils/constants.py | 2 +- nemo_curator/tasks/multimodal.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/utils/constants.py b/nemo_curator/stages/multimodal/utils/constants.py index 94f97d6d0a..fbd108b5c0 100644 --- a/nemo_curator/stages/multimodal/utils/constants.py +++ b/nemo_curator/stages/multimodal/utils/constants.py @@ -12,6 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -DEFAULT_WEBDATASET_EXTENSIONS = (".tar", ".tar.gz", ".tgz", ".tar.zst") +DEFAULT_WEBDATASET_EXTENSIONS = (".tar", ".tar.gz", ".tgz") DEFAULT_JSON_EXTENSIONS = (".json",) DEFAULT_IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif") diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index c3b1d81e92..0061e40bc8 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -40,7 +40,7 @@ class MultiBatchTask(Task[pa.Table | pd.DataFrame]): """Task carrying row-wise multimodal records.""" - data: pa.Table | pd.DataFrame = field(default_factory=pa.Table) + data: pa.Table | pd.DataFrame = field(default_factory=lambda: pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA)) def to_pyarrow(self) -> pa.Table: if isinstance(self.data, pa.Table): From c5e39bcec15ce8bf55e411ccac9e536f4c3e3295 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:12:01 +0000 Subject: [PATCH 17/62] Trim multimodal reader/task duplication and simplify parsing Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 11 +++---- nemo_curator/tasks/multimodal.py | 33 +++---------------- 2 files changed, 9 insertions(+), 35 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index c03be8f980..ea36a630ff 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -43,7 +43,6 @@ class _ReadContext: source_shard: str tar_path: str member_names: set[str] - storage_options: dict[str, object] byte_cache: dict[tuple[str, str], bytes | None] @@ -146,11 +145,6 @@ def append_row(row: dict[str, Any]) -> None: def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = { - self.source_id_field, - *( [self.sample_id_field] if self.sample_id_field else [] ), - self.texts_field, - self.images_field, - *( [self.image_member_field] if self.image_member_field else [] ), "sample_id", "position", "modality", @@ -160,6 +154,10 @@ def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: "metadata_source", "metadata_json", "materialize_error", + self.source_id_field, + self.texts_field, + self.images_field, + *(field for field in (self.sample_id_field, self.image_member_field) if field), } return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) @@ -267,7 +265,6 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: source_shard=source_shard, tar_path=tar_path, member_names=member_names, - storage_options=storage_options, byte_cache={}, ) for member in members: diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index 0061e40bc8..b28148ba8e 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -103,40 +103,17 @@ def build_metadata_source( @staticmethod def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: """Parse one metadata_source JSON string into a source locator dict.""" - if source_value is None or pd.isna(source_value): - return { - "source_id": None, - "source_shard": None, - "content_path": None, - "content_key": None, - } - if source_value == "": - return { - "source_id": None, - "source_shard": None, - "content_path": None, - "content_key": None, - } + keys = ("source_id", "source_shard", "content_path", "content_key") + if source_value is None or pd.isna(source_value) or source_value == "": + return dict.fromkeys(keys) parsed = json.loads(source_value) if not isinstance(parsed, dict): msg = "metadata_source must decode to a JSON object" raise TypeError(msg) - return { - "source_id": parsed.get("source_id"), - "source_shard": parsed.get("source_shard"), - "content_path": parsed.get("content_path"), - "content_key": parsed.get("content_key"), - } + return {key: parsed.get(key) for key in keys} def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: - """Return a pandas view with parsed metadata source columns added. - - Added columns: - - {prefix}source_id - - {prefix}source_shard - - {prefix}content_path - - {prefix}content_key - """ + """Return a pandas view with parsed metadata source columns added.""" df = self.to_pandas().copy() parsed = [self.parse_metadata_source(value) for value in df["metadata_source"].tolist()] parsed_df = pd.DataFrame.from_records( From c2a1cd324997d581aeda38ba6fbf038671157fa2 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:12:46 +0000 Subject: [PATCH 18/62] Remove redundant multimodal source-id validation unit test Signed-off-by: Vibhu Jawa --- tests/stages/multimodal/test_multimodal_core.py | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 4de171076a..d280d39b1c 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -20,10 +20,7 @@ import pyarrow as pa import pytest -from nemo_curator.stages.multimodal.utils import ( - load_bytes_from_content_reference, - require_source_id_field, -) +from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -82,9 +79,3 @@ def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> N cache: dict[tuple[str, str], bytes | None] = {} assert load_bytes_from_content_reference(str(direct_path), None, {}, cache) == direct_payload assert load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) == tar_payload - - -def test_require_source_id_field() -> None: - assert require_source_id_field("pdf_name") == "pdf_name" - with pytest.raises(ValueError, match="source_id_field must be provided explicitly"): - require_source_id_field("") From 9d37539fc0c23d17c482ecde36f253dae0ad7d51 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:13:35 +0000 Subject: [PATCH 19/62] Restore explicit multimodal parsing and reader field exclusions Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 11 +++++---- nemo_curator/tasks/multimodal.py | 24 +++++++++++++++---- 2 files changed, 27 insertions(+), 8 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index ea36a630ff..c03be8f980 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -43,6 +43,7 @@ class _ReadContext: source_shard: str tar_path: str member_names: set[str] + storage_options: dict[str, object] byte_cache: dict[tuple[str, str], bytes | None] @@ -145,6 +146,11 @@ def append_row(row: dict[str, Any]) -> None: def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = { + self.source_id_field, + *( [self.sample_id_field] if self.sample_id_field else [] ), + self.texts_field, + self.images_field, + *( [self.image_member_field] if self.image_member_field else [] ), "sample_id", "position", "modality", @@ -154,10 +160,6 @@ def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: "metadata_source", "metadata_json", "materialize_error", - self.source_id_field, - self.texts_field, - self.images_field, - *(field for field in (self.sample_id_field, self.image_member_field) if field), } return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) @@ -265,6 +267,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: source_shard=source_shard, tar_path=tar_path, member_names=member_names, + storage_options=storage_options, byte_cache={}, ) for member in members: diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index b28148ba8e..d294bffa4a 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -103,14 +103,30 @@ def build_metadata_source( @staticmethod def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: """Parse one metadata_source JSON string into a source locator dict.""" - keys = ("source_id", "source_shard", "content_path", "content_key") - if source_value is None or pd.isna(source_value) or source_value == "": - return dict.fromkeys(keys) + if source_value is None or pd.isna(source_value): + return { + "source_id": None, + "source_shard": None, + "content_path": None, + "content_key": None, + } + if source_value == "": + return { + "source_id": None, + "source_shard": None, + "content_path": None, + "content_key": None, + } parsed = json.loads(source_value) if not isinstance(parsed, dict): msg = "metadata_source must decode to a JSON object" raise TypeError(msg) - return {key: parsed.get(key) for key in keys} + return { + "source_id": parsed.get("source_id"), + "source_shard": parsed.get("source_shard"), + "content_path": parsed.get("content_path"), + "content_key": parsed.get("content_key"), + } def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: """Return a pandas view with parsed metadata source columns added.""" From 2d62af2ae5b30301754370dddbeebd930db1f216 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:15:12 +0000 Subject: [PATCH 20/62] Consolidate multimodal metadata source missing-value handling Signed-off-by: Vibhu Jawa --- nemo_curator/tasks/multimodal.py | 26 +++++++++++--------------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index d294bffa4a..189cbc0ae2 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -103,14 +103,8 @@ def build_metadata_source( @staticmethod def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: """Parse one metadata_source JSON string into a source locator dict.""" - if source_value is None or pd.isna(source_value): - return { - "source_id": None, - "source_shard": None, - "content_path": None, - "content_key": None, - } - if source_value == "": + keys = ("source_id", "source_shard", "content_path", "content_key") + if source_value is None or pd.isna(source_value) or source_value == "": return { "source_id": None, "source_shard": None, @@ -121,15 +115,17 @@ def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: if not isinstance(parsed, dict): msg = "metadata_source must decode to a JSON object" raise TypeError(msg) - return { - "source_id": parsed.get("source_id"), - "source_shard": parsed.get("source_shard"), - "content_path": parsed.get("content_path"), - "content_key": parsed.get("content_key"), - } + return {key: parsed.get(key) for key in keys} def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: - """Return a pandas view with parsed metadata source columns added.""" + """Return a pandas view with parsed metadata source columns added. + + Added columns: + - {prefix}source_id + - {prefix}source_shard + - {prefix}content_path + - {prefix}content_key + """ df = self.to_pandas().copy() parsed = [self.parse_metadata_source(value) for value in df["metadata_source"].tolist()] parsed_df = pd.DataFrame.from_records( From 89e7df209bbdc3cbf86c7878164f30c89618acb5 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 01:16:29 -0800 Subject: [PATCH 21/62] Update nemo_curator/stages/multimodal/io/writers/multimodal.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Vibhu Jawa Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/io/writers/multimodal.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 6a376503c0..92c3accd02 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -143,8 +143,10 @@ class MultimodalParquetWriterStage(BaseMultimodalTabularWriter): def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: # Empirically best default from current benchmark sweep. + # Note: row_group_size is in rows; 128_000 rows is a typical Parquet best-practice default. + # Callers can override this via write_kwargs["row_group_size"] if needed. write_kwargs.setdefault("compression", "snappy") - write_kwargs.setdefault("row_group_size", 128) + write_kwargs.setdefault("row_group_size", 128_000) writer_backend = str(write_kwargs.pop("writer_backend", "pandas")).lower() if writer_backend == "pyarrow": write_kwargs.pop("index", None) From cc6e4b2eb5e8b7e59946fce673c07caf2a19ffb6 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:18:40 +0000 Subject: [PATCH 22/62] Remove multimodal pyarrow writer backend toggle Signed-off-by: Vibhu Jawa --- benchmarking/scripts/multimodal_mint1t_benchmark.py | 3 --- .../stages/multimodal/io/writers/multimodal.py | 10 ---------- 2 files changed, 13 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 288dae8099..01ff1aa2aa 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -37,7 +37,6 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: write_kwargs["row_group_size"] = args.parquet_row_group_size if args.parquet_compression is not None: write_kwargs["compression"] = args.parquet_compression - write_kwargs["writer_backend"] = args.parquet_write_backend pipeline = Pipeline( name="multimodal_mint1t_benchmark", description="Benchmark: WebDataset MINT1T to multimodal parquet", @@ -101,7 +100,6 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: "materialize_on_write": args.materialize_on_write, "parquet_row_group_size": args.parquet_row_group_size, "parquet_compression": args.parquet_compression, - "parquet_write_backend": args.parquet_write_backend, "mode": args.mode, }, "metrics": { @@ -128,7 +126,6 @@ def main() -> int: parser.add_argument("--no-materialize-on-read", action="store_false", dest="materialize_on_read") parser.add_argument("--parquet-row-group-size", type=int, default=None) parser.add_argument("--parquet-compression", type=str, default=None) - parser.add_argument("--parquet-write-backend", type=str, default="pandas", choices=["pandas", "pyarrow"]) parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") parser.add_argument("--mode", type=str, default="overwrite", choices=["ignore", "overwrite", "append", "error"]) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py index 92c3accd02..52660ba65e 100644 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ b/nemo_curator/stages/multimodal/io/writers/multimodal.py @@ -19,8 +19,6 @@ from typing import TYPE_CHECKING, Any import pandas as pd -import pyarrow as pa -import pyarrow.parquet as pq from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference, resolve_storage_options @@ -147,13 +145,5 @@ def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[ # Callers can override this via write_kwargs["row_group_size"] if needed. write_kwargs.setdefault("compression", "snappy") write_kwargs.setdefault("row_group_size", 128_000) - writer_backend = str(write_kwargs.pop("writer_backend", "pandas")).lower() - if writer_backend == "pyarrow": - write_kwargs.pop("index", None) - write_kwargs.pop("storage_options", None) - with self._time_metric("parquet_write_s"): - table = pa.Table.from_pandas(df, preserve_index=False) - pq.write_table(table, file_path, **write_kwargs) - return with self._time_metric("parquet_write_s"): df.to_parquet(file_path, **write_kwargs) From 7faee07adb8c71aab19042db45ac05e8c458582a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:20:45 +0000 Subject: [PATCH 23/62] Update uv.lock for Pillow image extras Signed-off-by: Vibhu Jawa --- uv.lock | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/uv.lock b/uv.lock index 7a5bcbd391..cb0c915716 100644 --- a/uv.lock +++ b/uv.lock @@ -4556,6 +4556,7 @@ all = [ { name = "nvidia-ml-py" }, { name = "opencv-python" }, { name = "peft" }, + { name = "pillow" }, { name = "pycld2" }, { name = "pycuda" }, { name = "pylibcugraph-cu12" }, @@ -4600,6 +4601,7 @@ deduplication-cuda12 = [ { name = "scikit-learn" }, ] image-cpu = [ + { name = "pillow" }, { name = "torchvision", version = "0.24.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64' or sys_platform == 'darwin'" }, { name = "torchvision", version = "0.24.1+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "platform_machine == 'x86_64' and sys_platform != 'darwin'" }, ] @@ -4609,6 +4611,7 @@ image-cuda12 = [ { name = "gpustat" }, { name = "nvidia-dali-cuda120" }, { name = "nvidia-ml-py" }, + { name = "pillow" }, { name = "pylibcugraph-cu12" }, { name = "pylibraft-cu12" }, { name = "raft-dask-cu12" }, @@ -4768,6 +4771,7 @@ requires-dist = [ { name = "opencv-python", marker = "extra == 'video-cpu'" }, { name = "pandas", specifier = ">=2.1.0" }, { name = "peft", marker = "extra == 'text-cpu'" }, + { name = "pillow", marker = "extra == 'image-cpu'" }, { name = "pyarrow" }, { name = "pycld2", marker = "extra == 'text-cpu'" }, { name = "pycuda", marker = "extra == 'video-cuda12'" }, From 7d2093c3a50a8a173050863fbd32816c8d17122a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:43:46 +0000 Subject: [PATCH 24/62] Simplify multimodal materialization and remove writer aliases Signed-off-by: Vibhu Jawa --- .../scripts/multimodal_mint1t_benchmark.py | 4 +- nemo_curator/stages/multimodal/io/__init__.py | 4 +- nemo_curator/stages/multimodal/io/writer.py | 28 ---- .../stages/multimodal/io/writers/__init__.py | 2 +- .../multimodal/io/writers/multimodal.py | 149 ----------------- .../stages/multimodal/io/writers/tabular.py | 84 ++++++++++ nemo_curator/stages/multimodal/stages.py | 31 ++-- .../stages/multimodal/utils/__init__.py | 2 + .../multimodal/utils/materialization.py | 150 ++++++++++++++++++ .../multimodal/test_multimodal_writer.py | 2 +- tutorials/multimodal/mint1t_mvp_pipeline.py | 4 +- 11 files changed, 261 insertions(+), 199 deletions(-) delete mode 100644 nemo_curator/stages/multimodal/io/writer.py delete mode 100644 nemo_curator/stages/multimodal/io/writers/multimodal.py create mode 100644 nemo_curator/stages/multimodal/io/writers/tabular.py diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 01ff1aa2aa..d34bb4393f 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -25,7 +25,7 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline -from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader +from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage from nemo_curator.tasks.utils import TaskPerfUtils @@ -54,7 +54,7 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: ) pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) pipeline.add_stage( - MultimodalParquetWriter( + MultimodalParquetWriterStage( path=args.output_path, materialize_on_write=args.materialize_on_write, write_kwargs=write_kwargs, diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/multimodal/io/__init__.py index d7b3898f91..9dd6096faf 100644 --- a/nemo_curator/stages/multimodal/io/__init__.py +++ b/nemo_curator/stages/multimodal/io/__init__.py @@ -13,6 +13,6 @@ # limitations under the License. from nemo_curator.stages.multimodal.io.reader import WebdatasetReader -from nemo_curator.stages.multimodal.io.writer import MultimodalParquetWriter +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage -__all__ = ["MultimodalParquetWriter", "WebdatasetReader"] +__all__ = ["MultimodalParquetWriterStage", "WebdatasetReader"] diff --git a/nemo_curator/stages/multimodal/io/writer.py b/nemo_curator/stages/multimodal/io/writer.py deleted file mode 100644 index ad0878fc17..0000000000 --- a/nemo_curator/stages/multimodal/io/writer.py +++ /dev/null @@ -1,28 +0,0 @@ -# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. -# -# 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 dataclasses import dataclass, field -from typing import Any - -from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage - - -@dataclass -class MultimodalParquetWriter(MultimodalParquetWriterStage): - """User-facing multimodal parquet writer alias.""" - - path: str - write_kwargs: dict[str, Any] = field(default_factory=dict) - materialize_on_write: bool = True - name: str = "multimodal_parquet_writer" diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py index 361dd7633f..b8fe30bc11 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.writers.multimodal import ( +from nemo_curator.stages.multimodal.io.writers.tabular import ( BaseMultimodalTabularWriter, MultimodalParquetWriterStage, ) diff --git a/nemo_curator/stages/multimodal/io/writers/multimodal.py b/nemo_curator/stages/multimodal/io/writers/multimodal.py deleted file mode 100644 index 52660ba65e..0000000000 --- a/nemo_curator/stages/multimodal/io/writers/multimodal.py +++ /dev/null @@ -1,149 +0,0 @@ -# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. -# -# 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 __future__ import annotations - -from abc import ABC, abstractmethod -from dataclasses import dataclass, field -from typing import TYPE_CHECKING, Any - -import pandas as pd - -from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference, resolve_storage_options - -from .base import BaseMultimodalWriter - -if TYPE_CHECKING: - from nemo_curator.tasks import MultiBatchTask - - -@dataclass -class _MaterializationBuffers: - binary_values: list[object] - error_values: list[str | None] - byte_cache: dict[tuple[str, str], bytes | None] - - -@dataclass -class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): - """Shared multimodal tabular writer with optional image materialization.""" - - write_kwargs: dict[str, Any] = field(default_factory=dict) - materialize_on_write: bool = True - name: str = "base_multimodal_tabular_writer" - - def _materialize_group( - self, - df: pd.DataFrame, - content_path: object, - idxs: list[int], - storage_options: dict[str, Any], - buffers: _MaterializationBuffers, - ) -> None: - binary_values = buffers.binary_values - error_values = buffers.error_values - if not content_path: - for idx in idxs: - error_values[idx] = "missing content_path" - return - - for idx in idxs: - raw_key = df.loc[idx, "_src_content_key"] - content_key = str(raw_key) if raw_key else None - payload = load_bytes_from_content_reference( - content_path=str(content_path), - content_key=content_key, - storage_options=storage_options, - byte_cache=buffers.byte_cache, - ) - if payload is None: - if content_key: - error_values[idx] = f"missing content_key '{content_key}'" - else: - error_values[idx] = "failed to read content_path" - continue - binary_values[idx] = payload - error_values[idx] = None - - def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: - if not self.materialize_on_write: - with self._time_metric("to_pandas_s"): - out = task.to_pandas() - self._log_metric("rows_out", float(len(out))) - return out - - with self._time_metric("parse_source_columns_s"): - out = task.with_parsed_source_columns(prefix="_src_").reset_index(drop=True) - if "materialize_error" in out.columns: - error_values = out["materialize_error"].astype("object").tolist() - else: - error_values = [None] * len(out) - binary_values = out["binary_content"].astype("object").tolist() - - image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) - self._log_metrics( - { - "rows_out": float(len(out)), - "image_rows": float((out["modality"] == "image").sum()), - "image_rows_missing_binary": float(image_mask.sum()), - } - ) - if not image_mask.any(): - return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") - - storage_options = resolve_storage_options(task=task, io_kwargs=self.write_kwargs) - pending = out[image_mask] - buffers = _MaterializationBuffers(binary_values=binary_values, error_values=error_values, byte_cache={}) - with self._time_metric("materialize_fetch_binary_s"): - for content_path, idxs in pending.groupby("_src_content_path").groups.items(): - self._materialize_group( - df=out, - content_path=content_path, - idxs=list(idxs), - storage_options=storage_options, - buffers=buffers, - ) - - out["binary_content"] = pd.Series(binary_values, dtype="object") - out["materialize_error"] = pd.Series(error_values, dtype="object") - self._log_metric("materialize_errors", float(sum(v is not None for v in error_values))) - return out.drop(columns=[c for c in out.columns if c.startswith("_src_")], errors="ignore") - - @abstractmethod - def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: - """Format-specific writer implementation.""" - - def write_data(self, task: MultiBatchTask, file_path: str) -> None: - with self._time_metric("materialize_dataframe_total_s"): - df = self._materialize_dataframe(task) - write_kwargs = {"index": None} - write_kwargs.update(self.write_kwargs) - self._write_dataframe(df, file_path, write_kwargs) - - -@dataclass -class MultimodalParquetWriterStage(BaseMultimodalTabularWriter): - """Thin parquet writer on top of the tabular multimodal base.""" - - file_extension: str = "parquet" - name: str = "multimodal_parquet_writer" - - def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: - # Empirically best default from current benchmark sweep. - # Note: row_group_size is in rows; 128_000 rows is a typical Parquet best-practice default. - # Callers can override this via write_kwargs["row_group_size"] if needed. - write_kwargs.setdefault("compression", "snappy") - write_kwargs.setdefault("row_group_size", 128_000) - with self._time_metric("parquet_write_s"): - df.to_parquet(file_path, **write_kwargs) diff --git a/nemo_curator/stages/multimodal/io/writers/tabular.py b/nemo_curator/stages/multimodal/io/writers/tabular.py new file mode 100644 index 0000000000..ed58e456c7 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/tabular.py @@ -0,0 +1,84 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import TYPE_CHECKING, Any + +from nemo_curator.stages.multimodal.utils import materialize_task_binary_content + +from .base import BaseMultimodalWriter + +if TYPE_CHECKING: + import pandas as pd + + from nemo_curator.tasks import MultiBatchTask + + +@dataclass +class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): + """Shared multimodal tabular writer with optional image materialization.""" + + write_kwargs: dict[str, Any] = field(default_factory=dict) + materialize_on_write: bool = True + name: str = "base_multimodal_tabular_writer" + + def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: + out = task.to_pandas() + image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) + self._log_metrics( + { + "rows_out": float(len(out)), + "image_rows": float((out["modality"] == "image").sum()), + "image_rows_missing_binary": float(image_mask.sum()), + } + ) + if not self.materialize_on_write or not image_mask.any(): + return out + + with self._time_metric("materialize_fetch_binary_s"): + out = materialize_task_binary_content(task, io_kwargs=self.write_kwargs).to_pandas() + if "materialize_error" in out.columns: + self._log_metric("materialize_errors", float(out["materialize_error"].notna().sum())) + return out + + @abstractmethod + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + """Format-specific writer implementation.""" + + def write_data(self, task: MultiBatchTask, file_path: str) -> None: + with self._time_metric("materialize_dataframe_total_s"): + df = self._materialize_dataframe(task) + write_kwargs = {"index": None} + write_kwargs.update(self.write_kwargs) + self._write_dataframe(df, file_path, write_kwargs) + + +@dataclass +class MultimodalParquetWriterStage(BaseMultimodalTabularWriter): + """Thin parquet writer on top of the tabular multimodal base.""" + + file_extension: str = "parquet" + name: str = "multimodal_parquet_writer" + + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + # Empirically best default from current benchmark sweep. + # Note: row_group_size is in rows; 128_000 rows is a typical Parquet best-practice default. + # Callers can override this via write_kwargs["row_group_size"] if needed. + write_kwargs.setdefault("compression", "snappy") + write_kwargs.setdefault("row_group_size", 128_000) + with self._time_metric("parquet_write_s"): + df.to_parquet(file_path, **write_kwargs) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 55a1f85cf3..354f4607db 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -17,13 +17,17 @@ import io from abc import ABC, abstractmethod from dataclasses import dataclass +from typing import TYPE_CHECKING import pandas as pd from nemo_curator.stages.base import ProcessingStage -from nemo_curator.stages.multimodal.utils import load_bytes_from_metadata_source, resolve_storage_options +from nemo_curator.stages.multimodal.utils import materialize_task_binary_content from nemo_curator.tasks import MultiBatchTask +if TYPE_CHECKING: + from collections.abc import Iterator + @dataclass class BaseMultimodalAnnotatorStage(ProcessingStage[MultiBatchTask, MultiBatchTask], ABC): @@ -65,6 +69,15 @@ class BaseMultimodalFilterStage(BaseMultimodalAnnotatorStage, ABC): def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: """Return boolean keep-mask aligned to dataframe index.""" + def iter_materialized_bytes( + self, task: MultiBatchTask, df: pd.DataFrame, row_mask: pd.Series + ) -> Iterator[tuple[int, bytes | None]]: + """Yield (row_index, bytes) for masked rows using shared materialization logic.""" + materialized_df = materialize_task_binary_content(task).to_pandas() + for idx in df[row_mask].index.tolist(): + row_bytes = materialized_df.loc[idx, "binary_content"] if "binary_content" in materialized_df.columns else None + yield idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None + def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: return df[self.keep_mask(task, df)] @@ -99,21 +112,11 @@ def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) if not jpeg_mask.any(): return keep_mask - storage_options = resolve_storage_options(task=task) - byte_cache: dict[tuple[str, str], bytes | None] = {} - for idx in df[jpeg_mask].index.tolist(): - image_bytes = df.loc[idx, "binary_content"] - if not isinstance(image_bytes, (bytes, bytearray)): - source_value = df.loc[idx, "metadata_source"] if "metadata_source" in df.columns else None - image_bytes = load_bytes_from_metadata_source( - source_value=source_value, - storage_options=storage_options, - byte_cache=byte_cache, - ) - if not isinstance(image_bytes, (bytes, bytearray)): + for idx, image_bytes in self.iter_materialized_bytes(task=task, df=df, row_mask=jpeg_mask): + if image_bytes is None: keep_mask.loc[idx] = False continue - aspect_ratio = self._image_aspect_ratio(bytes(image_bytes)) + aspect_ratio = self._image_aspect_ratio(image_bytes) if aspect_ratio is None: keep_mask.loc[idx] = False continue diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py index f5d2c12a7d..ff2f7b8879 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -20,6 +20,7 @@ from nemo_curator.stages.multimodal.utils.materialization import ( load_bytes_from_content_reference, load_bytes_from_metadata_source, + materialize_task_binary_content, ) from nemo_curator.stages.multimodal.utils.validation_utils import ( require_source_id_field, @@ -33,6 +34,7 @@ "DEFAULT_WEBDATASET_EXTENSIONS", "load_bytes_from_content_reference", "load_bytes_from_metadata_source", + "materialize_task_binary_content", "require_source_id_field", "resolve_storage_options", "validate_and_project_source_fields", diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index eae81f8d78..f10fa34a94 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -17,9 +17,12 @@ import tarfile import fsspec +import pandas as pd from nemo_curator.tasks import MultiBatchTask +from .validation_utils import resolve_storage_options + def load_bytes_from_content_reference( content_path: str | None, @@ -65,3 +68,150 @@ def load_bytes_from_metadata_source( storage_options=storage_options, byte_cache=byte_cache, ) + + +def _init_materialization_buffers(df: pd.DataFrame) -> tuple[list[object], list[str | None]]: + error_values = ( + df["materialize_error"].astype("object").tolist() if "materialize_error" in df.columns else [None] * len(df) + ) + binary_values = df["binary_content"].astype("object").tolist() if "binary_content" in df.columns else [None] * len(df) + return binary_values, error_values + + +def _build_image_mask( + df: pd.DataFrame, + *, + only_missing_binary: bool, + image_content_types: tuple[str, ...] | None, +) -> pd.Series: + image_mask = (df["modality"] == "image") if "modality" in df.columns else pd.Series(False, index=df.index, dtype=bool) + if image_content_types is not None and "content_type" in df.columns: + image_mask &= df["content_type"].isin(image_content_types) + if only_missing_binary and "binary_content" in df.columns: + image_mask &= df["binary_content"].isna() + return image_mask + + +def _fill_materialized_bytes( + df: pd.DataFrame, + image_mask: pd.Series, + *, + storage_options: dict[str, object], + binary_values: list[object], + error_values: list[str | None], +) -> None: + pending = df[image_mask] + for content_path, idxs in pending.groupby("_src_content_path").groups.items(): + if not content_path: + for idx in idxs: + error_values[idx] = "missing content_path" + continue + keyed_rows: list[tuple[int, str]] = [] + direct_rows: list[int] = [] + for idx in idxs: + raw_key = df.loc[idx, "_src_content_key"] + if raw_key: + keyed_rows.append((idx, str(raw_key))) + else: + direct_rows.append(idx) + content_path_str = str(content_path) + _fill_group_keyed_rows(content_path_str, keyed_rows, storage_options, binary_values, error_values) + _fill_group_direct_rows(content_path_str, direct_rows, storage_options, binary_values, error_values) + + +def _fill_group_keyed_rows( + content_path: str, + keyed_rows: list[tuple[int, str]], + storage_options: dict[str, object], + binary_values: list[object], + error_values: list[str | None], +) -> None: + if not keyed_rows: + return + key_cache: dict[str, bytes | None] = {} + try: + with fsspec.open(content_path, mode="rb", **storage_options) as fobj, tarfile.open( + fileobj=fobj, mode="r:*" + ) as tf: + for idx, content_key in keyed_rows: + if content_key not in key_cache: + try: + extracted = tf.extractfile(content_key) + except KeyError: + extracted = None + key_cache[content_key] = extracted.read() if extracted is not None else None + payload = key_cache[content_key] + if payload is None: + error_values[idx] = f"missing content_key '{content_key}'" + continue + binary_values[idx] = payload + error_values[idx] = None + except Exception: # noqa: BLE001 + for idx, _ in keyed_rows: + error_values[idx] = "failed to read content_path" + + +def _fill_group_direct_rows( + content_path: str, + direct_rows: list[int], + storage_options: dict[str, object], + binary_values: list[object], + error_values: list[str | None], +) -> None: + if not direct_rows: + return + try: + with fsspec.open(content_path, mode="rb", **storage_options) as fobj: + payload = fobj.read() + for idx in direct_rows: + binary_values[idx] = payload + error_values[idx] = None + except Exception: # noqa: BLE001 + for idx in direct_rows: + error_values[idx] = "failed to read content_path" + + +def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTask: + return MultiBatchTask( + task_id=task.task_id, + dataset_name=task.dataset_name, + data=df, + _metadata=task._metadata, + _stage_perf=task._stage_perf, + ) + + +def materialize_task_binary_content( + task: MultiBatchTask, + *, + io_kwargs: dict[str, object] | None = None, + only_missing_binary: bool = True, + image_content_types: tuple[str, ...] | None = None, +) -> MultiBatchTask: + """Return a task with image-row binary content materialized from metadata_source.""" + df = task.with_parsed_source_columns(prefix="_src_").reset_index(drop=True) + if df.empty: + return task + binary_values, error_values = _init_materialization_buffers(df) + image_mask = _build_image_mask( + df, + only_missing_binary=only_missing_binary, + image_content_types=image_content_types, + ) + if not image_mask.any(): + out = df.drop(columns=[c for c in df.columns if c.startswith("_src_")], errors="ignore") + return _task_with_dataframe(task, out) + + storage_options = resolve_storage_options(task=task, io_kwargs=io_kwargs) + _fill_materialized_bytes( + df, + image_mask, + storage_options=storage_options, + binary_values=binary_values, + error_values=error_values, + ) + + out = df.drop(columns=[c for c in df.columns if c.startswith("_src_")], errors="ignore") + out["binary_content"] = pd.Series(binary_values, dtype="object") + out["materialize_error"] = pd.Series(error_values, dtype="object") + return _task_with_dataframe(task, out) diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 50a0c73e6d..1a20f0945f 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -19,7 +19,7 @@ import pyarrow as pa from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage -from nemo_curator.stages.multimodal.io.writers.multimodal import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index e577b2bc17..e5990d04e3 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -17,7 +17,7 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline -from nemo_curator.stages.multimodal.io import MultimodalParquetWriter, WebdatasetReader +from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage @@ -43,7 +43,7 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: ) pipe.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) pipe.add_stage( - MultimodalParquetWriter( + MultimodalParquetWriterStage( path=args.output_path, materialize_on_write=args.materialize_on_write, write_kwargs=write_kwargs, From 3c42153ed75d8a81fbccecfd916e4243fb650b17 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:45:42 +0000 Subject: [PATCH 25/62] Remove redundant multimodal JPEG column guard Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/stages.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 354f4607db..17dcda1ef7 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -107,8 +107,6 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: keep_mask = pd.Series(True, index=df.index, dtype=bool) - if "modality" not in df.columns or "content_type" not in df.columns: - return keep_mask jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) if not jpeg_mask.any(): return keep_mask From 2a0e0f8fac87c605cf1bc212d0221fa1c1685abc Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:50:20 +0000 Subject: [PATCH 26/62] Move multimodal row-validity filtering into base filter Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/stages.py | 39 +++++++++++++----------- 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 17dcda1ef7..77b45c4e56 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -63,11 +63,29 @@ def process(self, task: MultiBatchTask) -> MultiBatchTask: class BaseMultimodalFilterStage(BaseMultimodalAnnotatorStage, ABC): """Base stage for multimodal filtering based on a keep-mask.""" + drop_invalid_rows: bool = True name: str = "base_multimodal_filter" @abstractmethod + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + """Return content-specific boolean keep-mask aligned to dataframe index.""" + + @staticmethod + def _basic_row_validity_mask(df: pd.DataFrame) -> pd.Series: + keep_mask = pd.Series(True, index=df.index, dtype=bool) + allowed = {"text", "image", "metadata"} + keep_mask &= df["modality"].isin(allowed) + metadata_pos = (df["modality"] == "metadata") & (df["position"] == -1) + content_pos = (df["modality"] != "metadata") & (df["position"] >= 0) + keep_mask &= metadata_pos | content_pos + return keep_mask + def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: - """Return boolean keep-mask aligned to dataframe index.""" + keep_mask = pd.Series(True, index=df.index, dtype=bool) + if self.drop_invalid_rows: + keep_mask &= self._basic_row_validity_mask(df) + keep_mask &= self.content_keep_mask(task, df) + return keep_mask def iter_materialized_bytes( self, task: MultiBatchTask, df: pd.DataFrame, row_mask: pd.Series @@ -86,7 +104,6 @@ def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): """Filter multimodal rows and enforce JPEG aspect-ratio bounds.""" - drop_invalid_rows: bool = True min_aspect_ratio: float = 0.2 max_aspect_ratio: float = 5.0 jpeg_content_types: tuple[str, ...] = ("image/jpeg", "image/jpg") @@ -122,19 +139,5 @@ def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: keep_mask.loc[idx] = False return keep_mask - @staticmethod - def _basic_row_validity_mask(df: pd.DataFrame) -> pd.Series: - keep_mask = pd.Series(True, index=df.index, dtype=bool) - allowed = {"text", "image", "metadata"} - keep_mask &= df["modality"].isin(allowed) - metadata_pos = (df["modality"] == "metadata") & (df["position"] == -1) - content_pos = (df["modality"] != "metadata") & (df["position"] >= 0) - keep_mask &= metadata_pos | content_pos - return keep_mask - - def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: - keep_mask = pd.Series(True, index=df.index, dtype=bool) - if self.drop_invalid_rows: - keep_mask &= self._basic_row_validity_mask(df) - keep_mask &= self._jpeg_keep_mask(task, df) - return keep_mask + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + return self._jpeg_keep_mask(task, df) From 0e6ccaa2883faa646cadd59c2d018156d7b8f58d Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:54:02 +0000 Subject: [PATCH 27/62] Fix ruff unused-noqa and local PIL import in multimodal stage Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/stages.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 77b45c4e56..4e30377dea 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -20,6 +20,7 @@ from typing import TYPE_CHECKING import pandas as pd +from PIL import Image from nemo_curator.stages.base import ProcessingStage from nemo_curator.stages.multimodal.utils import materialize_task_binary_content @@ -111,8 +112,6 @@ class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: - from PIL import Image # type: ignore[import-not-found] # noqa: PLC0415 - try: with Image.open(io.BytesIO(image_bytes)) as image: width, height = image.size From fa50bea5b511fffc7b562d123d23722a45aa652d Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 09:59:18 +0000 Subject: [PATCH 28/62] Align multimodal PIL import with text-stage local import style Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/stages.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 4e30377dea..73ae8957d6 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -20,7 +20,6 @@ from typing import TYPE_CHECKING import pandas as pd -from PIL import Image from nemo_curator.stages.base import ProcessingStage from nemo_curator.stages.multimodal.utils import materialize_task_binary_content @@ -112,6 +111,14 @@ class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: + try: + from PIL import Image + except ModuleNotFoundError as exc: + msg = ( + "Pillow is required for MultimodalJpegAspectRatioFilterStage. " + "Install dependency group `image_cpu` (or `pillow`)." + ) + raise RuntimeError(msg) from exc try: with Image.open(io.BytesIO(image_bytes)) as image: width, height = image.size From fdd3e2207278c61083de502121239c93ad6e1587 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 02:06:45 -0800 Subject: [PATCH 29/62] Apply suggestions from code review Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Vibhu Jawa Signed-off-by: Vibhu Jawa --- .../stages/multimodal/utils/materialization.py | 4 ++-- tests/stages/multimodal/__init__.py | 12 ++++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index f10fa34a94..2a8fd15f2b 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -102,7 +102,7 @@ def _fill_materialized_bytes( ) -> None: pending = df[image_mask] for content_path, idxs in pending.groupby("_src_content_path").groups.items(): - if not content_path: + if content_path is None or pd.isna(content_path): for idx in idxs: error_values[idx] = "missing content_path" continue @@ -110,7 +110,7 @@ def _fill_materialized_bytes( direct_rows: list[int] = [] for idx in idxs: raw_key = df.loc[idx, "_src_content_key"] - if raw_key: + if raw_key not in (None, "") and pd.notna(raw_key): keyed_rows.append((idx, str(raw_key))) else: direct_rows.append(idx) diff --git a/tests/stages/multimodal/__init__.py b/tests/stages/multimodal/__init__.py index 3e4afde2e2..4fc25d0d3c 100644 --- a/tests/stages/multimodal/__init__.py +++ b/tests/stages/multimodal/__init__.py @@ -1 +1,13 @@ # Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 5bf4e76f9cf8840da4824f49cf245b3ba4016739 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 18 Feb 2026 10:12:01 +0000 Subject: [PATCH 30/62] Fix multimodal index alignment, content_type, schema, and parquet index Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 12 ++++- .../stages/multimodal/io/writers/tabular.py | 2 +- nemo_curator/stages/multimodal/stages.py | 23 ++++++--- .../stages/multimodal/test_multimodal_core.py | 37 ++++++++++++++ .../multimodal/test_multimodal_reader.py | 48 +++++++++++++++++++ .../multimodal/test_multimodal_writer.py | 24 ++++++++++ 6 files changed, 136 insertions(+), 10 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index c03be8f980..1784131a94 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -132,7 +132,7 @@ def append_row(row: dict[str, Any]) -> None: if isinstance(images, list): for idx, image_token in enumerate(images): content_key = self._resolve_image_content_key(image_token, image_member_name, member_names) - content_type, _ = mimetypes.guess_type(image_member_name or "") + content_type, _ = mimetypes.guess_type(content_key or image_member_name or "") append_row( { "position": idx, @@ -144,6 +144,14 @@ def append_row(row: dict[str, Any]) -> None: return rows + def _empty_output_schema(self) -> pa.Schema: + schema = MULTIMODAL_SCHEMA + if not self.fields: + return schema + existing = set(schema.names) + passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] + return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema + def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = { self.source_id_field, @@ -281,7 +289,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: ) ) - table = pa.Table.from_pylist(rows) if rows else pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA) + table = pa.Table.from_pylist(rows) if rows else pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) batches: list[MultiBatchTask] = [] for idx, split in enumerate(splits): diff --git a/nemo_curator/stages/multimodal/io/writers/tabular.py b/nemo_curator/stages/multimodal/io/writers/tabular.py index ed58e456c7..bf7ad3fabf 100644 --- a/nemo_curator/stages/multimodal/io/writers/tabular.py +++ b/nemo_curator/stages/multimodal/io/writers/tabular.py @@ -62,7 +62,7 @@ def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[ def write_data(self, task: MultiBatchTask, file_path: str) -> None: with self._time_metric("materialize_dataframe_total_s"): df = self._materialize_dataframe(task) - write_kwargs = {"index": None} + write_kwargs = {"index": False} write_kwargs.update(self.write_kwargs) self._write_dataframe(df, file_path, write_kwargs) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 73ae8957d6..ee628339ed 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -28,6 +28,11 @@ if TYPE_CHECKING: from collections.abc import Iterator +try: + from PIL import Image +except ImportError: + Image = None + @dataclass class BaseMultimodalAnnotatorStage(ProcessingStage[MultiBatchTask, MultiBatchTask], ABC): @@ -92,9 +97,15 @@ def iter_materialized_bytes( ) -> Iterator[tuple[int, bytes | None]]: """Yield (row_index, bytes) for masked rows using shared materialization logic.""" materialized_df = materialize_task_binary_content(task).to_pandas() - for idx in df[row_mask].index.tolist(): - row_bytes = materialized_df.loc[idx, "binary_content"] if "binary_content" in materialized_df.columns else None - yield idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None + if "binary_content" not in materialized_df.columns: + for idx in df[row_mask].index.tolist(): + yield idx, None + return + selected_positions = [pos for pos, keep in enumerate(row_mask.tolist()) if bool(keep)] + for pos in selected_positions: + row_idx = df.index[pos] + row_bytes = materialized_df.iloc[pos]["binary_content"] + yield row_idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: return df[self.keep_mask(task, df)] @@ -111,14 +122,12 @@ class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: - try: - from PIL import Image - except ModuleNotFoundError as exc: + if Image is None: msg = ( "Pillow is required for MultimodalJpegAspectRatioFilterStage. " "Install dependency group `image_cpu` (or `pillow`)." ) - raise RuntimeError(msg) from exc + raise RuntimeError(msg) try: with Image.open(io.BytesIO(image_bytes)) as image: width, height = image.size diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index d280d39b1c..5b239050e0 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -17,9 +17,11 @@ from io import BytesIO from pathlib import Path +import pandas as pd import pyarrow as pa import pytest +from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -79,3 +81,38 @@ def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> N cache: dict[tuple[str, str], bytes | None] = {} assert load_bytes_from_content_reference(str(direct_path), None, {}, cache) == direct_payload assert load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) == tar_payload + + +def test_jpeg_filter_handles_non_default_dataframe_index() -> None: + df = pd.DataFrame( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "ok", + "binary_content": None, + "metadata_source": None, + "metadata_json": None, + "materialize_error": None, + }, + { + "sample_id": "s1", + "position": 1, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": b"not-a-valid-jpeg", + "metadata_source": None, + "metadata_json": None, + "materialize_error": None, + }, + ] + ) + df.index = pd.Index([10, 42]) + task = MultiBatchTask(task_id="non_default_index", dataset_name="d1", data=df) + stage = MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=False) + out = stage.process(task).to_pandas() + assert len(out) == 1 + assert out.iloc[0]["modality"] == "text" diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index d841de3987..4a3adbc429 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -127,6 +127,54 @@ def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: assert "frames" not in df.columns +def test_reader_uses_resolved_content_key_for_content_type(tmp_path: Path) -> None: + tar_path = tmp_path / "content-type-resolve.tar" + payload = { + "doc_id": "doc-ct", + "source_doc": "ct.pdf", + "captions": ["hello"], + "frames": ["token.png"], + "primary_image": "fallback.jpg", + } + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name="sample.meta.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + png_info = tarfile.TarInfo(name="token.png") + png_info.size = 3 + tf.addfile(png_info, BytesIO(b"png")) + jpg_info = tarfile.TarInfo(name="fallback.jpg") + jpg_info.size = 3 + tf.addfile(jpg_info, BytesIO(b"jpg")) + + task = _task_for_tar(tar_path, "content_type_resolve") + reader = WebdatasetReaderStage( + sample_id_field="doc_id", + source_id_field="source_doc", + texts_field="captions", + images_field="frames", + image_member_field="primary_image", + json_extensions=(".meta.json",), + ) + df = _as_df(reader.process(task)) + image_row = df[df["modality"] == "image"].iloc[0] + assert image_row["content_type"] == "image/png" + + +def test_reader_empty_output_schema_includes_requested_passthrough_fields(tmp_path: Path) -> None: + tar_path = tmp_path / "empty-no-json.tar" + with tarfile.open(tar_path, "w") as tf: + img_info = tarfile.TarInfo(name="image.jpg") + img_info.size = 3 + tf.addfile(img_info, BytesIO(b"abc")) + + task = _task_for_tar(tar_path, "empty_schema") + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("p_hash",)) + df = _as_df(reader.process(task)) + assert "p_hash" in df.columns + + @pytest.mark.parametrize( ("task_id", "fields", "error_pattern"), [ diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 1a20f0945f..29d690575c 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -100,3 +100,27 @@ def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> written = pd.read_parquet(write_task.data[0]) assert written.loc[0, "binary_content"] == image_bytes assert pd.isna(written.loc[0, "materialize_error"]) + + +def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: + df = pd.DataFrame( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "metadata_source": None, + "metadata_json": None, + "materialize_error": None, + } + ] + ) + df.index = pd.Index([99]) + task = MultiBatchTask(task_id="idx_task", dataset_name="mint_test", data=df) + writer = MultimodalParquetWriterStage(path=str(tmp_path / "out_idx"), materialize_on_write=False, mode="overwrite") + write_task = writer.process(task) + written = pd.read_parquet(write_task.data[0]) + assert "__index_level_0__" not in written.columns From fe57ab639094bce471ead7bd1d1a4eb98974b51a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 24 Feb 2026 01:39:37 +0000 Subject: [PATCH 31/62] Fix multimodal alignment and materialization behavior Signed-off-by: Vibhu Jawa --- .../multimodal/io/readers/webdataset.py | 46 +++++----- .../stages/multimodal/utils/__init__.py | 4 +- .../multimodal/utils/materialization.py | 84 ++++++++++--------- nemo_curator/tasks/multimodal.py | 65 ++++++++------ .../stages/multimodal/test_multimodal_core.py | 26 +++--- .../multimodal/test_multimodal_writer.py | 16 ++-- 6 files changed, 132 insertions(+), 109 deletions(-) diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 1784131a94..d3da236de5 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -40,7 +40,6 @@ @dataclass class _ReadContext: - source_shard: str tar_path: str member_names: set[str] storage_options: dict[str, object] @@ -73,7 +72,6 @@ def _rows_from_sample( source: dict[str, str], member_names: set[str], ) -> list[dict[str, Any]]: - source_id = sample.get(self.source_id_field) rows: list[dict[str, Any]] = [] images = sample.get(self.images_field) image_member_name = self._resolve_default_image_member_name(sample_id, sample, images, member_names) @@ -82,12 +80,10 @@ def _rows_from_sample( json_member_name = source["json_member_name"] passthrough_row = self._build_passthrough_row(sample) - def build_metadata_source(content_key: str | None) -> str: - return MultiBatchTask.build_metadata_source( - source_id=source_id, - source_shard=source_shard, - content_path=tar_path, - content_key=content_key, + def build_source_ref(content_key: str | None) -> str: + return MultiBatchTask.build_source_ref( + path=tar_path, + member=content_key, ) def append_row(row: dict[str, Any]) -> None: @@ -99,7 +95,7 @@ def append_row(row: dict[str, Any]) -> None: "content_type": row.get("content_type"), "text_content": row.get("text_content"), "binary_content": row.get("binary_content"), - "metadata_source": row.get("metadata_source"), + "source_ref": row.get("source_ref"), "metadata_json": row.get("metadata_json"), "materialize_error": None, **passthrough_row, @@ -111,8 +107,18 @@ def append_row(row: dict[str, Any]) -> None: "position": -1, "modality": "metadata", "content_type": "application/json", - "metadata_source": build_metadata_source(json_member_name), - "metadata_json": json.dumps(sample, ensure_ascii=True), + "source_ref": build_source_ref(json_member_name), + "metadata_json": json.dumps( + { + **sample, + "_sample_source": { + "source_shard": source_shard, + "tar_path": tar_path, + "json_member_name": json_member_name, + }, + }, + ensure_ascii=True, + ), } ) @@ -125,7 +131,7 @@ def append_row(row: dict[str, Any]) -> None: "modality": "text", "content_type": "text/plain", "text_content": text_value if isinstance(text_value, str) else None, - "metadata_source": build_metadata_source(json_member_name), + "source_ref": build_source_ref(json_member_name), } ) @@ -138,7 +144,7 @@ def append_row(row: dict[str, Any]) -> None: "position": idx, "modality": "image", "content_type": content_type or ("application/octet-stream" if image_member_name else None), - "metadata_source": build_metadata_source(content_key), + "source_ref": build_source_ref(content_key), } ) @@ -155,17 +161,17 @@ def _empty_output_schema(self) -> pa.Schema: def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = { self.source_id_field, - *( [self.sample_id_field] if self.sample_id_field else [] ), + *([self.sample_id_field] if self.sample_id_field else []), self.texts_field, self.images_field, - *( [self.image_member_field] if self.image_member_field else [] ), + *([self.image_member_field] if self.image_member_field else []), "sample_id", "position", "modality", "content_type", "text_content", "binary_content", - "metadata_source", + "source_ref", "metadata_json", "materialize_error", } @@ -237,7 +243,7 @@ def _rows_from_member( else Path(member.name).stem ) source = { - "source_shard": context.source_shard, + "source_shard": Path(context.tar_path).name, "tar_path": context.tar_path, "json_member_name": member.name, } @@ -251,10 +257,10 @@ def _rows_from_member( for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue - source = MultiBatchTask.parse_metadata_source(row["metadata_source"]) + source = MultiBatchTask.parse_source_ref(row["source_ref"]) row["binary_content"] = self._load_image_bytes_from_tar( tf=tf, - content_key=source.get("content_key"), + member=source.get("member"), context=context, ) return sample_rows @@ -264,7 +270,6 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) for tar_path in task.data: - source_shard = Path(tar_path).name with ( fsspec.open(tar_path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf, @@ -272,7 +277,6 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: members = [m for m in tf.getmembers() if m.isfile()] member_names = {m.name for m in members} context = _ReadContext( - source_shard=source_shard, tar_path=tar_path, member_names=member_names, storage_options=storage_options, diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py index ff2f7b8879..5b39cff5c4 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -19,7 +19,7 @@ ) from nemo_curator.stages.multimodal.utils.materialization import ( load_bytes_from_content_reference, - load_bytes_from_metadata_source, + load_bytes_from_source_ref, materialize_task_binary_content, ) from nemo_curator.stages.multimodal.utils.validation_utils import ( @@ -33,7 +33,7 @@ "DEFAULT_JSON_EXTENSIONS", "DEFAULT_WEBDATASET_EXTENSIONS", "load_bytes_from_content_reference", - "load_bytes_from_metadata_source", + "load_bytes_from_source_ref", "materialize_task_binary_content", "require_source_id_field", "resolve_storage_options", diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index 2a8fd15f2b..805c171386 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -25,24 +25,24 @@ def load_bytes_from_content_reference( - content_path: str | None, - content_key: str | None, + path: str | None, + member: str | None, storage_options: dict[str, object], byte_cache: dict[tuple[str, str], bytes | None], ) -> bytes | None: - if not content_path: + if not path: return None - cache_key = (str(content_path), str(content_key or "")) + cache_key = (str(path), str(member or "")) if cache_key in byte_cache: return byte_cache[cache_key] try: - with fsspec.open(str(content_path), mode="rb", **storage_options) as fobj: - if content_key: + with fsspec.open(str(path), mode="rb", **storage_options) as fobj: + if member: with tarfile.open(fileobj=fobj, mode="r:*") as tf: try: - extracted = tf.extractfile(content_key) + extracted = tf.extractfile(member) except KeyError: extracted = None payload = extracted.read() if extracted is not None else None @@ -56,15 +56,15 @@ def load_bytes_from_content_reference( return None -def load_bytes_from_metadata_source( +def load_bytes_from_source_ref( source_value: str | None, storage_options: dict[str, object], byte_cache: dict[tuple[str, str], bytes | None], ) -> bytes | None: - source = MultiBatchTask.parse_metadata_source(source_value) + source = MultiBatchTask.parse_source_ref(source_value) return load_bytes_from_content_reference( - content_path=source.get("content_path"), - content_key=source.get("content_key"), + path=source.get("path"), + member=source.get("member"), storage_options=storage_options, byte_cache=byte_cache, ) @@ -74,7 +74,9 @@ def _init_materialization_buffers(df: pd.DataFrame) -> tuple[list[object], list[ error_values = ( df["materialize_error"].astype("object").tolist() if "materialize_error" in df.columns else [None] * len(df) ) - binary_values = df["binary_content"].astype("object").tolist() if "binary_content" in df.columns else [None] * len(df) + binary_values = ( + df["binary_content"].astype("object").tolist() if "binary_content" in df.columns else [None] * len(df) + ) return binary_values, error_values @@ -84,7 +86,9 @@ def _build_image_mask( only_missing_binary: bool, image_content_types: tuple[str, ...] | None, ) -> pd.Series: - image_mask = (df["modality"] == "image") if "modality" in df.columns else pd.Series(False, index=df.index, dtype=bool) + image_mask = ( + (df["modality"] == "image") if "modality" in df.columns else pd.Series(False, index=df.index, dtype=bool) + ) if image_content_types is not None and "content_type" in df.columns: image_mask &= df["content_type"].isin(image_content_types) if only_missing_binary and "binary_content" in df.columns: @@ -101,26 +105,28 @@ def _fill_materialized_bytes( error_values: list[str | None], ) -> None: pending = df[image_mask] - for content_path, idxs in pending.groupby("_src_content_path").groups.items(): - if content_path is None or pd.isna(content_path): + for path, idxs in pending.groupby("_src_path").groups.items(): + if path is None or pd.isna(path): for idx in idxs: - error_values[idx] = "missing content_path" + error_values[idx] = "missing path" continue + keyed_rows: list[tuple[int, str]] = [] direct_rows: list[int] = [] for idx in idxs: - raw_key = df.loc[idx, "_src_content_key"] - if raw_key not in (None, "") and pd.notna(raw_key): - keyed_rows.append((idx, str(raw_key))) + raw_member = df.loc[idx, "_src_member"] + if raw_member not in (None, "") and pd.notna(raw_member): + keyed_rows.append((idx, str(raw_member))) else: direct_rows.append(idx) - content_path_str = str(content_path) - _fill_group_keyed_rows(content_path_str, keyed_rows, storage_options, binary_values, error_values) - _fill_group_direct_rows(content_path_str, direct_rows, storage_options, binary_values, error_values) + + path_str = str(path) + _fill_group_keyed_rows(path_str, keyed_rows, storage_options, binary_values, error_values) + _fill_group_direct_rows(path_str, direct_rows, storage_options, binary_values, error_values) def _fill_group_keyed_rows( - content_path: str, + path: str, keyed_rows: list[tuple[int, str]], storage_options: dict[str, object], binary_values: list[object], @@ -128,31 +134,32 @@ def _fill_group_keyed_rows( ) -> None: if not keyed_rows: return + key_cache: dict[str, bytes | None] = {} try: - with fsspec.open(content_path, mode="rb", **storage_options) as fobj, tarfile.open( - fileobj=fobj, mode="r:*" - ) as tf: - for idx, content_key in keyed_rows: - if content_key not in key_cache: + with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: + for idx, member in keyed_rows: + if member not in key_cache: try: - extracted = tf.extractfile(content_key) + extracted = tf.extractfile(member) except KeyError: extracted = None - key_cache[content_key] = extracted.read() if extracted is not None else None - payload = key_cache[content_key] + key_cache[member] = extracted.read() if extracted is not None else None + + payload = key_cache[member] if payload is None: - error_values[idx] = f"missing content_key '{content_key}'" + error_values[idx] = f"missing member '{member}'" continue + binary_values[idx] = payload error_values[idx] = None except Exception: # noqa: BLE001 for idx, _ in keyed_rows: - error_values[idx] = "failed to read content_path" + error_values[idx] = "failed to read path" def _fill_group_direct_rows( - content_path: str, + path: str, direct_rows: list[int], storage_options: dict[str, object], binary_values: list[object], @@ -161,14 +168,14 @@ def _fill_group_direct_rows( if not direct_rows: return try: - with fsspec.open(content_path, mode="rb", **storage_options) as fobj: + with fsspec.open(path, mode="rb", **storage_options) as fobj: payload = fobj.read() for idx in direct_rows: binary_values[idx] = payload error_values[idx] = None except Exception: # noqa: BLE001 for idx in direct_rows: - error_values[idx] = "failed to read content_path" + error_values[idx] = "failed to read path" def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTask: @@ -188,10 +195,11 @@ def materialize_task_binary_content( only_missing_binary: bool = True, image_content_types: tuple[str, ...] | None = None, ) -> MultiBatchTask: - """Return a task with image-row binary content materialized from metadata_source.""" - df = task.with_parsed_source_columns(prefix="_src_").reset_index(drop=True) + """Return a task with image-row binary content materialized from source_ref.""" + df = task.with_parsed_source_ref_columns(prefix="_src_").reset_index(drop=True) if df.empty: return task + binary_values, error_values = _init_materialization_buffers(df) image_mask = _build_image_mask( df, diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index 189cbc0ae2..4a24506ab5 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -29,7 +29,7 @@ pa.field("content_type", pa.string(), nullable=True), pa.field("text_content", pa.string(), nullable=True), pa.field("binary_content", pa.large_binary(), nullable=True), - pa.field("metadata_source", pa.string(), nullable=True), + pa.field("source_ref", pa.string(), nullable=True), pa.field("metadata_json", pa.string(), nullable=True), pa.field("materialize_error", pa.string(), nullable=True), ] @@ -84,53 +84,64 @@ def validate(self) -> bool: return True @staticmethod - def build_metadata_source( - source_id: str | None, - source_shard: str | None, - content_path: str | None, - content_key: str | None, + def build_source_ref( + path: str | None, + member: str | None, + byte_offset: int | None = None, + byte_size: int | None = None, ) -> str: return json.dumps( { - "source_id": source_id, - "source_shard": source_shard, - "content_path": content_path, - "content_key": content_key, + "path": path, + "member": member, + "byte_offset": byte_offset, + "byte_size": byte_size, }, ensure_ascii=True, ) @staticmethod - def parse_metadata_source(source_value: str | None) -> dict[str, str | None]: - """Parse one metadata_source JSON string into a source locator dict.""" - keys = ("source_id", "source_shard", "content_path", "content_key") + def parse_source_ref(source_value: str | None) -> dict[str, str | int | None]: + """Parse one source_ref JSON string into a locator dict.""" if source_value is None or pd.isna(source_value) or source_value == "": return { - "source_id": None, - "source_shard": None, - "content_path": None, - "content_key": None, + "path": None, + "member": None, + "byte_offset": None, + "byte_size": None, } parsed = json.loads(source_value) if not isinstance(parsed, dict): - msg = "metadata_source must decode to a JSON object" + msg = "source_ref must decode to a JSON object" raise TypeError(msg) - return {key: parsed.get(key) for key in keys} - def with_parsed_source_columns(self, prefix: str = "_src_") -> pd.DataFrame: - """Return a pandas view with parsed metadata source columns added. + # Soft migration for older locator payloads. + path = parsed.get("path", parsed.get("content_path")) + member = parsed.get("member", parsed.get("content_key")) + byte_offset = parsed.get("byte_offset") + byte_size = parsed.get("byte_size") + + return { + "path": path if path is None else str(path), + "member": member if member is None else str(member), + "byte_offset": int(byte_offset) if byte_offset is not None else None, + "byte_size": int(byte_size) if byte_size is not None else None, + } + + def with_parsed_source_ref_columns(self, prefix: str = "_src_") -> pd.DataFrame: + """Return a pandas view with parsed source_ref columns added. Added columns: - - {prefix}source_id - - {prefix}source_shard - - {prefix}content_path - - {prefix}content_key + - {prefix}path + - {prefix}member + - {prefix}byte_offset + - {prefix}byte_size """ df = self.to_pandas().copy() - parsed = [self.parse_metadata_source(value) for value in df["metadata_source"].tolist()] + parsed = [self.parse_source_ref(value) for value in df["source_ref"].tolist()] parsed_df = pd.DataFrame.from_records( parsed, - columns=["source_id", "source_shard", "content_path", "content_key"], + columns=["path", "member", "byte_offset", "byte_size"], ) for col in parsed_df.columns: df[f"{prefix}{col}"] = parsed_df[col].to_numpy(copy=False) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 5b239050e0..c70b187d1d 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -38,12 +38,12 @@ def single_row_table() -> pa.Table: "content_type": "text/plain", "text_content": "hello", "binary_content": None, - "metadata_source": json.dumps( + "source_ref": json.dumps( { - "source_id": "doc.pdf", - "source_shard": "shard-00000.tar", - "content_path": "/dataset/shard-00000.tar", - "content_key": "s1.json", + "path": "/dataset/shard-00000.tar", + "member": "s1.json", + "byte_offset": 10, + "byte_size": 20, } ), "metadata_json": None, @@ -59,12 +59,12 @@ def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: return MultiBatchTask(task_id="t1", dataset_name="d1", data=single_row_table) -def test_with_parsed_source_columns(single_row_task: MultiBatchTask) -> None: - df = single_row_task.with_parsed_source_columns() - assert df.loc[0, "_src_source_id"] == "doc.pdf" - assert df.loc[0, "_src_source_shard"] == "shard-00000.tar" - assert df.loc[0, "_src_content_path"] == "/dataset/shard-00000.tar" - assert df.loc[0, "_src_content_key"] == "s1.json" +def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None: + df = single_row_task.with_parsed_source_ref_columns() + assert df.loc[0, "_src_path"] == "/dataset/shard-00000.tar" + assert df.loc[0, "_src_member"] == "s1.json" + assert df.loc[0, "_src_byte_offset"] == 10 + assert df.loc[0, "_src_byte_size"] == 20 def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> None: @@ -93,7 +93,7 @@ def test_jpeg_filter_handles_non_default_dataframe_index() -> None: "content_type": "text/plain", "text_content": "ok", "binary_content": None, - "metadata_source": None, + "source_ref": None, "metadata_json": None, "materialize_error": None, }, @@ -104,7 +104,7 @@ def test_jpeg_filter_handles_non_default_dataframe_index() -> None: "content_type": "image/jpeg", "text_content": None, "binary_content": b"not-a-valid-jpeg", - "metadata_source": None, + "source_ref": None, "metadata_json": None, "materialize_error": None, }, diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 29d690575c..84b6793f74 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -30,13 +30,13 @@ def _read_batch(input_task: FileGroupTask) -> MultiBatchTask: return batch -def _metadata_source(content_path: str, content_key: str | None, source_shard: str = "shard-00000.tar") -> str: +def _source_ref(content_path: str, content_key: str | None) -> str: return json.dumps( { - "source_id": "doc.pdf", - "source_shard": source_shard, - "content_path": content_path, - "content_key": content_key, + "path": content_path, + "member": content_key, + "byte_offset": None, + "byte_size": None, } ) @@ -47,7 +47,7 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input image_mask = df["modality"] == "image" assert image_mask.any() first_image_idx = df[image_mask].index[0] - df.loc[first_image_idx, "metadata_source"] = _metadata_source("/definitely/missing/path.tar", "abc123.tiff") + df.loc[first_image_idx, "source_ref"] = _source_ref("/definitely/missing/path.tar", "abc123.tiff") bad_batch = MultiBatchTask( task_id=batch.task_id, dataset_name=batch.dataset_name, @@ -79,7 +79,7 @@ def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> "content_type": "image/jpeg", "text_content": None, "binary_content": None, - "metadata_source": _metadata_source(str(raw_path), None, source_shard="raw_image.jpg"), + "source_ref": _source_ref(str(raw_path), None), "metadata_json": None, "materialize_error": None, } @@ -112,7 +112,7 @@ def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: "content_type": "text/plain", "text_content": "hello", "binary_content": None, - "metadata_source": None, + "source_ref": None, "metadata_json": None, "materialize_error": None, } From 85b9cf3823026a15cf1c114a34b83eeeb815de48 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 24 Feb 2026 01:49:24 +0000 Subject: [PATCH 32/62] Remove stale BLE001 noqa directives in MINT1T benchmark Signed-off-by: Vibhu Jawa --- benchmarking/scripts/multimodal_mint1t_benchmark.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index d34bb4393f..56d6f31076 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -78,7 +78,7 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: logger.info("Pipeline:\n{}", pipeline.describe()) output_tasks = pipeline.run(executor) success = True - except Exception as e: # noqa: BLE001 + except Exception as e: logger.error("Benchmark failed: {}", e) logger.debug(traceback.format_exc()) @@ -136,7 +136,7 @@ def main() -> int: ray_client.start() try: results = run_benchmark(args) - except Exception as e: # noqa: BLE001 + except Exception as e: logger.error("Benchmark crashed: {}", e) logger.debug(traceback.format_exc()) results = { From 6a207edcf75e090afa961a9f575ffc4efd4f06e2 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 05:17:12 +0000 Subject: [PATCH 33/62] Rename metadata_source to source_ref, fix correctness bugs, optimize split_table, expand tests - Rename metadata_source -> source_ref with cleaner schema (path, member, byte_offset, byte_size) and soft migration for older content_path/content_key payloads - Fix iter_materialized_bytes index alignment bug (positional vs DataFrame index) - Fix variable shadowing in webdataset reader materialize-on-read path - Fix groupby dropping NaN rows in materialization (add dropna=False) - Optimize split_table_by_group_max_bytes: sort+slice O(n log n) instead of filter-per-group O(groups * rows) - Remove source_shard from _ReadContext, derive inline from tar_path - Embed _sample_source provenance in metadata_json instead of source_ref - Fix BaseMultimodalReader.name default from empty string - Add 16 new tests (28 total): split_table, validity mask, composite decompose, materialize, source_ref parsing with soft migration - Add AGENTS.md with environment setup and benchmark dataset paths Made-with: Cursor Signed-off-by: Vibhu Jawa --- AGENTS.md | 27 +++ nemo_curator/core/utils.py | 20 +- .../stages/multimodal/io/readers/base.py | 2 +- .../multimodal/io/readers/webdataset.py | 15 +- nemo_curator/stages/multimodal/stages.py | 6 +- .../multimodal/utils/materialization.py | 2 +- .../stages/multimodal/test_multimodal_core.py | 177 +++++++++++++++++- 7 files changed, 228 insertions(+), 21 deletions(-) create mode 100644 AGENTS.md diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000000..6730349cfd --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,27 @@ +# Agent Preferences + +## Environment Setup Before Python +- Always run: `source /home/nfs/vjawa/.bashrc` +- Then run: `cd /raid/vjawa/NeMo-Curator && source .venv/bin/activate` + +## Running Tests +- Multimodal tests: `python -m pytest tests/stages/multimodal/ -v` +- Full test suite: `python -m pytest tests/ -q` +- Lint check: `python -m ruff check nemo_curator/ tests/` + +## Benchmarking +- Single shard smoke test (no materialization): + ``` + python benchmarking/scripts/multimodal_mint1t_benchmark.py \ + --benchmark-results-path .tmp_multimodal_runs/run_name \ + --input-path /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar \ + --output-path .tmp_multimodal_runs/run_name/output \ + --no-materialize-on-write --no-materialize-on-read --mode overwrite + ``` +- Full 10GB (90 shards): use `--input-path /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` + +## Available Datasets +- Single shard (79MB): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar` +- 10GB MINT1T (90 tar shards): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` +- 20GB interleaved sample (17 tars): `/raid/vjawa/mint_interleaved_100mb_sample/webdataset/` +- 173GB parquet subset (997 files): `/datasets/vjawa/nvmint_mint1t_parquet_1k_subset/` diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index 2f0ca2db66..9dce70cf88 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -208,10 +208,19 @@ def split_table_by_group_max_bytes( msg = f"Group column '{group_column}' not found in table" raise ValueError(msg) - group_values = [str(v) for v in pc.unique(table[group_column]).to_pylist()] + # Sort by group column so rows for each group are contiguous -- O(n log n) + # then slice at group boundaries instead of O(groups * rows) filtering. + sort_indices = pc.sort_indices(table, sort_keys=[(group_column, "ascending")]) + table = table.take(sort_indices) + col = table[group_column] + group_tables: list[pa.Table] = [] - for group_value in group_values: - group_tables.append(table.filter(pc.equal(table[group_column], group_value))) + start = 0 + for i in range(1, table.num_rows): + if col[i].as_py() != col[i - 1].as_py(): + group_tables.append(table.slice(start, i - start)) + start = i + group_tables.append(table.slice(start, table.num_rows - start)) chunks: list[list[pa.Table]] = [] chunk_tables: list[pa.Table] = [] @@ -227,7 +236,4 @@ def split_table_by_group_max_bytes( if chunk_tables: chunks.append(chunk_tables) - out_tables: list[pa.Table] = [] - for chunk in chunks: - out_tables.append(pa.concat_tables(chunk) if len(chunk) > 1 else chunk[0]) - return out_tables + return [pa.concat_tables(chunk) if len(chunk) > 1 else chunk[0] for chunk in chunks] diff --git a/nemo_curator/stages/multimodal/io/readers/base.py b/nemo_curator/stages/multimodal/io/readers/base.py index eab4bb0e62..b5dbdcb39b 100644 --- a/nemo_curator/stages/multimodal/io/readers/base.py +++ b/nemo_curator/stages/multimodal/io/readers/base.py @@ -24,7 +24,7 @@ class BaseMultimodalReader(ProcessingStage[FileGroupTask, MultiBatchTask]): """Base contract for multimodal readers.""" read_kwargs: dict[str, Any] = field(default_factory=dict) - name: str = "" + name: str = "base_multimodal_reader" def inputs(self) -> tuple[list[str], list[str]]: return ["data"], [] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index d3da236de5..2979c52f8e 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -75,7 +75,6 @@ def _rows_from_sample( rows: list[dict[str, Any]] = [] images = sample.get(self.images_field) image_member_name = self._resolve_default_image_member_name(sample_id, sample, images, member_names) - source_shard = source["source_shard"] tar_path = source["tar_path"] json_member_name = source["json_member_name"] passthrough_row = self._build_passthrough_row(sample) @@ -112,7 +111,7 @@ def append_row(row: dict[str, Any]) -> None: { **sample, "_sample_source": { - "source_shard": source_shard, + "source_shard": Path(tar_path).name, "tar_path": tar_path, "json_member_name": json_member_name, }, @@ -211,16 +210,16 @@ def _resolve_image_content_key( @staticmethod def _load_image_bytes_from_tar( tf: tarfile.TarFile, - content_key: str | None, + member: str | None, context: _ReadContext, ) -> bytes | None: - if not content_key: + if not member: return None - cache_key = (context.tar_path, content_key) + cache_key = (context.tar_path, member) if cache_key in context.byte_cache: return context.byte_cache[cache_key] try: - extracted = tf.extractfile(content_key) + extracted = tf.extractfile(member) except KeyError: extracted = None payload = extracted.read() if extracted is not None else None @@ -257,10 +256,10 @@ def _rows_from_member( for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue - source = MultiBatchTask.parse_source_ref(row["source_ref"]) + parsed_ref = MultiBatchTask.parse_source_ref(row["source_ref"]) row["binary_content"] = self._load_image_bytes_from_tar( tf=tf, - member=source.get("member"), + member=parsed_ref.get("member"), context=context, ) return sample_rows diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index ee628339ed..fc791ef9a1 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -96,13 +96,13 @@ def iter_materialized_bytes( self, task: MultiBatchTask, df: pd.DataFrame, row_mask: pd.Series ) -> Iterator[tuple[int, bytes | None]]: """Yield (row_index, bytes) for masked rows using shared materialization logic.""" - materialized_df = materialize_task_binary_content(task).to_pandas() + materialized_df = materialize_task_binary_content(task).to_pandas().reset_index(drop=True) if "binary_content" not in materialized_df.columns: for idx in df[row_mask].index.tolist(): yield idx, None return - selected_positions = [pos for pos, keep in enumerate(row_mask.tolist()) if bool(keep)] - for pos in selected_positions: + df_reset = df.reset_index(drop=True) + for pos in df_reset[row_mask.to_numpy()].index: row_idx = df.index[pos] row_bytes = materialized_df.iloc[pos]["binary_content"] yield row_idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index 805c171386..386c20f720 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -105,7 +105,7 @@ def _fill_materialized_bytes( error_values: list[str | None], ) -> None: pending = df[image_mask] - for path, idxs in pending.groupby("_src_path").groups.items(): + for path, idxs in pending.groupby("_src_path", dropna=False).groups.items(): if path is None or pd.isna(path): for idx in idxs: error_values[idx] = "missing path" diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index c70b187d1d..74abeeac0f 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -21,8 +21,14 @@ import pyarrow as pa import pytest -from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage +from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.stages.multimodal.io.reader import WebdatasetReader +from nemo_curator.stages.multimodal.stages import ( + BaseMultimodalFilterStage, + MultimodalJpegAspectRatioFilterStage, +) from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference +from nemo_curator.stages.multimodal.utils.materialization import materialize_task_binary_content from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -67,6 +73,20 @@ def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None assert df.loc[0, "_src_byte_size"] == 20 +def test_parse_source_ref_soft_migration() -> None: + old_format = json.dumps({"content_path": "/old/path.tar", "content_key": "old.json"}) + parsed = MultiBatchTask.parse_source_ref(old_format) + assert parsed["path"] == "/old/path.tar" + assert parsed["member"] == "old.json" + assert parsed["byte_offset"] is None + assert parsed["byte_size"] is None + + +def test_parse_source_ref_empty_values() -> None: + assert MultiBatchTask.parse_source_ref(None)["path"] is None + assert MultiBatchTask.parse_source_ref("")["path"] is None + + def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> None: direct_path = tmp_path / "direct.bin" direct_payload = b"direct-bytes" @@ -83,6 +103,11 @@ def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> N assert load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) == tar_payload +def test_load_bytes_from_content_reference_caches() -> None: + cache: dict[tuple[str, str], bytes | None] = {("/fake", ""): b"cached"} + assert load_bytes_from_content_reference("/fake", None, {}, cache) == b"cached" + + def test_jpeg_filter_handles_non_default_dataframe_index() -> None: df = pd.DataFrame( [ @@ -116,3 +141,153 @@ def test_jpeg_filter_handles_non_default_dataframe_index() -> None: out = stage.process(task).to_pandas() assert len(out) == 1 assert out.iloc[0]["modality"] == "text" + + +# --- split_table_by_group_max_bytes tests --- + + +def test_split_table_none_max_bytes() -> None: + table = pa.table({"g": ["a", "a", "b"], "v": [1, 2, 3]}) + result = split_table_by_group_max_bytes(table, "g", None) + assert len(result) == 1 + assert result[0].num_rows == 3 + + +def test_split_table_empty_table() -> None: + table = pa.table({"g": pa.array([], type=pa.string()), "v": pa.array([], type=pa.int64())}) + result = split_table_by_group_max_bytes(table, "g", 100) + assert len(result) == 1 + assert result[0].num_rows == 0 + + +def test_split_table_invalid_max_bytes() -> None: + table = pa.table({"g": ["a"], "v": [1]}) + with pytest.raises(ValueError, match="max_batch_bytes must be > 0"): + split_table_by_group_max_bytes(table, "g", 0) + + +def test_split_table_missing_column() -> None: + table = pa.table({"g": ["a"], "v": [1]}) + with pytest.raises(ValueError, match="not found in table"): + split_table_by_group_max_bytes(table, "missing", 100) + + +def test_split_table_single_large_group() -> None: + table = pa.table({"g": ["a"] * 100, "v": list(range(100))}) + result = split_table_by_group_max_bytes(table, "g", 1) + assert len(result) == 1 + assert result[0].num_rows == 100 + + +def test_split_table_multiple_groups_split() -> None: + table = pa.table({"g": ["a", "a", "b", "b", "c", "c"], "v": [1, 2, 3, 4, 5, 6]}) + small_limit = table.slice(0, 2).nbytes + 1 + result = split_table_by_group_max_bytes(table, "g", small_limit) + assert len(result) >= 2 + total_rows = sum(t.num_rows for t in result) + assert total_rows == 6 + + +def test_split_table_preserves_group_integrity() -> None: + table = pa.table({"g": ["a", "b", "a", "b"], "v": [1, 2, 3, 4]}) + result = split_table_by_group_max_bytes(table, "g", 1) + for chunk in result: + groups = chunk["g"].to_pylist() + assert len(set(groups)) == 1 or all(g == groups[0] for g in groups) + + +# --- basic_row_validity_mask tests --- + + +def test_basic_row_validity_mask_filters_bad_modality() -> None: + df = pd.DataFrame( + { + "modality": ["text", "image", "video", "metadata"], + "position": [0, 1, 2, -1], + } + ) + mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) + assert mask.tolist() == [True, True, False, True] + + +def test_basic_row_validity_mask_enforces_position_rules() -> None: + df = pd.DataFrame( + { + "modality": ["metadata", "metadata", "text", "text"], + "position": [-1, 0, 0, -1], + } + ) + mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) + assert mask.tolist() == [True, False, True, False] + + +# --- CompositeStage decomposition test --- + + +def test_webdataset_reader_composite_decompose(tmp_path: Path) -> None: + reader = WebdatasetReader( + file_paths=str(tmp_path), + source_id_field="pdf_name", + ) + stages = reader.decompose() + assert len(stages) == 2 + assert stages[0].name == "file_partitioning" + assert stages[1].name == "webdataset_reader" + + +# --- materialize_task_binary_content tests --- + + +def test_materialize_empty_task() -> None: + task = MultiBatchTask(task_id="empty", dataset_name="d", data=pa.table({"sample_id": pa.array([], type=pa.string()), "position": pa.array([], type=pa.int32()), "modality": pa.array([], type=pa.string()), "content_type": pa.array([], type=pa.string()), "text_content": pa.array([], type=pa.string()), "binary_content": pa.array([], type=pa.large_binary()), "source_ref": pa.array([], type=pa.string()), "metadata_json": pa.array([], type=pa.string()), "materialize_error": pa.array([], type=pa.string())})) + result = materialize_task_binary_content(task) + assert result.num_items == 0 + + +def test_materialize_no_image_rows() -> None: + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="no_img", dataset_name="d", data=table) + result = materialize_task_binary_content(task) + assert result.num_items == 1 + + +def test_materialize_fills_binary_from_direct_path(tmp_path: Path) -> None: + image_bytes = b"test-image-content" + img_path = tmp_path / "test.jpg" + img_path.write_bytes(image_bytes) + + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": None, + "source_ref": MultiBatchTask.build_source_ref(path=str(img_path), member=None), + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="mat", dataset_name="d", data=table) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == image_bytes From bbfcaebf171cd2047b2dc7e7ebbe4f493b64f687 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 05:25:17 +0000 Subject: [PATCH 34/62] Remove redundant get_all_file_paths_under call in collect_parquet_output_metrics Use get_all_file_paths_and_size_under once and extract paths from the result tuples instead of calling both functions on the same directory. Made-with: Cursor Signed-off-by: Vibhu Jawa --- benchmarking/scripts/utils.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index b8cc45fdc1..0ef5aead25 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -22,7 +22,7 @@ from nemo_curator.backends.experimental.ray_actor_pool.executor import RayActorPoolExecutor from nemo_curator.backends.experimental.ray_data import RayDataExecutor from nemo_curator.backends.xenna import XennaExecutor -from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under, get_all_file_paths_under +from nemo_curator.utils.file_utils import get_all_file_paths_and_size_under _executor_map = {"ray_data": RayDataExecutor, "xenna": XennaExecutor, "ray_actors": RayActorPoolExecutor} @@ -98,16 +98,12 @@ def write_benchmark_results(results: dict, output_path: str | Path) -> None: def collect_parquet_output_metrics(output_path: Path) -> dict[str, Any]: - parquet_files = get_all_file_paths_under( - str(output_path), - recurse_subdirectories=True, - keep_extensions=[".parquet"], - ) output_files_with_size = get_all_file_paths_and_size_under( str(output_path), recurse_subdirectories=True, keep_extensions=[".parquet"], ) + parquet_files = [path for path, _ in output_files_with_size] num_files = len(parquet_files) total_size_bytes = int(sum(size for _, size in output_files_with_size)) num_rows = 0 From ea3e40e21f157ca2bda1cc024a890972e8693245 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 05:46:03 +0000 Subject: [PATCH 35/62] Rewrite materialization with three-strategy dispatch and remove all noqa suppressions - Add _classify_rows() to partition image rows into tar-extract, range-read, and direct-read groups based on source_ref content - Add _fill_range_read_rows() using fs.cat_ranges() for batched byte-range reads (key optimization for remote/S3 paths with byte_offset/byte_size) - Populate byte_offset/byte_size from TarInfo in WebdatasetReaderStage so downstream materialization can use range reads - Remove duplicate _load_image_bytes_from_tar from webdataset reader; use shared _extract_tar_member helper - Remove load_bytes_from_content_reference and load_bytes_from_source_ref (consolidated into the three-strategy dispatch) - Replace all bare except Exception (noqa: BLE001) with specific exception types: OSError, tarfile.TarError, ValueError, SyntaxError - Add no-noqa rule to AGENTS.md - Add 9 new tests for classify_rows, range-read, tar-extract, mixed dispatch, and error handling (37 total) Made-with: Cursor Signed-off-by: Vibhu Jawa --- AGENTS.md | 3 + .../multimodal/io/readers/webdataset.py | 39 +- nemo_curator/stages/multimodal/stages.py | 2 +- .../stages/multimodal/utils/__init__.py | 4 - .../multimodal/utils/materialization.py | 283 ++++++++------ .../stages/multimodal/test_multimodal_core.py | 358 +++++++++++++----- 6 files changed, 448 insertions(+), 241 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 6730349cfd..358eb48eee 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -20,6 +20,9 @@ ``` - Full 10GB (90 shards): use `--input-path /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` +## Code Style +- NEVER add `# noqa:` comments to suppress lint warnings. Fix the underlying issue instead (refactor the code, reduce arguments, etc.). + ## Available Datasets - Single shard (79MB): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar` - 10GB MINT1T (90 tar shards): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 2979c52f8e..f8a799858d 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -42,8 +42,9 @@ class _ReadContext: tar_path: str member_names: set[str] + member_info: dict[str, tarfile.TarInfo] storage_options: dict[str, object] - byte_cache: dict[tuple[str, str], bytes | None] + byte_cache: dict[str, bytes | None] @dataclass @@ -71,6 +72,7 @@ def _rows_from_sample( sample: dict[str, Any], source: dict[str, str], member_names: set[str], + member_info: dict[str, tarfile.TarInfo] | None = None, ) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] images = sample.get(self.images_field) @@ -80,9 +82,17 @@ def _rows_from_sample( passthrough_row = self._build_passthrough_row(sample) def build_source_ref(content_key: str | None) -> str: + byte_offset = None + byte_size = None + if content_key and member_info and content_key in member_info: + info = member_info[content_key] + byte_offset = info.offset_data + byte_size = info.size return MultiBatchTask.build_source_ref( path=tar_path, member=content_key, + byte_offset=byte_offset, + byte_size=byte_size, ) def append_row(row: dict[str, Any]) -> None: @@ -208,22 +218,15 @@ def _resolve_image_content_key( return default_image_member_name @staticmethod - def _load_image_bytes_from_tar( - tf: tarfile.TarFile, - member: str | None, - context: _ReadContext, - ) -> bytes | None: - if not member: - return None - cache_key = (context.tar_path, member) - if cache_key in context.byte_cache: - return context.byte_cache[cache_key] + def _extract_tar_member(tf: tarfile.TarFile, member_name: str, cache: dict[str, bytes | None]) -> bytes | None: + if member_name in cache: + return cache[member_name] try: - extracted = tf.extractfile(member) + extracted = tf.extractfile(member_name) except KeyError: extracted = None payload = extracted.read() if extracted is not None else None - context.byte_cache[cache_key] = payload + cache[member_name] = payload return payload def _rows_from_member( @@ -251,17 +254,16 @@ def _rows_from_member( sample=payload, source=source, member_names=context.member_names, + member_info=context.member_info, ) if self.materialize_on_read: for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue parsed_ref = MultiBatchTask.parse_source_ref(row["source_ref"]) - row["binary_content"] = self._load_image_bytes_from_tar( - tf=tf, - member=parsed_ref.get("member"), - context=context, - ) + content_key = parsed_ref.get("member") + if content_key: + row["binary_content"] = self._extract_tar_member(tf, content_key, context.byte_cache) return sample_rows def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: @@ -278,6 +280,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: context = _ReadContext( tar_path=tar_path, member_names=member_names, + member_info={m.name: m for m in members}, storage_options=storage_options, byte_cache={}, ) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index fc791ef9a1..93d1a9b1ef 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -131,7 +131,7 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: try: with Image.open(io.BytesIO(image_bytes)) as image: width, height = image.size - except Exception: # noqa: BLE001 + except (OSError, SyntaxError, ValueError): return None if height <= 0: return None diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/multimodal/utils/__init__.py index 5b39cff5c4..51451f00e0 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/multimodal/utils/__init__.py @@ -18,8 +18,6 @@ DEFAULT_WEBDATASET_EXTENSIONS, ) from nemo_curator.stages.multimodal.utils.materialization import ( - load_bytes_from_content_reference, - load_bytes_from_source_ref, materialize_task_binary_content, ) from nemo_curator.stages.multimodal.utils.validation_utils import ( @@ -32,8 +30,6 @@ "DEFAULT_IMAGE_EXTENSIONS", "DEFAULT_JSON_EXTENSIONS", "DEFAULT_WEBDATASET_EXTENSIONS", - "load_bytes_from_content_reference", - "load_bytes_from_source_ref", "materialize_task_binary_content", "require_source_id_field", "resolve_storage_options", diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index 386c20f720..5c8557daba 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -15,59 +15,180 @@ from __future__ import annotations import tarfile +from typing import NamedTuple import fsspec import pandas as pd +from fsspec.core import url_to_fs +from loguru import logger from nemo_curator.tasks import MultiBatchTask from .validation_utils import resolve_storage_options +_TAR_EXTENSIONS = (".tar", ".tar.gz", ".tgz") -def load_bytes_from_content_reference( - path: str | None, - member: str | None, + +class _ClassifiedRows(NamedTuple): + tar_extract: dict[str, list[tuple[int, str]]] + range_read: dict[str, list[tuple[int, str, int, int]]] + direct_read: dict[str, list[int]] + missing: list[int] + + +def _classify_rows( + df: pd.DataFrame, + image_mask: pd.Series, +) -> _ClassifiedRows: + """Partition pending image rows into three I/O strategy groups. + + - tar_extract: has member name but no byte_offset (must open tar and extractfile) + - range_read: has member + byte_offset + byte_size (can use fs.cat_ranges) + - direct_read: no member (path is the file itself) + - missing: path is None/NaN + """ + tar_extract: dict[str, list[tuple[int, str]]] = {} + range_read: dict[str, list[tuple[int, str, int, int]]] = {} + direct_read: dict[str, list[int]] = {} + missing: list[int] = [] + + for idx in df[image_mask].index: + path = df.loc[idx, "_src_path"] + if path is None or (isinstance(path, float) and pd.isna(path)) or path == "": + missing.append(idx) + continue + + path_str = str(path) + raw_member = df.loc[idx, "_src_member"] + has_member = raw_member not in (None, "") and pd.notna(raw_member) + + if not has_member: + direct_read.setdefault(path_str, []).append(idx) + continue + + member_str = str(raw_member) + raw_offset = df.loc[idx, "_src_byte_offset"] + raw_size = df.loc[idx, "_src_byte_size"] + has_range = raw_offset is not None and raw_size is not None and pd.notna(raw_offset) and pd.notna(raw_size) + + if has_range and int(raw_size) > 0: + range_read.setdefault(path_str, []).append((idx, member_str, int(raw_offset), int(raw_size))) + else: + tar_extract.setdefault(path_str, []).append((idx, member_str)) + + return _ClassifiedRows(tar_extract=tar_extract, range_read=range_read, direct_read=direct_read, missing=missing) + + +def _fill_tar_extract_rows( + groups: dict[str, list[tuple[int, str]]], storage_options: dict[str, object], - byte_cache: dict[tuple[str, str], bytes | None], -) -> bytes | None: - if not path: - return None + binary_values: list[object], + error_values: list[str | None], +) -> None: + """Open each tar once and extract all needed members sequentially.""" + for path, keyed_rows in groups.items(): + key_cache: dict[str, bytes | None] = {} + try: + with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: + for idx, member in keyed_rows: + if member not in key_cache: + try: + extracted = tf.extractfile(member) + except KeyError: + extracted = None + key_cache[member] = extracted.read() if extracted is not None else None + + payload = key_cache[member] + if payload is None: + error_values[idx] = f"missing member '{member}'" + continue + + binary_values[idx] = payload + error_values[idx] = None + except (OSError, tarfile.TarError): + for idx, _ in keyed_rows: + error_values[idx] = "failed to read path" + + +def _fill_range_read_rows( + groups: dict[str, list[tuple[int, str, int, int]]], + storage_options: dict[str, object], + binary_values: list[object], + error_values: list[str | None], +) -> None: + """Batch byte-range reads per path using fs.cat_ranges().""" + for path, entries in groups.items(): + try: + fs, fs_path = url_to_fs(path, **storage_options) + except (ValueError, OSError): + for idx, *_ in entries: + error_values[idx] = "failed to resolve filesystem" + continue + + paths = [fs_path] * len(entries) + starts = [offset for _, _, offset, _ in entries] + ends = [offset + size for _, _, offset, size in entries] - cache_key = (str(path), str(member or "")) - if cache_key in byte_cache: - return byte_cache[cache_key] + try: + blobs = fs.cat_ranges(paths, starts, ends) + except OSError as exc: + logger.warning(f"cat_ranges failed for {path} ({len(entries)} ranges): {exc}") + for idx, *_ in entries: + error_values[idx] = "cat_ranges failed" + continue + + for (idx, member, _offset, _size), blob in zip(entries, blobs, strict=True): + if isinstance(blob, Exception): + error_values[idx] = f"range read error for member '{member}'" + continue + if blob is None or len(blob) == 0: + error_values[idx] = f"empty range read for member '{member}'" + continue + binary_values[idx] = bytes(blob) if not isinstance(blob, bytes) else blob + error_values[idx] = None + +def _fill_direct_read_rows( + groups: dict[str, list[int]], + storage_options: dict[str, object], + binary_values: list[object], + error_values: list[str | None], +) -> None: + """Read each direct file once, share bytes across all rows referencing it.""" + for path, row_idxs in groups.items(): + payload = _read_direct_file(path, storage_options) + for idx in row_idxs: + if payload is not None: + binary_values[idx] = payload + error_values[idx] = None + else: + error_values[idx] = "failed to read path" + + +def _read_direct_file(path: str, storage_options: dict[str, object]) -> bytes | None: try: - with fsspec.open(str(path), mode="rb", **storage_options) as fobj: - if member: - with tarfile.open(fileobj=fobj, mode="r:*") as tf: - try: - extracted = tf.extractfile(member) - except KeyError: - extracted = None - payload = extracted.read() if extracted is not None else None - byte_cache[cache_key] = payload - return payload - payload = fobj.read() - byte_cache[cache_key] = payload - return payload - except Exception: # noqa: BLE001 - byte_cache[cache_key] = None + with fsspec.open(path, mode="rb", **storage_options) as fobj: + return fobj.read() + except OSError: return None -def load_bytes_from_source_ref( - source_value: str | None, +def _fill_materialized_bytes( + df: pd.DataFrame, + image_mask: pd.Series, + *, storage_options: dict[str, object], - byte_cache: dict[tuple[str, str], bytes | None], -) -> bytes | None: - source = MultiBatchTask.parse_source_ref(source_value) - return load_bytes_from_content_reference( - path=source.get("path"), - member=source.get("member"), - storage_options=storage_options, - byte_cache=byte_cache, - ) + binary_values: list[object], + error_values: list[str | None], +) -> None: + classified = _classify_rows(df, image_mask) + + for idx in classified.missing: + error_values[idx] = "missing path" + + _fill_tar_extract_rows(classified.tar_extract, storage_options, binary_values, error_values) + _fill_range_read_rows(classified.range_read, storage_options, binary_values, error_values) + _fill_direct_read_rows(classified.direct_read, storage_options, binary_values, error_values) def _init_materialization_buffers(df: pd.DataFrame) -> tuple[list[object], list[str | None]]: @@ -96,88 +217,6 @@ def _build_image_mask( return image_mask -def _fill_materialized_bytes( - df: pd.DataFrame, - image_mask: pd.Series, - *, - storage_options: dict[str, object], - binary_values: list[object], - error_values: list[str | None], -) -> None: - pending = df[image_mask] - for path, idxs in pending.groupby("_src_path", dropna=False).groups.items(): - if path is None or pd.isna(path): - for idx in idxs: - error_values[idx] = "missing path" - continue - - keyed_rows: list[tuple[int, str]] = [] - direct_rows: list[int] = [] - for idx in idxs: - raw_member = df.loc[idx, "_src_member"] - if raw_member not in (None, "") and pd.notna(raw_member): - keyed_rows.append((idx, str(raw_member))) - else: - direct_rows.append(idx) - - path_str = str(path) - _fill_group_keyed_rows(path_str, keyed_rows, storage_options, binary_values, error_values) - _fill_group_direct_rows(path_str, direct_rows, storage_options, binary_values, error_values) - - -def _fill_group_keyed_rows( - path: str, - keyed_rows: list[tuple[int, str]], - storage_options: dict[str, object], - binary_values: list[object], - error_values: list[str | None], -) -> None: - if not keyed_rows: - return - - key_cache: dict[str, bytes | None] = {} - try: - with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: - for idx, member in keyed_rows: - if member not in key_cache: - try: - extracted = tf.extractfile(member) - except KeyError: - extracted = None - key_cache[member] = extracted.read() if extracted is not None else None - - payload = key_cache[member] - if payload is None: - error_values[idx] = f"missing member '{member}'" - continue - - binary_values[idx] = payload - error_values[idx] = None - except Exception: # noqa: BLE001 - for idx, _ in keyed_rows: - error_values[idx] = "failed to read path" - - -def _fill_group_direct_rows( - path: str, - direct_rows: list[int], - storage_options: dict[str, object], - binary_values: list[object], - error_values: list[str | None], -) -> None: - if not direct_rows: - return - try: - with fsspec.open(path, mode="rb", **storage_options) as fobj: - payload = fobj.read() - for idx in direct_rows: - binary_values[idx] = payload - error_values[idx] = None - except Exception: # noqa: BLE001 - for idx in direct_rows: - error_values[idx] = "failed to read path" - - def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTask: return MultiBatchTask( task_id=task.task_id, @@ -195,7 +234,13 @@ def materialize_task_binary_content( only_missing_binary: bool = True, image_content_types: tuple[str, ...] | None = None, ) -> MultiBatchTask: - """Return a task with image-row binary content materialized from source_ref.""" + """Return a task with image-row binary content materialized from source_ref. + + Dispatches to three I/O strategies based on source_ref contents: + - range_read: byte_offset + byte_size present -> batched fs.cat_ranges() + - tar_extract: member present, no byte range -> open tar + extractfile + - direct_read: no member -> read file directly + """ df = task.with_parsed_source_ref_columns(prefix="_src_").reset_index(drop=True) if df.empty: return task diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 74abeeac0f..2b2212d6c6 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -27,11 +27,54 @@ BaseMultimodalFilterStage, MultimodalJpegAspectRatioFilterStage, ) -from nemo_curator.stages.multimodal.utils import load_bytes_from_content_reference -from nemo_curator.stages.multimodal.utils.materialization import materialize_task_binary_content +from nemo_curator.stages.multimodal.utils.materialization import ( + _classify_rows, + materialize_task_binary_content, +) from nemo_curator.tasks import MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA +# --- helpers --- + + +def _make_tar(tmp_path: Path, members: dict[str, bytes], name: str = "shard.tar") -> str: + tar_path = tmp_path / name + with tarfile.open(tar_path, "w") as tf: + for member_name, payload in members.items(): + info = tarfile.TarInfo(name=member_name) + info.size = len(payload) + tf.addfile(info, BytesIO(payload)) + return str(tar_path) + + +def _image_task(rows: list[dict], metadata: dict | None = None) -> MultiBatchTask: + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + return MultiBatchTask(task_id="test", dataset_name="d", data=table, _metadata=metadata or {}) + + +def _image_row( + path: str | None, + member: str | None = None, + byte_offset: int | None = None, + byte_size: int | None = None, +) -> dict: + return { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": None, + "source_ref": MultiBatchTask.build_source_ref( + path=path, member=member, byte_offset=byte_offset, byte_size=byte_size + ), + "metadata_json": None, + "materialize_error": None, + } + + +# --- source_ref parsing tests --- + @pytest.fixture def single_row_table() -> pa.Table: @@ -45,12 +88,7 @@ def single_row_table() -> pa.Table: "text_content": "hello", "binary_content": None, "source_ref": json.dumps( - { - "path": "/dataset/shard-00000.tar", - "member": "s1.json", - "byte_offset": 10, - "byte_size": 20, - } + {"path": "/dataset/shard.tar", "member": "s1.json", "byte_offset": 10, "byte_size": 20} ), "metadata_json": None, "materialize_error": None, @@ -67,7 +105,7 @@ def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None: df = single_row_task.with_parsed_source_ref_columns() - assert df.loc[0, "_src_path"] == "/dataset/shard-00000.tar" + assert df.loc[0, "_src_path"] == "/dataset/shard.tar" assert df.loc[0, "_src_member"] == "s1.json" assert df.loc[0, "_src_byte_offset"] == 10 assert df.loc[0, "_src_byte_size"] == 20 @@ -87,25 +125,218 @@ def test_parse_source_ref_empty_values() -> None: assert MultiBatchTask.parse_source_ref("")["path"] is None -def test_load_bytes_from_content_reference_direct_and_keyed(tmp_path: Path) -> None: - direct_path = tmp_path / "direct.bin" - direct_payload = b"direct-bytes" - direct_path.write_bytes(direct_payload) - tar_path = tmp_path / "blob.tar" - tar_payload = b"tar-bytes" - with tarfile.open(tar_path, "w") as tf: - info = tarfile.TarInfo(name="x.bin") - info.size = len(tar_payload) - tf.addfile(info, BytesIO(tar_payload)) +# --- classify_rows tests --- + + +def test_classify_rows_direct_read() -> None: + df = pd.DataFrame( + {"_src_path": ["/img.jpg"], "_src_member": [None], "_src_byte_offset": [None], "_src_byte_size": [None]} + ) + mask = pd.Series([True]) + result = _classify_rows(df, mask) + assert "/img.jpg" in result.direct_read + assert not result.tar_extract + assert not result.range_read + + +def test_classify_rows_tar_extract() -> None: + df = pd.DataFrame( + {"_src_path": ["/shard.tar"], "_src_member": ["img.jpg"], "_src_byte_offset": [None], "_src_byte_size": [None]} + ) + mask = pd.Series([True]) + result = _classify_rows(df, mask) + assert "/shard.tar" in result.tar_extract + assert not result.range_read + assert not result.direct_read + + +def test_classify_rows_range_read() -> None: + df = pd.DataFrame( + {"_src_path": ["/shard.tar"], "_src_member": ["img.jpg"], "_src_byte_offset": [512], "_src_byte_size": [1024]} + ) + mask = pd.Series([True]) + result = _classify_rows(df, mask) + assert "/shard.tar" in result.range_read + assert not result.tar_extract + assert not result.direct_read + entry = result.range_read["/shard.tar"][0] + assert entry == (0, "img.jpg", 512, 1024) + + +def test_classify_rows_missing_path() -> None: + df = pd.DataFrame( + {"_src_path": [None], "_src_member": [None], "_src_byte_offset": [None], "_src_byte_size": [None]} + ) + mask = pd.Series([True]) + result = _classify_rows(df, mask) + assert result.missing == [0] + + +def test_classify_rows_mixed_batch() -> None: + df = pd.DataFrame( + { + "_src_path": ["/img.jpg", "/shard.tar", "/shard.tar", None], + "_src_member": [None, "a.jpg", "b.jpg", None], + "_src_byte_offset": [None, None, 100, None], + "_src_byte_size": [None, None, 200, None], + } + ) + mask = pd.Series([True, True, True, True]) + result = _classify_rows(df, mask) + assert len(result.direct_read["/img.jpg"]) == 1 + assert len(result.tar_extract["/shard.tar"]) == 1 + assert len(result.range_read["/shard.tar"]) == 1 + assert result.missing == [3] + + +# --- materialize: direct read --- + + +def test_materialize_fills_binary_from_direct_path(tmp_path: Path) -> None: + image_bytes = b"test-image-content" + img_path = tmp_path / "test.jpg" + img_path.write_bytes(image_bytes) + + task = _image_task([_image_row(path=str(img_path))]) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == image_bytes + assert pd.isna(df.loc[0, "materialize_error"]) + + +# --- materialize: tar extract (no byte_offset) --- + + +def test_materialize_fills_binary_from_tar_extract(tmp_path: Path) -> None: + payload = b"tar-image-bytes" + tar_path = _make_tar(tmp_path, {"img.jpg": payload}) + + task = _image_task([_image_row(path=tar_path, member="img.jpg")]) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == payload + assert pd.isna(df.loc[0, "materialize_error"]) + + +def test_materialize_tar_extract_missing_member(tmp_path: Path) -> None: + tar_path = _make_tar(tmp_path, {"other.jpg": b"data"}) + + task = _image_task([_image_row(path=tar_path, member="missing.jpg")]) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert pd.isna(df.loc[0, "binary_content"]) or df.loc[0, "binary_content"] is None + assert "missing member" in str(df.loc[0, "materialize_error"]) + + +# --- materialize: range read (with byte_offset/byte_size) --- + + +def test_materialize_fills_binary_from_range_read(tmp_path: Path) -> None: + payload = b"range-read-image-bytes" + raw_file = tmp_path / "data.bin" + raw_file.write_bytes(b"HEADER" + payload + b"FOOTER") + + task = _image_task( + [_image_row(path=str(raw_file), member="data.bin", byte_offset=6, byte_size=len(payload))] + ) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == payload + assert pd.isna(df.loc[0, "materialize_error"]) + + +def test_materialize_range_read_bad_path(tmp_path: Path) -> None: + task = _image_task( + [_image_row(path=str(tmp_path / "nonexistent.bin"), member="x", byte_offset=0, byte_size=10)] + ) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert isinstance(df.loc[0, "materialize_error"], str) + + +# --- materialize: mixed batch --- + + +def test_materialize_mixed_strategies(tmp_path: Path) -> None: + direct_bytes = b"direct-img" + direct_path = tmp_path / "direct.jpg" + direct_path.write_bytes(direct_bytes) + + tar_bytes = b"tar-img" + tar_path = _make_tar(tmp_path, {"member.jpg": tar_bytes}) + + range_bytes = b"range-img" + range_file = tmp_path / "range.bin" + range_file.write_bytes(b"XX" + range_bytes + b"YY") + + rows = [ + _image_row(path=str(direct_path)), + _image_row(path=tar_path, member="member.jpg"), + _image_row(path=str(range_file), member="range.bin", byte_offset=2, byte_size=len(range_bytes)), + ] + for i, row in enumerate(rows): + row["position"] = i + task = _image_task(rows) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == direct_bytes + assert df.loc[1, "binary_content"] == tar_bytes + assert df.loc[2, "binary_content"] == range_bytes + + +# --- materialize: edge cases --- + + +def test_materialize_empty_task() -> None: + task = MultiBatchTask( + task_id="empty", + dataset_name="d", + data=pa.table({ + "sample_id": pa.array([], type=pa.string()), + "position": pa.array([], type=pa.int32()), + "modality": pa.array([], type=pa.string()), + "content_type": pa.array([], type=pa.string()), + "text_content": pa.array([], type=pa.string()), + "binary_content": pa.array([], type=pa.large_binary()), + "source_ref": pa.array([], type=pa.string()), + "metadata_json": pa.array([], type=pa.string()), + "materialize_error": pa.array([], type=pa.string()), + }), + ) + result = materialize_task_binary_content(task) + assert result.num_items == 0 + + +def test_materialize_no_image_rows() -> None: + table = pa.Table.from_pylist( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + } + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="no_img", dataset_name="d", data=table) + result = materialize_task_binary_content(task) + assert result.num_items == 1 + - cache: dict[tuple[str, str], bytes | None] = {} - assert load_bytes_from_content_reference(str(direct_path), None, {}, cache) == direct_payload - assert load_bytes_from_content_reference(str(tar_path), "x.bin", {}, cache) == tar_payload +def test_materialize_missing_path_sets_error() -> None: + task = _image_task([_image_row(path=None)]) + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert "missing path" in str(df.loc[0, "materialize_error"]) -def test_load_bytes_from_content_reference_caches() -> None: - cache: dict[tuple[str, str], bytes | None] = {("/fake", ""): b"cached"} - assert load_bytes_from_content_reference("/fake", None, {}, cache) == b"cached" +# --- JPEG filter --- def test_jpeg_filter_handles_non_default_dataframe_index() -> None: @@ -200,23 +431,13 @@ def test_split_table_preserves_group_integrity() -> None: def test_basic_row_validity_mask_filters_bad_modality() -> None: - df = pd.DataFrame( - { - "modality": ["text", "image", "video", "metadata"], - "position": [0, 1, 2, -1], - } - ) + df = pd.DataFrame({"modality": ["text", "image", "video", "metadata"], "position": [0, 1, 2, -1]}) mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) assert mask.tolist() == [True, True, False, True] def test_basic_row_validity_mask_enforces_position_rules() -> None: - df = pd.DataFrame( - { - "modality": ["metadata", "metadata", "text", "text"], - "position": [-1, 0, 0, -1], - } - ) + df = pd.DataFrame({"modality": ["metadata", "metadata", "text", "text"], "position": [-1, 0, 0, -1]}) mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) assert mask.tolist() == [True, False, True, False] @@ -225,69 +446,8 @@ def test_basic_row_validity_mask_enforces_position_rules() -> None: def test_webdataset_reader_composite_decompose(tmp_path: Path) -> None: - reader = WebdatasetReader( - file_paths=str(tmp_path), - source_id_field="pdf_name", - ) + reader = WebdatasetReader(file_paths=str(tmp_path), source_id_field="pdf_name") stages = reader.decompose() assert len(stages) == 2 assert stages[0].name == "file_partitioning" assert stages[1].name == "webdataset_reader" - - -# --- materialize_task_binary_content tests --- - - -def test_materialize_empty_task() -> None: - task = MultiBatchTask(task_id="empty", dataset_name="d", data=pa.table({"sample_id": pa.array([], type=pa.string()), "position": pa.array([], type=pa.int32()), "modality": pa.array([], type=pa.string()), "content_type": pa.array([], type=pa.string()), "text_content": pa.array([], type=pa.string()), "binary_content": pa.array([], type=pa.large_binary()), "source_ref": pa.array([], type=pa.string()), "metadata_json": pa.array([], type=pa.string()), "materialize_error": pa.array([], type=pa.string())})) - result = materialize_task_binary_content(task) - assert result.num_items == 0 - - -def test_materialize_no_image_rows() -> None: - table = pa.Table.from_pylist( - [ - { - "sample_id": "s1", - "position": 0, - "modality": "text", - "content_type": "text/plain", - "text_content": "hello", - "binary_content": None, - "source_ref": None, - "metadata_json": None, - "materialize_error": None, - } - ], - schema=MULTIMODAL_SCHEMA, - ) - task = MultiBatchTask(task_id="no_img", dataset_name="d", data=table) - result = materialize_task_binary_content(task) - assert result.num_items == 1 - - -def test_materialize_fills_binary_from_direct_path(tmp_path: Path) -> None: - image_bytes = b"test-image-content" - img_path = tmp_path / "test.jpg" - img_path.write_bytes(image_bytes) - - table = pa.Table.from_pylist( - [ - { - "sample_id": "s1", - "position": 0, - "modality": "image", - "content_type": "image/jpeg", - "text_content": None, - "binary_content": None, - "source_ref": MultiBatchTask.build_source_ref(path=str(img_path), member=None), - "metadata_json": None, - "materialize_error": None, - } - ], - schema=MULTIMODAL_SCHEMA, - ) - task = MultiBatchTask(task_id="mat", dataset_name="d", data=table) - result = materialize_task_binary_content(task) - df = result.to_pandas() - assert df.loc[0, "binary_content"] == image_bytes From 9d5c5eec4f4537fcc32a2ba3b4b70f91da17450b Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 05:54:43 +0000 Subject: [PATCH 36/62] Add RESERVED_COLUMNS, REQUIRED_COLUMNS, and module docstring to MultiBatchTask - Add RESERVED_COLUMNS frozenset derived from MULTIMODAL_SCHEMA as single source of truth for pipeline-managed column names - Add REQUIRED_COLUMNS class attribute derived from non-nullable schema fields - Add module docstring with full reserved vs user column reference table - Reader _build_passthrough_row now uses RESERVED_COLUMNS instead of re-listing all 9 column names - Reorganize MultiBatchTask with section comments and method docstrings - Update README with reserved/user column distinction and passthrough example Made-with: Cursor Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/README.md | 148 ++++++++++++++++++ .../multimodal/io/readers/webdataset.py | 13 +- nemo_curator/tasks/multimodal.py | 74 ++++++--- 3 files changed, 200 insertions(+), 35 deletions(-) create mode 100644 nemo_curator/stages/multimodal/README.md diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md new file mode 100644 index 0000000000..d6a5addf3a --- /dev/null +++ b/nemo_curator/stages/multimodal/README.md @@ -0,0 +1,148 @@ +# Multimodal Pipeline + +Row-wise multimodal ingestion and write path for WebDataset tar shards (MINT-1T style), with materialization support for local, remote, and tar-archived binary content. + +## Architecture + +``` +WebDataset tar shards + | + v +┌─────────────────────────┐ +│ WebdatasetReader │ CompositeStage: FilePartitioning + WebdatasetReaderStage +│ (io/reader.py) │ Parses tar members -> normalized multimodal rows +└────────┬────────────────┘ + | MultiBatchTask (Arrow/Pandas) + v +┌─────────────────────────┐ +│ Filter Stages │ e.g. MultimodalJpegAspectRatioFilterStage +│ (stages.py) │ Row-wise filtering with optional materialization +└────────┬────────────────┘ + | + v +┌─────────────────────────┐ +│ MultimodalParquetWriter│ Parquet output with optional materialize-on-write +│ (io/writers/tabular.py)│ Supports snappy/zstd compression, configurable row groups +└─────────────────────────┘ +``` + +## Schema (`MULTIMODAL_SCHEMA`) + +Defined in `nemo_curator/tasks/multimodal.py`. Columns are split into **reserved** (managed by the pipeline) and **user** (passthrough from source data). + +### Reserved columns (`RESERVED_COLUMNS`) + +These are set and managed by pipeline stages. Users should not write to them directly. + +| Column | Type | Category | Description | +|--------|------|----------|-------------| +| `sample_id` | string (required) | Identity | Unique document/sample identifier | +| `position` | int32 (required) | Identity | Position within sample (-1 for metadata rows) | +| `modality` | string (required) | Identity | One of: `text`, `image`, `metadata` | +| `content_type` | string | Content | MIME type (e.g. `text/plain`, `image/jpeg`) | +| `text_content` | string | Content | Text payload for text rows | +| `binary_content` | large_binary | Content | Image bytes (populated by materialization) | +| `source_ref` | string | Internal | JSON locator: `{path, member, byte_offset, byte_size}` | +| `metadata_json` | string | Internal | Full JSON payload for metadata rows | +| `materialize_error` | string | Internal | Error message if materialization failed | + +### User columns (passthrough) + +Extra fields from the source data flow through the pipeline as additional columns. Specify them with the `fields` parameter on the reader: + +```python +reader = WebdatasetReader( + source_id_field="pdf_name", + file_paths="/data/shards/", + fields=("p_hash", "score", "aux"), # These become extra columns +) +``` + +If `fields` is `None` (default), all non-reserved fields from the source JSON are passed through. If specified explicitly, only the listed fields are included -- and the reader validates they exist and don't collide with reserved names. + +## Key Concepts + +### MultiBatchTask + +The task type for multimodal data (`nemo_curator/tasks/multimodal.py`). Wraps either a PyArrow Table or Pandas DataFrame. + +Class attributes: +- `REQUIRED_COLUMNS` -- frozenset of columns that must always be present (non-nullable schema fields) + +Key methods: +- `build_source_ref(path, member, byte_offset, byte_size)` -- build a JSON locator string +- `parse_source_ref(value)` -- parse back with soft migration for older formats +- `with_parsed_source_ref_columns(prefix)` -- expand source_ref into DataFrame columns +- `to_pyarrow()` / `to_pandas()` -- conversion between formats + +### source_ref + +A JSON string embedded in each row that tracks where the original content lives: + +```json +{ + "path": "/data/shard-00000.tar", + "member": "abc123.jpg", + "byte_offset": 1024, + "byte_size": 45678 +} +``` + +- `path` + `member` -- tar archive path and member name +- `path` alone (no member) -- direct file path +- `byte_offset` + `byte_size` -- enables range reads without opening the tar + +### Materialization + +Binary content (images) can be loaded lazily. Three I/O strategies dispatch automatically based on `source_ref` content (`utils/materialization.py`): + +| Strategy | When | How | +|----------|------|-----| +| **Range read** | `byte_offset` + `byte_size` present | `fs.cat_ranges()` -- batched HTTP range requests per path | +| **Tar extract** | `member` present, no byte range | Open tar once, `extractfile()` per member | +| **Direct read** | No `member` | Read entire file via `fsspec.open()` | + +Materialization can happen at read time (`materialize_on_read=True`) or write time (`materialize_on_write=True`). + +## Usage + +```python +from nemo_curator.pipeline import Pipeline +from nemo_curator.stages.multimodal.io import WebdatasetReader, MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage + +pipeline = Pipeline(name="mint1t_pipeline") +pipeline.add_stage(WebdatasetReader( + source_id_field="pdf_name", + file_paths="/data/mint1t/shards/", +)) +pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) +pipeline.add_stage(MultimodalParquetWriterStage( + path="/output/parquet/", + materialize_on_write=True, + mode="overwrite", +)) +pipeline.run() +``` + +## File Layout + +``` +stages/multimodal/ +├── __init__.py # Exports filter/annotator stages +├── stages.py # BaseMultimodalAnnotatorStage, BaseMultimodalFilterStage, +│ # MultimodalJpegAspectRatioFilterStage +├── io/ +│ ├── __init__.py # Exports WebdatasetReader, MultimodalParquetWriterStage +│ ├── reader.py # WebdatasetReader (CompositeStage) +│ ├── readers/ +│ │ ├── base.py # BaseMultimodalReader +│ │ └── webdataset.py # WebdatasetReaderStage (ProcessingStage) +│ └── writers/ +│ ├── base.py # BaseMultimodalWriter +│ └── tabular.py # BaseMultimodalTabularWriter, MultimodalParquetWriterStage +└── utils/ + ├── constants.py # Default file extensions + ├── materialization.py # Three-strategy materialization dispatch + └── validation_utils.py # Field validation, storage options resolution +``` diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index f8a799858d..2c0c1fd0c0 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -33,7 +33,7 @@ validate_and_project_source_fields, ) from nemo_curator.tasks import FileGroupTask, MultiBatchTask -from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA, RESERVED_COLUMNS from .base import BaseMultimodalReader @@ -168,21 +168,12 @@ def _empty_output_schema(self) -> pa.Schema: return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: - excluded = { + excluded = RESERVED_COLUMNS | { self.source_id_field, *([self.sample_id_field] if self.sample_id_field else []), self.texts_field, self.images_field, *([self.image_member_field] if self.image_member_field else []), - "sample_id", - "position", - "modality", - "content_type", - "text_content", - "binary_content", - "source_ref", - "metadata_json", - "materialize_error", } return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index 4a24506ab5..de90dce005 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -12,6 +12,30 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Multimodal task type and schema for row-wise multimodal records. + +Schema columns fall into two categories: + +**Reserved columns** (``RESERVED_COLUMNS``) -- managed by pipeline stages: + + ================== ============= =========== =============================================== + Column Type Category Description + ================== ============= =========== =============================================== + ``sample_id`` string (req) Identity Unique document/sample identifier + ``position`` int32 (req) Identity Position within sample (-1 for metadata rows) + ``modality`` string (req) Identity One of: ``text``, ``image``, ``metadata`` + ``content_type`` string Content MIME type (e.g. ``text/plain``, ``image/jpeg``) + ``text_content`` string Content Text payload for text rows + ``binary_content`` large_binary Content Image bytes (populated by materialization) + ``source_ref`` string Internal JSON locator: path, member, byte_offset, byte_size + ``metadata_json`` string Internal Full JSON payload for metadata rows + ``materialize_error`` string Internal Error message if materialization failed + ================== ============= =========== =============================================== + +**User columns** (passthrough) -- extra fields from source data added via the +``fields`` parameter on the reader. These flow through the pipeline untouched. +""" + import json from dataclasses import dataclass, field @@ -35,13 +59,24 @@ ] ) +RESERVED_COLUMNS: frozenset[str] = frozenset(MULTIMODAL_SCHEMA.names) + @dataclass class MultiBatchTask(Task[pa.Table | pd.DataFrame]): - """Task carrying row-wise multimodal records.""" + """Task carrying row-wise multimodal records. + + See module docstring for the full schema reference (reserved vs user columns). + """ + + REQUIRED_COLUMNS: frozenset[str] = frozenset( + name for name, f in zip(MULTIMODAL_SCHEMA.names, MULTIMODAL_SCHEMA, strict=True) if not f.nullable + ) data: pa.Table | pd.DataFrame = field(default_factory=lambda: pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA)) + # -- conversion -- + def to_pyarrow(self) -> pa.Table: if isinstance(self.data, pa.Table): return self.data @@ -54,11 +89,12 @@ def to_pandas(self) -> pd.DataFrame: if isinstance(self.data, pd.DataFrame): return self.data if isinstance(self.data, pa.Table): - # Strict mode: preserve Arrow-backed nullable/native types in pandas. return self.data.to_pandas(types_mapper=pd.ArrowDtype) msg = f"Cannot convert {type(self.data)} to Pandas DataFrame" raise TypeError(msg) + # -- introspection -- + @property def num_items(self) -> int: return len(self.data) @@ -75,14 +111,15 @@ def validate(self) -> bool: if self.num_items <= 0: logger.warning(f"Task {self.task_id} has no items") return False - required = {"sample_id", "position", "modality"} columns = set(self.get_columns()) - missing = sorted(required - columns) + missing = sorted(self.REQUIRED_COLUMNS - columns) if missing: logger.warning(f"Task {self.task_id} missing required columns: {missing}") return False return True + # -- source_ref helpers -- + @staticmethod def build_source_ref( path: str | None, @@ -90,32 +127,25 @@ def build_source_ref( byte_offset: int | None = None, byte_size: int | None = None, ) -> str: + """Build a ``source_ref`` JSON locator string.""" return json.dumps( - { - "path": path, - "member": member, - "byte_offset": byte_offset, - "byte_size": byte_size, - }, + {"path": path, "member": member, "byte_offset": byte_offset, "byte_size": byte_size}, ensure_ascii=True, ) @staticmethod def parse_source_ref(source_value: str | None) -> dict[str, str | int | None]: - """Parse one source_ref JSON string into a locator dict.""" + """Parse a ``source_ref`` JSON string into a locator dict. + + Supports soft migration from older ``content_path``/``content_key`` payloads. + """ if source_value is None or pd.isna(source_value) or source_value == "": - return { - "path": None, - "member": None, - "byte_offset": None, - "byte_size": None, - } + return {"path": None, "member": None, "byte_offset": None, "byte_size": None} parsed = json.loads(source_value) if not isinstance(parsed, dict): msg = "source_ref must decode to a JSON object" raise TypeError(msg) - # Soft migration for older locator payloads. path = parsed.get("path", parsed.get("content_path")) member = parsed.get("member", parsed.get("content_key")) byte_offset = parsed.get("byte_offset") @@ -129,13 +159,9 @@ def parse_source_ref(source_value: str | None) -> dict[str, str | int | None]: } def with_parsed_source_ref_columns(self, prefix: str = "_src_") -> pd.DataFrame: - """Return a pandas view with parsed source_ref columns added. + """Return a DataFrame copy with parsed ``source_ref`` columns added. - Added columns: - - {prefix}path - - {prefix}member - - {prefix}byte_offset - - {prefix}byte_size + Columns: ``{prefix}path``, ``{prefix}member``, ``{prefix}byte_offset``, ``{prefix}byte_size``. """ df = self.to_pandas().copy() parsed = [self.parse_source_ref(value) for value in df["source_ref"].tolist()] From 16e4f9dab466a37c34adcd71204d3685e33cbf92 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 05:55:15 +0000 Subject: [PATCH 37/62] Remove AGENTS.md from tracking and add to .gitignore Made-with: Cursor Signed-off-by: Vibhu Jawa --- .gitignore | 1 + AGENTS.md | 30 ------------------------------ 2 files changed, 1 insertion(+), 30 deletions(-) delete mode 100644 AGENTS.md diff --git a/.gitignore b/.gitignore index 19f033f2ba..26eeb25629 100644 --- a/.gitignore +++ b/.gitignore @@ -155,3 +155,4 @@ data/ # macOS Files .DS_Store +AGENTS.md diff --git a/AGENTS.md b/AGENTS.md deleted file mode 100644 index 358eb48eee..0000000000 --- a/AGENTS.md +++ /dev/null @@ -1,30 +0,0 @@ -# Agent Preferences - -## Environment Setup Before Python -- Always run: `source /home/nfs/vjawa/.bashrc` -- Then run: `cd /raid/vjawa/NeMo-Curator && source .venv/bin/activate` - -## Running Tests -- Multimodal tests: `python -m pytest tests/stages/multimodal/ -v` -- Full test suite: `python -m pytest tests/ -q` -- Lint check: `python -m ruff check nemo_curator/ tests/` - -## Benchmarking -- Single shard smoke test (no materialization): - ``` - python benchmarking/scripts/multimodal_mint1t_benchmark.py \ - --benchmark-results-path .tmp_multimodal_runs/run_name \ - --input-path /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar \ - --output-path .tmp_multimodal_runs/run_name/output \ - --no-materialize-on-write --no-materialize-on-read --mode overwrite - ``` -- Full 10GB (90 shards): use `--input-path /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` - -## Code Style -- NEVER add `# noqa:` comments to suppress lint warnings. Fix the underlying issue instead (refactor the code, reduce arguments, etc.). - -## Available Datasets -- Single shard (79MB): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar` -- 10GB MINT1T (90 tar shards): `/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/` -- 20GB interleaved sample (17 tars): `/raid/vjawa/mint_interleaved_100mb_sample/webdataset/` -- 173GB parquet subset (997 files): `/datasets/vjawa/nvmint_mint1t_parquet_1k_subset/` From 002449cb0ef59497cebaa241d342c24862dabd8d Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 06:06:28 +0000 Subject: [PATCH 38/62] Collapse writer hierarchy and introduce _SampleContext in reader Writer: - Merge BaseMultimodalTabularWriter into BaseMultimodalWriter (3 layers -> 2) - materialize_on_write, _materialize_dataframe(), and write_data() template now live in the base; subclasses only implement _write_dataframe() - MultimodalParquetWriterStage inherits BaseMultimodalWriter directly - Remove BaseMultimodalTabularWriter from exports Reader: - Add _SampleContext dataclass bundling per-sample state (sample_id, sample, tar_path, json_member_name, member_names, member_info, passthrough) - _metadata_row, _text_rows, _image_rows each take (self, ctx) instead of 6 separate positional args -- cleaner for subclassing - _build_row is now a @staticmethod taking (ctx, row_fields dict) - _build_source_ref takes (self, ctx, content_key) instead of 4 params Made-with: Cursor Signed-off-by: Vibhu Jawa --- nemo_curator/stages/multimodal/README.md | 4 +- .../multimodal/io/readers/webdataset.py | 239 ++++++++++-------- .../stages/multimodal/io/writers/__init__.py | 7 +- .../stages/multimodal/io/writers/base.py | 50 +++- .../stages/multimodal/io/writers/tabular.py | 53 +--- 5 files changed, 181 insertions(+), 172 deletions(-) diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index d6a5addf3a..56e96e5e0b 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -139,8 +139,8 @@ stages/multimodal/ │ │ ├── base.py # BaseMultimodalReader │ │ └── webdataset.py # WebdatasetReaderStage (ProcessingStage) │ └── writers/ -│ ├── base.py # BaseMultimodalWriter -│ └── tabular.py # BaseMultimodalTabularWriter, MultimodalParquetWriterStage +│ ├── base.py # BaseMultimodalWriter (filesystem + materialization + process) +│ └── tabular.py # MultimodalParquetWriterStage └── utils/ ├── constants.py # Default file extensions ├── materialization.py # Three-strategy materialization dispatch diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 2c0c1fd0c0..94ec404ecd 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -40,6 +40,8 @@ @dataclass class _ReadContext: + """Per-tar state shared across all members in a single tar archive.""" + tar_path: str member_names: set[str] member_info: dict[str, tarfile.TarInfo] @@ -47,6 +49,19 @@ class _ReadContext: byte_cache: dict[str, bytes | None] +@dataclass +class _SampleContext: + """Per-sample state passed to row builder methods.""" + + sample_id: str + sample: dict[str, Any] + tar_path: str + json_member_name: str + member_names: set[str] + member_info: dict[str, tarfile.TarInfo] | None + passthrough: dict[str, Any] + + @dataclass class WebdatasetReaderStage(BaseMultimodalReader): """Read MINT1T-style WebDataset shards into a row-wise multimodal task.""" @@ -66,106 +81,100 @@ class WebdatasetReaderStage(BaseMultimodalReader): def __post_init__(self) -> None: self.source_id_field = require_source_id_field(self.source_id_field) - def _rows_from_sample( - self, - sample_id: str, - sample: dict[str, Any], - source: dict[str, str], - member_names: set[str], - member_info: dict[str, tarfile.TarInfo] | None = None, - ) -> list[dict[str, Any]]: - rows: list[dict[str, Any]] = [] - images = sample.get(self.images_field) - image_member_name = self._resolve_default_image_member_name(sample_id, sample, images, member_names) - tar_path = source["tar_path"] - json_member_name = source["json_member_name"] - passthrough_row = self._build_passthrough_row(sample) - - def build_source_ref(content_key: str | None) -> str: - byte_offset = None - byte_size = None - if content_key and member_info and content_key in member_info: - info = member_info[content_key] - byte_offset = info.offset_data - byte_size = info.size - return MultiBatchTask.build_source_ref( - path=tar_path, - member=content_key, - byte_offset=byte_offset, - byte_size=byte_size, - ) + # -- source_ref construction -- - def append_row(row: dict[str, Any]) -> None: - rows.append( - { - "sample_id": sample_id, - "position": row["position"], - "modality": row["modality"], - "content_type": row.get("content_type"), - "text_content": row.get("text_content"), - "binary_content": row.get("binary_content"), - "source_ref": row.get("source_ref"), - "metadata_json": row.get("metadata_json"), - "materialize_error": None, - **passthrough_row, - } - ) + def _build_source_ref(self, ctx: _SampleContext, content_key: str | None) -> str: + byte_offset = None + byte_size = None + if content_key and ctx.member_info and content_key in ctx.member_info: + info = ctx.member_info[content_key] + byte_offset = info.offset_data + byte_size = info.size + return MultiBatchTask.build_source_ref( + path=ctx.tar_path, member=content_key, byte_offset=byte_offset, byte_size=byte_size, + ) + + # -- row builders (override in subclasses for custom formats) -- + + @staticmethod + def _build_row(ctx: _SampleContext, row_fields: dict[str, Any]) -> dict[str, Any]: + return { + "sample_id": ctx.sample_id, + "position": row_fields.get("position"), + "modality": row_fields.get("modality"), + "content_type": row_fields.get("content_type"), + "text_content": row_fields.get("text_content"), + "binary_content": row_fields.get("binary_content"), + "source_ref": row_fields.get("source_ref"), + "metadata_json": row_fields.get("metadata_json"), + "materialize_error": None, + **ctx.passthrough, + } - append_row( - { - "position": -1, - "modality": "metadata", - "content_type": "application/json", - "source_ref": build_source_ref(json_member_name), - "metadata_json": json.dumps( - { - **sample, - "_sample_source": { - "source_shard": Path(tar_path).name, - "tar_path": tar_path, - "json_member_name": json_member_name, - }, + def _metadata_row(self, ctx: _SampleContext) -> dict[str, Any]: + return self._build_row(ctx, { + "position": -1, + "modality": "metadata", + "content_type": "application/json", + "source_ref": self._build_source_ref(ctx, ctx.json_member_name), + "metadata_json": json.dumps( + { + **ctx.sample, + "_sample_source": { + "source_shard": Path(ctx.tar_path).name, + "tar_path": ctx.tar_path, + "json_member_name": ctx.json_member_name, }, - ensure_ascii=True, - ), - } - ) + }, + ensure_ascii=True, + ), + }) - texts = sample.get(self.texts_field) - if isinstance(texts, list): - for idx, text_value in enumerate(texts): - append_row( - { - "position": idx, - "modality": "text", - "content_type": "text/plain", - "text_content": text_value if isinstance(text_value, str) else None, - "source_ref": build_source_ref(json_member_name), - } - ) + def _text_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: + texts = ctx.sample.get(self.texts_field) + if not isinstance(texts, list): + return [] + source_ref = self._build_source_ref(ctx, ctx.json_member_name) + return [ + self._build_row(ctx, { + "position": idx, + "modality": "text", + "content_type": "text/plain", + "text_content": text_value if isinstance(text_value, str) else None, + "source_ref": source_ref, + }) + for idx, text_value in enumerate(texts) + ] - if isinstance(images, list): - for idx, image_token in enumerate(images): - content_key = self._resolve_image_content_key(image_token, image_member_name, member_names) - content_type, _ = mimetypes.guess_type(content_key or image_member_name or "") - append_row( - { - "position": idx, - "modality": "image", - "content_type": content_type or ("application/octet-stream" if image_member_name else None), - "source_ref": build_source_ref(content_key), - } - ) + def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: + images = ctx.sample.get(self.images_field) + if not isinstance(images, list): + return [] + image_member_name = self._resolve_default_image_member_name( + ctx.sample_id, ctx.sample, images, ctx.member_names, + ) + rows: list[dict[str, Any]] = [] + for idx, image_token in enumerate(images): + content_key = self._resolve_image_content_key(image_token, image_member_name, ctx.member_names) + content_type, _ = mimetypes.guess_type(content_key or image_member_name or "") + rows.append(self._build_row(ctx, { + "position": idx, + "modality": "image", + "content_type": content_type or ("application/octet-stream" if image_member_name else None), + "source_ref": self._build_source_ref(ctx, content_key), + })) + return rows + # -- sample-level orchestration -- + + def _rows_from_sample(self, ctx: _SampleContext) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + rows.append(self._metadata_row(ctx)) + rows.extend(self._text_rows(ctx)) + rows.extend(self._image_rows(ctx)) return rows - def _empty_output_schema(self) -> pa.Schema: - schema = MULTIMODAL_SCHEMA - if not self.fields: - return schema - existing = set(schema.names) - passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] - return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema + # -- passthrough / schema helpers -- def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: excluded = RESERVED_COLUMNS | { @@ -177,6 +186,16 @@ def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: } return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) + def _empty_output_schema(self) -> pa.Schema: + schema = MULTIMODAL_SCHEMA + if not self.fields: + return schema + existing = set(schema.names) + passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] + return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema + + # -- image member resolution -- + def _resolve_default_image_member_name( self, sample_id: str, @@ -208,6 +227,8 @@ def _resolve_image_content_key( return image_token return default_image_member_name + # -- tar member extraction -- + @staticmethod def _extract_tar_member(tf: tarfile.TarFile, member_name: str, cache: dict[str, bytes | None]) -> bytes | None: if member_name in cache: @@ -220,11 +241,13 @@ def _extract_tar_member(tf: tarfile.TarFile, member_name: str, cache: dict[str, cache[member_name] = payload return payload + # -- per-member processing -- + def _rows_from_member( self, tf: tarfile.TarFile, member: tarfile.TarInfo, - context: _ReadContext, + read_ctx: _ReadContext, ) -> list[dict[str, Any]]: extracted = tf.extractfile(member) if extracted is None: @@ -235,18 +258,16 @@ def _rows_from_member( if self.sample_id_field and payload.get(self.sample_id_field) is not None else Path(member.name).stem ) - source = { - "source_shard": Path(context.tar_path).name, - "tar_path": context.tar_path, - "json_member_name": member.name, - } - sample_rows = self._rows_from_sample( + ctx = _SampleContext( sample_id=sample_id, sample=payload, - source=source, - member_names=context.member_names, - member_info=context.member_info, + tar_path=read_ctx.tar_path, + json_member_name=member.name, + member_names=read_ctx.member_names, + member_info=read_ctx.member_info, + passthrough=self._build_passthrough_row(payload), ) + sample_rows = self._rows_from_sample(ctx) if self.materialize_on_read: for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: @@ -254,9 +275,11 @@ def _rows_from_member( parsed_ref = MultiBatchTask.parse_source_ref(row["source_ref"]) content_key = parsed_ref.get("member") if content_key: - row["binary_content"] = self._extract_tar_member(tf, content_key, context.byte_cache) + row["binary_content"] = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) return sample_rows + # -- main entry point -- + def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: rows: list[dict[str, Any]] = [] storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) @@ -268,7 +291,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: ): members = [m for m in tf.getmembers() if m.isfile()] member_names = {m.name for m in members} - context = _ReadContext( + read_ctx = _ReadContext( tar_path=tar_path, member_names=member_names, member_info={m.name: m for m in members}, @@ -278,13 +301,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: for member in members: if not member.name.endswith(self.json_extensions): continue - rows.extend( - self._rows_from_member( - tf=tf, - member=member, - context=context, - ) - ) + rows.extend(self._rows_from_member(tf=tf, member=member, read_ctx=read_ctx)) table = pa.Table.from_pylist(rows) if rows else pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py index b8fe30bc11..88b47f60c2 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -12,9 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.writers.tabular import ( - BaseMultimodalTabularWriter, - MultimodalParquetWriterStage, -) +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage -__all__ = ["BaseMultimodalTabularWriter", "MultimodalParquetWriterStage"] +__all__ = ["MultimodalParquetWriterStage"] diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/multimodal/io/writers/base.py index 3b145a9072..a2c4d8b2e4 100644 --- a/nemo_curator/stages/multimodal/io/writers/base.py +++ b/nemo_curator/stages/multimodal/io/writers/base.py @@ -12,33 +12,45 @@ # See the License for the specific language governing permissions and # limitations under the License. +from __future__ import annotations + import uuid from abc import ABC, abstractmethod from dataclasses import dataclass, field -from typing import Any, Literal +from typing import TYPE_CHECKING, Any, Literal from fsspec.core import url_to_fs from loguru import logger import nemo_curator.stages.text.io.writer.utils as writer_utils from nemo_curator.stages.base import ProcessingStage +from nemo_curator.stages.multimodal.utils import materialize_task_binary_content from nemo_curator.tasks import FileGroupTask, MultiBatchTask from nemo_curator.utils.client_utils import is_remote_url from nemo_curator.utils.file_utils import check_output_mode +if TYPE_CHECKING: + import pandas as pd + @dataclass class BaseMultimodalWriter(ProcessingStage[MultiBatchTask, FileGroupTask], ABC): - """Base class for multimodal writers.""" + """Base class for multimodal writers. + + Handles filesystem setup, deterministic file naming, optional binary + materialization, and process() orchestration. Subclasses implement + ``_write_dataframe`` for format-specific output. + """ path: str file_extension: str write_kwargs: dict[str, Any] = field(default_factory=dict) + materialize_on_write: bool = True name: str = "base_multimodal_writer" mode: Literal["ignore", "overwrite", "append", "error"] = "ignore" append_mode_implemented: bool = False - def __post_init__(self): + def __post_init__(self) -> None: self.storage_options = (self.write_kwargs or {}).get("storage_options", {}) self.fs, self._fs_path = url_to_fs(self.path, **self.storage_options) check_output_mode(self.mode, self.fs, self._fs_path, append_mode_implemented=self.append_mode_implemented) @@ -49,9 +61,39 @@ def inputs(self) -> tuple[list[str], list[str]]: def outputs(self) -> tuple[list[str], list[str]]: return ["data"], [] + # -- materialization -- + + def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: + out = task.to_pandas() + image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) + self._log_metrics( + { + "rows_out": float(len(out)), + "image_rows": float((out["modality"] == "image").sum()), + "image_rows_missing_binary": float(image_mask.sum()), + } + ) + if not self.materialize_on_write or not image_mask.any(): + return out + + with self._time_metric("materialize_fetch_binary_s"): + out = materialize_task_binary_content(task, io_kwargs=self.write_kwargs).to_pandas() + if "materialize_error" in out.columns: + self._log_metric("materialize_errors", float(out["materialize_error"].notna().sum())) + return out + + # -- write pipeline -- + @abstractmethod + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + """Format-specific DataFrame writer. Subclasses implement this.""" + def write_data(self, task: MultiBatchTask, file_path: str) -> None: - """Format-specific write implementation.""" + with self._time_metric("materialize_dataframe_total_s"): + df = self._materialize_dataframe(task) + write_kwargs: dict[str, Any] = {"index": False} + write_kwargs.update(self.write_kwargs) + self._write_dataframe(df, file_path, write_kwargs) def process(self, task: MultiBatchTask) -> FileGroupTask: if source_files := task._metadata.get("source_files"): diff --git a/nemo_curator/stages/multimodal/io/writers/tabular.py b/nemo_curator/stages/multimodal/io/writers/tabular.py index bf7ad3fabf..48d44c0baa 100644 --- a/nemo_curator/stages/multimodal/io/writers/tabular.py +++ b/nemo_curator/stages/multimodal/io/writers/tabular.py @@ -14,70 +14,23 @@ from __future__ import annotations -from abc import ABC, abstractmethod -from dataclasses import dataclass, field +from dataclasses import dataclass from typing import TYPE_CHECKING, Any -from nemo_curator.stages.multimodal.utils import materialize_task_binary_content - from .base import BaseMultimodalWriter if TYPE_CHECKING: import pandas as pd - from nemo_curator.tasks import MultiBatchTask - - -@dataclass -class BaseMultimodalTabularWriter(BaseMultimodalWriter, ABC): - """Shared multimodal tabular writer with optional image materialization.""" - - write_kwargs: dict[str, Any] = field(default_factory=dict) - materialize_on_write: bool = True - name: str = "base_multimodal_tabular_writer" - - def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: - out = task.to_pandas() - image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) - self._log_metrics( - { - "rows_out": float(len(out)), - "image_rows": float((out["modality"] == "image").sum()), - "image_rows_missing_binary": float(image_mask.sum()), - } - ) - if not self.materialize_on_write or not image_mask.any(): - return out - - with self._time_metric("materialize_fetch_binary_s"): - out = materialize_task_binary_content(task, io_kwargs=self.write_kwargs).to_pandas() - if "materialize_error" in out.columns: - self._log_metric("materialize_errors", float(out["materialize_error"].notna().sum())) - return out - - @abstractmethod - def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: - """Format-specific writer implementation.""" - - def write_data(self, task: MultiBatchTask, file_path: str) -> None: - with self._time_metric("materialize_dataframe_total_s"): - df = self._materialize_dataframe(task) - write_kwargs = {"index": False} - write_kwargs.update(self.write_kwargs) - self._write_dataframe(df, file_path, write_kwargs) - @dataclass -class MultimodalParquetWriterStage(BaseMultimodalTabularWriter): - """Thin parquet writer on top of the tabular multimodal base.""" +class MultimodalParquetWriterStage(BaseMultimodalWriter): + """Write multimodal rows to Parquet with optional binary materialization.""" file_extension: str = "parquet" name: str = "multimodal_parquet_writer" def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: - # Empirically best default from current benchmark sweep. - # Note: row_group_size is in rows; 128_000 rows is a typical Parquet best-practice default. - # Callers can override this via write_kwargs["row_group_size"] if needed. write_kwargs.setdefault("compression", "snappy") write_kwargs.setdefault("row_group_size", 128_000) with self._time_metric("parquet_write_s"): From 44c7ccad667f30d3090667d4a315e0214d582f64 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 08:37:00 +0000 Subject: [PATCH 39/62] Fix memory explosion and data duplication in multimodal materialization - Deduplicate range reads in _fill_range_read_rows: multiple rows referencing the same byte range now share a single fs.cat_ranges() call (14x I/O reduction for MINT-1T TIFF data) - Extract individual frames from multi-frame TIFFs during materialization (frame_index in source_ref), eliminating 17x data duplication in parquet output (45GB -> 865MB for 5 shards) - Fix _resolve_image_content_key: None tokens produce empty source_ref (no materialization), non-matching strings fall back to default member with frame_index for TIFF content types - Fix _build_source_ref: content_key=None emits path=None to prevent reading entire tar file as raw bytes via direct_read path - Reconcile table schema for non-empty tables (canonical types for reserved columns, inferred types for passthrough) - Optimize collect_parquet_output_metrics: use pq.ParquetFile metadata for row counts and selective column reads instead of pd.read_parquet - Remove dead content_path/content_key soft-migration from parse_source_ref (net-new feature, no legacy data) - Clear byte_cache per sample in reader to bound memory during materialize_on_read Made-with: Cursor Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../scripts/multimodal_mint1t_benchmark.py | 3 + benchmarking/scripts/utils.py | 26 ++-- .../multimodal/io/readers/webdataset.py | 38 +++++- .../multimodal/utils/materialization.py | 120 ++++++++++++++---- nemo_curator/tasks/multimodal.py | 29 +++-- .../stages/multimodal/test_multimodal_core.py | 33 ++++- .../multimodal/test_multimodal_reader.py | 31 +++++ 7 files changed, 222 insertions(+), 58 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 56d6f31076..79388e3d87 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -83,7 +83,10 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: logger.debug(traceback.format_exc()) elapsed = time.perf_counter() - start + metrics_start = time.perf_counter() output_metrics = collect_parquet_output_metrics(output_path) + metrics_elapsed = time.perf_counter() - metrics_start + logger.info("collect_parquet_output_metrics took {:.3f}s", metrics_elapsed) task_metrics = TaskPerfUtils.aggregate_task_metrics(output_tasks, prefix="task") writer_stats = {k: v for k, v in task_metrics.items() if "multimodal_" in k and "_writer" in k} logger.info("Writer stage stats: {}", writer_stats) diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index 0ef5aead25..dccbbdc175 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -17,7 +17,7 @@ from pathlib import Path from typing import Any -import pandas as pd +import pyarrow.parquet as pq from nemo_curator.backends.experimental.ray_actor_pool.executor import RayActorPoolExecutor from nemo_curator.backends.experimental.ray_data import RayDataExecutor @@ -110,15 +110,21 @@ def collect_parquet_output_metrics(output_path: Path) -> dict[str, Any]: modality_counts: dict[str, int] = {} materialize_error_count = 0 for path in parquet_files: - df = pd.read_parquet(path) - num_rows += len(df) - if "modality" in df.columns: - vc = df["modality"].value_counts(dropna=False).to_dict() - for k, v in vc.items(): - key = str(k) - modality_counts[key] = modality_counts.get(key, 0) + int(v) - if "materialize_error" in df.columns: - materialize_error_count += int(df["materialize_error"].notna().sum()) + pf = pq.ParquetFile(path) + num_rows += pf.metadata.num_rows + schema_names = set(pf.schema_arrow.names) + cols = [c for c in ("modality", "materialize_error") if c in schema_names] + if not cols: + continue + table = pq.read_table(path, columns=cols) + if "modality" in table.column_names: + counts = table.column("modality").value_counts() + for row in counts.to_pylist(): + key = str(row["values"]) if row["values"] is not None else "None" + modality_counts[key] = modality_counts.get(key, 0) + int(row["counts"]) + if "materialize_error" in table.column_names: + col = table.column("materialize_error") + materialize_error_count += col.length() - col.null_count return { "num_output_files": num_files, "output_total_bytes": total_size_bytes, diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 94ec404ecd..be7d053d6c 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -83,15 +83,20 @@ def __post_init__(self) -> None: # -- source_ref construction -- - def _build_source_ref(self, ctx: _SampleContext, content_key: str | None) -> str: + def _build_source_ref( + self, ctx: _SampleContext, content_key: str | None, *, frame_index: int | None = None, + ) -> str: + if content_key is None: + return MultiBatchTask.build_source_ref(path=None, member=None) byte_offset = None byte_size = None - if content_key and ctx.member_info and content_key in ctx.member_info: + if ctx.member_info and content_key in ctx.member_info: info = ctx.member_info[content_key] byte_offset = info.offset_data byte_size = info.size return MultiBatchTask.build_source_ref( - path=ctx.tar_path, member=content_key, byte_offset=byte_offset, byte_size=byte_size, + path=ctx.tar_path, member=content_key, + byte_offset=byte_offset, byte_size=byte_size, frame_index=frame_index, ) # -- row builders (override in subclasses for custom formats) -- @@ -154,14 +159,20 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: ctx.sample_id, ctx.sample, images, ctx.member_names, ) rows: list[dict[str, Any]] = [] + frame_counter = 0 for idx, image_token in enumerate(images): content_key = self._resolve_image_content_key(image_token, image_member_name, ctx.member_names) content_type, _ = mimetypes.guess_type(content_key or image_member_name or "") + frame_index = None + is_multiframe_candidate = content_type == "image/tiff" + if content_key is not None and image_token is not None and is_multiframe_candidate: + frame_index = frame_counter + frame_counter += 1 rows.append(self._build_row(ctx, { "position": idx, "modality": "image", "content_type": content_type or ("application/octet-stream" if image_member_name else None), - "source_ref": self._build_source_ref(ctx, content_key), + "source_ref": self._build_source_ref(ctx, content_key, frame_index=frame_index), })) return rows @@ -194,6 +205,18 @@ def _empty_output_schema(self) -> pa.Schema: passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema + @staticmethod + def _reconcile_schema(inferred: pa.Schema) -> pa.Schema: + """Build a schema with canonical types for reserved columns and inferred types for passthrough.""" + canonical = {f.name: f for f in MULTIMODAL_SCHEMA} + fields = [] + for f in inferred: + if f.name in canonical: + fields.append(canonical[f.name]) + else: + fields.append(f) + return pa.schema(fields) + # -- image member resolution -- def _resolve_default_image_member_name( @@ -276,6 +299,7 @@ def _rows_from_member( content_key = parsed_ref.get("member") if content_key: row["binary_content"] = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) + read_ctx.byte_cache.clear() return sample_rows # -- main entry point -- @@ -303,7 +327,11 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: continue rows.extend(self._rows_from_member(tf=tf, member=member, read_ctx=read_ctx)) - table = pa.Table.from_pylist(rows) if rows else pa.Table.from_pylist([], schema=self._empty_output_schema()) + if rows: + table = pa.Table.from_pylist(rows) + table = table.cast(self._reconcile_schema(table.schema)) + else: + table = pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) batches: list[MultiBatchTask] = [] for idx, split in enumerate(splits): diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index 5c8557daba..4a16201a59 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -14,6 +14,7 @@ from __future__ import annotations +import io import tarfile from typing import NamedTuple @@ -21,6 +22,7 @@ import pandas as pd from fsspec.core import url_to_fs from loguru import logger +from PIL import Image as _Image from nemo_curator.tasks import MultiBatchTask @@ -30,12 +32,21 @@ class _ClassifiedRows(NamedTuple): - tar_extract: dict[str, list[tuple[int, str]]] - range_read: dict[str, list[tuple[int, str, int, int]]] + tar_extract: dict[str, list[tuple[int, str, int | None]]] + range_read: dict[str, list[tuple[int, str, int, int, int | None]]] direct_read: dict[str, list[int]] missing: list[int] +def _get_frame_index(df: pd.DataFrame, idx: int) -> int | None: + if "_src_frame_index" not in df.columns: + return None + val = df.loc[idx, "_src_frame_index"] + if val is None or (isinstance(val, float) and pd.isna(val)): + return None + return int(val) + + def _classify_rows( df: pd.DataFrame, image_mask: pd.Series, @@ -47,8 +58,8 @@ def _classify_rows( - direct_read: no member (path is the file itself) - missing: path is None/NaN """ - tar_extract: dict[str, list[tuple[int, str]]] = {} - range_read: dict[str, list[tuple[int, str, int, int]]] = {} + tar_extract: dict[str, list[tuple[int, str, int | None]]] = {} + range_read: dict[str, list[tuple[int, str, int, int, int | None]]] = {} direct_read: dict[str, list[int]] = {} missing: list[int] = [] @@ -67,20 +78,41 @@ def _classify_rows( continue member_str = str(raw_member) + frame_idx = _get_frame_index(df, idx) raw_offset = df.loc[idx, "_src_byte_offset"] raw_size = df.loc[idx, "_src_byte_size"] has_range = raw_offset is not None and raw_size is not None and pd.notna(raw_offset) and pd.notna(raw_size) if has_range and int(raw_size) > 0: - range_read.setdefault(path_str, []).append((idx, member_str, int(raw_offset), int(raw_size))) + range_read.setdefault(path_str, []).append((idx, member_str, int(raw_offset), int(raw_size), frame_idx)) else: - tar_extract.setdefault(path_str, []).append((idx, member_str)) + tar_extract.setdefault(path_str, []).append((idx, member_str, frame_idx)) return _ClassifiedRows(tar_extract=tar_extract, range_read=range_read, direct_read=direct_read, missing=missing) +def _extract_tiff_frame(tiff_bytes: bytes, frame_index: int) -> bytes | None: + """Extract a single frame from a multi-frame TIFF, returning it as a single-frame TIFF. + + Returns the raw bytes unchanged if the data is not a TIFF. + """ + try: + with _Image.open(io.BytesIO(tiff_bytes)) as img: + if img.format != "TIFF": + return tiff_bytes + if frame_index >= getattr(img, "n_frames", 1): + return None + img.seek(frame_index) + compression = img.info.get("compression", "tiff_deflate") + buf = io.BytesIO() + img.save(buf, format="TIFF", compression=compression) + return buf.getvalue() + except (OSError, SyntaxError, ValueError): + return None + + def _fill_tar_extract_rows( - groups: dict[str, list[tuple[int, str]]], + groups: dict[str, list[tuple[int, str, int | None]]], storage_options: dict[str, object], binary_values: list[object], error_values: list[str | None], @@ -90,7 +122,7 @@ def _fill_tar_extract_rows( key_cache: dict[str, bytes | None] = {} try: with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: - for idx, member in keyed_rows: + for idx, member, frame_idx in keyed_rows: if member not in key_cache: try: extracted = tf.extractfile(member) @@ -103,20 +135,63 @@ def _fill_tar_extract_rows( error_values[idx] = f"missing member '{member}'" continue + if frame_idx is not None: + payload = _extract_tiff_frame(payload, frame_idx) + if payload is None: + error_values[idx] = f"failed to extract frame {frame_idx} from '{member}'" + continue + binary_values[idx] = payload error_values[idx] = None except (OSError, tarfile.TarError): - for idx, _ in keyed_rows: + for idx, *_ in keyed_rows: error_values[idx] = "failed to read path" +def _resolve_frame( + raw_bytes: bytes, frame_idx: int | None, frame_cache: dict[tuple[int, int | None], bytes | None], +) -> bytes | None: + """Return raw_bytes or an extracted single-frame TIFF if frame_idx is set. Caches results.""" + cache_key = (id(raw_bytes), frame_idx) + if cache_key not in frame_cache: + frame_cache[cache_key] = _extract_tiff_frame(raw_bytes, frame_idx) if frame_idx is not None else raw_bytes + return frame_cache[cache_key] + + +def _scatter_range_blobs( + blobs: list[object], + range_keys: list[tuple[int, int]], + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]], + binary_values: list[object], + error_values: list[str | None], +) -> None: + """Distribute deduplicated range-read results, extracting TIFF frames as needed.""" + frame_cache: dict[tuple[int, int | None], bytes | None] = {} + for key, blob in zip(range_keys, blobs, strict=True): + if isinstance(blob, Exception): + for idx, member, _fi in unique_ranges[key]: + error_values[idx] = f"range read error for member '{member}'" + elif blob is None or len(blob) == 0: + for idx, member, _fi in unique_ranges[key]: + error_values[idx] = f"empty range read for member '{member}'" + else: + raw = bytes(blob) if not isinstance(blob, bytes) else blob + for idx, member, frame_idx in unique_ranges[key]: + payload = _resolve_frame(raw, frame_idx, frame_cache) + if payload is None: + error_values[idx] = f"failed to extract frame {frame_idx} from '{member}'" + else: + binary_values[idx] = payload + error_values[idx] = None + + def _fill_range_read_rows( - groups: dict[str, list[tuple[int, str, int, int]]], + groups: dict[str, list[tuple[int, str, int, int, int | None]]], storage_options: dict[str, object], binary_values: list[object], error_values: list[str | None], ) -> None: - """Batch byte-range reads per path using fs.cat_ranges().""" + """Batch byte-range reads per path using fs.cat_ranges(), deduplicating identical ranges.""" for path, entries in groups.items(): try: fs, fs_path = url_to_fs(path, **storage_options) @@ -125,27 +200,24 @@ def _fill_range_read_rows( error_values[idx] = "failed to resolve filesystem" continue - paths = [fs_path] * len(entries) - starts = [offset for _, _, offset, _ in entries] - ends = [offset + size for _, _, offset, size in entries] + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = {} + for idx, member, offset, size, frame_idx in entries: + unique_ranges.setdefault((offset, size), []).append((idx, member, frame_idx)) + + range_keys = list(unique_ranges.keys()) + dedup_paths = [fs_path] * len(range_keys) + starts = [offset for offset, _ in range_keys] + ends = [offset + size for offset, size in range_keys] try: - blobs = fs.cat_ranges(paths, starts, ends) + blobs = fs.cat_ranges(dedup_paths, starts, ends) except OSError as exc: logger.warning(f"cat_ranges failed for {path} ({len(entries)} ranges): {exc}") for idx, *_ in entries: error_values[idx] = "cat_ranges failed" continue - for (idx, member, _offset, _size), blob in zip(entries, blobs, strict=True): - if isinstance(blob, Exception): - error_values[idx] = f"range read error for member '{member}'" - continue - if blob is None or len(blob) == 0: - error_values[idx] = f"empty range read for member '{member}'" - continue - binary_values[idx] = bytes(blob) if not isinstance(blob, bytes) else blob - error_values[idx] = None + _scatter_range_blobs(blobs, range_keys, unique_ranges, binary_values, error_values) def _fill_direct_read_rows( diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index de90dce005..12c618f9b7 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -126,48 +126,51 @@ def build_source_ref( member: str | None, byte_offset: int | None = None, byte_size: int | None = None, + frame_index: int | None = None, ) -> str: """Build a ``source_ref`` JSON locator string.""" - return json.dumps( - {"path": path, "member": member, "byte_offset": byte_offset, "byte_size": byte_size}, - ensure_ascii=True, - ) + ref: dict[str, object] = { + "path": path, "member": member, "byte_offset": byte_offset, "byte_size": byte_size, + } + if frame_index is not None: + ref["frame_index"] = frame_index + return json.dumps(ref, ensure_ascii=True) @staticmethod def parse_source_ref(source_value: str | None) -> dict[str, str | int | None]: - """Parse a ``source_ref`` JSON string into a locator dict. - - Supports soft migration from older ``content_path``/``content_key`` payloads. - """ + """Parse a ``source_ref`` JSON string into a locator dict.""" if source_value is None or pd.isna(source_value) or source_value == "": - return {"path": None, "member": None, "byte_offset": None, "byte_size": None} + return {"path": None, "member": None, "byte_offset": None, "byte_size": None, "frame_index": None} parsed = json.loads(source_value) if not isinstance(parsed, dict): msg = "source_ref must decode to a JSON object" raise TypeError(msg) - path = parsed.get("path", parsed.get("content_path")) - member = parsed.get("member", parsed.get("content_key")) + path = parsed.get("path") + member = parsed.get("member") byte_offset = parsed.get("byte_offset") byte_size = parsed.get("byte_size") + frame_index = parsed.get("frame_index") return { "path": path if path is None else str(path), "member": member if member is None else str(member), "byte_offset": int(byte_offset) if byte_offset is not None else None, "byte_size": int(byte_size) if byte_size is not None else None, + "frame_index": int(frame_index) if frame_index is not None else None, } def with_parsed_source_ref_columns(self, prefix: str = "_src_") -> pd.DataFrame: """Return a DataFrame copy with parsed ``source_ref`` columns added. - Columns: ``{prefix}path``, ``{prefix}member``, ``{prefix}byte_offset``, ``{prefix}byte_size``. + Columns: ``{prefix}path``, ``{prefix}member``, ``{prefix}byte_offset``, + ``{prefix}byte_size``, ``{prefix}frame_index``. """ df = self.to_pandas().copy() parsed = [self.parse_source_ref(value) for value in df["source_ref"].tolist()] parsed_df = pd.DataFrame.from_records( parsed, - columns=["path", "member", "byte_offset", "byte_size"], + columns=["path", "member", "byte_offset", "byte_size", "frame_index"], ) for col in parsed_df.columns: df[f"{prefix}{col}"] = parsed_df[col].to_numpy(copy=False) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 2b2212d6c6..c54cd93a00 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -111,11 +111,11 @@ def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None assert df.loc[0, "_src_byte_size"] == 20 -def test_parse_source_ref_soft_migration() -> None: - old_format = json.dumps({"content_path": "/old/path.tar", "content_key": "old.json"}) - parsed = MultiBatchTask.parse_source_ref(old_format) - assert parsed["path"] == "/old/path.tar" - assert parsed["member"] == "old.json" +def test_parse_source_ref_ignores_legacy_keys() -> None: + legacy_format = json.dumps({"content_path": "/old/path.tar", "content_key": "old.json"}) + parsed = MultiBatchTask.parse_source_ref(legacy_format) + assert parsed["path"] is None + assert parsed["member"] is None assert parsed["byte_offset"] is None assert parsed["byte_size"] is None @@ -160,7 +160,7 @@ def test_classify_rows_range_read() -> None: assert not result.tar_extract assert not result.direct_read entry = result.range_read["/shard.tar"][0] - assert entry == (0, "img.jpg", 512, 1024) + assert entry == (0, "img.jpg", 512, 1024, None) def test_classify_rows_missing_path() -> None: @@ -254,6 +254,27 @@ def test_materialize_range_read_bad_path(tmp_path: Path) -> None: assert isinstance(df.loc[0, "materialize_error"], str) +# --- materialize: range read deduplication --- + + +def test_materialize_range_read_deduplicates_identical_ranges(tmp_path: Path) -> None: + payload = b"shared-image-bytes" + raw_file = tmp_path / "data.bin" + raw_file.write_bytes(b"HDR" + payload + b"TRL") + + rows = [ + _image_row(path=str(raw_file), member="img.tiff", byte_offset=3, byte_size=len(payload)), + _image_row(path=str(raw_file), member="img.tiff", byte_offset=3, byte_size=len(payload)), + _image_row(path=str(raw_file), member="img.tiff", byte_offset=3, byte_size=len(payload)), + ] + task = _image_task(rows) + result = materialize_task_binary_content(task) + df = result.to_pandas() + for i in range(3): + assert df.loc[i, "binary_content"] == payload + assert pd.isna(df.loc[i, "materialize_error"]) + + # --- materialize: mixed batch --- diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 4a3adbc429..1310680a7e 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -162,6 +162,37 @@ def test_reader_uses_resolved_content_key_for_content_type(tmp_path: Path) -> No assert image_row["content_type"] == "image/png" +def test_reader_image_tokens_with_frame_index(tmp_path: Path) -> None: + """Non-None tokens get frame_index and resolve to default TIFF. None tokens get no content.""" + tar_path = tmp_path / "sub-image-shard.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["text1", "text2", "text3"], + "images": [None, "page_0_image_15", "page_1_image_22"], + } + _write_tar_sample(tar_path, payload, json_name="sample.json", image_name="doc.pdf.tiff", image_bytes=b"TIFF_DATA") + task = _task_for_tar(tar_path, "sub_image_test") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", sample_id_field="pdf_name", image_extensions=(".tiff",), + ) + df = _as_df(reader.process(task)) + + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 3 + + refs = [MultiBatchTask.parse_source_ref(v) for v in image_rows["source_ref"].tolist()] + + assert refs[0]["member"] is None, "None token should have no content" + assert refs[0]["path"] is None + assert refs[0]["frame_index"] is None + + assert refs[1]["member"] == "doc.pdf.tiff", "Non-matching string should resolve to default TIFF" + assert refs[1]["frame_index"] == 0, "First non-None token gets frame_index=0" + + assert refs[2]["member"] == "doc.pdf.tiff" + assert refs[2]["frame_index"] == 1, "Second non-None token gets frame_index=1" + + def test_reader_empty_output_schema_includes_requested_passthrough_fields(tmp_path: Path) -> None: tar_path = tmp_path / "empty-no-json.tar" with tarfile.open(tar_path, "w") as tf: From 62e0d051622598ad0429b1caf4290365cb751b66 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Thu, 26 Feb 2026 08:51:07 +0000 Subject: [PATCH 40/62] Update multimodal README to document frame_index and fix class name - Add frame_index parameter to build_source_ref signature, source_ref JSON example, bullet descriptions, and schema table - Document TIFF frame extraction behavior in materialization section - Fix MultimodalParquetWriter -> MultimodalParquetWriterStage in architecture diagram Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/stages/multimodal/README.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index 56e96e5e0b..c4bd23e9ef 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -21,7 +21,8 @@ WebDataset tar shards | v ┌─────────────────────────┐ -│ MultimodalParquetWriter│ Parquet output with optional materialize-on-write +│ MultimodalParquet- │ MultimodalParquetWriterStage +│ WriterStage │ Parquet output with optional materialize-on-write │ (io/writers/tabular.py)│ Supports snappy/zstd compression, configurable row groups └─────────────────────────┘ ``` @@ -42,7 +43,7 @@ These are set and managed by pipeline stages. Users should not write to them dir | `content_type` | string | Content | MIME type (e.g. `text/plain`, `image/jpeg`) | | `text_content` | string | Content | Text payload for text rows | | `binary_content` | large_binary | Content | Image bytes (populated by materialization) | -| `source_ref` | string | Internal | JSON locator: `{path, member, byte_offset, byte_size}` | +| `source_ref` | string | Internal | JSON locator: `{path, member, byte_offset, byte_size, frame_index}` | | `metadata_json` | string | Internal | Full JSON payload for metadata rows | | `materialize_error` | string | Internal | Error message if materialization failed | @@ -70,7 +71,7 @@ Class attributes: - `REQUIRED_COLUMNS` -- frozenset of columns that must always be present (non-nullable schema fields) Key methods: -- `build_source_ref(path, member, byte_offset, byte_size)` -- build a JSON locator string +- `build_source_ref(path, member, byte_offset, byte_size, frame_index)` -- build a JSON locator string - `parse_source_ref(value)` -- parse back with soft migration for older formats - `with_parsed_source_ref_columns(prefix)` -- expand source_ref into DataFrame columns - `to_pyarrow()` / `to_pandas()` -- conversion between formats @@ -84,13 +85,15 @@ A JSON string embedded in each row that tracks where the original content lives: "path": "/data/shard-00000.tar", "member": "abc123.jpg", "byte_offset": 1024, - "byte_size": 45678 + "byte_size": 45678, + "frame_index": null } ``` - `path` + `member` -- tar archive path and member name - `path` alone (no member) -- direct file path - `byte_offset` + `byte_size` -- enables range reads without opening the tar +- `frame_index` (optional) -- selects a single frame from a multi-frame TIFF during materialization ### Materialization @@ -102,6 +105,8 @@ Binary content (images) can be loaded lazily. Three I/O strategies dispatch auto | **Tar extract** | `member` present, no byte range | Open tar once, `extractfile()` per member | | **Direct read** | No `member` | Read entire file via `fsspec.open()` | +When `frame_index` is set in the `source_ref`, materialization extracts a single frame from a multi-frame TIFF and returns it as a standalone TIFF. Non-TIFF content is returned unchanged regardless of `frame_index`. + Materialization can happen at read time (`materialize_on_read=True`) or write time (`materialize_on_write=True`). ## Usage From 1c85e7358ad6dbece42bac83b1dccf8a71876d4a Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 01:24:00 +0000 Subject: [PATCH 41/62] Add multimodal parquet reader, WDS writer, and fix review issues - Add MultimodalParquetReaderStage and composite MultimodalParquetReader for reading parquet files in MULTIMODAL_SCHEMA format - Add MultimodalWebdatasetWriterStage for writing multimodal rows to WebDataset tar shards with fsspec support for remote (S3) writes - Extract shared read_parquet_files utility from text ParquetReaderStage - Add split_table_by_group_max_bytes to core utils for Arrow table splitting - Add Parquet-to-WDS benchmark script with S3 source_ref filtering - Fix test_classify_rows_range_read assertion (4-tuple not 5-tuple) - Fix lint: unused static method args and pd.isnull -> pd.isna in tests - Fix _write_tar to use fsspec.open() for remote filesystem compatibility Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../multimodal_parquet_to_wds_benchmark.py | 207 ++++++++++++++ benchmarking/scripts/utils.py | 32 +++ nemo_curator/core/utils.py | 45 ++- nemo_curator/stages/multimodal/io/__init__.py | 10 +- nemo_curator/stages/multimodal/io/reader.py | 38 +++ .../stages/multimodal/io/readers/__init__.py | 3 +- .../stages/multimodal/io/readers/base.py | 27 ++ .../stages/multimodal/io/readers/parquet.py | 74 +++++ .../multimodal/io/readers/webdataset.py | 19 +- .../stages/multimodal/io/writers/__init__.py | 3 +- .../stages/multimodal/io/writers/base.py | 18 +- .../multimodal/io/writers/webdataset.py | 199 +++++++++++++ .../multimodal/utils/materialization.py | 265 +++++++++++------- nemo_curator/stages/text/io/reader/parquet.py | 36 +-- pyproject.toml | 4 +- tests/stages/multimodal/test_data_gen.py | 200 +++++++++++++ .../test_materialize_error_handling.py | 98 +++++++ .../stages/multimodal/test_multimodal_core.py | 2 +- .../test_multimodal_parquet_reader.py | 101 +++++++ .../multimodal/test_multimodal_reader.py | 29 ++ .../multimodal/test_multimodal_roundtrip.py | 140 +++++++++ .../multimodal/test_multimodal_wds_writer.py | 179 ++++++++++++ .../multimodal/test_multimodal_writer.py | 13 +- uv.lock | 106 +------ 24 files changed, 1574 insertions(+), 274 deletions(-) create mode 100644 benchmarking/scripts/multimodal_parquet_to_wds_benchmark.py create mode 100644 nemo_curator/stages/multimodal/io/readers/parquet.py create mode 100644 nemo_curator/stages/multimodal/io/writers/webdataset.py create mode 100644 tests/stages/multimodal/test_data_gen.py create mode 100644 tests/stages/multimodal/test_materialize_error_handling.py create mode 100644 tests/stages/multimodal/test_multimodal_parquet_reader.py create mode 100644 tests/stages/multimodal/test_multimodal_roundtrip.py create mode 100644 tests/stages/multimodal/test_multimodal_wds_writer.py diff --git a/benchmarking/scripts/multimodal_parquet_to_wds_benchmark.py b/benchmarking/scripts/multimodal_parquet_to_wds_benchmark.py new file mode 100644 index 0000000000..b68ba12b2a --- /dev/null +++ b/benchmarking/scripts/multimodal_parquet_to_wds_benchmark.py @@ -0,0 +1,207 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +"""Benchmark for multimodal Parquet-to-WebDataset conversion.""" + +import argparse +import time +import traceback +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import pyarrow as pa +from loguru import logger +from utils import collect_webdataset_output_metrics, setup_executor, write_benchmark_results + +from nemo_curator.core.client import RayClient +from nemo_curator.pipeline import Pipeline +from nemo_curator.stages.base import ProcessingStage +from nemo_curator.stages.multimodal.io import MultimodalParquetReader, MultimodalWebdatasetWriterStage +from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks.utils import TaskPerfUtils + + +@dataclass +class _S3SourceRefFilterStage(ProcessingStage[MultiBatchTask, MultiBatchTask]): + """Drop samples where any image row has a non-S3 source_ref (benchmark-only helper).""" + + name: str = "s3_source_ref_filter" + + def inputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def outputs(self) -> tuple[list[str], list[str]]: + return ["data"], [] + + def process(self, task: MultiBatchTask) -> MultiBatchTask | None: + df = task.to_pandas() + image_df = df[df["modality"] == "image"].copy() + ref_strs = image_df["source_ref"].fillna("").astype(str) + non_s3 = ref_strs.str.contains('"path":', na=False) & ~ref_strs.str.contains('"path": "s3://', na=False) + bad_sids = set(image_df.loc[non_s3, "sample_id"].unique()) + + if not bad_sids: + return task + + filtered = df[~df["sample_id"].isin(bad_sids)].reset_index(drop=True) + logger.info(f"S3 filter: dropped {len(bad_sids)} samples with non-S3 image refs, {len(filtered)} rows remain") + if filtered.empty: + return None + + table = pa.Table.from_pandas(filtered, preserve_index=False) + return MultiBatchTask( + task_id=task.task_id, dataset_name=task.dataset_name, + data=table, _metadata=task._metadata, _stage_perf=task._stage_perf, + ) + + +def _build_storage_options(args: argparse.Namespace) -> dict[str, Any]: + if not args.s3_access_key: + return {} + opts: dict[str, Any] = { + "key": args.s3_access_key, + "secret": args.s3_secret_key, + } + client_kwargs: dict[str, str] = {} + if args.s3_endpoint: + client_kwargs["endpoint_url"] = args.s3_endpoint + if args.s3_region: + client_kwargs["region_name"] = args.s3_region + if client_kwargs: + opts["client_kwargs"] = client_kwargs + return opts + + +def create_pipeline(args: argparse.Namespace) -> Pipeline: + storage_options = _build_storage_options(args) + write_kwargs: dict[str, Any] = {} + if storage_options: + write_kwargs["storage_options"] = storage_options + pipeline = Pipeline( + name="multimodal_parquet_to_wds_benchmark", + description="Benchmark: Multimodal parquet to WebDataset tar shards", + ) + pipeline.add_stage( + MultimodalParquetReader( + file_paths=args.input_path, + files_per_partition=args.files_per_partition, + max_batch_bytes=args.output_max_batch_bytes, + read_kwargs={}, + ) + ) + if args.filter_s3_only: + pipeline.add_stage(_S3SourceRefFilterStage()) + pipeline.add_stage( + MultimodalWebdatasetWriterStage( + path=args.output_path, + materialize_on_write=args.materialize_on_write, + on_materialize_error=args.on_materialize_error, + write_kwargs=write_kwargs, + mode=args.mode, + ) + ) + return pipeline + + +def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: + executor = setup_executor(args.executor) + input_path = str(Path(args.input_path).absolute()) + output_path = Path(args.output_path).absolute() + output_path.mkdir(parents=True, exist_ok=True) + + start = time.perf_counter() + output_tasks = [] + success = False + try: + pipeline = create_pipeline(args) + logger.info("Pipeline:\n{}", pipeline.describe()) + output_tasks = pipeline.run(executor) + success = True + except Exception as e: + logger.error("Benchmark failed: {}", e) + logger.debug(traceback.format_exc()) + + elapsed = time.perf_counter() - start + metrics_start = time.perf_counter() + output_metrics = collect_webdataset_output_metrics(output_path) + metrics_elapsed = time.perf_counter() - metrics_start + logger.info("collect_webdataset_output_metrics took {:.3f}s", metrics_elapsed) + task_metrics = TaskPerfUtils.aggregate_task_metrics(output_tasks, prefix="task") + samples = output_metrics.get("num_samples", 0) + return { + "params": { + "executor": args.executor, + "input_path": input_path, + "output_path": str(output_path), + "files_per_partition": args.files_per_partition, + "output_max_batch_bytes": args.output_max_batch_bytes, + "materialize_on_write": args.materialize_on_write, + "on_materialize_error": args.on_materialize_error, + "mode": args.mode, + }, + "metrics": { + "is_success": success, + "time_taken_s": elapsed, + "throughput_samples_per_sec": (samples / elapsed) if elapsed > 0 else 0.0, + **task_metrics, + **output_metrics, + }, + "tasks": output_tasks, + } + + +def main() -> int: + parser = argparse.ArgumentParser(description="Multimodal Parquet-to-WebDataset benchmark") + parser.add_argument("--benchmark-results-path", type=Path, required=True) + parser.add_argument("--executor", default="xenna", choices=["xenna", "ray_data"]) + parser.add_argument("--input-path", type=str, required=True) + parser.add_argument("--output-path", type=str, required=True) + parser.add_argument("--files-per-partition", type=int, default=1) + parser.add_argument("--output-max-batch-bytes", type=int, default=None) + parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") + parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") + parser.add_argument( + "--on-materialize-error", type=str, default="error", choices=["error", "warn", "drop_row", "drop_sample"], + ) + parser.add_argument("--mode", type=str, default="overwrite", choices=["ignore", "overwrite", "append", "error"]) + parser.add_argument("--filter-s3-only", action="store_true", default=False) + parser.add_argument("--s3-access-key", type=str, default=None) + parser.add_argument("--s3-secret-key", type=str, default=None) + parser.add_argument("--s3-endpoint", type=str, default=None) + parser.add_argument("--s3-region", type=str, default=None) + parser.set_defaults(materialize_on_write=False) + args = parser.parse_args() + + ray_client = RayClient() + ray_client.start() + try: + results = run_benchmark(args) + except Exception as e: + logger.error("Benchmark crashed: {}", e) + logger.debug(traceback.format_exc()) + results = { + "params": vars(args), + "metrics": {"is_success": False}, + "tasks": [], + } + finally: + write_benchmark_results(results, args.benchmark_results_path) + ray_client.stop() + + return 0 if results["metrics"]["is_success"] else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index dccbbdc175..50b993c9cd 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -135,6 +135,38 @@ def collect_parquet_output_metrics(output_path: Path) -> dict[str, Any]: } +def collect_webdataset_output_metrics(output_path: Path) -> dict[str, Any]: + import tarfile + + output_files = get_all_file_paths_and_size_under( + str(output_path), + recurse_subdirectories=True, + keep_extensions=[".tar"], + ) + tar_files = [path for path, _ in output_files] + num_files = len(tar_files) + total_size_bytes = int(sum(size for _, size in output_files)) + num_samples = 0 + num_image_members = 0 + for path in tar_files: + with tarfile.open(path, "r") as tf: + for member in tf.getmembers(): + if not member.isfile(): + continue + if member.name.endswith(".json"): + num_samples += 1 + else: + num_image_members += 1 + return { + "num_output_files": num_files, + "output_total_bytes": total_size_bytes, + "output_total_mb": total_size_bytes / (1024 * 1024), + "num_samples": num_samples, + "num_image_members": num_image_members, + "avg_samples_per_tar": (num_samples / num_files) if num_files > 0 else 0.0, + } + + def convert_paths_to_strings(obj: object) -> object: """ Convert Path objects to strings, support conversions in container types in a recursive manner. diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index 9dce70cf88..6f1325c61f 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -208,32 +208,31 @@ def split_table_by_group_max_bytes( msg = f"Group column '{group_column}' not found in table" raise ValueError(msg) - # Sort by group column so rows for each group are contiguous -- O(n log n) - # then slice at group boundaries instead of O(groups * rows) filtering. sort_indices = pc.sort_indices(table, sort_keys=[(group_column, "ascending")]) table = table.take(sort_indices) col = table[group_column] + n = table.num_rows - group_tables: list[pa.Table] = [] - start = 0 - for i in range(1, table.num_rows): - if col[i].as_py() != col[i - 1].as_py(): - group_tables.append(table.slice(start, i - start)) - start = i - group_tables.append(table.slice(start, table.num_rows - start)) - - chunks: list[list[pa.Table]] = [] - chunk_tables: list[pa.Table] = [] - chunk_bytes = 0 - for group_table in group_tables: - group_bytes = int(group_table.nbytes) - if chunk_tables and (chunk_bytes + group_bytes > max_batch_bytes): - chunks.append(chunk_tables) - chunk_tables = [] - chunk_bytes = 0 - chunk_tables.append(group_table) + if n <= 1: + return [table] + + ne = pc.not_equal(col.slice(1), col.slice(0, n - 1)) + split_points = pc.indices_nonzero(ne).to_pylist() + group_starts = [0, *(p + 1 for p in split_points)] + group_ends = [*(p + 1 for p in split_points), n] + + avg_bytes_per_row = table.nbytes / n + chunk_split_indices: list[int] = [] + chunk_bytes = 0.0 + for i, (gs, ge) in enumerate(zip(group_starts, group_ends, strict=True)): + group_bytes = (ge - gs) * avg_bytes_per_row + if i > 0 and chunk_bytes > 0 and (chunk_bytes + group_bytes > max_batch_bytes): + chunk_split_indices.append(gs) + chunk_bytes = 0.0 chunk_bytes += group_bytes - if chunk_tables: - chunks.append(chunk_tables) - return [pa.concat_tables(chunk) if len(chunk) > 1 else chunk[0] for chunk in chunks] + if not chunk_split_indices: + return [table] + all_starts = [0, *chunk_split_indices] + all_ends = [*chunk_split_indices, n] + return [table.slice(s, e - s) for s, e in zip(all_starts, all_ends, strict=True)] diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/multimodal/io/__init__.py index 9dd6096faf..6dc0d5c37e 100644 --- a/nemo_curator/stages/multimodal/io/__init__.py +++ b/nemo_curator/stages/multimodal/io/__init__.py @@ -12,7 +12,13 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.reader import WebdatasetReader +from nemo_curator.stages.multimodal.io.reader import MultimodalParquetReader, WebdatasetReader from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage -__all__ = ["MultimodalParquetWriterStage", "WebdatasetReader"] +__all__ = [ + "MultimodalParquetReader", + "MultimodalParquetWriterStage", + "MultimodalWebdatasetWriterStage", + "WebdatasetReader", +] diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index b450e530f8..f518d14e88 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -17,6 +17,7 @@ from nemo_curator.stages.base import CompositeStage from nemo_curator.stages.file_partitioning import FilePartitioningStage +from nemo_curator.stages.multimodal.io.readers.parquet import MultimodalParquetReaderStage from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.multimodal.utils import ( DEFAULT_IMAGE_EXTENSIONS, @@ -77,3 +78,40 @@ def decompose(self) -> list: fields=self.fields, ), ] + + +@dataclass +class MultimodalParquetReader(CompositeStage[_EmptyTask, MultiBatchTask]): + """Composite stage for reading parquet files in multimodal schema. + + Decomposes into: + 1. FilePartitioningStage - partitions files into groups + 2. MultimodalParquetReaderStage - reads file groups into MultiBatchTasks + """ + + file_paths: str | list[str] + files_per_partition: int | None = None + max_batch_bytes: int | None = None + read_kwargs: dict[str, Any] = field(default_factory=dict) + fields: list[str] | None = None + file_extensions: list[str] = field(default_factory=lambda: [".parquet"]) + name: str = "multimodal_parquet_reader" + + def __post_init__(self): + super().__init__() + self.storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) + + def decompose(self) -> list: + return [ + FilePartitioningStage( + file_paths=self.file_paths, + files_per_partition=self.files_per_partition, + file_extensions=self.file_extensions, + storage_options=self.storage_options, + ), + MultimodalParquetReaderStage( + read_kwargs=self.read_kwargs, + fields=self.fields, + max_batch_bytes=self.max_batch_bytes, + ), + ] diff --git a/nemo_curator/stages/multimodal/io/readers/__init__.py b/nemo_curator/stages/multimodal/io/readers/__init__.py index 1734a25f29..1f5b2381ef 100644 --- a/nemo_curator/stages/multimodal/io/readers/__init__.py +++ b/nemo_curator/stages/multimodal/io/readers/__init__.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from nemo_curator.stages.multimodal.io.readers.parquet import MultimodalParquetReaderStage from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage -__all__ = ["WebdatasetReaderStage"] +__all__ = ["MultimodalParquetReaderStage", "WebdatasetReaderStage"] diff --git a/nemo_curator/stages/multimodal/io/readers/base.py b/nemo_curator/stages/multimodal/io/readers/base.py index b5dbdcb39b..ee1acdd9e9 100644 --- a/nemo_curator/stages/multimodal/io/readers/base.py +++ b/nemo_curator/stages/multimodal/io/readers/base.py @@ -15,8 +15,11 @@ from dataclasses import dataclass, field from typing import Any +import pyarrow as pa + from nemo_curator.stages.base import ProcessingStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @dataclass @@ -31,3 +34,27 @@ def inputs(self) -> tuple[list[str], list[str]]: def outputs(self) -> tuple[list[str], list[str]]: return ["data"], ["sample_id", "position", "modality"] + + @staticmethod + def reconcile_schema(inferred: pa.Schema) -> pa.Schema: + """Build a schema with canonical types for reserved columns and inferred types for passthrough. + + Avoids unsafe downcasts from large_string -> string or large_binary -> binary + which would cause offset overflow on large tables. + """ + large_compat: dict[tuple[pa.DataType, pa.DataType], pa.DataType] = { + (pa.large_string(), pa.string()): pa.large_string(), + (pa.large_binary(), pa.binary()): pa.large_binary(), + (pa.large_binary(), pa.large_binary()): pa.large_binary(), + (pa.large_string(), pa.large_string()): pa.large_string(), + } + canonical = {f.name: f for f in MULTIMODAL_SCHEMA} + fields: list[pa.Field] = [] + for f in inferred: + if f.name not in canonical: + fields.append(f) + continue + target = canonical[f.name] + resolved_type = large_compat.get((f.type, target.type), target.type) + fields.append(pa.field(f.name, resolved_type, nullable=target.nullable)) + return pa.schema(fields) diff --git a/nemo_curator/stages/multimodal/io/readers/parquet.py b/nemo_curator/stages/multimodal/io/readers/parquet.py new file mode 100644 index 0000000000..e22b0d9a08 --- /dev/null +++ b/nemo_curator/stages/multimodal/io/readers/parquet.py @@ -0,0 +1,74 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +from dataclasses import dataclass +from typing import Any + +import pyarrow as pa + +from nemo_curator.core.utils import split_table_by_group_max_bytes +from nemo_curator.stages.multimodal.utils import resolve_storage_options +from nemo_curator.stages.text.io.reader.parquet import read_parquet_files +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + +from .base import BaseMultimodalReader + + +@dataclass +class MultimodalParquetReaderStage(BaseMultimodalReader): + """Read parquet files in MULTIMODAL_SCHEMA format into MultiBatchTask. + + Delegates actual parquet I/O to the shared ``read_parquet_files()`` utility, + then reconciles schema and splits by sample_id to produce MultiBatchTask(s). + """ + + fields: list[str] | None = None + max_batch_bytes: int | None = None + name: str = "multimodal_parquet_reader" + + def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: + storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) + effective_kwargs: dict[str, Any] = dict(self.read_kwargs) if self.read_kwargs else {} + if storage_options: + effective_kwargs["storage_options"] = storage_options + + df = read_parquet_files(task.data, read_kwargs=effective_kwargs, fields=self.fields) + + if df.empty: + msg = f"No data read from parquet files in task {task.task_id}" + raise ValueError(msg) + + table = pa.Table.from_pandas(df, preserve_index=False) + table = table.cast(self.reconcile_schema(table.schema)) + splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) + + metadata = dict(task._metadata) + if storage_options: + metadata["source_storage_options"] = storage_options + + batches: list[MultiBatchTask] = [] + for idx, split in enumerate(splits): + task_id = f"{task.task_id}_processed" if len(splits) == 1 else f"{task.task_id}_processed_{idx:05d}" + batches.append( + MultiBatchTask( + task_id=task_id, + dataset_name=task.dataset_name, + data=split, + _metadata=metadata, + _stage_perf=task._stage_perf, + ) + ) + return batches if len(batches) > 1 else batches[0] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index be7d053d6c..a880377383 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -205,18 +205,6 @@ def _empty_output_schema(self) -> pa.Schema: passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema - @staticmethod - def _reconcile_schema(inferred: pa.Schema) -> pa.Schema: - """Build a schema with canonical types for reserved columns and inferred types for passthrough.""" - canonical = {f.name: f for f in MULTIMODAL_SCHEMA} - fields = [] - for f in inferred: - if f.name in canonical: - fields.append(canonical[f.name]) - else: - fields.append(f) - return pa.schema(fields) - # -- image member resolution -- def _resolve_default_image_member_name( @@ -298,7 +286,10 @@ def _rows_from_member( parsed_ref = MultiBatchTask.parse_source_ref(row["source_ref"]) content_key = parsed_ref.get("member") if content_key: - row["binary_content"] = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) + binary_content = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) + row["binary_content"] = binary_content + if binary_content is None: + row["materialize_error"] = f"missing member '{content_key}'" read_ctx.byte_cache.clear() return sample_rows @@ -329,7 +320,7 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: if rows: table = pa.Table.from_pylist(rows) - table = table.cast(self._reconcile_schema(table.schema)) + table = table.cast(self.reconcile_schema(table.schema)) else: table = pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py index 88b47f60c2..defb7fec05 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -13,5 +13,6 @@ # limitations under the License. from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage -__all__ = ["MultimodalParquetWriterStage"] +__all__ = ["MultimodalParquetWriterStage", "MultimodalWebdatasetWriterStage"] diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/multimodal/io/writers/base.py index a2c4d8b2e4..8b80054210 100644 --- a/nemo_curator/stages/multimodal/io/writers/base.py +++ b/nemo_curator/stages/multimodal/io/writers/base.py @@ -49,6 +49,7 @@ class BaseMultimodalWriter(ProcessingStage[MultiBatchTask, FileGroupTask], ABC): name: str = "base_multimodal_writer" mode: Literal["ignore", "overwrite", "append", "error"] = "ignore" append_mode_implemented: bool = False + on_materialize_error: Literal["error", "warn", "drop_row", "drop_sample"] = "error" def __post_init__(self) -> None: self.storage_options = (self.write_kwargs or {}).get("storage_options", {}) @@ -79,7 +80,22 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: with self._time_metric("materialize_fetch_binary_s"): out = materialize_task_binary_content(task, io_kwargs=self.write_kwargs).to_pandas() if "materialize_error" in out.columns: - self._log_metric("materialize_errors", float(out["materialize_error"].notna().sum())) + error_mask = out["materialize_error"].notna() + error_count = int(error_mask.sum()) + self._log_metric("materialize_errors", float(error_count)) + if error_count > 0: + if self.on_materialize_error == "error": + msg = f"{error_count} image(s) failed to materialize" + raise RuntimeError(msg) + elif self.on_materialize_error == "warn": + logger.warning(f"{error_count} image(s) failed to materialize, keeping rows") + elif self.on_materialize_error == "drop_row": + logger.warning(f"Dropping {error_count} image rows with materialize errors") + out = out[~error_mask].reset_index(drop=True) + elif self.on_materialize_error == "drop_sample": + bad_samples = out.loc[error_mask, "sample_id"].unique() + logger.warning(f"Dropping {len(bad_samples)} samples with materialize errors") + out = out[~out["sample_id"].isin(bad_samples)].reset_index(drop=True) return out # -- write pipeline -- diff --git a/nemo_curator/stages/multimodal/io/writers/webdataset.py b/nemo_curator/stages/multimodal/io/writers/webdataset.py new file mode 100644 index 0000000000..03bd723dec --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/webdataset.py @@ -0,0 +1,199 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import io +import json +import mimetypes +import re +import tarfile +import time +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any + +import fsspec +import pandas as pd +from loguru import logger + +from .base import BaseMultimodalWriter + +if TYPE_CHECKING: + import numpy as np + + from nemo_curator.tasks import MultiBatchTask + +_MIME_TO_EXT: dict[str, str] = { + "image/jpeg": "jpg", + "image/png": "png", + "image/tiff": "tiff", + "image/gif": "gif", + "image/webp": "webp", + "image/bmp": "bmp", +} + +_SANITIZE_RE = re.compile(r"[^\w\-.]") + + +def _sanitize_key(raw: str) -> str: + """Produce a filesystem-safe WebDataset key from a raw sample_id.""" + return _SANITIZE_RE.sub("_", raw)[:200] + + +def _ext_from_content_type(content_type: object) -> str: + if isinstance(content_type, str) and content_type in _MIME_TO_EXT: + return _MIME_TO_EXT[content_type] + if isinstance(content_type, str): + ext = mimetypes.guess_extension(content_type, strict=False) + if ext: + return ext.lstrip(".") + return "bin" + + +def _add_tar_member(tf: tarfile.TarFile, name: str, data: bytes, mtime: float) -> None: + ti = tarfile.TarInfo(name=name) + ti.size = len(data) + ti.mtime = mtime + ti.mode = 0o0444 + ti.uname = "bigdata" + ti.gname = "bigdata" + tf.addfile(ti, io.BytesIO(data)) + + +@dataclass +class _ColumnArrays: + """Pre-extracted numpy arrays from the DataFrame for fast row-level access.""" + + modality: np.ndarray + position: np.ndarray + text_content: np.ndarray + binary_content: np.ndarray + content_type: np.ndarray + metadata_json: np.ndarray + + +def _build_index(sid_col: np.ndarray) -> list[tuple[str, list[int]]]: + """Return (sample_id, row_indices) pairs in first-occurrence order.""" + sid_to_indices: dict[str, list[int]] = {} + insertion_order: list[str] = [] + for i, raw in enumerate(sid_col): + sid = str(raw) + if sid not in sid_to_indices: + sid_to_indices[sid] = [] + insertion_order.append(sid) + sid_to_indices[sid].append(i) + return [(sid, sid_to_indices[sid]) for sid in insertion_order] + + +def _extract_metadata_payload(meta_val: object) -> dict[str, Any]: + if meta_val is None or pd.isna(meta_val): + return {} + try: + parsed = json.loads(str(meta_val)) + except (json.JSONDecodeError, TypeError): + return {} + if not isinstance(parsed, dict): + return {} + parsed.pop("_sample_source", None) + return parsed + + +def _collect_images( + image_entries: list[tuple[int, object, object]], +) -> tuple[list[str | None], list[tuple[str, bytes]]]: + image_entries.sort(key=lambda x: x[0]) + images: list[str | None] = [] + binaries: list[tuple[str, bytes]] = [] + ext_counter: dict[str, int] = {} + for _, binary, content_type in image_entries: + has_binary = binary is not None and not pd.isna(binary) and isinstance(binary, (bytes, bytearray)) + if has_binary: + ext = _ext_from_content_type(content_type) + count = ext_counter.get(ext, 0) + ext_counter[ext] = count + 1 + member_key = ext if count == 0 else f"{count}.{ext}" + binaries.append((member_key, bytes(binary))) + images.append(member_key) + else: + images.append(None) + return images, binaries + + +def _write_sample(tf: tarfile.TarFile, key: str, indices: list[int], cols: _ColumnArrays, mtime: float) -> None: + payload: dict[str, Any] = {} + text_entries: list[tuple[int, object]] = [] + image_entries: list[tuple[int, object, object]] = [] + + for idx in indices: + mod = str(cols.modality[idx]) + if mod == "metadata": + payload.update(_extract_metadata_payload(cols.metadata_json[idx])) + elif mod == "text": + text_entries.append((int(cols.position[idx]), cols.text_content[idx])) + elif mod == "image": + image_entries.append((int(cols.position[idx]), cols.binary_content[idx], cols.content_type[idx])) + + text_entries.sort(key=lambda x: x[0]) + payload["texts"] = [str(v) if v is not None and not pd.isna(v) else None for _, v in text_entries] + images, binaries = _collect_images(image_entries) + payload["images"] = images + + json_bytes = json.dumps(payload, ensure_ascii=True).encode("utf-8") + _add_tar_member(tf, f"{key}.json", json_bytes, mtime) + for member_key, binary_data in binaries: + _add_tar_member(tf, f"{key}.{member_key}", binary_data, mtime) + + +@dataclass +class MultimodalWebdatasetWriterStage(BaseMultimodalWriter): + """Write multimodal rows to WebDataset tar shards.""" + + file_extension: str = "tar" + name: str = "multimodal_webdataset_writer" + + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + pass + + def write_data(self, task: MultiBatchTask, file_path: str) -> None: + with self._time_metric("materialize_dataframe_total_s"): + df = self._materialize_dataframe(task) + + with self._time_metric("webdataset_write_s"): + self._write_tar(df, file_path) + + def _write_tar(self, df: pd.DataFrame, file_path: str) -> None: + mtime = time.time() + samples_written = 0 + + cols = _ColumnArrays( + modality=df["modality"].to_numpy(), + position=df["position"].to_numpy(), + text_content=df["text_content"].to_numpy(), + binary_content=df["binary_content"].to_numpy(), + content_type=df["content_type"].to_numpy(), + metadata_json=df["metadata_json"].to_numpy(), + ) + sample_index = _build_index(df["sample_id"].to_numpy()) + + with ( + fsspec.open(file_path, mode="wb", **self.storage_options) as fobj, + tarfile.open(fileobj=fobj, mode="w") as tf, + ): + for sid, indices in sample_index: + _write_sample(tf, _sanitize_key(sid), indices, cols, mtime) + samples_written += 1 + if samples_written % 10000 == 0: + logger.info(f"WebDataset writer: {samples_written}/{len(sample_index)} samples written") + + self._log_metric("samples_written", float(samples_written)) diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/multimodal/utils/materialization.py index 4a16201a59..3bb4ee5fed 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/multimodal/utils/materialization.py @@ -14,15 +14,16 @@ from __future__ import annotations -import io import tarfile -from typing import NamedTuple +from typing import TYPE_CHECKING, NamedTuple + +if TYPE_CHECKING: + from collections.abc import Iterator import fsspec import pandas as pd from fsspec.core import url_to_fs from loguru import logger -from PIL import Image as _Image from nemo_curator.tasks import MultiBatchTask @@ -32,21 +33,12 @@ class _ClassifiedRows(NamedTuple): - tar_extract: dict[str, list[tuple[int, str, int | None]]] - range_read: dict[str, list[tuple[int, str, int, int, int | None]]] + tar_extract: dict[str, list[tuple[int, str]]] + range_read: dict[str, list[tuple[int, str, int, int]]] direct_read: dict[str, list[int]] missing: list[int] -def _get_frame_index(df: pd.DataFrame, idx: int) -> int | None: - if "_src_frame_index" not in df.columns: - return None - val = df.loc[idx, "_src_frame_index"] - if val is None or (isinstance(val, float) and pd.isna(val)): - return None - return int(val) - - def _classify_rows( df: pd.DataFrame, image_mask: pd.Series, @@ -58,8 +50,8 @@ def _classify_rows( - direct_read: no member (path is the file itself) - missing: path is None/NaN """ - tar_extract: dict[str, list[tuple[int, str, int | None]]] = {} - range_read: dict[str, list[tuple[int, str, int, int, int | None]]] = {} + tar_extract: dict[str, list[tuple[int, str]]] = {} + range_read: dict[str, list[tuple[int, str, int, int]]] = {} direct_read: dict[str, list[int]] = {} missing: list[int] = [] @@ -78,41 +70,20 @@ def _classify_rows( continue member_str = str(raw_member) - frame_idx = _get_frame_index(df, idx) raw_offset = df.loc[idx, "_src_byte_offset"] raw_size = df.loc[idx, "_src_byte_size"] has_range = raw_offset is not None and raw_size is not None and pd.notna(raw_offset) and pd.notna(raw_size) if has_range and int(raw_size) > 0: - range_read.setdefault(path_str, []).append((idx, member_str, int(raw_offset), int(raw_size), frame_idx)) + range_read.setdefault(path_str, []).append((idx, member_str, int(raw_offset), int(raw_size))) else: - tar_extract.setdefault(path_str, []).append((idx, member_str, frame_idx)) + tar_extract.setdefault(path_str, []).append((idx, member_str)) return _ClassifiedRows(tar_extract=tar_extract, range_read=range_read, direct_read=direct_read, missing=missing) -def _extract_tiff_frame(tiff_bytes: bytes, frame_index: int) -> bytes | None: - """Extract a single frame from a multi-frame TIFF, returning it as a single-frame TIFF. - - Returns the raw bytes unchanged if the data is not a TIFF. - """ - try: - with _Image.open(io.BytesIO(tiff_bytes)) as img: - if img.format != "TIFF": - return tiff_bytes - if frame_index >= getattr(img, "n_frames", 1): - return None - img.seek(frame_index) - compression = img.info.get("compression", "tiff_deflate") - buf = io.BytesIO() - img.save(buf, format="TIFF", compression=compression) - return buf.getvalue() - except (OSError, SyntaxError, ValueError): - return None - - def _fill_tar_extract_rows( - groups: dict[str, list[tuple[int, str, int | None]]], + groups: dict[str, list[tuple[int, str]]], storage_options: dict[str, object], binary_values: list[object], error_values: list[str | None], @@ -122,7 +93,7 @@ def _fill_tar_extract_rows( key_cache: dict[str, bytes | None] = {} try: with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: - for idx, member, frame_idx in keyed_rows: + for idx, member in keyed_rows: if member not in key_cache: try: extracted = tf.extractfile(member) @@ -135,63 +106,20 @@ def _fill_tar_extract_rows( error_values[idx] = f"missing member '{member}'" continue - if frame_idx is not None: - payload = _extract_tiff_frame(payload, frame_idx) - if payload is None: - error_values[idx] = f"failed to extract frame {frame_idx} from '{member}'" - continue - binary_values[idx] = payload error_values[idx] = None except (OSError, tarfile.TarError): - for idx, *_ in keyed_rows: + for idx, _ in keyed_rows: error_values[idx] = "failed to read path" -def _resolve_frame( - raw_bytes: bytes, frame_idx: int | None, frame_cache: dict[tuple[int, int | None], bytes | None], -) -> bytes | None: - """Return raw_bytes or an extracted single-frame TIFF if frame_idx is set. Caches results.""" - cache_key = (id(raw_bytes), frame_idx) - if cache_key not in frame_cache: - frame_cache[cache_key] = _extract_tiff_frame(raw_bytes, frame_idx) if frame_idx is not None else raw_bytes - return frame_cache[cache_key] - - -def _scatter_range_blobs( - blobs: list[object], - range_keys: list[tuple[int, int]], - unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]], - binary_values: list[object], - error_values: list[str | None], -) -> None: - """Distribute deduplicated range-read results, extracting TIFF frames as needed.""" - frame_cache: dict[tuple[int, int | None], bytes | None] = {} - for key, blob in zip(range_keys, blobs, strict=True): - if isinstance(blob, Exception): - for idx, member, _fi in unique_ranges[key]: - error_values[idx] = f"range read error for member '{member}'" - elif blob is None or len(blob) == 0: - for idx, member, _fi in unique_ranges[key]: - error_values[idx] = f"empty range read for member '{member}'" - else: - raw = bytes(blob) if not isinstance(blob, bytes) else blob - for idx, member, frame_idx in unique_ranges[key]: - payload = _resolve_frame(raw, frame_idx, frame_cache) - if payload is None: - error_values[idx] = f"failed to extract frame {frame_idx} from '{member}'" - else: - binary_values[idx] = payload - error_values[idx] = None - - def _fill_range_read_rows( - groups: dict[str, list[tuple[int, str, int, int, int | None]]], + groups: dict[str, list[tuple[int, str, int, int]]], storage_options: dict[str, object], binary_values: list[object], error_values: list[str | None], ) -> None: - """Batch byte-range reads per path using fs.cat_ranges(), deduplicating identical ranges.""" + """Batch byte-range reads per path using fs.cat_ranges().""" for path, entries in groups.items(): try: fs, fs_path = url_to_fs(path, **storage_options) @@ -200,24 +128,27 @@ def _fill_range_read_rows( error_values[idx] = "failed to resolve filesystem" continue - unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = {} - for idx, member, offset, size, frame_idx in entries: - unique_ranges.setdefault((offset, size), []).append((idx, member, frame_idx)) - - range_keys = list(unique_ranges.keys()) - dedup_paths = [fs_path] * len(range_keys) - starts = [offset for offset, _ in range_keys] - ends = [offset + size for offset, size in range_keys] + paths = [fs_path] * len(entries) + starts = [offset for _, _, offset, _ in entries] + ends = [offset + size for _, _, offset, size in entries] try: - blobs = fs.cat_ranges(dedup_paths, starts, ends) + blobs = fs.cat_ranges(paths, starts, ends) except OSError as exc: logger.warning(f"cat_ranges failed for {path} ({len(entries)} ranges): {exc}") for idx, *_ in entries: error_values[idx] = "cat_ranges failed" continue - _scatter_range_blobs(blobs, range_keys, unique_ranges, binary_values, error_values) + for (idx, member, _offset, _size), blob in zip(entries, blobs, strict=True): + if isinstance(blob, Exception): + error_values[idx] = f"range read error for member '{member}'" + continue + if blob is None or len(blob) == 0: + error_values[idx] = f"empty range read for member '{member}'" + continue + binary_values[idx] = bytes(blob) if not isinstance(blob, bytes) else blob + error_values[idx] = None def _fill_direct_read_rows( @@ -289,6 +220,125 @@ def _build_image_mask( return image_mask +def iter_source_grouped_bytes( + task: MultiBatchTask, + row_indices: list[int], + storage_options: dict[str, object] | None = None, +) -> Iterator[tuple[int, bytes | None]]: + """Yield ``(row_index, image_bytes)`` grouped by source path. + + Opens one source (tar / file) at a time, yields all requested rows from + that source, then releases the bytes before moving to the next source. + This bounds peak memory to O(images_per_source) instead of O(all_images). + """ + if not row_indices: + return + + df = task.to_pandas() + if storage_options is None: + storage_options = resolve_storage_options(task=task) + + source_refs = [MultiBatchTask.parse_source_ref(df.loc[idx, "source_ref"]) for idx in row_indices] + + groups: dict[str, list[tuple[int, dict]]] = {} + missing: list[int] = [] + for idx, ref in zip(row_indices, source_refs, strict=True): + path = ref.get("path") + if path is None or path == "": + missing.append(idx) + else: + groups.setdefault(str(path), []).append((idx, ref)) + + for idx in missing: + yield idx, None + + for path, entries in groups.items(): + results: dict[int, bytes | None] = {} + _fill_source_group(path, entries, storage_options, results) + for idx, _ in entries: + yield idx, results.get(idx) + del results + + +def _fill_source_group( + path: str, + entries: list[tuple[int, dict]], + storage_options: dict[str, object], + results: dict[int, bytes | None], +) -> None: + """Materialize bytes for all entries sharing a single source path.""" + range_entries = [] + tar_entries = [] + direct_entries = [] + + for idx, ref in entries: + member = ref.get("member") + has_member = member is not None and member != "" + if not has_member: + direct_entries.append(idx) + continue + offset = ref.get("byte_offset") + size = ref.get("byte_size") + if offset is not None and size is not None and size > 0: + range_entries.append((idx, str(member), int(offset), int(size))) + else: + tar_entries.append((idx, str(member))) + + if range_entries: + _fill_source_group_range(path, range_entries, storage_options, results) + if tar_entries: + _fill_source_group_tar(path, tar_entries, storage_options, results) + if direct_entries: + payload = _read_direct_file(path, storage_options) + for idx in direct_entries: + results[idx] = payload + + +def _fill_source_group_range( + path: str, + entries: list[tuple[int, str, int, int]], + storage_options: dict[str, object], + results: dict[int, bytes | None], +) -> None: + try: + fs, fs_path = url_to_fs(path, **storage_options) + except (ValueError, OSError): + return + paths = [fs_path] * len(entries) + starts = [offset for _, _, offset, _ in entries] + ends = [offset + size for _, _, offset, size in entries] + try: + blobs = fs.cat_ranges(paths, starts, ends) + except OSError: + return + for (idx, _member, _offset, _size), blob in zip(entries, blobs, strict=True): + if isinstance(blob, Exception) or blob is None or len(blob) == 0: + results[idx] = None + else: + results[idx] = bytes(blob) if not isinstance(blob, bytes) else blob + + +def _fill_source_group_tar( + path: str, + entries: list[tuple[int, str]], + storage_options: dict[str, object], + results: dict[int, bytes | None], +) -> None: + try: + with fsspec.open(path, mode="rb", **storage_options) as fobj, tarfile.open(fileobj=fobj, mode="r:*") as tf: + cache: dict[str, bytes | None] = {} + for idx, member in entries: + if member not in cache: + try: + extracted = tf.extractfile(member) + except KeyError: + extracted = None + cache[member] = extracted.read() if extracted is not None else None + results[idx] = cache[member] + except (OSError, tarfile.TarError): + pass + + def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTask: return MultiBatchTask( task_id=task.task_id, @@ -313,9 +363,14 @@ def materialize_task_binary_content( - tar_extract: member present, no byte range -> open tar + extractfile - direct_read: no member -> read file directly """ - df = task.with_parsed_source_ref_columns(prefix="_src_").reset_index(drop=True) + df = task.to_pandas().reset_index(drop=True) if df.empty: return task + parsed = [MultiBatchTask.parse_source_ref(v) for v in df["source_ref"].tolist()] + parsed_df = pd.DataFrame.from_records(parsed, columns=["path", "member", "byte_offset", "byte_size"]) + for col in parsed_df.columns: + df[f"_src_{col}"] = parsed_df[col].to_numpy(copy=False) + del parsed, parsed_df binary_values, error_values = _init_materialization_buffers(df) image_mask = _build_image_mask( @@ -324,8 +379,9 @@ def materialize_task_binary_content( image_content_types=image_content_types, ) if not image_mask.any(): - out = df.drop(columns=[c for c in df.columns if c.startswith("_src_")], errors="ignore") - return _task_with_dataframe(task, out) + for col in [c for c in df.columns if c.startswith("_src_")]: + del df[col] + return _task_with_dataframe(task, df) storage_options = resolve_storage_options(task=task, io_kwargs=io_kwargs) _fill_materialized_bytes( @@ -336,7 +392,8 @@ def materialize_task_binary_content( error_values=error_values, ) - out = df.drop(columns=[c for c in df.columns if c.startswith("_src_")], errors="ignore") - out["binary_content"] = pd.Series(binary_values, dtype="object") - out["materialize_error"] = pd.Series(error_values, dtype="object") - return _task_with_dataframe(task, out) + for col in [c for c in df.columns if c.startswith("_src_")]: + del df[col] + df["binary_content"] = pd.Series(binary_values, dtype="object") + df["materialize_error"] = pd.Series(error_values, dtype="object") + return _task_with_dataframe(task, df) diff --git a/nemo_curator/stages/text/io/reader/parquet.py b/nemo_curator/stages/text/io/reader/parquet.py index 8138d0e5bb..cd82c56a5d 100644 --- a/nemo_curator/stages/text/io/reader/parquet.py +++ b/nemo_curator/stages/text/io/reader/parquet.py @@ -25,6 +25,23 @@ from .base import BaseReader +def read_parquet_files( + paths: list[str], + read_kwargs: dict[str, Any] | None = None, + fields: list[str] | None = None, +) -> pd.DataFrame: + """Read Parquet files into a single DataFrame using Pandas with pyarrow backend.""" + read_kwargs = {} if read_kwargs is None else dict(read_kwargs) + if fields is not None: + read_kwargs.setdefault("columns", fields) + read_kwargs.setdefault("engine", "pyarrow") + read_kwargs.setdefault("dtype_backend", "pyarrow") + return pd.concat( + (pd.read_parquet(path, **read_kwargs) for path in paths), + ignore_index=True, + ) + + @dataclass class ParquetReaderStage(BaseReader): """ @@ -45,24 +62,7 @@ def read_data( read_kwargs: dict[str, Any] | None = None, fields: list[str] | None = None, ) -> pd.DataFrame: - """Read Parquet files using Pandas. Raises an exception if reading fails.""" - - # Normalize read_kwargs to a dict to avoid TypeError when None - # Work on a copy to avoid mutating caller's dict - read_kwargs = {} if read_kwargs is None else dict(read_kwargs) - - update_kwargs = {} - if fields is not None: - update_kwargs["columns"] = fields - if "engine" not in read_kwargs: - update_kwargs["engine"] = "pyarrow" - if "dtype_backend" not in read_kwargs: - update_kwargs["dtype_backend"] = "pyarrow" - read_kwargs.update(update_kwargs) - return pd.concat( - (pd.read_parquet(path, **read_kwargs) for path in paths), - ignore_index=True, - ) + return read_parquet_files(paths, read_kwargs, fields) @dataclass diff --git a/pyproject.toml b/pyproject.toml index dd4987aebd..ebca063de4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -54,7 +54,7 @@ dependencies = [ "absl-py>=2.0.0,<3.0.0", "comment_parser", "cosmos-xenna==0.1.2", - "fsspec", + "fsspec>=2024.0", "hydra-core", "jieba==0.42.1", "loguru", @@ -182,7 +182,7 @@ test = [ "pytest-httpserver", "pytest-loguru", "scikit-learn<1.8.0", # cuml 25.10.0 is incompatible with scikit-learn 1.8.0 - "s3fs", # added for testing cloud fs + "s3fs>=2024.0", ] [tool.uv] diff --git a/tests/stages/multimodal/test_data_gen.py b/tests/stages/multimodal/test_data_gen.py new file mode 100644 index 0000000000..e962425597 --- /dev/null +++ b/tests/stages/multimodal/test_data_gen.py @@ -0,0 +1,200 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +import json +import tarfile +from io import BytesIO +from typing import TYPE_CHECKING, Any + +import pyarrow as pa +import pyarrow.parquet as pq +from PIL import Image + +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + +if TYPE_CHECKING: + from pathlib import Path + + +def generate_jpeg_bytes(width: int = 100, height: int = 80, seed: int = 0) -> bytes: + img = Image.new("RGB", (width, height), color=(seed * 37 % 256, seed * 71 % 256, seed * 113 % 256)) + buf = BytesIO() + img.save(buf, format="JPEG") + return buf.getvalue() + + +def generate_png_bytes(width: int = 100, height: int = 80, seed: int = 0) -> bytes: + img = Image.new("RGB", (width, height), color=(seed * 41 % 256, seed * 67 % 256, seed * 97 % 256)) + buf = BytesIO() + img.save(buf, format="PNG") + return buf.getvalue() + + +def build_mint1t_tar( + tmp_path: Path, + samples: list[dict[str, Any]] | None = None, + tar_name: str = "shard-00000.tar", +) -> str: + if samples is None: + samples = [ + { + "sample_id": "sample_a", + "json_payload": { + "pdf_name": "doc_a.pdf", + "texts": ["Hello world", "Second paragraph"], + "images": ["sample_a.jpg"], + "score": 0.95, + }, + "image_bytes": generate_jpeg_bytes(seed=1), + "image_ext": ".jpg", + }, + { + "sample_id": "sample_b", + "json_payload": { + "pdf_name": "doc_b.pdf", + "texts": ["Another doc"], + "images": ["sample_b.jpg", None], + "score": 0.72, + }, + "image_bytes": generate_jpeg_bytes(seed=2), + "image_ext": ".jpg", + }, + ] + + tmp_path.mkdir(parents=True, exist_ok=True) + tar_path = tmp_path / tar_name + with tarfile.open(tar_path, "w") as tf: + for s in samples: + sid = s["sample_id"] + payload_bytes = json.dumps(s["json_payload"]).encode("utf-8") + json_info = tarfile.TarInfo(name=f"{sid}.json") + json_info.size = len(payload_bytes) + tf.addfile(json_info, BytesIO(payload_bytes)) + + img_bytes = s["image_bytes"] + img_info = tarfile.TarInfo(name=f"{sid}{s['image_ext']}") + img_info.size = len(img_bytes) + tf.addfile(img_info, BytesIO(img_bytes)) + + return str(tar_path) + + +def build_multimodal_parquet( + tmp_path: Path, + num_samples: int = 3, + materialized: bool = True, + file_name: str = "test_multimodal.parquet", + image_dir: Path | None = None, +) -> str: + tmp_path.mkdir(parents=True, exist_ok=True) + if image_dir is not None: + image_dir.mkdir(parents=True, exist_ok=True) + + rows: list[dict[str, Any]] = [] + for i in range(num_samples): + sid = f"sample_{i:03d}" + img_bytes = generate_jpeg_bytes(seed=i) if materialized else None + + source_ref_path = None + if not materialized and image_dir is not None: + img_file = image_dir / f"{sid}.jpg" + img_file.write_bytes(generate_jpeg_bytes(seed=i)) + source_ref_path = str(img_file) + + source_ref = json.dumps({ + "path": source_ref_path, + "member": None, + "byte_offset": None, + "byte_size": None, + }) if source_ref_path else None + + metadata_json = json.dumps({ + "pdf_name": f"doc_{i}.pdf", + "texts": [f"Text from sample {i}", f"More text {i}"], + "images": [f"{sid}.jpg"], + "score": 0.5 + i * 0.1, + }) + + rows.append({ + "sample_id": sid, "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": metadata_json, "materialize_error": None, + }) + rows.append({ + "sample_id": sid, "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": f"Text from sample {i}", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }) + rows.append({ + "sample_id": sid, "position": 1, "modality": "text", + "content_type": "text/plain", "text_content": f"More text {i}", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }) + rows.append({ + "sample_id": sid, "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": img_bytes, "source_ref": source_ref, + "metadata_json": None, "materialize_error": None, + }) + + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + parquet_path = tmp_path / file_name + pq.write_table(table, str(parquet_path)) + return str(parquet_path) + + +def build_bad_source_ref_parquet( + tmp_path: Path, + num_samples: int = 2, + file_name: str = "bad_refs.parquet", +) -> str: + tmp_path.mkdir(parents=True, exist_ok=True) + rows: list[dict[str, Any]] = [] + for i in range(num_samples): + sid = f"bad_sample_{i:03d}" + bad_ref = json.dumps({ + "path": f"/nonexistent/path/image_{i}.jpg", + "member": None, + "byte_offset": None, + "byte_size": None, + }) + rows.append({ + "sample_id": sid, "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": json.dumps({"texts": [f"text {i}"], "images": [None]}), + "materialize_error": None, + }) + rows.append({ + "sample_id": sid, "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": f"text {i}", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }) + rows.append({ + "sample_id": sid, "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, "source_ref": bad_ref, + "metadata_json": None, "materialize_error": None, + }) + + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + parquet_path = tmp_path / file_name + pq.write_table(table, str(parquet_path)) + return str(parquet_path) diff --git a/tests/stages/multimodal/test_materialize_error_handling.py b/tests/stages/multimodal/test_materialize_error_handling.py new file mode 100644 index 0000000000..774bfd1148 --- /dev/null +++ b/tests/stages/multimodal/test_materialize_error_handling.py @@ -0,0 +1,98 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 pathlib import Path + +import pandas as pd +import pytest + +from nemo_curator.stages.multimodal.io.readers.parquet import MultimodalParquetReaderStage +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + +from .test_data_gen import build_bad_source_ref_parquet + + +def _read_bad_parquet(tmp_path: Path) -> MultiBatchTask: + pq_path = build_bad_source_ref_parquet(tmp_path / "input", num_samples=3) + reader = MultimodalParquetReaderStage() + task = FileGroupTask( + task_id="fg_bad", dataset_name="test", data=[pq_path], + _metadata={"source_files": [pq_path]}, + ) + return reader.process(task) + + +def test_error_mode_raises_on_materialize_failure(tmp_path: Path): + batch = _read_bad_parquet(tmp_path) + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalParquetWriterStage( + path=str(out_dir), materialize_on_write=True, + on_materialize_error="error", mode="overwrite", + ) + with pytest.raises(RuntimeError, match="failed to materialize"): + writer.process(batch) + + +def test_drop_row_mode_removes_failed_image_rows(tmp_path: Path): + batch = _read_bad_parquet(tmp_path) + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalParquetWriterStage( + path=str(out_dir), materialize_on_write=True, + on_materialize_error="drop_row", mode="overwrite", + ) + result = writer.process(batch) + written = pd.read_parquet(result.data[0]) + image_rows = written[written["modality"] == "image"] + assert len(image_rows) == 0 + + +def test_drop_sample_mode_removes_entire_samples(tmp_path: Path): + batch = _read_bad_parquet(tmp_path) + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalParquetWriterStage( + path=str(out_dir), materialize_on_write=True, + on_materialize_error="drop_sample", mode="overwrite", + ) + result = writer.process(batch) + written = pd.read_parquet(result.data[0]) + assert len(written) == 0 + + +def test_wds_writer_error_mode(tmp_path: Path): + batch = _read_bad_parquet(tmp_path) + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=True, + on_materialize_error="error", mode="overwrite", + ) + with pytest.raises(RuntimeError, match="failed to materialize"): + writer.process(batch) + + +def test_wds_writer_drop_row_mode(tmp_path: Path): + batch = _read_bad_parquet(tmp_path) + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=True, + on_materialize_error="drop_row", mode="overwrite", + ) + result = writer.process(batch) + assert result.data[0].endswith(".tar") diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index c54cd93a00..0301b5a6a4 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -160,7 +160,7 @@ def test_classify_rows_range_read() -> None: assert not result.tar_extract assert not result.direct_read entry = result.range_read["/shard.tar"][0] - assert entry == (0, "img.jpg", 512, 1024, None) + assert entry == (0, "img.jpg", 512, 1024) def test_classify_rows_missing_path() -> None: diff --git a/tests/stages/multimodal/test_multimodal_parquet_reader.py b/tests/stages/multimodal/test_multimodal_parquet_reader.py new file mode 100644 index 0000000000..04ed555fde --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_parquet_reader.py @@ -0,0 +1,101 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 pathlib import Path + +import pytest + +from nemo_curator.stages.multimodal.io.readers.parquet import MultimodalParquetReaderStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + +from .test_data_gen import build_multimodal_parquet + + +def _make_task(parquet_path: str) -> FileGroupTask: + return FileGroupTask( + task_id="file_group_0", + dataset_name="test_dataset", + data=[parquet_path], + _metadata={"source_files": [parquet_path]}, + ) + + +def test_reader_reads_materialized_parquet(tmp_path: Path): + pq_path = build_multimodal_parquet(tmp_path, num_samples=3, materialized=True) + reader = MultimodalParquetReaderStage() + result = reader.process(_make_task(pq_path)) + + assert isinstance(result, MultiBatchTask) + df = result.to_pandas() + assert len(df) == 12 # 3 samples * 4 rows each (metadata + 2 text + 1 image) + assert set(df["sample_id"].unique()) == {"sample_000", "sample_001", "sample_002"} + assert set(df["modality"].unique()) == {"metadata", "text", "image"} + + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 3 + for _, row in image_rows.iterrows(): + assert isinstance(row["binary_content"], bytes) + assert len(row["binary_content"]) > 0 + + +def test_reader_reads_non_materialized_parquet(tmp_path: Path): + pq_path = build_multimodal_parquet( + tmp_path, num_samples=2, materialized=False, image_dir=tmp_path / "images", + ) + reader = MultimodalParquetReaderStage() + result = reader.process(_make_task(pq_path)) + + df = result.to_pandas() + assert len(df) == 8 # 2 samples * 4 rows + image_rows = df[df["modality"] == "image"] + assert image_rows["binary_content"].isna().all() + assert image_rows["source_ref"].notna().all() + + +def test_reader_preserves_sample_integrity(tmp_path: Path): + pq_path = build_multimodal_parquet(tmp_path, num_samples=5, materialized=True) + reader = MultimodalParquetReaderStage() + result = reader.process(_make_task(pq_path)) + + df = result.to_pandas() + for sid in df["sample_id"].unique(): + group = df[df["sample_id"] == sid] + assert (group["modality"] == "metadata").sum() == 1 + assert (group["modality"] == "text").sum() == 2 + assert (group["modality"] == "image").sum() == 1 + + +def test_reader_with_fields_filter(tmp_path: Path): + pq_path = build_multimodal_parquet(tmp_path, num_samples=2, materialized=True) + reader = MultimodalParquetReaderStage( + fields=["sample_id", "modality", "position", "text_content"], + ) + result = reader.process(_make_task(pq_path)) + + df = result.to_pandas() + assert "text_content" in df.columns + assert "binary_content" not in df.columns + + +def test_reader_raises_on_empty_parquet(tmp_path: Path): + import pyarrow as pa + import pyarrow.parquet as pq + + from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + + empty_path = tmp_path / "empty.parquet" + pq.write_table(pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA), str(empty_path)) + reader = MultimodalParquetReaderStage() + with pytest.raises(ValueError, match="No data read"): + reader.process(_make_task(str(empty_path))) diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 1310680a7e..195636ff3d 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -206,6 +206,35 @@ def test_reader_empty_output_schema_includes_requested_passthrough_fields(tmp_pa assert "p_hash" in df.columns +def test_reader_materialize_on_read_sets_error_for_failed_extraction(tmp_path: Path) -> None: + """When materialize_on_read=True and _extract_tar_member returns None, materialize_error must be set.""" + + class _FailingExtractReader(WebdatasetReaderStage): + @staticmethod + def _extract_tar_member(_tf: tarfile.TarFile, _member_name: str, _cache: dict[str, bytes | None]) -> None: + return None + + tar_path = tmp_path / "extract-fail.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello"], + "images": ["image.jpg"], + } + _write_tar_sample(tar_path, payload) + + task = _task_for_tar(tar_path, "extract_fail_test") + reader = _FailingExtractReader( + source_id_field="pdf_name", + materialize_on_read=True, + ) + df = _as_df(reader.process(task)) + + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 1 + assert pd.isna(image_rows.iloc[0]["binary_content"]) + assert "missing member" in str(image_rows.iloc[0]["materialize_error"]) + + @pytest.mark.parametrize( ("task_id", "fields", "error_pattern"), [ diff --git a/tests/stages/multimodal/test_multimodal_roundtrip.py b/tests/stages/multimodal/test_multimodal_roundtrip.py new file mode 100644 index 0000000000..6fcdbb681f --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_roundtrip.py @@ -0,0 +1,140 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 tarfile +from pathlib import Path + +from nemo_curator.stages.multimodal.io.readers.parquet import MultimodalParquetReaderStage +from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage +from nemo_curator.tasks import FileGroupTask, MultiBatchTask + +from .test_data_gen import build_mint1t_tar, build_multimodal_parquet + + +def test_parquet_to_wds_to_parquet(tmp_path: Path): + pq_path = build_multimodal_parquet(tmp_path / "input", num_samples=3, materialized=True) + + reader = MultimodalParquetReaderStage() + task = FileGroupTask( + task_id="fg_0", dataset_name="test", data=[pq_path], _metadata={"source_files": [pq_path]}, + ) + batch = reader.process(task) + assert isinstance(batch, MultiBatchTask) + original_df = batch.to_pandas() + + wds_dir = tmp_path / "wds_output" + wds_dir.mkdir() + wds_writer = MultimodalWebdatasetWriterStage( + path=str(wds_dir), materialize_on_write=False, mode="overwrite", + ) + wds_result = wds_writer.process(batch) + tar_path = wds_result.data[0] + + wds_reader = WebdatasetReaderStage(source_id_field="pdf_name", materialize_on_read=True) + wds_task = FileGroupTask( + task_id="fg_wds", dataset_name="test", data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) + wds_batch = wds_reader.process(wds_task) + if isinstance(wds_batch, list): + wds_batch = wds_batch[0] + + pq_dir2 = tmp_path / "pq_output" + pq_dir2.mkdir() + pq_writer = MultimodalParquetWriterStage( + path=str(pq_dir2), materialize_on_write=False, mode="overwrite", + ) + pq_writer.process(wds_batch) + + reader2 = MultimodalParquetReaderStage() + pq_files = list(pq_dir2.glob("*.parquet")) + assert len(pq_files) >= 1 + task2 = FileGroupTask( + task_id="fg_2", dataset_name="test", data=[str(p) for p in pq_files], + _metadata={"source_files": [str(p) for p in pq_files]}, + ) + final_batch = reader2.process(task2) + final_df = final_batch.to_pandas() + + orig_samples = set(original_df["sample_id"].unique()) + final_samples = set(final_df["sample_id"].unique()) + assert len(final_samples) == len(orig_samples) + + for sid in orig_samples: + orig_mask = (original_df["sample_id"] == sid) & (original_df["modality"] == "text") + orig_texts = sorted(original_df[orig_mask]["text_content"].tolist()) + final_mask = (final_df["sample_id"] == sid) & (final_df["modality"] == "text") + final_texts = sorted(final_df[final_mask]["text_content"].dropna().tolist()) + assert orig_texts == final_texts, f"Text mismatch for {sid}" + + +def test_wds_to_parquet_to_wds(tmp_path: Path): + tar_path = build_mint1t_tar(tmp_path / "input") + + wds_reader = WebdatasetReaderStage(source_id_field="pdf_name", materialize_on_read=True) + task = FileGroupTask( + task_id="fg_0", dataset_name="test", data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) + batch = wds_reader.process(task) + if isinstance(batch, list): + batch = batch[0] + original_df = batch.to_pandas() + + pq_dir = tmp_path / "pq_output" + pq_dir.mkdir() + pq_writer = MultimodalParquetWriterStage( + path=str(pq_dir), materialize_on_write=False, mode="overwrite", + ) + pq_writer.process(batch) + + pq_reader = MultimodalParquetReaderStage() + pq_files = list(pq_dir.glob("*.parquet")) + pq_task = FileGroupTask( + task_id="fg_pq", dataset_name="test", data=[str(p) for p in pq_files], + _metadata={"source_files": [str(p) for p in pq_files]}, + ) + pq_batch = pq_reader.process(pq_task) + if isinstance(pq_batch, list): + pq_batch = pq_batch[0] + + wds_dir = tmp_path / "wds_output" + wds_dir.mkdir() + wds_writer = MultimodalWebdatasetWriterStage( + path=str(wds_dir), materialize_on_write=False, mode="overwrite", + ) + wds_writer.process(pq_batch) + + tar_files = list(wds_dir.glob("*.tar")) + assert len(tar_files) >= 1 + + with tarfile.open(tar_files[0], "r") as tf: + json_members = [m for m in tf.getmembers() if m.name.endswith(".json")] + assert len(json_members) == 2 + + for member in json_members: + payload = json.load(tf.extractfile(member)) + assert "texts" in payload + assert "images" in payload + assert isinstance(payload["texts"], list) + + orig_image_rows = original_df[original_df["modality"] == "image"] + materialized_count = orig_image_rows["binary_content"].notna().sum() + + with tarfile.open(tar_files[0], "r") as tf: + img_members = [m for m in tf.getmembers() if m.name.endswith(".jpg")] + assert len(img_members) == materialized_count diff --git a/tests/stages/multimodal/test_multimodal_wds_writer.py b/tests/stages/multimodal/test_multimodal_wds_writer.py new file mode 100644 index 0000000000..34169e27fb --- /dev/null +++ b/tests/stages/multimodal/test_multimodal_wds_writer.py @@ -0,0 +1,179 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 tarfile +from pathlib import Path + +import pyarrow as pa + +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage +from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + +from .test_data_gen import generate_jpeg_bytes + + +def _make_task(num_samples: int = 2) -> MultiBatchTask: + rows = [] + for i in range(num_samples): + sid = f"sample_{i:03d}" + img_bytes = generate_jpeg_bytes(seed=i) + metadata_json = json.dumps({ + "pdf_name": f"doc_{i}.pdf", + "texts": [f"text_{i}_0", f"text_{i}_1"], + "images": [f"{sid}.jpg"], + "score": 0.5 + i * 0.1, + }) + rows.extend([ + { + "sample_id": sid, "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": metadata_json, "materialize_error": None, + }, + { + "sample_id": sid, "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": f"text_{i}_0", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": sid, "position": 1, "modality": "text", + "content_type": "text/plain", "text_content": f"text_{i}_1", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": sid, "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": img_bytes, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + ]) + + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + return MultiBatchTask( + task_id="test_task", + dataset_name="test_dataset", + data=table, + _metadata={"source_files": ["test.parquet"]}, + ) + + +def test_writer_produces_valid_tar(tmp_path: Path): + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + result = writer.process(_make_task(num_samples=2)) + + assert len(result.data) == 1 + tar_path = result.data[0] + assert tar_path.endswith(".tar") + + with tarfile.open(tar_path, "r") as tf: + members = [m for m in tf.getmembers() if m.isfile()] + names = {m.name for m in members} + assert len(names) >= 4 # 2 samples * (json + jpg) + + json_members = [n for n in names if n.endswith(".json")] + assert len(json_members) == 2 + + +def test_writer_preserves_text_content(tmp_path: Path): + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + writer.process(_make_task(num_samples=1)) + + tar_files = list(out_dir.glob("*.tar")) + assert len(tar_files) == 1 + + with tarfile.open(tar_files[0], "r") as tf: + for member in tf.getmembers(): + if member.name.endswith(".json"): + payload = json.load(tf.extractfile(member)) + assert "texts" in payload + assert payload["texts"] == ["text_0_0", "text_0_1"] + assert "images" in payload + + +def test_writer_preserves_image_bytes(tmp_path: Path): + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + writer.process(_make_task(num_samples=1)) + + expected_bytes = generate_jpeg_bytes(seed=0) + tar_files = list(out_dir.glob("*.tar")) + with tarfile.open(tar_files[0], "r") as tf: + for member in tf.getmembers(): + if member.name.endswith(".jpg"): + actual_bytes = tf.extractfile(member).read() + assert actual_bytes == expected_bytes + + +def test_writer_handles_no_binary_content(tmp_path: Path): + rows = [ + { + "sample_id": "s1", "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": json.dumps({"texts": ["hi"], "images": [None]}), + "materialize_error": None, + }, + { + "sample_id": "s1", "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": "hi", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": "s1", "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + ] + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + task = MultiBatchTask( + task_id="no_binary", dataset_name="test", data=table, + _metadata={"source_files": ["x"]}, + ) + + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + writer.process(task) + + tar_files = list(out_dir.glob("*.tar")) + with tarfile.open(tar_files[0], "r") as tf: + names = {m.name for m in tf.getmembers() if m.isfile()} + jpg_members = [n for n in names if n.endswith(".jpg")] + assert len(jpg_members) == 0 + + json_members = [n for n in names if n.endswith(".json")] + assert len(json_members) == 1 + for m in tf.getmembers(): + if m.name.endswith(".json"): + payload = json.load(tf.extractfile(m)) + assert payload["images"] == [None] diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 84b6793f74..1211aee1a8 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -56,13 +56,20 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input _stage_perf=batch._stage_perf, ) - writer = MultimodalParquetWriterStage(path=str(tmp_path / "out_bad"), materialize_on_write=True, mode="overwrite") + writer = MultimodalParquetWriterStage( + path=str(tmp_path / "out_bad"), materialize_on_write=True, on_materialize_error="warn", mode="overwrite", + ) write_task = writer.process(bad_batch) written = pd.read_parquet(write_task.data[0]) + assert len(written) == len(df), "warn mode should preserve all rows" target = written.loc[first_image_idx] - assert pd.isna(target["binary_content"]) - assert isinstance(target["materialize_error"], str) + assert pd.isna(target["binary_content"]), "failed image should have no binary_content" + assert isinstance(target["materialize_error"], str), "failed image should have an error message" + assert "failed" in target["materialize_error"].lower() or "missing" in target["materialize_error"].lower() + + non_image_rows = written[written["modality"] != "image"] + assert non_image_rows["materialize_error"].isna().all(), "non-image rows should have no materialize errors" def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> None: diff --git a/uv.lock b/uv.lock index cb0c915716..52f4daf956 100644 --- a/uv.lock +++ b/uv.lock @@ -575,21 +575,12 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/75/aa/abcd75e9600987a0bc6cfe9b6b2ff3f0e2cb08c170addc6e76035b5c4cb3/blake3-1.0.8.tar.gz", hash = "sha256:513cc7f0f5a7c035812604c2c852a0c1468311345573de647e310aca4ab165ba", size = 117308, upload-time = "2025-10-14T06:47:48.83Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/df/0825da1cde7ca63a8bcdc785ca7f8647b025e9497eef18c75bb9754dbd26/blake3-1.0.8-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9e1d70bf76c02846d0868a3d413eb6c430b76a315e12f1b2e59b5cf56c1f62a3", size = 374945, upload-time = "2025-10-14T06:45:13.99Z" }, - { url = "https://files.pythonhosted.org/packages/db/8f/9431bf5fe0eedeb2aadb4fe81fb18945cf8d49adad98e7988fb3cdac76c2/blake3-1.0.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97c076d58ee37eb5b2d8d91bb9db59c5a008fd59c71845dc57fe438aeeabaf10", size = 507107, upload-time = "2025-10-14T06:45:17.055Z" }, - { url = "https://files.pythonhosted.org/packages/ac/55/3712cdaebaefa8d5acec46f8df7861ba1832e1e188bc1333dd5acd31f760/blake3-1.0.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78731ce7fca46f776ae45fb5271a2a76c4a92c9687dd4337e84b2ae9a174b28f", size = 393955, upload-time = "2025-10-14T06:45:18.718Z" }, { url = "https://files.pythonhosted.org/packages/1f/d0/add0441e7aaa6b358cac0ddc9246f0799b60d25f06bd542b554afe19fd85/blake3-1.0.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c65e373c8b47174b969ee61a89ee56922f722972eb650192845c8546df8d9db9", size = 387577, upload-time = "2025-10-14T06:45:20.332Z" }, { url = "https://files.pythonhosted.org/packages/28/c7/90c01091465628acff96534e82d4b3bc16ca22c515f69916d2715273c0e3/blake3-1.0.8-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:67d9c42c42eb1c7aedcf901591c743266009fcf48babf6d6f8450f567cb94a84", size = 554650, upload-time = "2025-10-14T06:45:23.047Z" }, { url = "https://files.pythonhosted.org/packages/3c/7e/ab9b5c4b650ff397d347451bfb1ad7e6e53dc06c945e2fd091f27a76422e/blake3-1.0.8-cp310-cp310-win_amd64.whl", hash = "sha256:725c52c4d393c7bd1a10682df322d480734002a1389b320366c660568708846b", size = 215660, upload-time = "2025-10-14T06:45:25.381Z" }, - { url = "https://files.pythonhosted.org/packages/a0/33/9d342a2bf5817f006bbe947335e5d387327541ea47590854947befd01251/blake3-1.0.8-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:58ce8d45a5bb5326482de72ea1969a378634236186a970fef63058a5b7b8b435", size = 374859, upload-time = "2025-10-14T06:45:35.262Z" }, - { url = "https://files.pythonhosted.org/packages/a5/67/167a65a4c431715407d07b1b8b1367698a3ad88e7260edb85f0c5293f08a/blake3-1.0.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b5573b052777142b2cecc453d022c3f21aa4aba75011258410bb98f41c1a727", size = 507519, upload-time = "2025-10-14T06:45:37.814Z" }, - { url = "https://files.pythonhosted.org/packages/32/e2/0886e192d634b264c613b0fbf380745b39992b424a0effc00ef08783644e/blake3-1.0.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe1b02ab49bfd969ef50b9f17482a2011c77536654af21807ba5c2674e0bb2a0", size = 393645, upload-time = "2025-10-14T06:45:39.146Z" }, { url = "https://files.pythonhosted.org/packages/fc/3b/7fb2fe615448caaa5f6632b2c7551117b38ccac747a3a5769181e9751641/blake3-1.0.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c7780666dc6be809b49442d6d5ce06fdbe33024a87560b58471103ec17644682", size = 387640, upload-time = "2025-10-14T06:45:40.546Z" }, { url = "https://files.pythonhosted.org/packages/7e/75/0252be37620699b79dbaa799c9b402d63142a131d16731df4ef09d135dd7/blake3-1.0.8-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c63ece266a43014cf29e772a82857cd8e90315ae3ed53e3c5204851596edd5f2", size = 554463, upload-time = "2025-10-14T06:45:43.22Z" }, { url = "https://files.pythonhosted.org/packages/34/d7/33b01e27dc3542dc9ec44132684506f880cd0257b04da0bf7f4b2afa41c8/blake3-1.0.8-cp311-cp311-win_amd64.whl", hash = "sha256:8f2ef8527a7a8afd99b16997d015851ccc0fe2a409082cebb980af2554e5c74c", size = 215733, upload-time = "2025-10-14T06:45:46.049Z" }, - { url = "https://files.pythonhosted.org/packages/e3/20/488475254976ed93fab57c67aa80d3b40df77f7d9db6528c9274bff53e08/blake3-1.0.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:66ca28a673025c40db3eba21a9cac52f559f83637efa675b3f6bd8683f0415f3", size = 374516, upload-time = "2025-10-14T06:45:51.23Z" }, - { url = "https://files.pythonhosted.org/packages/cb/7d/db0626df16029713e7e61b67314c4835e85c296d82bd907c21c6ea271da2/blake3-1.0.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5b5da177d62cc4b7edf0cea08fe4dec960c9ac27f916131efa890a01f747b93", size = 505420, upload-time = "2025-10-14T06:45:54.445Z" }, - { url = "https://files.pythonhosted.org/packages/5b/55/6e737850c2d58a6d9de8a76dad2ae0f75b852a23eb4ecb07a0b165e6e436/blake3-1.0.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:38209b10482c97e151681ea3e91cc7141f56adbbf4820a7d701a923124b41e6a", size = 394189, upload-time = "2025-10-14T06:45:55.719Z" }, { url = "https://files.pythonhosted.org/packages/5b/94/eafaa5cdddadc0c9c603a6a6d8339433475e1a9f60c8bb9c2eed2d8736b6/blake3-1.0.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504d1399b7fb91dfe5c25722d2807990493185faa1917456455480c36867adb5", size = 388001, upload-time = "2025-10-14T06:45:57.067Z" }, { url = "https://files.pythonhosted.org/packages/0e/c6/d1fe8bdea4a6088bd54b5a58bc40aed89a4e784cd796af7722a06f74bae7/blake3-1.0.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a25db3d36b55f5ed6a86470155cc749fc9c5b91c949b8d14f48658f9d960d9ec", size = 554211, upload-time = "2025-10-14T06:46:00.269Z" }, { url = "https://files.pythonhosted.org/packages/4d/42/bbd02647169e3fbed27558555653ac2578c6f17ccacf7d1956c58ef1d214/blake3-1.0.8-cp312-cp312-win_amd64.whl", hash = "sha256:6a6eafc29e4f478d365a87d2f25782a521870c8514bb43734ac85ae9be71caf7", size = 215704, upload-time = "2025-10-14T06:46:02.79Z" }, @@ -2031,38 +2022,18 @@ version = "0.8.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/69/e7/f89d54fb04104114dd0552836dc2b47914f416cc0e200b409dd04a33de5e/fastar-0.8.0.tar.gz", hash = "sha256:f4d4d68dbf1c4c2808f0e730fac5843493fc849f70fe3ad3af60dfbaf68b9a12", size = 68524, upload-time = "2025-11-26T02:36:00.72Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/5e/4608184aa57cb6a54f62c1eb3e5133ba8d461fc7f13193c0255effbec12a/fastar-0.8.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a90695a601a78bbca910fdf2efcdf3103c55d0de5a5c6e93556d707bf886250b", size = 765987, upload-time = "2025-11-26T02:32:59.701Z" }, - { url = "https://files.pythonhosted.org/packages/e0/53/6afd2b680dddfa10df9a16bbcf6cabfee0d92435d5c7e3f4cfe3b1712662/fastar-0.8.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d0bf655ff4c9320b0ca8a5b128063d5093c0c8c1645a2b5f7167143fd8531aa", size = 930900, upload-time = "2025-11-26T02:33:16.059Z" }, - { url = "https://files.pythonhosted.org/packages/ef/1e/b7a304bfcc1d06845cbfa4b464516f6fff9c8c6692f6ef80a3a86b04e199/fastar-0.8.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d8df22cdd8d58e7689aa89b2e4a07e8e5fa4f88d2d9c2621f0e88a49be97ccea", size = 821523, upload-time = "2025-11-26T02:33:30.897Z" }, { url = "https://files.pythonhosted.org/packages/1d/da/9ef8605c6d233cd6ca3a95f7f518ac22aa064903afe6afa57733bfb7c31b/fastar-0.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8a5e6ad722685128521c8fb44cf25bd38669650ba3a4b466b8903e5aa28e1a0", size = 821268, upload-time = "2025-11-26T02:34:04.003Z" }, - { url = "https://files.pythonhosted.org/packages/ca/a6/366b15f432d85d4089e6e4b52a09cc2a2bcf4d7a1f0771e3d3194deccb1e/fastar-0.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:175db2a98d67ced106468e8987975484f8bbbd5ad99201da823b38bafb565ed5", size = 1041921, upload-time = "2025-11-26T02:35:07.292Z" }, { url = "https://files.pythonhosted.org/packages/c2/e2/a587796111a3cd4b78cd61ec3fc1252d8517d81f763f4164ed5680f84810/fastar-0.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:01084cb75f13ca6a8e80bd41584322523189f8e81b472053743d6e6c3062b5a6", size = 995141, upload-time = "2025-11-26T02:35:42.449Z" }, { url = "https://files.pythonhosted.org/packages/be/a9/8da4deb840121c59deabd939ce2dca3d6beec85576f3743d1144441938b5/fastar-0.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:fbc0f2ed0f4add7fb58034c576584d44d7eaaf93dee721dfb26dbed6e222dbac", size = 490701, upload-time = "2025-11-26T02:36:09.625Z" }, - { url = "https://files.pythonhosted.org/packages/d6/45/3eb0ee945a0b5d5f9df7e7c25c037ce7fa441cd0b4d44f76d286e2f4396a/fastar-0.8.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3719541a12bb09ab1eae91d2c987a9b2b7d7149c52e7109ba6e15b74aabc49b1", size = 765587, upload-time = "2025-11-26T02:33:01.174Z" }, - { url = "https://files.pythonhosted.org/packages/51/bb/7defd6ec0d9570b1987d8ebde52d07d97f3f26e10b592fb3e12738eba39a/fastar-0.8.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7a9b0fff8079b18acdface7ef1b7f522fd9a589f65ca4a1a0dd7c92a0886c2a2", size = 931150, upload-time = "2025-11-26T02:33:17.374Z" }, - { url = "https://files.pythonhosted.org/packages/28/54/62e51e684dab347c61878afbf09e177029c1a91eb1e39ef244e6b3ef9efa/fastar-0.8.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ac073576c1931959191cb20df38bab21dd152f66c940aa3ca8b22e39f753b2f3", size = 821354, upload-time = "2025-11-26T02:33:32.083Z" }, { url = "https://files.pythonhosted.org/packages/53/a8/12708ea4d21e3cf9f485b2a67d44ce84d949a6eddcc9aa5b3d324585ab43/fastar-0.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:003b59a7c3e405b6a7bff8fab17d31e0ccbc7f06730a8f8ca1694eeea75f3c76", size = 821626, upload-time = "2025-11-26T02:34:05.685Z" }, - { url = "https://files.pythonhosted.org/packages/dc/59/2dbe0dc2570764475e60030403738faa261a9d3bff16b08629c378ab939a/fastar-0.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:90957a30e64418b02df5b4d525bea50403d98a4b1f29143ce5914ddfa7e54ee4", size = 1041536, upload-time = "2025-11-26T02:35:08.926Z" }, { url = "https://files.pythonhosted.org/packages/cb/e7/23e3a19e06d261d1894f98eca9458f98c090c505a0c712dafc0ff1fc2965/fastar-0.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a03eaf287bbc93064688a1220580ce261e7557c8898f687f4d0b281c85b28d3c", size = 994992, upload-time = "2025-11-26T02:35:44.009Z" }, { url = "https://files.pythonhosted.org/packages/cb/3c/0142bee993c431ee91cf5535e6e4b079ad491f620c215fcd79b7e5ffeb2b/fastar-0.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:b48abd6056fef7bc3d414aafb453c5b07fdf06d2df5a2841d650288a3aa1e9d3", size = 490863, upload-time = "2025-11-26T02:36:11.114Z" }, - { url = "https://files.pythonhosted.org/packages/d0/00/c3155171b976003af3281f5258189f1935b15d1221bfc7467b478c631216/fastar-0.8.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:83c391e5b789a720e4d0029b9559f5d6dee3226693c5b39c0eab8eaece997e0f", size = 764717, upload-time = "2025-11-26T02:33:02.453Z" }, - { url = "https://files.pythonhosted.org/packages/b7/43/405b7ad76207b2c11b7b59335b70eac19e4a2653977f5588a1ac8fed54f4/fastar-0.8.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3258d7a78a72793cdd081545da61cabe85b1f37634a1d0b97ffee0ff11d105ef", size = 931502, upload-time = "2025-11-26T02:33:18.619Z" }, - { url = "https://files.pythonhosted.org/packages/da/8a/a3dde6d37cc3da4453f2845cdf16675b5686b73b164f37e2cc579b057c2c/fastar-0.8.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e6eab95dd985cdb6a50666cbeb9e4814676e59cfe52039c880b69d67cfd44767", size = 821454, upload-time = "2025-11-26T02:33:33.427Z" }, { url = "https://files.pythonhosted.org/packages/da/c1/904fe2468609c8990dce9fe654df3fbc7324a8d8e80d8240ae2c89757064/fastar-0.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:829b1854166141860887273c116c94e31357213fa8e9fe8baeb18bd6c38aa8d9", size = 821647, upload-time = "2025-11-26T02:34:07Z" }, - { url = "https://files.pythonhosted.org/packages/af/af/60c1bfa6edab72366461a95f053d0f5f7ab1825fe65ca2ca367432cd8629/fastar-0.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b864a95229a7db0814cd9ef7987cb713fd43dce1b0d809dd17d9cd6f02fdde3e", size = 1040207, upload-time = "2025-11-26T02:35:10.65Z" }, { url = "https://files.pythonhosted.org/packages/a7/74/cf663af53c4706ba88e6b4af44a6b0c3bd7d7ca09f079dc40647a8f06585/fastar-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7f41c51ee96f338662ee3c3df4840511ba3f9969606840f1b10b7cb633a3c716", size = 994877, upload-time = "2025-11-26T02:35:45.797Z" }, { url = "https://files.pythonhosted.org/packages/dc/34/fc3b5e56d71a17b1904800003d9251716e8fd65f662e1b10a26881698a74/fastar-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:fc645994d5b927d769121094e8a649b09923b3c13a8b0b98696d8f853f23c532", size = 490429, upload-time = "2025-11-26T02:36:12.707Z" }, - { url = "https://files.pythonhosted.org/packages/36/b6/043b263c4126bf6557c942d099503989af9c5c7ee5cca9a04e00f754816f/fastar-0.8.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a78e5221b94a80800930b7fd0d0e797ae73aadf7044c05ed46cb9bdf870f022", size = 766755, upload-time = "2025-11-26T02:33:11.595Z" }, - { url = "https://files.pythonhosted.org/packages/57/ff/29a5dc06f2940439ebf98661ecc98d48d3f22fed8d6a2d5dc985d1e8da24/fastar-0.8.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:997092d31ff451de8d0568f6773f3517cb87dcd0bc76184edb65d7154390a6f8", size = 932732, upload-time = "2025-11-26T02:33:27.122Z" }, - { url = "https://files.pythonhosted.org/packages/eb/e8/2218830f422b37aad52c24b53cb84b5d88bd6fd6ad411bd6689b1a32500d/fastar-0.8.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:558e8fcf8fe574541df5db14a46cd98bfbed14a811b7014a54f2b714c0cfac42", size = 822571, upload-time = "2025-11-26T02:33:42.986Z" }, { url = "https://files.pythonhosted.org/packages/6e/fd/ba6dfeff77cddfe58d85c490b1735c002b81c0d6f826916a8b6c4f8818bc/fastar-0.8.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1d2a54f87e2908cc19e1a6ee249620174fbefc54a219aba1eaa6f31657683c3", size = 822440, upload-time = "2025-11-26T02:34:15.439Z" }, - { url = "https://files.pythonhosted.org/packages/ee/c7/18115927f16deb1ddffdbd4ae992e7e33064bc6defa2b92a147948f8bc0c/fastar-0.8.0-pp310-pypy310_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:0afbb92f78bf29d5e9db76fb46cbabc429e49015cddf72ab9e761afbe88ac100", size = 1042675, upload-time = "2025-11-26T02:35:20.252Z" }, { url = "https://files.pythonhosted.org/packages/44/ee/25cd645db749b206bb95e1512e57e75d56ccbbb8ec3536f52a7979deab6b/fastar-0.8.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e6c4d6329da568ec36b1347b0c09c4d27f9dfdeddf9f438ddb16799ecf170098", size = 997397, upload-time = "2025-11-26T02:35:56.215Z" }, - { url = "https://files.pythonhosted.org/packages/0b/90/23a3f6c252f11b10c70f854bce09abc61f71b5a0e6a4b0eac2bcb9a2c583/fastar-0.8.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ef0bcf4385bbdd3c1acecce2d9ea7dab7cc9b8ee0581bbccb7ab11908a7ce288", size = 766861, upload-time = "2025-11-26T02:33:12.824Z" }, - { url = "https://files.pythonhosted.org/packages/76/bb/beeb9078380acd4484db5c957d066171695d9340e3526398eb230127b0c2/fastar-0.8.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f10ef62b6eda6cb6fd9ba8e1fe08a07d7b2bdcc8eaa00eb91566143b92ed7eee", size = 932667, upload-time = "2025-11-26T02:33:28.405Z" }, - { url = "https://files.pythonhosted.org/packages/f4/6d/b034cc637bd0ee638d5a85d08e941b0b8ffd44cf391fb751ba98233734f7/fastar-0.8.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c4f6c82a8ee98c17aa48585ee73b51c89c1b010e5c951af83e07c3436180e3fc", size = 822712, upload-time = "2025-11-26T02:33:44.27Z" }, { url = "https://files.pythonhosted.org/packages/e2/2b/7d183c63f59227c4689792042d6647f2586a5e7273b55e81745063088d81/fastar-0.8.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6129067fcb86276635b5857010f4e9b9c7d5d15dd571bb03c6c1ed73c40fd92", size = 822659, upload-time = "2025-11-26T02:34:16.815Z" }, - { url = "https://files.pythonhosted.org/packages/a4/b9/9a8c3fd59958c1c8027bc075af11722cdc62c4968bb277e841d131232289/fastar-0.8.0-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:382bfe82c026086487cb17fee12f4c1e2b4e67ce230f2e04487d3e7ddfd69031", size = 1042911, upload-time = "2025-11-26T02:35:21.857Z" }, { url = "https://files.pythonhosted.org/packages/9e/8a/218ab6d9a2bab3b07718e6cd8405529600edc1e9c266320e8524c8f63251/fastar-0.8.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:1aa7dbde2d2d73eb5b6203d0f74875cb66350f0f1b4325b4839fc8fbbf5d074e", size = 997309, upload-time = "2025-11-26T02:35:57.722Z" }, ] @@ -2495,7 +2466,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/6a/33d1702184d94106d3cdd7bfb788e19723206fce152e303473ca3b946c7b/greenlet-3.3.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:6f8496d434d5cb2dce025773ba5597f71f5410ae499d5dd9533e0653258cdb3d", size = 273658, upload-time = "2025-12-04T14:23:37.494Z" }, { url = "https://files.pythonhosted.org/packages/d6/b7/2b5805bbf1907c26e434f4e448cd8b696a0b71725204fa21a211ff0c04a7/greenlet-3.3.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b96dc7eef78fd404e022e165ec55327f935b9b52ff355b067eb4a0267fc1cffb", size = 574810, upload-time = "2025-12-04T14:50:04.154Z" }, { url = "https://files.pythonhosted.org/packages/94/38/343242ec12eddf3d8458c73f555c084359883d4ddc674240d9e61ec51fd6/greenlet-3.3.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73631cd5cccbcfe63e3f9492aaa664d278fda0ce5c3d43aeda8e77317e38efbd", size = 586248, upload-time = "2025-12-04T14:57:39.35Z" }, - { url = "https://files.pythonhosted.org/packages/f0/d0/0ae86792fb212e4384041e0ef8e7bc66f59a54912ce407d26a966ed2914d/greenlet-3.3.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b299a0cb979f5d7197442dccc3aee67fce53500cd88951b7e6c35575701c980b", size = 597403, upload-time = "2025-12-04T15:07:10.831Z" }, { url = "https://files.pythonhosted.org/packages/b6/a8/15d0aa26c0036a15d2659175af00954aaaa5d0d66ba538345bd88013b4d7/greenlet-3.3.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dee147740789a4632cace364816046e43310b59ff8fb79833ab043aefa72fd5", size = 586910, upload-time = "2025-12-04T14:25:59.705Z" }, { url = "https://files.pythonhosted.org/packages/e1/9b/68d5e3b7ccaba3907e5532cf8b9bf16f9ef5056a008f195a367db0ff32db/greenlet-3.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:39b28e339fc3c348427560494e28d8a6f3561c8d2bcf7d706e1c624ed8d822b9", size = 1547206, upload-time = "2025-12-04T15:04:21.027Z" }, { url = "https://files.pythonhosted.org/packages/66/bd/e3086ccedc61e49f91e2cfb5ffad9d8d62e5dc85e512a6200f096875b60c/greenlet-3.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b3c374782c2935cc63b2a27ba8708471de4ad1abaa862ffdb1ef45a643ddbb7d", size = 1613359, upload-time = "2025-12-04T14:27:26.548Z" }, @@ -2503,7 +2473,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1f/cb/48e964c452ca2b92175a9b2dca037a553036cb053ba69e284650ce755f13/greenlet-3.3.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e29f3018580e8412d6aaf5641bb7745d38c85228dacf51a73bd4e26ddf2a6a8e", size = 274908, upload-time = "2025-12-04T14:23:26.435Z" }, { url = "https://files.pythonhosted.org/packages/28/da/38d7bff4d0277b594ec557f479d65272a893f1f2a716cad91efeb8680953/greenlet-3.3.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a687205fb22794e838f947e2194c0566d3812966b41c78709554aa883183fb62", size = 577113, upload-time = "2025-12-04T14:50:05.493Z" }, { url = "https://files.pythonhosted.org/packages/3c/f2/89c5eb0faddc3ff014f1c04467d67dee0d1d334ab81fadbf3744847f8a8a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4243050a88ba61842186cb9e63c7dfa677ec146160b0efd73b855a3d9c7fcf32", size = 590338, upload-time = "2025-12-04T14:57:41.136Z" }, - { url = "https://files.pythonhosted.org/packages/80/d7/db0a5085035d05134f8c089643da2b44cc9b80647c39e93129c5ef170d8f/greenlet-3.3.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:670d0f94cd302d81796e37299bcd04b95d62403883b24225c6b5271466612f45", size = 601098, upload-time = "2025-12-04T15:07:11.898Z" }, { url = "https://files.pythonhosted.org/packages/dc/a6/e959a127b630a58e23529972dbc868c107f9d583b5a9f878fb858c46bc1a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb3a8ec3db4a3b0eb8a3c25436c2d49e3505821802074969db017b87bc6a948", size = 590206, upload-time = "2025-12-04T14:26:01.254Z" }, { url = "https://files.pythonhosted.org/packages/48/60/29035719feb91798693023608447283b266b12efc576ed013dd9442364bb/greenlet-3.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2de5a0b09eab81fc6a382791b995b1ccf2b172a9fec934747a7a23d2ff291794", size = 1550668, upload-time = "2025-12-04T15:04:22.439Z" }, { url = "https://files.pythonhosted.org/packages/0a/5f/783a23754b691bfa86bd72c3033aa107490deac9b2ef190837b860996c9f/greenlet-3.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4449a736606bd30f27f8e1ff4678ee193bc47f6ca810d705981cfffd6ce0d8c5", size = 1615483, upload-time = "2025-12-04T14:27:28.083Z" }, @@ -2511,7 +2480,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f8/0a/a3871375c7b9727edaeeea994bfff7c63ff7804c9829c19309ba2e058807/greenlet-3.3.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:b01548f6e0b9e9784a2c99c5651e5dc89ffcbe870bc5fb2e5ef864e9cc6b5dcb", size = 276379, upload-time = "2025-12-04T14:23:30.498Z" }, { url = "https://files.pythonhosted.org/packages/43/ab/7ebfe34dce8b87be0d11dae91acbf76f7b8246bf9d6b319c741f99fa59c6/greenlet-3.3.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:349345b770dc88f81506c6861d22a6ccd422207829d2c854ae2af8025af303e3", size = 597294, upload-time = "2025-12-04T14:50:06.847Z" }, { url = "https://files.pythonhosted.org/packages/a4/39/f1c8da50024feecd0793dbd5e08f526809b8ab5609224a2da40aad3a7641/greenlet-3.3.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e8e18ed6995e9e2c0b4ed264d2cf89260ab3ac7e13555b8032b25a74c6d18655", size = 607742, upload-time = "2025-12-04T14:57:42.349Z" }, - { url = "https://files.pythonhosted.org/packages/77/cb/43692bcd5f7a0da6ec0ec6d58ee7cddb606d055ce94a62ac9b1aa481e969/greenlet-3.3.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c024b1e5696626890038e34f76140ed1daf858e37496d33f2af57f06189e70d7", size = 622297, upload-time = "2025-12-04T15:07:13.552Z" }, { url = "https://files.pythonhosted.org/packages/75/b0/6bde0b1011a60782108c01de5913c588cf51a839174538d266de15e4bf4d/greenlet-3.3.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:047ab3df20ede6a57c35c14bf5200fcf04039d50f908270d3f9a7a82064f543b", size = 609885, upload-time = "2025-12-04T14:26:02.368Z" }, { url = "https://files.pythonhosted.org/packages/49/0e/49b46ac39f931f59f987b7cd9f34bfec8ef81d2a1e6e00682f55be5de9f4/greenlet-3.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2d9ad37fc657b1102ec880e637cccf20191581f75c64087a549e66c57e1ceb53", size = 1567424, upload-time = "2025-12-04T15:04:23.757Z" }, { url = "https://files.pythonhosted.org/packages/05/f5/49a9ac2dff7f10091935def9165c90236d8f175afb27cbed38fb1d61ab6b/greenlet-3.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83cd0e36932e0e7f36a64b732a6f60c2fc2df28c351bae79fbaf4f8092fe7614", size = 1636017, upload-time = "2025-12-04T14:27:29.688Z" }, @@ -4736,7 +4704,7 @@ requires-dist = [ { name = "einops", marker = "extra == 'video-cpu'" }, { name = "fasttext", marker = "extra == 'text-cpu'", specifier = "==0.9.3" }, { name = "flash-attn", marker = "platform_machine == 'x86_64' and sys_platform != 'darwin' and extra == 'video-cuda12'", specifier = "<=2.8.3" }, - { name = "fsspec" }, + { name = "fsspec", specifier = ">=2024.0" }, { name = "ftfy", marker = "extra == 'text-cpu'" }, { name = "gpustat", marker = "extra == 'cuda12'" }, { name = "hydra-core" }, @@ -4822,7 +4790,7 @@ test = [ { name = "pytest-cov" }, { name = "pytest-httpserver" }, { name = "pytest-loguru" }, - { name = "s3fs" }, + { name = "s3fs", specifier = ">=2024.0" }, { name = "scikit-learn", specifier = "<1.8.0" }, ] @@ -4963,15 +4931,7 @@ version = "1.13.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/43/73/79a0b22fc731989c708068427579e840a6cf4e937fe7ae5c5d0b7356ac22/ninja-1.13.0.tar.gz", hash = "sha256:4a40ce995ded54d9dc24f8ea37ff3bf62ad192b547f6c7126e7e25045e76f978", size = 242558, upload-time = "2025-08-11T15:10:19.421Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/56/c7/ba22748fb59f7f896b609cd3e568d28a0a367a6d953c24c461fe04fc4433/ninja-1.13.0-py3-none-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:60056592cf495e9a6a4bea3cd178903056ecb0943e4de45a2ea825edb6dc8d3e", size = 202736, upload-time = "2025-08-11T15:09:55.745Z" }, - { url = "https://files.pythonhosted.org/packages/79/22/d1de07632b78ac8e6b785f41fa9aad7a978ec8c0a1bf15772def36d77aac/ninja-1.13.0-py3-none-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:1c97223cdda0417f414bf864cfb73b72d8777e57ebb279c5f6de368de0062988", size = 179034, upload-time = "2025-08-11T15:09:57.394Z" }, { url = "https://files.pythonhosted.org/packages/ed/de/0e6edf44d6a04dabd0318a519125ed0415ce437ad5a1ec9b9be03d9048cf/ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fb46acf6b93b8dd0322adc3a4945452a4e774b75b91293bafcc7b7f8e6517dfa", size = 180716, upload-time = "2025-08-11T15:09:58.696Z" }, - { url = "https://files.pythonhosted.org/packages/54/28/938b562f9057aaa4d6bfbeaa05e81899a47aebb3ba6751e36c027a7f5ff7/ninja-1.13.0-py3-none-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4be9c1b082d244b1ad7ef41eb8ab088aae8c109a9f3f0b3e56a252d3e00f42c1", size = 146843, upload-time = "2025-08-11T15:10:00.046Z" }, - { url = "https://files.pythonhosted.org/packages/2a/fb/d06a3838de4f8ab866e44ee52a797b5491df823901c54943b2adb0389fbb/ninja-1.13.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:6739d3352073341ad284246f81339a384eec091d9851a886dfa5b00a6d48b3e2", size = 154402, upload-time = "2025-08-11T15:10:01.657Z" }, - { url = "https://files.pythonhosted.org/packages/9d/70/c99d0c2c809f992752453cce312848abb3b1607e56d4cd1b6cded317351a/ninja-1.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:aa45b4037b313c2f698bc13306239b8b93b4680eb47e287773156ac9e9304714", size = 472501, upload-time = "2025-08-11T15:10:04.735Z" }, - { url = "https://files.pythonhosted.org/packages/8c/45/9151bba2c8d0ae2b6260f71696330590de5850e5574b7b5694dce6023e20/ninja-1.13.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:3d7d7779d12cb20c6d054c61b702139fd23a7a964ec8f2c823f1ab1b084150db", size = 642420, upload-time = "2025-08-11T15:10:08.35Z" }, - { url = "https://files.pythonhosted.org/packages/3c/fb/95752eb635bb8ad27d101d71bef15bc63049de23f299e312878fc21cb2da/ninja-1.13.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:d741a5e6754e0bda767e3274a0f0deeef4807f1fec6c0d7921a0244018926ae5", size = 585106, upload-time = "2025-08-11T15:10:09.818Z" }, - { url = "https://files.pythonhosted.org/packages/c1/31/aa56a1a286703800c0cbe39fb4e82811c277772dc8cd084f442dd8e2938a/ninja-1.13.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:e8bad11f8a00b64137e9b315b137d8bb6cbf3086fbdc43bf1f90fd33324d2e96", size = 707138, upload-time = "2025-08-11T15:10:11.366Z" }, { url = "https://files.pythonhosted.org/packages/34/6f/5f5a54a1041af945130abdb2b8529cbef0cdcbbf9bcf3f4195378319d29a/ninja-1.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b4f2a072db3c0f944c32793e91532d8948d20d9ab83da9c0c7c15b5768072200", size = 581758, upload-time = "2025-08-11T15:10:13.295Z" }, { url = "https://files.pythonhosted.org/packages/29/45/c0adfbfb0b5895aa18cec400c535b4f7ff3e52536e0403602fc1a23f7de9/ninja-1.13.0-py3-none-win_amd64.whl", hash = "sha256:fb8ee8719f8af47fed145cced4a85f0755dd55d45b2bddaf7431fa89803c5f3e", size = 309975, upload-time = "2025-08-11T15:10:16.697Z" }, ] @@ -5493,10 +5453,7 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/3e/92/2d038d096f29179c7c9571b431f9e739f87a487121901725e23fe338dd9d/openai_harmony-0.0.8.tar.gz", hash = "sha256:6e43f98e6c242fa2de6f8ea12eab24af63fa2ed3e89c06341fb9d92632c5cbdf", size = 284777, upload-time = "2025-11-05T19:07:06.727Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fa/4c/b553c9651662d6ce102ca7f3629d268b23df1abe5841e24bed81e8a8e949/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5cfcfd963b50a41fc656c84d3440ca6eecdccd6c552158ce790b8f2e33dfb5a9", size = 2704083, upload-time = "2025-11-05T19:06:50.205Z" }, - { url = "https://files.pythonhosted.org/packages/11/3c/33f3374e4624e0e776f6b13b73c45a7ead7f9c4529f8369ed5bfcaa30cac/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b4d5cfa168e74d08f8ba6d58a7e49bc7daef4d58951ec69b66b0d56f4927a68d", size = 3427031, upload-time = "2025-11-05T19:06:51.829Z" }, { url = "https://files.pythonhosted.org/packages/25/3f/1a192b93bb47c6b44cd98ba8cc1d3d2a9308f1bb700c3017e6352da11bda/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c007d277218a50db8839e599ed78e0fffe5130f614c3f6d93ae257f282071a29", size = 2953260, upload-time = "2025-11-05T19:06:55.406Z" }, - { url = "https://files.pythonhosted.org/packages/1d/10/4327dbf87f75ae813405fd9a9b4a5cde63d506ffed0a096a440a4cabd89c/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:cbaa3bda75ef0d8836e1f8cc84af62f971b1d756d740efc95c38c3e04c0bfde2", size = 2932931, upload-time = "2025-11-05T19:07:01.437Z" }, { url = "https://files.pythonhosted.org/packages/60/c3/3d1e01e2dba517a91760e4a03e4f20ffc75039a6fe584d0e6f9b5c78fd15/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:007b0476a1f331f8130783f901f1da6f5a7057af1a4891f1b6a31dec364189b5", size = 3205080, upload-time = "2025-11-05T19:07:05.078Z" }, { url = "https://files.pythonhosted.org/packages/40/1f/c83cf5a206c263ee70448a5ae4264682555f4d0b5bed0d2cc6ca1108103d/openai_harmony-0.0.8-cp38-abi3-win_amd64.whl", hash = "sha256:39d44f0d8f466bd56698e7ead708bead3141e27b9b87e3ab7d5a6d0e4a869ee5", size = 2438369, upload-time = "2025-11-05T19:07:08.1Z" }, ] @@ -6183,36 +6140,12 @@ source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", hash = "sha256:c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053", size = 137272, upload-time = "2025-12-06T13:27:04.013Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/1c/22/e89739d8bc9b96c68ead44b4eec42fe555683d9997e4ba65216d384920fc/pybase64-1.4.3-cp310-cp310-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6ec7e53dd09b0a8116ccf5c3265c7c7fce13c980747525be76902aef36a514a", size = 68903, upload-time = "2025-12-06T13:22:31.29Z" }, - { url = "https://files.pythonhosted.org/packages/42/ad/f47dc7e6fe32022b176868b88b671a32dab389718c8ca905cab79280aaaf/pybase64-1.4.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:4ec645f32b50593879031e09158f8681a1db9f5df0f72af86b3969a1c5d1fa2b", size = 54533, upload-time = "2025-12-06T13:22:33.457Z" }, - { url = "https://files.pythonhosted.org/packages/7c/9a/7ab312b5a324833953b00e47b23eb4f83d45bd5c5c854b4b4e51b2a0cf5b/pybase64-1.4.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:634a000c5b3485ccc18bb9b244e0124f74b6fbc7f43eade815170237a7b34c64", size = 57187, upload-time = "2025-12-06T13:22:34.566Z" }, - { url = "https://files.pythonhosted.org/packages/2c/84/80acab1fcbaaae103e6b862ef5019192c8f2cd8758433595a202179a0d1d/pybase64-1.4.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:309ea32ad07639a485580af1be0ad447a434deb1924e76adced63ac2319cfe15", size = 57730, upload-time = "2025-12-06T13:22:35.581Z" }, - { url = "https://files.pythonhosted.org/packages/1f/24/84256d472400ea3163d7d69c44bb7e2e1027f0f1d4d20c47629a7dc4578e/pybase64-1.4.3-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:d10d517566b748d3f25f6ac7162af779360c1c6426ad5f962927ee205990d27c", size = 53036, upload-time = "2025-12-06T13:22:36.621Z" }, - { url = "https://files.pythonhosted.org/packages/dc/1c/a341b050746658cbec8cab3c733aeb3ef52ce8f11e60d0d47adbdf729ebf/pybase64-1.4.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1b591d774ac09d5eb73c156a03277cb271438fbd8042bae4109ff3a827cd218c", size = 50114, upload-time = "2025-12-06T13:22:38.752Z" }, - { url = "https://files.pythonhosted.org/packages/4c/71/774748eecc7fe23869b7e5df028e3c4c2efa16b506b83ea3fa035ea95dc2/pybase64-1.4.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:df8b122d5be2c96962231cc4831d9c2e1eae6736fb12850cec4356d8b06fe6f8", size = 55700, upload-time = "2025-12-06T13:22:41.289Z" }, - { url = "https://files.pythonhosted.org/packages/b3/91/dd15075bb2fe0086193e1cd4bad80a43652c38d8a572f9218d46ba721802/pybase64-1.4.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:31b7a85c661fc591bbcce82fb8adaebe2941e6a83b08444b0957b77380452a4b", size = 52491, upload-time = "2025-12-06T13:22:42.628Z" }, - { url = "https://files.pythonhosted.org/packages/7b/27/f357d63ea3774c937fc47160e040419ed528827aa3d4306d5ec9826259c0/pybase64-1.4.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e6d7beaae65979fef250e25e66cf81c68a8f81910bcda1a2f43297ab486a7e4e", size = 53957, upload-time = "2025-12-06T13:22:44.615Z" }, { url = "https://files.pythonhosted.org/packages/b3/c3/243693771701a54e67ff5ccbf4c038344f429613f5643169a7befc51f007/pybase64-1.4.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4a6276bc3a3962d172a2b5aba544d89881c4037ea954517b86b00892c703d007", size = 68422, upload-time = "2025-12-06T13:22:45.641Z" }, { url = "https://files.pythonhosted.org/packages/79/28/c169a769fe90128f16d394aad87b2096dd4bf2f035ae0927108a46b617df/pybase64-1.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:5db0b6bbda15110db2740c61970a8fda3bf9c93c3166a3f57f87c7865ed1125c", size = 35799, upload-time = "2025-12-06T13:22:48.731Z" }, { url = "https://files.pythonhosted.org/packages/64/15/8d60b9ec5e658185fc2ee3333e01a6e30d717cf677b24f47cbb3a859d13c/pybase64-1.4.3-cp311-cp311-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95a57cccf106352a72ed8bc8198f6820b16cc7d55aa3867a16dea7011ae7c218", size = 71370, upload-time = "2025-12-06T13:22:55.517Z" }, - { url = "https://files.pythonhosted.org/packages/a9/00/8ffcf9810bd23f3984698be161cf7edba656fd639b818039a7be1d6405d4/pybase64-1.4.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:9fe9922698f3e2f72874b26890d53a051c431d942701bb3a37aae94da0b12107", size = 56652, upload-time = "2025-12-06T13:22:57.724Z" }, - { url = "https://files.pythonhosted.org/packages/81/62/379e347797cdea4ab686375945bc77ad8d039c688c0d4d0cfb09d247beb9/pybase64-1.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:af5f4bd29c86b59bb4375e0491d16ec8a67548fa99c54763aaedaf0b4b5a6632", size = 59382, upload-time = "2025-12-06T13:22:58.758Z" }, - { url = "https://files.pythonhosted.org/packages/c6/f2/9338ffe2f487086f26a2c8ca175acb3baa86fce0a756ff5670a0822bb877/pybase64-1.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c302f6ca7465262908131411226e02100f488f531bb5e64cb901aa3f439bccd9", size = 59990, upload-time = "2025-12-06T13:23:01.007Z" }, - { url = "https://files.pythonhosted.org/packages/f9/a4/85a6142b65b4df8625b337727aa81dc199642de3d09677804141df6ee312/pybase64-1.4.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:2f3f439fa4d7fde164ebbbb41968db7d66b064450ab6017c6c95cef0afa2b349", size = 54923, upload-time = "2025-12-06T13:23:02.369Z" }, - { url = "https://files.pythonhosted.org/packages/b0/73/d7e19a63e795c13837f2356268d95dc79d1180e756f57ced742a1e52fdeb/pybase64-1.4.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:56e6526f8565642abc5f84338cc131ce298a8ccab696b19bdf76fa6d7dc592ef", size = 52338, upload-time = "2025-12-06T13:23:04.458Z" }, - { url = "https://files.pythonhosted.org/packages/5d/b3/63cec68f9d6f6e4c0b438d14e5f1ef536a5fe63ce14b70733ac5e31d7ab8/pybase64-1.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:62ad29a5026bb22cfcd1ca484ec34b0a5ced56ddba38ceecd9359b2818c9c4f9", size = 58055, upload-time = "2025-12-06T13:23:06.931Z" }, - { url = "https://files.pythonhosted.org/packages/d5/cb/7acf7c3c06f9692093c07f109668725dc37fb9a3df0fa912b50add645195/pybase64-1.4.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:11b9d1d2d32ec358c02214363b8fc3651f6be7dd84d880ecd597a6206a80e121", size = 54430, upload-time = "2025-12-06T13:23:07.936Z" }, - { url = "https://files.pythonhosted.org/packages/33/39/4eb33ff35d173bfff4002e184ce8907f5d0a42d958d61cd9058ef3570179/pybase64-1.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0aebaa7f238caa0a0d373616016e2040c6c879ebce3ba7ab3c59029920f13640", size = 56272, upload-time = "2025-12-06T13:23:09.253Z" }, { url = "https://files.pythonhosted.org/packages/19/97/a76d65c375a254e65b730c6f56bf528feca91305da32eceab8bcc08591e6/pybase64-1.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e504682b20c63c2b0c000e5f98a80ea867f8d97642e042a5a39818e44ba4d599", size = 70904, upload-time = "2025-12-06T13:23:10.336Z" }, { url = "https://files.pythonhosted.org/packages/39/dc/32efdf2f5927e5449cc341c266a1bbc5fecd5319a8807d9c5405f76e6d02/pybase64-1.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:a90a8fa16a901fabf20de824d7acce07586e6127dc2333f1de05f73b1f848319", size = 35797, upload-time = "2025-12-06T13:23:13.174Z" }, { url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4", size = 71599, upload-time = "2025-12-06T13:23:20.195Z" }, - { url = "https://files.pythonhosted.org/packages/da/5d/c38d1572027fc601b62d7a407721688b04b4d065d60ca489912d6893e6cf/pybase64-1.4.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:c48361f90db32bacaa5518419d4eb9066ba558013aaf0c7781620279ecddaeb9", size = 56712, upload-time = "2025-12-06T13:23:22.77Z" }, - { url = "https://files.pythonhosted.org/packages/e7/d4/4e04472fef485caa8f561d904d4d69210a8f8fc1608ea15ebd9012b92655/pybase64-1.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:702bcaa16ae02139d881aeaef5b1c8ffb4a3fae062fe601d1e3835e10310a517", size = 59300, upload-time = "2025-12-06T13:23:24.543Z" }, - { url = "https://files.pythonhosted.org/packages/86/e7/16e29721b86734b881d09b7e23dfd7c8408ad01a4f4c7525f3b1088e25ec/pybase64-1.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:53d0ffe1847b16b647c6413d34d1de08942b7724273dd57e67dcbdb10c574045", size = 60278, upload-time = "2025-12-06T13:23:25.608Z" }, - { url = "https://files.pythonhosted.org/packages/b1/02/18515f211d7c046be32070709a8efeeef8a0203de4fd7521e6b56404731b/pybase64-1.4.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:9a1792e8b830a92736dae58f0c386062eb038dfe8004fb03ba33b6083d89cd43", size = 54817, upload-time = "2025-12-06T13:23:26.633Z" }, - { url = "https://files.pythonhosted.org/packages/b4/8a/a2588dfe24e1bbd742a554553778ab0d65fdf3d1c9a06d10b77047d142aa/pybase64-1.4.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e97b7bdbd62e71898cd542a6a9e320d9da754ff3ebd02cb802d69087ee94d468", size = 52404, upload-time = "2025-12-06T13:23:28.714Z" }, - { url = "https://files.pythonhosted.org/packages/d3/3a/87c3201e555ed71f73e961a787241a2438c2bbb2ca8809c29ddf938a3157/pybase64-1.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c0efcf78f11cf866bed49caa7b97552bc4855a892f9cc2372abcd3ed0056f0d", size = 57854, upload-time = "2025-12-06T13:23:31.17Z" }, - { url = "https://files.pythonhosted.org/packages/fd/7d/931c2539b31a7b375e7d595b88401eeb5bd6c5ce1059c9123f9b608aaa14/pybase64-1.4.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:66e3791f2ed725a46593f8bd2761ff37d01e2cdad065b1dceb89066f476e50c6", size = 54333, upload-time = "2025-12-06T13:23:32.422Z" }, - { url = "https://files.pythonhosted.org/packages/de/5e/537601e02cc01f27e9d75f440f1a6095b8df44fc28b1eef2cd739aea8cec/pybase64-1.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:72bb0b6bddadab26e1b069bb78e83092711a111a80a0d6b9edcb08199ad7299b", size = 56492, upload-time = "2025-12-06T13:23:33.515Z" }, { url = "https://files.pythonhosted.org/packages/96/97/2a2e57acf8f5c9258d22aba52e71f8050e167b29ed2ee1113677c1b600c1/pybase64-1.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5b3365dbcbcdb0a294f0f50af0c0a16b27a232eddeeb0bceeefd844ef30d2a23", size = 70974, upload-time = "2025-12-06T13:23:36.27Z" }, { url = "https://files.pythonhosted.org/packages/83/e3/507ab649d8c3512c258819c51d25c45d6e29d9ca33992593059e7b646a33/pybase64-1.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:9f2da8f56d9b891b18b4daf463a0640eae45a80af548ce435be86aa6eff3603b", size = 35833, upload-time = "2025-12-06T13:23:38.877Z" }, { url = "https://files.pythonhosted.org/packages/bf/44/d4b7adc7bf4fd5b52d8d099121760c450a52c390223806b873f0b6a2d551/pybase64-1.4.3-graalpy311-graalpy242_311_native-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a492518f3078a4e3faaef310697d21df9c6bc71908cebc8c2f6fbfa16d7d6b1f", size = 43227, upload-time = "2025-12-06T13:26:21.845Z" }, @@ -7174,38 +7107,18 @@ version = "0.7.6" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/e5/f5/8bed2310abe4ae04b67a38374a4d311dd85220f5d8da56f47ae9361be0b0/rignore-0.7.6.tar.gz", hash = "sha256:00d3546cd793c30cb17921ce674d2c8f3a4b00501cb0e3dd0e82217dbeba2671", size = 57140, upload-time = "2025-11-05T21:41:21.968Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/35/71518847e10bdbf359badad8800e4681757a01f4777b3c5e03dbde8a42d8/rignore-0.7.6-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:626c3d4ba03af266694d25101bc1d8d16eda49c5feb86cedfec31c614fceca7d", size = 873813, upload-time = "2025-11-05T20:41:04.71Z" }, - { url = "https://files.pythonhosted.org/packages/f6/c8/32ae405d3e7fd4d9f9b7838f2fcca0a5005bb87fa514b83f83fd81c0df22/rignore-0.7.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0a43841e651e7a05a4274b9026cc408d1912e64016ede8cd4c145dae5d0635be", size = 1168019, upload-time = "2025-11-05T20:41:20.723Z" }, - { url = "https://files.pythonhosted.org/packages/25/98/013c955982bc5b4719bf9a5bea58be317eea28aa12bfd004025e3cd7c000/rignore-0.7.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7978c498dbf7f74d30cdb8859fe612167d8247f0acd377ae85180e34490725da", size = 942822, upload-time = "2025-11-05T20:41:36.99Z" }, { url = "https://files.pythonhosted.org/packages/90/fb/9a3f3156c6ed30bcd597e63690353edac1fcffe9d382ad517722b56ac195/rignore-0.7.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d22f72ab695c07d2d96d2a645208daff17084441b5d58c07378c9dd6f9c4c87", size = 959820, upload-time = "2025-11-05T20:42:06.364Z" }, - { url = "https://files.pythonhosted.org/packages/df/26/4b635f4ea5baf4baa8ba8eee06163f6af6e76dfbe72deb57da34bb24b19d/rignore-0.7.6-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:ce2617fe28c51367fd8abfd4eeea9e61664af63c17d4ea00353d8ef56dfb95fa", size = 1139028, upload-time = "2025-11-05T21:40:27.977Z" }, { url = "https://files.pythonhosted.org/packages/fb/f4/27475db769a57cff18fe7e7267b36e6cdb5b1281caa185ba544171106cba/rignore-0.7.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:02cd240bfd59ecc3907766f4839cbba20530a2e470abca09eaa82225e4d946fb", size = 1128531, upload-time = "2025-11-05T21:41:02.734Z" }, { url = "https://files.pythonhosted.org/packages/c0/8a/53185c69abb3bb362e8a46b8089999f820bf15655629ff8395107633c8ab/rignore-0.7.6-cp310-cp310-win_amd64.whl", hash = "sha256:d80afd6071c78baf3765ec698841071b19e41c326f994cfa69b5a1df676f5d39", size = 727001, upload-time = "2025-11-05T21:41:32.778Z" }, - { url = "https://files.pythonhosted.org/packages/fb/c9/390a8fdfabb76d71416be773bd9f162977bd483084f68daf19da1dec88a6/rignore-0.7.6-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ba5524f5178deca4d7695e936604ebc742acb8958f9395776e1fcb8133f8257a", size = 873633, upload-time = "2025-11-05T20:41:06.193Z" }, - { url = "https://files.pythonhosted.org/packages/df/c9/79404fcb0faa76edfbc9df0901f8ef18568d1104919ebbbad6d608c888d1/rignore-0.7.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:62020dbb89a1dd4b84ab3d60547b3b2eb2723641d5fb198463643f71eaaed57d", size = 1167633, upload-time = "2025-11-05T20:41:22.491Z" }, - { url = "https://files.pythonhosted.org/packages/6e/8d/b3466d32d445d158a0aceb80919085baaae495b1f540fb942f91d93b5e5b/rignore-0.7.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b34acd532769d5a6f153a52a98dcb81615c949ab11697ce26b2eb776af2e174d", size = 941434, upload-time = "2025-11-05T20:41:38.151Z" }, { url = "https://files.pythonhosted.org/packages/e8/40/9cd949761a7af5bc27022a939c91ff622d29c7a0b66d0c13a863097dde2d/rignore-0.7.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c5e53b752f9de44dff7b3be3c98455ce3bf88e69d6dc0cf4f213346c5e3416c", size = 959461, upload-time = "2025-11-05T20:42:08.476Z" }, - { url = "https://files.pythonhosted.org/packages/17/18/162eedadb4c2282fa4c521700dbf93c9b14b8842e8354f7d72b445b8d593/rignore-0.7.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:5991e46ab9b4868334c9e372ab0892b0150f3f586ff2b1e314272caeb38aaedb", size = 1139012, upload-time = "2025-11-05T21:40:29.399Z" }, { url = "https://files.pythonhosted.org/packages/9f/22/1c1a65047df864def9a047dbb40bc0b580b8289a4280e62779cd61ae21f2/rignore-0.7.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aaf938530dcc0b47c4cfa52807aa2e5bfd5ca6d57a621125fe293098692f6345", size = 1128182, upload-time = "2025-11-05T21:41:04.239Z" }, { url = "https://files.pythonhosted.org/packages/7c/c8/dda0983e1845706beb5826459781549a840fe5a7eb934abc523e8cd17814/rignore-0.7.6-cp311-cp311-win_amd64.whl", hash = "sha256:44f35ee844b1a8cea50d056e6a595190ce9d42d3cccf9f19d280ae5f3058973a", size = 727139, upload-time = "2025-11-05T21:41:34.367Z" }, - { url = "https://files.pythonhosted.org/packages/b3/2b/ee96db17ac1835e024c5d0742eefb7e46de60020385ac883dd3d1cde2c1f/rignore-0.7.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5fd5ab3840b8c16851d327ed06e9b8be6459702a53e5ab1fc4073b684b3789e", size = 873963, upload-time = "2025-11-05T20:41:07.49Z" }, - { url = "https://files.pythonhosted.org/packages/a5/8c/ad5a57bbb9d14d5c7e5960f712a8a0b902472ea3f4a2138cbf70d1777b75/rignore-0.7.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ced2a248352636a5c77504cb755dc02c2eef9a820a44d3f33061ce1bb8a7f2d2", size = 1169216, upload-time = "2025-11-05T20:41:23.73Z" }, - { url = "https://files.pythonhosted.org/packages/80/e6/5b00bc2a6bc1701e6878fca798cf5d9125eb3113193e33078b6fc0d99123/rignore-0.7.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a04a3b73b75ddc12c9c9b21efcdaab33ca3832941d6f1d67bffd860941cd448a", size = 942942, upload-time = "2025-11-05T20:41:39.393Z" }, { url = "https://files.pythonhosted.org/packages/85/e5/7f99bd0cc9818a91d0e8b9acc65b792e35750e3bdccd15a7ee75e64efca4/rignore-0.7.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d24321efac92140b7ec910ac7c53ab0f0c86a41133d2bb4b0e6a7c94967f44dd", size = 959787, upload-time = "2025-11-05T20:42:09.765Z" }, - { url = "https://files.pythonhosted.org/packages/d4/cf/2c64f0b6725149f7c6e7e5a909d14354889b4beaadddaa5fff023ec71084/rignore-0.7.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5719ea14ea2b652c0c0894be5dfde954e1853a80dea27dd2fbaa749618d837f5", size = 1139186, upload-time = "2025-11-05T21:40:31.27Z" }, { url = "https://files.pythonhosted.org/packages/7f/5e/13b249613fd5d18d58662490ab910a9f0be758981d1797789913adb4e918/rignore-0.7.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3efdcf1dd84d45f3e2bd2f93303d9be103888f56dfa7c3349b5bf4f0657ec696", size = 1127725, upload-time = "2025-11-05T21:41:05.804Z" }, { url = "https://files.pythonhosted.org/packages/26/87/69387fb5dd81a0f771936381431780b8cf66fcd2cfe9495e1aaf41548931/rignore-0.7.6-cp312-cp312-win_amd64.whl", hash = "sha256:c96a285e4a8bfec0652e0bfcf42b1aabcdda1e7625f5006d188e3b1c87fdb543", size = 726090, upload-time = "2025-11-05T21:41:36.485Z" }, - { url = "https://files.pythonhosted.org/packages/09/ba/e5ea89fbde8e37a90ce456e31c5e9d85512cef5ae38e0f4d2426eb776a19/rignore-0.7.6-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d1a6671b2082c13bfd9a5cf4ce64670f832a6d41470556112c4ab0b6519b2fc4", size = 876987, upload-time = "2025-11-05T20:41:16.219Z" }, - { url = "https://files.pythonhosted.org/packages/d0/fb/93d14193f0ec0c3d35b763f0a000e9780f63b2031f3d3756442c2152622d/rignore-0.7.6-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2468729b4c5295c199d084ab88a40afcb7c8b974276805105239c07855bbacee", size = 1171110, upload-time = "2025-11-05T20:41:32.631Z" }, - { url = "https://files.pythonhosted.org/packages/9e/46/08436312ff96ffa29cfa4e1a987efc37e094531db46ba5e9fda9bb792afd/rignore-0.7.6-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:775710777fd71e5fdf54df69cdc249996a1d6f447a2b5bfb86dbf033fddd9cf9", size = 943339, upload-time = "2025-11-05T20:41:47.128Z" }, { url = "https://files.pythonhosted.org/packages/34/28/3b3c51328f505cfaf7e53f408f78a1e955d561135d02f9cb0341ea99f69a/rignore-0.7.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4565407f4a77f72cf9d91469e75d15d375f755f0a01236bb8aaa176278cc7085", size = 961680, upload-time = "2025-11-05T20:42:18.061Z" }, - { url = "https://files.pythonhosted.org/packages/43/f0/250b785c2e473b1ab763eaf2be820934c2a5409a722e94b279dddac21c7d/rignore-0.7.6-pp310-pypy310_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:1b63a3dd76225ea35b01dd6596aa90b275b5d0f71d6dc28fce6dd295d98614aa", size = 1140998, upload-time = "2025-11-05T21:40:40.603Z" }, { url = "https://files.pythonhosted.org/packages/97/f4/aeb548374129dce3dc191a4bb598c944d9ed663f467b9af830315d86059c/rignore-0.7.6-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9a0c6792406ae36f4e7664dc772da909451d46432ff8485774526232d4885063", size = 1130190, upload-time = "2025-11-05T21:41:16.403Z" }, - { url = "https://files.pythonhosted.org/packages/55/e4/b3c5dfdd8d8a10741dfe7199ef45d19a0e42d0c13aa377c83bd6caf65d90/rignore-0.7.6-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53fb28882d2538cb2d231972146c4927a9d9455e62b209f85d634408c4103538", size = 874843, upload-time = "2025-11-05T20:41:17.687Z" }, - { url = "https://files.pythonhosted.org/packages/cc/10/d6f3750233881a2a154cefc9a6a0a9b19da526b19f7f08221b552c6f827d/rignore-0.7.6-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:87409f7eeb1103d6b77f3472a3a0d9a5953e3ae804a55080bdcb0120ee43995b", size = 1170348, upload-time = "2025-11-05T20:41:34.21Z" }, - { url = "https://files.pythonhosted.org/packages/6e/10/ad98ca05c9771c15af734cee18114a3c280914b6e34fde9ffea2e61e88aa/rignore-0.7.6-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:684014e42e4341ab3ea23a203551857fcc03a7f8ae96ca3aefb824663f55db32", size = 942315, upload-time = "2025-11-05T20:41:48.508Z" }, { url = "https://files.pythonhosted.org/packages/de/00/ab5c0f872acb60d534e687e629c17e0896c62da9b389c66d3aa16b817aa8/rignore-0.7.6-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77356ebb01ba13f8a425c3d30fcad40e57719c0e37670d022d560884a30e4767", size = 961047, upload-time = "2025-11-05T20:42:19.403Z" }, - { url = "https://files.pythonhosted.org/packages/67/56/36d5d34210e5e7dfcd134eed8335b19e80ae940ee758f493e4f2b344dd70/rignore-0.7.6-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:c081f17290d8a2b96052b79207622aa635686ea39d502b976836384ede3d303c", size = 1139789, upload-time = "2025-11-05T21:40:42.119Z" }, { url = "https://files.pythonhosted.org/packages/ce/8b/a1299085b28a2f6135e30370b126e3c5055b61908622f2488ade67641479/rignore-0.7.6-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:d8955b57e42f2a5434670d5aa7b75eaf6e74602ccd8955dddf7045379cd762fb", size = 1129444, upload-time = "2025-11-05T21:41:17.906Z" }, ] @@ -7663,18 +7576,12 @@ source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/8d/48/49393a96a2eef1ab418b17475fb92b8fcfad83d099e678751b05472e69de/setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e", size = 27002, upload-time = "2025-09-05T12:51:25.278Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/0e/f8/17bda581c517678260e6541b600eeb67745f53596dc077174141ba2f6702/setproctitle-1.3.7-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:00afa6fc507967d8c9d592a887cdc6c1f5742ceac6a4354d111ca0214847732c", size = 31793, upload-time = "2025-09-05T12:49:10.297Z" }, - { url = "https://files.pythonhosted.org/packages/59/27/1a07c38121967061564f5e0884414a5ab11a783260450172d4fc68c15621/setproctitle-1.3.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83fcd271567d133eb9532d3b067c8a75be175b2b3b271e2812921a05303a693f", size = 34578, upload-time = "2025-09-05T12:49:13.393Z" }, - { url = "https://files.pythonhosted.org/packages/67/24/e4677ae8e1cb0d549ab558b12db10c175a889be0974c589c428fece5433e/setproctitle-1.3.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a05509cfb2059e5d2ddff701d38e474169e9ce2a298cf1b6fd5f3a213a553fe5", size = 33363, upload-time = "2025-09-05T12:49:16.829Z" }, { url = "https://files.pythonhosted.org/packages/55/d4/69ce66e4373a48fdbb37489f3ded476bb393e27f514968c3a69a67343ae0/setproctitle-1.3.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6da835e76ae18574859224a75db6e15c4c2aaa66d300a57efeaa4c97ca4c7381", size = 31508, upload-time = "2025-09-05T12:49:18.032Z" }, { url = "https://files.pythonhosted.org/packages/dc/fe/dd206cc19a25561921456f6cb12b405635319299b6f366e0bebe872abc18/setproctitle-1.3.7-cp310-cp310-win_amd64.whl", hash = "sha256:a97200acc6b64ec4cada52c2ecaf1fba1ef9429ce9c542f8a7db5bcaa9dcbd95", size = 13245, upload-time = "2025-09-05T12:49:21.023Z" }, { url = "https://files.pythonhosted.org/packages/18/2e/bd03ff02432a181c1787f6fc2a678f53b7dacdd5ded69c318fe1619556e8/setproctitle-1.3.7-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1607b963e7b53e24ec8a2cb4e0ab3ae591d7c6bf0a160feef0551da63452b37f", size = 32191, upload-time = "2025-09-05T12:49:24.567Z" }, - { url = "https://files.pythonhosted.org/packages/a0/3c/65edc65db3fa3df400cf13b05e9d41a3c77517b4839ce873aa6b4043184f/setproctitle-1.3.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f8d961bba676e07d77665204f36cffaa260f526e7b32d07ab3df6a2c1dfb44ba", size = 34963, upload-time = "2025-09-05T12:49:27.044Z" }, - { url = "https://files.pythonhosted.org/packages/4a/18/77a765a339ddf046844cb4513353d8e9dcd8183da9cdba6e078713e6b0b2/setproctitle-1.3.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:db116850fcf7cca19492030f8d3b4b6e231278e8fe097a043957d22ce1bdf3ee", size = 33657, upload-time = "2025-09-05T12:49:30.323Z" }, { url = "https://files.pythonhosted.org/packages/6b/63/f0b6205c64d74d2a24a58644a38ec77bdbaa6afc13747e75973bf8904932/setproctitle-1.3.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:316664d8b24a5c91ee244460bdaf7a74a707adaa9e14fbe0dc0a53168bb9aba1", size = 31836, upload-time = "2025-09-05T12:49:32.309Z" }, { url = "https://files.pythonhosted.org/packages/b6/7b/822a23f17e9003dfdee92cd72758441ca2a3680388da813a371b716fb07f/setproctitle-1.3.7-cp311-cp311-win_amd64.whl", hash = "sha256:acb9097213a8dd3410ed9f0dc147840e45ca9797785272928d4be3f0e69e3be4", size = 13243, upload-time = "2025-09-05T12:49:34.553Z" }, { url = "https://files.pythonhosted.org/packages/d0/99/71630546b9395b095f4082be41165d1078204d1696c2d9baade3de3202d0/setproctitle-1.3.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629", size = 32932, upload-time = "2025-09-05T12:49:39.271Z" }, - { url = "https://files.pythonhosted.org/packages/5c/00/a5949a8bb06ef5e7df214fc393bb2fb6aedf0479b17214e57750dfdd0f24/setproctitle-1.3.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6", size = 35605, upload-time = "2025-09-05T12:49:42.362Z" }, - { url = "https://files.pythonhosted.org/packages/ca/14/b843a251296ce55e2e17c017d6b9f11ce0d3d070e9265de4ecad948b913d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a", size = 34434, upload-time = "2025-09-05T12:49:45.31Z" }, { url = "https://files.pythonhosted.org/packages/c8/b7/06145c238c0a6d2c4bc881f8be230bb9f36d2bf51aff7bddcb796d5eed67/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739", size = 32795, upload-time = "2025-09-05T12:49:46.419Z" }, { url = "https://files.pythonhosted.org/packages/e2/5b/a9fe517912cd6e28cf43a212b80cb679ff179a91b623138a99796d7d18a0/setproctitle-1.3.7-cp312-cp312-win_amd64.whl", hash = "sha256:9888ceb4faea3116cf02a920ff00bfbc8cc899743e4b4ac914b03625bdc3c300", size = 13247, upload-time = "2025-09-05T12:49:49.16Z" }, { url = "https://files.pythonhosted.org/packages/41/89/5b6f2faedd6ced3d3c085a5efbd91380fb1f61f4c12bc42acad37932f4e9/setproctitle-1.3.7-pp310-pypy310_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:502b902a0e4c69031b87870ff4986c290ebbb12d6038a70639f09c331b18efb2", size = 14284, upload-time = "2025-09-05T12:51:18.393Z" }, @@ -8820,21 +8727,12 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/9c/eda4615863cd8621e89aed4df680d8c3ec3da6a4cf1da113c17decd87c7f/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f0ab1c1af0cb38e3f598244c17919fb1a84d1629cc08355b0074b6d7f53138ac", size = 459065, upload-time = "2025-10-14T15:04:22.795Z" }, - { url = "https://files.pythonhosted.org/packages/86/93/cfa597fa9389e122488f7ffdbd6db505b3b915ca7435ecd7542e855898c2/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e84087b432b6ac94778de547e08611266f1f8ffad28c0ee4c82e028b0fc5966d", size = 595837, upload-time = "2025-10-14T15:04:25.057Z" }, - { url = "https://files.pythonhosted.org/packages/57/1e/68c1ed5652b48d89fc24d6af905d88ee4f82fa8bc491e2666004e307ded1/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:620bae625f4cb18427b1bb1a2d9426dc0dd5a5ba74c7c2cdb9de405f7b129863", size = 473456, upload-time = "2025-10-14T15:04:26.497Z" }, { url = "https://files.pythonhosted.org/packages/d5/dc/1a680b7458ffa3b14bb64878112aefc8f2e4f73c5af763cbf0bd43100658/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:544364b2b51a9b0c7000a4b4b02f90e9423d97fbbf7e06689236443ebcad81ab", size = 455614, upload-time = "2025-10-14T15:04:27.539Z" }, { url = "https://files.pythonhosted.org/packages/9b/73/bb5f38590e34687b2a9c47a244aa4dd50c56a825969c92c9c5fc7387cea1/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1a0bb430adb19ef49389e1ad368450193a90038b5b752f4ac089ec6942c4dff4", size = 622459, upload-time = "2025-10-14T15:04:29.491Z" }, { url = "https://files.pythonhosted.org/packages/11/a0/a60c5a7c2ec59fa062d9a9c61d02e3b6abd94d32aac2d8344c4bdd033326/watchfiles-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a36d8efe0f290835fd0f33da35042a1bb5dc0e83cbc092dcf69bce442579e88e", size = 287453, upload-time = "2025-10-14T15:04:31.53Z" }, - { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" }, - { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" }, - { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" }, { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" }, { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" }, { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" }, - { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" }, - { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" }, - { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" }, { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" }, { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" }, { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" }, From 028a1fd5c1c7345f9ffa08e476319246b1aef217 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 02:19:49 +0000 Subject: [PATCH 42/62] Fix interleaved position tracking and optimize split_table Skip None placeholder entries in _text_rows and _image_rows so that parallel texts/images arrays produce non-overlapping interleaved positions instead of duplicate rows at every position. Before: 996 rows per shard (470 text + 470 image + 56 metadata) with overlapping positions between text and image modalities. After: 526 rows per shard (228 text + 242 image + 56 metadata) with correct non-overlapping interleaved positions. Also replace split_table_by_group_max_bytes with a faster Arrow-native implementation using pc.not_equal + pc.indices_nonzero for group boundary detection and average-bytes-per-row estimation. Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/core/utils.py | 45 ++++++++--------- .../multimodal/io/readers/webdataset.py | 7 ++- .../multimodal/test_multimodal_reader.py | 50 +++++++++++++++---- 3 files changed, 68 insertions(+), 34 deletions(-) diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index 9dce70cf88..6f1325c61f 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -208,32 +208,31 @@ def split_table_by_group_max_bytes( msg = f"Group column '{group_column}' not found in table" raise ValueError(msg) - # Sort by group column so rows for each group are contiguous -- O(n log n) - # then slice at group boundaries instead of O(groups * rows) filtering. sort_indices = pc.sort_indices(table, sort_keys=[(group_column, "ascending")]) table = table.take(sort_indices) col = table[group_column] + n = table.num_rows - group_tables: list[pa.Table] = [] - start = 0 - for i in range(1, table.num_rows): - if col[i].as_py() != col[i - 1].as_py(): - group_tables.append(table.slice(start, i - start)) - start = i - group_tables.append(table.slice(start, table.num_rows - start)) - - chunks: list[list[pa.Table]] = [] - chunk_tables: list[pa.Table] = [] - chunk_bytes = 0 - for group_table in group_tables: - group_bytes = int(group_table.nbytes) - if chunk_tables and (chunk_bytes + group_bytes > max_batch_bytes): - chunks.append(chunk_tables) - chunk_tables = [] - chunk_bytes = 0 - chunk_tables.append(group_table) + if n <= 1: + return [table] + + ne = pc.not_equal(col.slice(1), col.slice(0, n - 1)) + split_points = pc.indices_nonzero(ne).to_pylist() + group_starts = [0, *(p + 1 for p in split_points)] + group_ends = [*(p + 1 for p in split_points), n] + + avg_bytes_per_row = table.nbytes / n + chunk_split_indices: list[int] = [] + chunk_bytes = 0.0 + for i, (gs, ge) in enumerate(zip(group_starts, group_ends, strict=True)): + group_bytes = (ge - gs) * avg_bytes_per_row + if i > 0 and chunk_bytes > 0 and (chunk_bytes + group_bytes > max_batch_bytes): + chunk_split_indices.append(gs) + chunk_bytes = 0.0 chunk_bytes += group_bytes - if chunk_tables: - chunks.append(chunk_tables) - return [pa.concat_tables(chunk) if len(chunk) > 1 else chunk[0] for chunk in chunks] + if not chunk_split_indices: + return [table] + all_starts = [0, *chunk_split_indices] + all_ends = [*chunk_split_indices, n] + return [table.slice(s, e - s) for s, e in zip(all_starts, all_ends, strict=True)] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index be7d053d6c..8a827b8bf9 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -145,10 +145,11 @@ def _text_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: "position": idx, "modality": "text", "content_type": "text/plain", - "text_content": text_value if isinstance(text_value, str) else None, + "text_content": str(text_value), "source_ref": source_ref, }) for idx, text_value in enumerate(texts) + if text_value is not None ] def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: @@ -161,11 +162,13 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] frame_counter = 0 for idx, image_token in enumerate(images): + if image_token is None: + continue content_key = self._resolve_image_content_key(image_token, image_member_name, ctx.member_names) content_type, _ = mimetypes.guess_type(content_key or image_member_name or "") frame_index = None is_multiframe_candidate = content_type == "image/tiff" - if content_key is not None and image_token is not None and is_multiframe_candidate: + if content_key is not None and is_multiframe_candidate: frame_index = frame_counter frame_counter += 1 rows.append(self._build_row(ctx, { diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 1310680a7e..17139264e5 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -163,7 +163,7 @@ def test_reader_uses_resolved_content_key_for_content_type(tmp_path: Path) -> No def test_reader_image_tokens_with_frame_index(tmp_path: Path) -> None: - """Non-None tokens get frame_index and resolve to default TIFF. None tokens get no content.""" + """Non-None tokens get frame_index and resolve to default TIFF. None tokens are skipped.""" tar_path = tmp_path / "sub-image-shard.tar" payload = { "pdf_name": "doc.pdf", @@ -178,19 +178,51 @@ def test_reader_image_tokens_with_frame_index(tmp_path: Path) -> None: df = _as_df(reader.process(task)) image_rows = df[df["modality"] == "image"] - assert len(image_rows) == 3 + assert len(image_rows) == 2, "None image tokens should be skipped" + + assert image_rows.iloc[0]["position"] == 1, "First non-None image at interleaved position 1" + assert image_rows.iloc[1]["position"] == 2, "Second non-None image at interleaved position 2" refs = [MultiBatchTask.parse_source_ref(v) for v in image_rows["source_ref"].tolist()] - assert refs[0]["member"] is None, "None token should have no content" - assert refs[0]["path"] is None - assert refs[0]["frame_index"] is None + assert refs[0]["member"] == "doc.pdf.tiff", "Non-matching string should resolve to default TIFF" + assert refs[0]["frame_index"] == 0, "First non-None token gets frame_index=0" + + assert refs[1]["member"] == "doc.pdf.tiff" + assert refs[1]["frame_index"] == 1, "Second non-None token gets frame_index=1" + + text_rows = df[df["modality"] == "text"] + assert len(text_rows) == 3 + assert text_rows["position"].tolist() == [0, 1, 2], "All text entries are strings so positions 0,1,2" + + +def test_reader_interleaved_positions_do_not_overlap(tmp_path: Path) -> None: + """Parallel texts/images arrays with None placeholders produce non-overlapping positions.""" + tar_path = tmp_path / "interleaved-shard.tar" + payload = { + "pdf_name": "interleaved.pdf", + "texts": ["intro text", None, "middle text", None, "conclusion"], + "images": [None, "page_img", None, "chart_img", None], + } + _write_tar_sample(tar_path, payload, image_name="interleaved.pdf.jpg", image_bytes=b"\xff\xd8\xff") + task = _task_for_tar(tar_path, "interleaved_test") + reader = WebdatasetReaderStage(source_id_field="pdf_name", sample_id_field="pdf_name") + df = _as_df(reader.process(task)) + + text_rows = df[df["modality"] == "text"].sort_values("position") + image_rows = df[df["modality"] == "image"].sort_values("position") + + assert text_rows["position"].tolist() == [0, 2, 4] + assert text_rows["text_content"].tolist() == ["intro text", "middle text", "conclusion"] + + assert image_rows["position"].tolist() == [1, 3] - assert refs[1]["member"] == "doc.pdf.tiff", "Non-matching string should resolve to default TIFF" - assert refs[1]["frame_index"] == 0, "First non-None token gets frame_index=0" + text_positions = set(text_rows["position"].tolist()) + image_positions = set(image_rows["position"].tolist()) + assert text_positions.isdisjoint(image_positions), "Text and image positions must not overlap" - assert refs[2]["member"] == "doc.pdf.tiff" - assert refs[2]["frame_index"] == 1, "Second non-None token gets frame_index=1" + all_positions = sorted(text_positions | image_positions) + assert all_positions == [0, 1, 2, 3, 4], "Interleaved positions should cover 0..N-1 without gaps" def test_reader_empty_output_schema_includes_requested_passthrough_fields(tmp_path: Path) -> None: From ed150e8b7dfc98cbb6119069de4304a5e968eda8 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 05:42:12 +0000 Subject: [PATCH 43/62] Address PR review feedback: task introspection, mutation stubs, and filter position recompute - Change metadata_json category from Internal to Content (docs + README) - Add count(modality=) method for filtered row counts; num_items now returns unique sample count (distinct sample_id values) - Add add_rows() and delete_rows() stubs (NotImplementedError) - Recompute content positions in BaseMultimodalFilterStage after row drops to close gaps (metadata rows keep position=-1) - Add tests for position recomputation, count(), and pandas data path Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/stages/multimodal/README.md | 2 +- nemo_curator/stages/multimodal/stages.py | 7 +- nemo_curator/tasks/multimodal.py | 51 +++++++++++- .../stages/multimodal/test_multimodal_core.py | 80 +++++++++++++++++++ 4 files changed, 136 insertions(+), 4 deletions(-) diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index c4bd23e9ef..09b94f2cab 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -44,7 +44,7 @@ These are set and managed by pipeline stages. Users should not write to them dir | `text_content` | string | Content | Text payload for text rows | | `binary_content` | large_binary | Content | Image bytes (populated by materialization) | | `source_ref` | string | Internal | JSON locator: `{path, member, byte_offset, byte_size, frame_index}` | -| `metadata_json` | string | Internal | Full JSON payload for metadata rows | +| `metadata_json` | string | Content | Full JSON payload for metadata rows | | `materialize_error` | string | Internal | Error message if materialization failed | ### User columns (passthrough) diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index 93d1a9b1ef..c760a29cfc 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -108,7 +108,12 @@ def iter_materialized_bytes( yield row_idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: - return df[self.keep_mask(task, df)] + filtered = df[self.keep_mask(task, df)].copy() + content_mask = filtered["modality"] != "metadata" + if content_mask.any(): + reindexed = filtered[content_mask].groupby("sample_id", sort=False).cumcount() + filtered.loc[content_mask, "position"] = reindexed.astype(filtered["position"].dtype) + return filtered @dataclass diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index 12c618f9b7..fc7ba59cac 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -28,7 +28,7 @@ ``text_content`` string Content Text payload for text rows ``binary_content`` large_binary Content Image bytes (populated by materialization) ``source_ref`` string Internal JSON locator: path, member, byte_offset, byte_size - ``metadata_json`` string Internal Full JSON payload for metadata rows + ``metadata_json`` string Content Full JSON payload for metadata rows ``materialize_error`` string Internal Error message if materialization failed ================== ============= =========== =============================================== @@ -41,6 +41,7 @@ import pandas as pd import pyarrow as pa +import pyarrow.compute as pc from loguru import logger from .tasks import Task @@ -97,7 +98,25 @@ def to_pandas(self) -> pd.DataFrame: @property def num_items(self) -> int: - return len(self.data) + """Number of unique samples (distinct ``sample_id`` values).""" + if isinstance(self.data, pa.Table): + return pc.count_distinct(self.data.column("sample_id")).as_py() + return int(self.data["sample_id"].nunique()) + + def count(self, *, modality: str | None = None) -> int: + """Return row count, optionally filtered by modality. + + Examples:: + + task.count() # total rows + task.count(modality="image") # image rows only + task.count(modality="text") # text rows only + """ + if modality is None: + return len(self.data) + if isinstance(self.data, pa.Table): + return pc.sum(pc.equal(self.data.column("modality"), modality)).as_py() + return int((self.data["modality"] == modality).sum()) def get_columns(self) -> list[str]: if isinstance(self.data, pd.DataFrame): @@ -118,6 +137,34 @@ def validate(self) -> bool: return False return True + # -- mutation (not yet implemented) -- + + def add_rows( + self, + rows: pa.Table | pd.DataFrame | list[dict], + sample_id: str | None = None, + auto_position: bool = True, + ) -> "MultiBatchTask": + """Add rows to this task. + + Args: + rows: New rows to append. Must contain required columns unless + overridden by *sample_id* / *auto_position*. + sample_id: If provided, assign this ``sample_id`` to all new rows. + auto_position: If ``True``, auto-assign ``position`` values + continuing from the existing maximum per sample. + """ + raise NotImplementedError + + def delete_rows(self, mask: pd.Series) -> "MultiBatchTask": + """Delete rows where *mask* is ``True``. + + Args: + mask: Boolean Series aligned to the data. ``True`` marks a row + for deletion. + """ + raise NotImplementedError + # -- source_ref helpers -- @staticmethod diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index c54cd93a00..9a5c98cd89 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -463,6 +463,86 @@ def test_basic_row_validity_mask_enforces_position_rules() -> None: assert mask.tolist() == [True, False, True, False] +# --- filter position preservation test --- + + +def test_filter_recomputes_positions_after_drop() -> None: + """Filtering must recompute content positions to close gaps; metadata stays at -1.""" + + class _DropOddPositions(BaseMultimodalFilterStage): + name: str = "drop_odd" + + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + pos = df["position"].astype(int) + return ~((df["modality"] != "metadata") & (pos % 2 == 1)) + + rows = [ + {"sample_id": "s1", "position": i, "modality": "text", "content_type": "text/plain", + "text_content": f"t{i}", "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None} + for i in range(4) + ] + [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": "{}", "materialize_error": None}, + ] + task = MultiBatchTask( + task_id="pos_test", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + ) + stage = _DropOddPositions(drop_invalid_rows=False) + result = stage.process(task) + out_df = result.to_pandas() + assert out_df["position"].tolist() == [0, 1, -1] + assert out_df["text_content"].iloc[0] == "t0" + assert out_df["text_content"].iloc[1] == "t2" + assert pd.isna(out_df["text_content"].iloc[2]) + + +# --- count / num_samples tests --- + + +def test_count_and_num_items() -> None: + table = pa.Table.from_pylist( + [ + {"sample_id": "s1", "position": 0, "modality": "text", "content_type": None, + "text_content": "a", "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None}, + {"sample_id": "s1", "position": 1, "modality": "image", "content_type": None, + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None}, + {"sample_id": "s2", "position": 0, "modality": "text", "content_type": None, + "text_content": "b", "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None}, + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="cnt", dataset_name="d", data=table) + assert task.num_items == 2 + assert task.count() == 3 + assert task.count(modality="text") == 2 + assert task.count(modality="image") == 1 + assert task.count(modality="metadata") == 0 + + +def test_count_with_pandas_data() -> None: + table = pa.Table.from_pylist( + [ + {"sample_id": "s1", "position": 0, "modality": "text", "content_type": None, + "text_content": "a", "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None}, + {"sample_id": "s1", "position": 1, "modality": "image", "content_type": None, + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None}, + ], + schema=MULTIMODAL_SCHEMA, + ) + task = MultiBatchTask(task_id="pd_cnt", dataset_name="d", data=table.to_pandas()) + assert task.num_items == 1 + assert task.count() == 2 + assert task.count(modality="image") == 1 + + # --- CompositeStage decomposition test --- From f834c6e95a1d7d40217b2d19299b5f8ca021bc64 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 05:53:34 +0000 Subject: [PATCH 44/62] Improve source_ref docstring with inline materialization strategy summary Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/stages/multimodal/README.md | 2 +- nemo_curator/tasks/multimodal.py | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index 09b94f2cab..ecceab6279 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -43,7 +43,7 @@ These are set and managed by pipeline stages. Users should not write to them dir | `content_type` | string | Content | MIME type (e.g. `text/plain`, `image/jpeg`) | | `text_content` | string | Content | Text payload for text rows | | `binary_content` | large_binary | Content | Image bytes (populated by materialization) | -| `source_ref` | string | Internal | JSON locator: `{path, member, byte_offset, byte_size, frame_index}` | +| `source_ref` | string | Internal | JSON locator `{path, member, byte_offset, byte_size, frame_index}`. `path` alone = direct/remote read; + `member` = tar extract; + `byte_offset/size` = range read (fastest). `path` accepts local or remote (`s3://`) URIs. | | `metadata_json` | string | Content | Full JSON payload for metadata rows | | `materialize_error` | string | Internal | Error message if materialization failed | diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index fc7ba59cac..036e0b5f47 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -27,7 +27,12 @@ ``content_type`` string Content MIME type (e.g. ``text/plain``, ``image/jpeg``) ``text_content`` string Content Text payload for text rows ``binary_content`` large_binary Content Image bytes (populated by materialization) - ``source_ref`` string Internal JSON locator: path, member, byte_offset, byte_size + ``source_ref`` string Internal JSON locator ``{path, member, + byte_offset, byte_size, frame_index}``. + ``path`` alone = direct/remote read; + + ``member`` = tar extract; + + ``byte_offset/size`` = range read (fastest). + ``path`` accepts local or remote (``s3://``) URIs. ``metadata_json`` string Content Full JSON payload for metadata rows ``materialize_error`` string Internal Error message if materialization failed ================== ============= =========== =============================================== From 45f12dc62749dbd9f9d150672dc77ef68c30ba8b Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 05:58:24 +0000 Subject: [PATCH 45/62] Clarify modality field is extensible beyond built-in values Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/stages/multimodal/README.md | 2 +- nemo_curator/tasks/multimodal.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index ecceab6279..3c6e4b810a 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -39,7 +39,7 @@ These are set and managed by pipeline stages. Users should not write to them dir |--------|------|----------|-------------| | `sample_id` | string (required) | Identity | Unique document/sample identifier | | `position` | int32 (required) | Identity | Position within sample (-1 for metadata rows) | -| `modality` | string (required) | Identity | One of: `text`, `image`, `metadata` | +| `modality` | string (required) | Identity | Row modality: `text`, `image`, `metadata` built-in; extensible to `audio`, `table`, `generated_image`, etc. | | `content_type` | string | Content | MIME type (e.g. `text/plain`, `image/jpeg`) | | `text_content` | string | Content | Text payload for text rows | | `binary_content` | large_binary | Content | Image bytes (populated by materialization) | diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/multimodal.py index 036e0b5f47..c59a4503ee 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/multimodal.py @@ -23,7 +23,9 @@ ================== ============= =========== =============================================== ``sample_id`` string (req) Identity Unique document/sample identifier ``position`` int32 (req) Identity Position within sample (-1 for metadata rows) - ``modality`` string (req) Identity One of: ``text``, ``image``, ``metadata`` + ``modality`` string (req) Identity Row modality -- built-in values are ``text``, + ``image``, and ``metadata``; extensible to + ``audio``, ``table``, ``generated_image``, etc. ``content_type`` string Content MIME type (e.g. ``text/plain``, ``image/jpeg``) ``text_content`` string Content Text payload for text rows ``binary_content`` large_binary Content Image bytes (populated by materialization) From f1cc65c67688a448af7e5e16ee77fa72973004c5 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 20:05:47 +0000 Subject: [PATCH 46/62] Add Lance writer, fix WebDataset writer interleaving and data preservation - Add MultimodalLanceWriterStage extending BaseMultimodalWriter for Lance format - Fix WebDataset writer to preserve interleaving via position-indexed parallel texts/images arrays (previously compact arrays lost position information) - Fix _sanitize_key to strip dots from WebDataset keys (dots are extension separators per the WDS spec; sample_ids containing ".parquet" caused all samples to merge into one) - Use position-based image naming (e.g., "0.jpg", "3.jpg") so images[pos] directly maps to sample[images[pos]] per WebDataset dict key convention - Preserve all extra (non-schema) columns in WebDataset JSON via _row_extra structured by modality: {text: [...], image: [...], metadata: {...}} with 1:1 alignment to texts/images arrays for zero data loss - Fix BaseMultimodalWriter.write_data to not leak storage_options into format-specific _write_dataframe calls - Add test_merged_parquet_3format_write.py benchmark script for Parquet, WebDataset, and Lance materialized writes from merged domain-bucket data - Add explore_outputs.ipynb verification notebook with webdataset/lance/PIL compliance checks and filtering UX demos - Add unit tests for Lance writer and WDS extra column preservation Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../test_merged_parquet_3format_write.py | 229 ++++++++ nemo_curator/stages/multimodal/io/__init__.py | 2 + .../stages/multimodal/io/writers/__init__.py | 3 +- .../stages/multimodal/io/writers/base.py | 2 +- .../stages/multimodal/io/writers/lance.py | 41 ++ .../multimodal/io/writers/webdataset.py | 147 ++--- tests/stages/multimodal/test_lance_writer.py | 187 +++++++ .../multimodal/test_multimodal_wds_writer.py | 82 ++- tmp_3_test_output/explore_outputs.ipynb | 526 ++++++++++++++++++ 9 files changed, 1154 insertions(+), 65 deletions(-) create mode 100644 benchmarking/scripts/test_merged_parquet_3format_write.py create mode 100644 nemo_curator/stages/multimodal/io/writers/lance.py create mode 100644 tests/stages/multimodal/test_lance_writer.py create mode 100644 tmp_3_test_output/explore_outputs.ipynb diff --git a/benchmarking/scripts/test_merged_parquet_3format_write.py b/benchmarking/scripts/test_merged_parquet_3format_write.py new file mode 100644 index 0000000000..79322efbc1 --- /dev/null +++ b/benchmarking/scripts/test_merged_parquet_3format_write.py @@ -0,0 +1,229 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +"""Test script: read merged parquet, filter to fully-matched samples, write 3 formats. + +Reads from the merged parquet domain-bucket data, keeps only samples where +every image row has match_status == "matched", then writes the first N samples +as materialized Parquet, WebDataset, and Lance. +""" + +from __future__ import annotations + +import argparse +import os +import time +from pathlib import Path + +import pyarrow.parquet as pq +from loguru import logger + +from nemo_curator.stages.multimodal.io.writers.lance import MultimodalLanceWriterStage +from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage +from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + +STORAGE_OPTIONS = { + "key": "team-iva-cc-image-text-release", + "secret": "e36b8dbaa53497da987baa9129acb3be", + "client_kwargs": { + "endpoint_url": "https://pdx.s8k.io", + "region_name": "us-east-1", + }, +} + + +def find_parquet_files(bucket_dir: str) -> list[str]: + return sorted( + os.path.join(bucket_dir, f) + for f in os.listdir(bucket_dir) + if f.endswith(".parquet") + ) + + +def load_and_filter(parquet_path: str, num_samples: int) -> MultiBatchTask: + """Load merged parquet, keep only fully-matched samples, return first N.""" + logger.info("Reading parquet: {}", parquet_path) + t0 = time.perf_counter() + table = pq.read_table(parquet_path) + logger.info("Read {} rows in {:.1f}s", table.num_rows, time.perf_counter() - t0) + + df = table.to_pandas() + + image_df = df[df["modality"] == "image"] + unmatched_sids = set( + image_df.loc[image_df["match_status"] != "matched", "sample_id"].unique() + ) + all_sids = set(df["sample_id"].unique()) + fully_matched_sids = all_sids - unmatched_sids + # Exclude sample_ids that have zero image rows (metadata/text-only docs) + sids_with_images = set(image_df["sample_id"].unique()) + fully_matched_sids = fully_matched_sids & sids_with_images + + logger.info( + "Samples: {} total, {} with images, {} fully matched", + len(all_sids), len(sids_with_images), len(fully_matched_sids), + ) + + selected_sids = sorted(fully_matched_sids)[:num_samples] + logger.info("Selected first {} sample_ids", len(selected_sids)) + + filtered = df[df["sample_id"].isin(selected_sids)].reset_index(drop=True) + logger.info("Filtered to {} rows across {} samples", len(filtered), len(selected_sids)) + + for col in MULTIMODAL_SCHEMA.names: + if col not in filtered.columns: + filtered[col] = None + + logger.info("Output columns: {} ({} total)", list(filtered.columns), len(filtered.columns)) + for sid in selected_sids: + sample = filtered[filtered["sample_id"] == sid] + imgs = sample[sample["modality"] == "image"] + logger.info( + " sample {} -- {} rows ({} text, {} image, {} metadata)", + sid[:80], len(sample), + (sample["modality"] == "text").sum(), + len(imgs), + (sample["modality"] == "metadata").sum(), + ) + + return MultiBatchTask( + task_id="test_3format", + dataset_name="merged_parquet_bucket0", + data=filtered, + _metadata={"source_files": [parquet_path]}, + ) + + +def write_parquet(task: MultiBatchTask, output_dir: str) -> str: + path = os.path.join(output_dir, "parquet") + os.makedirs(path, exist_ok=True) + writer = MultimodalParquetWriterStage( + path=path, + materialize_on_write=True, + write_kwargs={"storage_options": STORAGE_OPTIONS}, + on_materialize_error="warn", + mode="overwrite", + ) + logger.info("Writing Parquet to {}", path) + t0 = time.perf_counter() + result = writer.process(task) + logger.info("Parquet write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) + return result.data[0] + + +def write_webdataset(task: MultiBatchTask, output_dir: str) -> str: + path = os.path.join(output_dir, "webdataset") + os.makedirs(path, exist_ok=True) + writer = MultimodalWebdatasetWriterStage( + path=path, + materialize_on_write=True, + write_kwargs={"storage_options": STORAGE_OPTIONS}, + on_materialize_error="warn", + mode="overwrite", + ) + logger.info("Writing WebDataset to {}", path) + t0 = time.perf_counter() + result = writer.process(task) + logger.info("WebDataset write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) + return result.data[0] + + +def write_lance(task: MultiBatchTask, output_dir: str) -> str: + path = os.path.join(output_dir, "lance") + os.makedirs(path, exist_ok=True) + writer = MultimodalLanceWriterStage( + path=path, + materialize_on_write=True, + write_kwargs={"storage_options": STORAGE_OPTIONS}, + on_materialize_error="warn", + mode="overwrite", + ) + logger.info("Writing Lance to {}", path) + t0 = time.perf_counter() + result = writer.process(task) + logger.info("Lance write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) + return result.data[0] + + +def verify_outputs(output_dir: str) -> None: + """Quick sanity check on the written outputs.""" + import lance + import pandas as pd + + parquet_dir = os.path.join(output_dir, "parquet") + pq_files = [os.path.join(parquet_dir, f) for f in os.listdir(parquet_dir) if f.endswith(".parquet")] + if pq_files: + df_pq = pd.read_parquet(pq_files[0]) + logger.info("[Verify] Parquet: {} rows, {} samples, columns={}", len(df_pq), df_pq["sample_id"].nunique(), list(df_pq.columns)) + img_rows = df_pq[df_pq["modality"] == "image"] + has_binary = img_rows["binary_content"].notna().sum() + logger.info("[Verify] Parquet image rows: {}, with binary: {}", len(img_rows), has_binary) + + wds_dir = os.path.join(output_dir, "webdataset") + tar_files = [f for f in os.listdir(wds_dir) if f.endswith(".tar")] + if tar_files: + import tarfile + tar_path = os.path.join(wds_dir, tar_files[0]) + with tarfile.open(tar_path, "r") as tf: + members = tf.getnames() + logger.info("[Verify] WebDataset tar: {} members, first 10: {}", len(members), members[:10]) + + lance_dir = os.path.join(output_dir, "lance") + lance_files = [f for f in os.listdir(lance_dir) if f.endswith(".lance")] + if lance_files: + ds = lance.dataset(os.path.join(lance_dir, lance_files[0])) + df_lance = ds.to_table().to_pandas() + logger.info("[Verify] Lance: {} rows, {} samples, columns={}", len(df_lance), df_lance["sample_id"].nunique(), list(df_lance.columns)) + img_rows = df_lance[df_lance["modality"] == "image"] + has_binary = img_rows["binary_content"].notna().sum() + logger.info("[Verify] Lance image rows: {}, with binary: {}", len(img_rows), has_binary) + + +def main() -> int: + parser = argparse.ArgumentParser(description="Test merged parquet -> 3-format materialized write") + parser.add_argument( + "--input-path", type=str, + default="/datasets/vjawa/mint1t_normalized/merged_parquet_domain_buckets_0_to_63/domain_bucket=0/", + ) + parser.add_argument("--output-path", type=str, default=".tmp_multimodal_runs/3format_test") + parser.add_argument("--num-samples", type=int, default=10) + parser.add_argument("--skip-verify", action="store_true", default=False) + args = parser.parse_args() + + parquet_files = find_parquet_files(args.input_path) + if not parquet_files: + logger.error("No parquet files found in {}", args.input_path) + return 1 + logger.info("Found {} parquet file(s) in {}", len(parquet_files), args.input_path) + + task = load_and_filter(parquet_files[0], num_samples=args.num_samples) + + output_dir = str(Path(args.output_path).absolute()) + os.makedirs(output_dir, exist_ok=True) + + write_parquet(task, output_dir) + write_webdataset(task, output_dir) + write_lance(task, output_dir) + + if not args.skip_verify: + verify_outputs(output_dir) + + logger.info("All 3 formats written to {}", output_dir) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/multimodal/io/__init__.py index 6dc0d5c37e..3bfd8bb4b6 100644 --- a/nemo_curator/stages/multimodal/io/__init__.py +++ b/nemo_curator/stages/multimodal/io/__init__.py @@ -13,10 +13,12 @@ # limitations under the License. from nemo_curator.stages.multimodal.io.reader import MultimodalParquetReader, WebdatasetReader +from nemo_curator.stages.multimodal.io.writers.lance import MultimodalLanceWriterStage from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage __all__ = [ + "MultimodalLanceWriterStage", "MultimodalParquetReader", "MultimodalParquetWriterStage", "MultimodalWebdatasetWriterStage", diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/multimodal/io/writers/__init__.py index defb7fec05..3291523b13 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/multimodal/io/writers/__init__.py @@ -12,7 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +from nemo_curator.stages.multimodal.io.writers.lance import MultimodalLanceWriterStage from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage -__all__ = ["MultimodalParquetWriterStage", "MultimodalWebdatasetWriterStage"] +__all__ = ["MultimodalLanceWriterStage", "MultimodalParquetWriterStage", "MultimodalWebdatasetWriterStage"] diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/multimodal/io/writers/base.py index 8b80054210..080521eda9 100644 --- a/nemo_curator/stages/multimodal/io/writers/base.py +++ b/nemo_curator/stages/multimodal/io/writers/base.py @@ -108,7 +108,7 @@ def write_data(self, task: MultiBatchTask, file_path: str) -> None: with self._time_metric("materialize_dataframe_total_s"): df = self._materialize_dataframe(task) write_kwargs: dict[str, Any] = {"index": False} - write_kwargs.update(self.write_kwargs) + write_kwargs.update({k: v for k, v in self.write_kwargs.items() if k != "storage_options"}) self._write_dataframe(df, file_path, write_kwargs) def process(self, task: MultiBatchTask) -> FileGroupTask: diff --git a/nemo_curator/stages/multimodal/io/writers/lance.py b/nemo_curator/stages/multimodal/io/writers/lance.py new file mode 100644 index 0000000000..f7e01aaeec --- /dev/null +++ b/nemo_curator/stages/multimodal/io/writers/lance.py @@ -0,0 +1,41 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any + +import pyarrow as pa + +from .base import BaseMultimodalWriter + +if TYPE_CHECKING: + import pandas as pd + + +@dataclass +class MultimodalLanceWriterStage(BaseMultimodalWriter): + """Write multimodal rows to Lance format with optional binary materialization.""" + + file_extension: str = "lance" + name: str = "multimodal_lance_writer" + + def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: + import lance + + write_kwargs.pop("index", None) + table = pa.Table.from_pandas(df, preserve_index=False) + with self._time_metric("lance_write_s"): + lance.write_dataset(table, file_path, mode="overwrite", **write_kwargs) diff --git a/nemo_curator/stages/multimodal/io/writers/webdataset.py b/nemo_curator/stages/multimodal/io/writers/webdataset.py index 03bd723dec..d34892fb2d 100644 --- a/nemo_curator/stages/multimodal/io/writers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/writers/webdataset.py @@ -27,11 +27,11 @@ import pandas as pd from loguru import logger +from nemo_curator.tasks.multimodal import RESERVED_COLUMNS + from .base import BaseMultimodalWriter if TYPE_CHECKING: - import numpy as np - from nemo_curator.tasks import MultiBatchTask _MIME_TO_EXT: dict[str, str] = { @@ -43,11 +43,15 @@ "image/bmp": "bmp", } -_SANITIZE_RE = re.compile(r"[^\w\-.]") +_SANITIZE_RE = re.compile(r"[^\w\-]") def _sanitize_key(raw: str) -> str: - """Produce a filesystem-safe WebDataset key from a raw sample_id.""" + """Produce a filesystem-safe WebDataset key free of dots. + + The WebDataset format uses dots as extension separators, so the sample key + (the part before the first dot) must not contain any dots. + """ return _SANITIZE_RE.sub("_", raw)[:200] @@ -71,19 +75,7 @@ def _add_tar_member(tf: tarfile.TarFile, name: str, data: bytes, mtime: float) - tf.addfile(ti, io.BytesIO(data)) -@dataclass -class _ColumnArrays: - """Pre-extracted numpy arrays from the DataFrame for fast row-level access.""" - - modality: np.ndarray - position: np.ndarray - text_content: np.ndarray - binary_content: np.ndarray - content_type: np.ndarray - metadata_json: np.ndarray - - -def _build_index(sid_col: np.ndarray) -> list[tuple[str, list[int]]]: +def _build_index(sid_col: list | pd.Series) -> list[tuple[str, list[int]]]: """Return (sample_id, row_indices) pairs in first-occurrence order.""" sid_to_indices: dict[str, list[int]] = {} insertion_order: list[str] = [] @@ -109,50 +101,87 @@ def _extract_metadata_payload(meta_val: object) -> dict[str, Any]: return parsed -def _collect_images( - image_entries: list[tuple[int, object, object]], -) -> tuple[list[str | None], list[tuple[str, bytes]]]: - image_entries.sort(key=lambda x: x[0]) - images: list[str | None] = [] - binaries: list[tuple[str, bytes]] = [] - ext_counter: dict[str, int] = {} - for _, binary, content_type in image_entries: - has_binary = binary is not None and not pd.isna(binary) and isinstance(binary, (bytes, bytearray)) - if has_binary: - ext = _ext_from_content_type(content_type) - count = ext_counter.get(ext, 0) - ext_counter[ext] = count + 1 - member_key = ext if count == 0 else f"{count}.{ext}" - binaries.append((member_key, bytes(binary))) - images.append(member_key) - else: - images.append(None) - return images, binaries - - -def _write_sample(tf: tarfile.TarFile, key: str, indices: list[int], cols: _ColumnArrays, mtime: float) -> None: +def _safe_json_value(val: object) -> object: + """Convert a value to a JSON-safe type.""" + if val is None or (isinstance(val, float) and pd.isna(val)): + return None + if isinstance(val, (bytes, bytearray)): + return None + if isinstance(val, (int, float, str, bool)): + return val + return str(val) + + +def _write_sample( + tf: tarfile.TarFile, + key: str, + sample_df: pd.DataFrame, + extra_columns: list[str], + mtime: float, +) -> None: payload: dict[str, Any] = {} - text_entries: list[tuple[int, object]] = [] - image_entries: list[tuple[int, object, object]] = [] - - for idx in indices: - mod = str(cols.modality[idx]) + text_at_pos: dict[int, object] = {} + image_at_pos: dict[int, tuple[object, object]] = {} + text_extra_at_pos: dict[int, dict[str, Any]] = {} + image_extra_at_pos: dict[int, dict[str, Any]] = {} + metadata_extra: dict[str, Any] = {} + + for _, row in sample_df.iterrows(): + mod = str(row["modality"]) + pos = int(row["position"]) + row_extra = {c: _safe_json_value(row[c]) for c in extra_columns} if extra_columns else {} if mod == "metadata": - payload.update(_extract_metadata_payload(cols.metadata_json[idx])) + payload.update(_extract_metadata_payload(row["metadata_json"])) + metadata_extra = row_extra elif mod == "text": - text_entries.append((int(cols.position[idx]), cols.text_content[idx])) + text_at_pos[pos] = row["text_content"] + text_extra_at_pos[pos] = row_extra elif mod == "image": - image_entries.append((int(cols.position[idx]), cols.binary_content[idx], cols.content_type[idx])) + image_at_pos[pos] = (row["binary_content"], row["content_type"]) + image_extra_at_pos[pos] = row_extra + + all_positions = set(text_at_pos) | set(image_at_pos) + n = max(all_positions) + 1 if all_positions else 0 - text_entries.sort(key=lambda x: x[0]) - payload["texts"] = [str(v) if v is not None and not pd.isna(v) else None for _, v in text_entries] - images, binaries = _collect_images(image_entries) + texts: list[str | None] = [None] * n + images: list[str | None] = [None] * n + binaries: list[tuple[str, bytes]] = [] + + for pos in range(n): + if pos in text_at_pos: + v = text_at_pos[pos] + texts[pos] = str(v) if v is not None and not pd.isna(v) else None + if pos in image_at_pos: + binary, content_type = image_at_pos[pos] + has_binary = binary is not None and not pd.isna(binary) and isinstance(binary, (bytes, bytearray)) + if has_binary: + ext = _ext_from_content_type(content_type) + member_suffix = f"{pos}.{ext}" + binaries.append((f"{key}.{member_suffix}", bytes(binary))) + images[pos] = member_suffix + else: + images[pos] = None + + payload["texts"] = texts payload["images"] = images + if extra_columns: + text_extra_list: list[dict[str, Any] | None] = [ + text_extra_at_pos.get(pos) for pos in range(n) + ] + image_extra_list: list[dict[str, Any] | None] = [ + image_extra_at_pos.get(pos) for pos in range(n) + ] + payload["_row_extra"] = { + "text": text_extra_list, + "image": image_extra_list, + "metadata": metadata_extra, + } + json_bytes = json.dumps(payload, ensure_ascii=True).encode("utf-8") _add_tar_member(tf, f"{key}.json", json_bytes, mtime) - for member_key, binary_data in binaries: - _add_tar_member(tf, f"{key}.{member_key}", binary_data, mtime) + for member_name, binary_data in binaries: + _add_tar_member(tf, member_name, binary_data, mtime) @dataclass @@ -176,22 +205,16 @@ def _write_tar(self, df: pd.DataFrame, file_path: str) -> None: mtime = time.time() samples_written = 0 - cols = _ColumnArrays( - modality=df["modality"].to_numpy(), - position=df["position"].to_numpy(), - text_content=df["text_content"].to_numpy(), - binary_content=df["binary_content"].to_numpy(), - content_type=df["content_type"].to_numpy(), - metadata_json=df["metadata_json"].to_numpy(), - ) - sample_index = _build_index(df["sample_id"].to_numpy()) + extra_columns = [c for c in df.columns if c not in RESERVED_COLUMNS] + sample_index = _build_index(df["sample_id"].tolist()) with ( fsspec.open(file_path, mode="wb", **self.storage_options) as fobj, tarfile.open(fileobj=fobj, mode="w") as tf, ): for sid, indices in sample_index: - _write_sample(tf, _sanitize_key(sid), indices, cols, mtime) + sample_df = df.iloc[indices] + _write_sample(tf, _sanitize_key(sid), sample_df, extra_columns, mtime) samples_written += 1 if samples_written % 10000 == 0: logger.info(f"WebDataset writer: {samples_written}/{len(sample_index)} samples written") diff --git a/tests/stages/multimodal/test_lance_writer.py b/tests/stages/multimodal/test_lance_writer.py new file mode 100644 index 0000000000..d7265a6ac5 --- /dev/null +++ b/tests/stages/multimodal/test_lance_writer.py @@ -0,0 +1,187 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 +from pathlib import Path + +import lance +import pandas as pd +import pyarrow as pa + +from nemo_curator.stages.multimodal.io.writers.lance import MultimodalLanceWriterStage +from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA + + +def _source_ref(content_path: str, content_key: str | None) -> str: + return json.dumps( + {"path": content_path, "member": content_key, "byte_offset": None, "byte_size": None} + ) + + +def _make_task(rows: list[dict], source_files: list[str] | None = None) -> MultiBatchTask: + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + metadata = {"source_files": source_files} if source_files else {} + return MultiBatchTask( + task_id="lance_test", + dataset_name="test_dataset", + data=table, + _metadata=metadata, + ) + + +def test_lance_writer_roundtrip_text_only(tmp_path: Path) -> None: + rows = [ + { + "sample_id": "s1", + "position": -1, + "modality": "metadata", + "content_type": "application/json", + "text_content": None, + "binary_content": None, + "source_ref": None, + "metadata_json": json.dumps({"url": "https://example.com"}), + "materialize_error": None, + }, + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "Hello world", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + }, + ] + task = _make_task(rows, source_files=["fake.parquet"]) + + writer = MultimodalLanceWriterStage( + path=str(tmp_path / "out_lance"), + materialize_on_write=False, + mode="overwrite", + ) + result = writer.process(task) + assert len(result.data) == 1 + + ds = lance.dataset(result.data[0]) + df_out = ds.to_table().to_pandas() + assert len(df_out) == 2 + assert set(df_out["sample_id"]) == {"s1"} + assert df_out.loc[df_out["modality"] == "text", "text_content"].iloc[0] == "Hello world" + + +def test_lance_writer_roundtrip_with_binary(tmp_path: Path) -> None: + image_bytes = b"fake-jpeg-content-12345" + raw_path = tmp_path / "test_image.jpg" + raw_path.write_bytes(image_bytes) + + rows = [ + { + "sample_id": "s1", + "position": -1, + "modality": "metadata", + "content_type": "application/json", + "text_content": None, + "binary_content": None, + "source_ref": None, + "metadata_json": json.dumps({"url": "https://example.com"}), + "materialize_error": None, + }, + { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": None, + "source_ref": _source_ref(str(raw_path), None), + "metadata_json": None, + "materialize_error": None, + }, + { + "sample_id": "s1", + "position": 1, + "modality": "text", + "content_type": "text/plain", + "text_content": "Caption for image", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + }, + ] + task = _make_task(rows, source_files=["fake.parquet"]) + + writer = MultimodalLanceWriterStage( + path=str(tmp_path / "out_lance_bin"), + materialize_on_write=True, + mode="overwrite", + ) + result = writer.process(task) + assert len(result.data) == 1 + assert result._metadata["format"] == "lance" + + ds = lance.dataset(result.data[0]) + df_out = ds.to_table().to_pandas() + assert len(df_out) == 3 + assert df_out["sample_id"].nunique() == 1 + + image_row = df_out[df_out["modality"] == "image"].iloc[0] + assert image_row["binary_content"] == image_bytes + assert pd.isna(image_row["materialize_error"]) + + text_row = df_out[df_out["modality"] == "text"].iloc[0] + assert text_row["text_content"] == "Caption for image" + + +def test_lance_writer_multiple_samples(tmp_path: Path) -> None: + rows = [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "First sample", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + }, + { + "sample_id": "s2", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "Second sample", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + }, + ] + task = _make_task(rows, source_files=["fake.parquet"]) + + writer = MultimodalLanceWriterStage( + path=str(tmp_path / "out_lance_multi"), + materialize_on_write=False, + mode="overwrite", + ) + result = writer.process(task) + + ds = lance.dataset(result.data[0]) + df_out = ds.to_table().to_pandas() + assert len(df_out) == 2 + assert set(df_out["sample_id"]) == {"s1", "s2"} diff --git a/tests/stages/multimodal/test_multimodal_wds_writer.py b/tests/stages/multimodal/test_multimodal_wds_writer.py index 34169e27fb..a3a70e572f 100644 --- a/tests/stages/multimodal/test_multimodal_wds_writer.py +++ b/tests/stages/multimodal/test_multimodal_wds_writer.py @@ -110,7 +110,7 @@ def test_writer_preserves_text_content(tmp_path: Path): payload = json.load(tf.extractfile(member)) assert "texts" in payload assert payload["texts"] == ["text_0_0", "text_0_1"] - assert "images" in payload + assert payload["images"] == ["0.jpg", None] def test_writer_preserves_image_bytes(tmp_path: Path): @@ -177,3 +177,83 @@ def test_writer_handles_no_binary_content(tmp_path: Path): if m.name.endswith(".json"): payload = json.load(tf.extractfile(m)) assert payload["images"] == [None] + + +def test_writer_preserves_extra_columns(tmp_path: Path): + """Extra (non-schema) columns must be round-tripped in _row_extra / _metadata_extra.""" + import pandas as pd + + img_bytes = generate_jpeg_bytes(seed=0) + df = pd.DataFrame([ + { + "sample_id": "s1", "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": json.dumps({"url": "https://example.com"}), + "materialize_error": None, + "nv_width": None, "nv_height": None, "match_status": None, + "custom_score": 0.95, + }, + { + "sample_id": "s1", "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": img_bytes, "source_ref": None, + "metadata_json": None, "materialize_error": None, + "nv_width": 100, "nv_height": 80, "match_status": "matched", + "custom_score": None, + }, + { + "sample_id": "s1", "position": 1, "modality": "text", + "content_type": "text/plain", "text_content": "caption", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + "nv_width": None, "nv_height": None, "match_status": None, + "custom_score": 0.7, + }, + ]) + task = MultiBatchTask( + task_id="extra_cols", dataset_name="test", data=df, + _metadata={"source_files": ["test.parquet"]}, + ) + + out_dir = tmp_path / "output" + out_dir.mkdir() + writer = MultimodalWebdatasetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + writer.process(task) + + tar_files = list(out_dir.glob("*.tar")) + with tarfile.open(tar_files[0], "r") as tf: + for m in tf.getmembers(): + if not m.name.endswith(".json"): + continue + payload = json.load(tf.extractfile(m)) + + assert "_row_extra" in payload, "Missing _row_extra in JSON payload" + row_extra = payload["_row_extra"] + assert "text" in row_extra, "Missing text key in _row_extra" + assert "image" in row_extra, "Missing image key in _row_extra" + assert "metadata" in row_extra, "Missing metadata key in _row_extra" + + assert len(row_extra["text"]) == 2, f"Expected 2 text entries, got {len(row_extra['text'])}" + assert len(row_extra["image"]) == 2, f"Expected 2 image entries, got {len(row_extra['image'])}" + + # pos 0: image row has nv_width=100, text row has nothing special + img_extra = row_extra["image"][0] + assert img_extra is not None + assert img_extra["nv_width"] == 100 + assert img_extra["nv_height"] == 80 + assert img_extra["match_status"] == "matched" + + # pos 1: text row has custom_score=0.7, no image + txt_extra = row_extra["text"][1] + assert txt_extra is not None + assert txt_extra["nv_width"] is None + assert txt_extra["custom_score"] == 0.7 + assert row_extra["image"][1] is None + + # metadata row + meta_extra = row_extra["metadata"] + assert meta_extra["custom_score"] == 0.95 + assert meta_extra["match_status"] is None diff --git a/tmp_3_test_output/explore_outputs.ipynb b/tmp_3_test_output/explore_outputs.ipynb new file mode 100644 index 0000000000..be693d04a6 --- /dev/null +++ b/tmp_3_test_output/explore_outputs.ipynb @@ -0,0 +1,526 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multimodal 3-Format Writer -- Zero Data Loss Verification\n", + "\n", + "Verifies Parquet, WebDataset, and Lance for 10 fully-matched samples.\n", + "Each format validated using canonical library. Extra columns (nv_*, match_*, etc.)\n", + "verified present in ALL formats including WebDataset JSON." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import json\n", + "from io import BytesIO\n", + "from pathlib import Path\n", + "\n", + "import lance\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pyarrow.parquet as pq\n", + "import webdataset as wds\n", + "from IPython.display import display, Image as IPImage\n", + "from PIL import Image\n", + "\n", + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.max_colwidth', 80)\n", + "OUTPUT_DIR = Path(\".\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 1. Parquet (PyArrow + PIL)" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "pq_files = list((OUTPUT_DIR / \"parquet\").glob(\"*.parquet\"))\n", + "pq_meta = pq.read_metadata(pq_files[0])\n", + "print(f\"Rows: {pq_meta.num_rows}, Cols: {pq_meta.num_columns}, Row groups: {pq_meta.num_row_groups}\")\n", + "table_pq = pq.read_table(pq_files[0])\n", + "df_pq = table_pq.to_pandas()\n", + "print(f\"Samples: {df_pq['sample_id'].nunique()}, Modalities: {df_pq['modality'].value_counts().to_dict()}\")\n", + "nv_cols = [c for c in df_pq.columns if c.startswith('nv_')]\n", + "print(f\"nv_* columns: {len(nv_cols)}, match_status: {df_pq['match_status'].value_counts(dropna=False).to_dict()}\")\n", + "\n", + "img_pq = df_pq[df_pq['modality'] == 'image']\n", + "print(f\"\\nImage rows: {len(img_pq)}, with binary: {img_pq['binary_content'].notna().sum()}\")\n", + "for _, row in img_pq.iterrows():\n", + " img = Image.open(BytesIO(row['binary_content']))\n", + " img.verify()\n", + "print(\"PASS: All Parquet images decodable via PIL.verify()\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# nv_* data for image rows\n", + "display(img_pq[['sample_id','position','nv_image_name','nv_width','nv_height','nv_img_byte_offset','nv_img_byte_size','match_status']].head(5))" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "for sid in df_pq['sample_id'].unique()[:3]:\n", + " sample = df_pq[df_pq['sample_id'] == sid].sort_values('position')\n", + " short_sid = sid.split(':')[-1] if ':' in sid else sid[-30:]\n", + " print(f\"\\n--- Sample ...:{short_sid} ---\")\n", + " for _, row in sample[sample['modality'] != 'metadata'].iterrows():\n", + " pos = row['position']\n", + " if row['modality'] == 'text':\n", + " print(f\" [pos={pos}] TEXT: {str(row['text_content'])[:100]}\")\n", + " elif row['modality'] == 'image':\n", + " blob = row['binary_content']\n", + " img = Image.open(BytesIO(blob))\n", + " print(f\" [pos={pos}] IMAGE: {len(blob):,}B, {img.size[0]}x{img.size[1]} {img.format}\")\n", + " display(IPImage(data=blob, width=300))" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 2. WebDataset (`webdataset` library + PIL + extra fields)" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "tar_files = list((OUTPUT_DIR / \"webdataset\").glob(\"*.tar\"))\n", + "tar_path = str(tar_files[0])\n", + "\n", + "raw_ds = wds.WebDataset(tar_path, shardshuffle=False)\n", + "raw_samples = list(raw_ds)\n", + "print(f\"wds.WebDataset loaded {len(raw_samples)} samples\")\n", + "for i, s in enumerate(raw_samples[:3]):\n", + " key = s.get('__key__', '?')\n", + " exts = sorted(k for k in s if not k.startswith('__'))\n", + " print(f\" [{i}] key=...{key[-60:]} members={exts[:5]}{'...' if len(exts)>5 else ''}\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# .decode(\"pil\") -- canonical WebDataset image decode verification\n", + "decoded_ds = wds.WebDataset(tar_path, shardshuffle=False).decode(\"pil\")\n", + "decoded_samples = list(decoded_ds)\n", + "total_images = 0\n", + "for s in decoded_samples:\n", + " for k, v in s.items():\n", + " if isinstance(v, Image.Image):\n", + " total_images += 1\n", + " arr = np.array(v)\n", + " assert arr.ndim >= 2, f\"Bad image shape: {arr.shape}\"\n", + "print(f\"PIL-decoded images: {total_images}\")\n", + "print(\"PASS: All WebDataset images decode to PIL and convert to numpy\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Interleaving + WebDataset compliance verification\n", + "# Per spec: images array contains extension keys (what wds returns as dict keys)\n", + "# so sample[images[pos]] directly retrieves the decoded image\n", + "print(\"=== Interleaving + WebDataset Compliance ===\")\n", + "for s in raw_samples:\n", + " key = s.get('__key__', '?')\n", + " payload = json.loads(s['json'])\n", + " texts = payload['texts']\n", + " images = payload['images']\n", + " assert len(texts) == len(images), f\"texts/images length mismatch for {key}\"\n", + "\n", + " # Verify image refs are valid webdataset dict keys (extension-based)\n", + " wds_keys = {k for k in s if not k.startswith('__')}\n", + " for pos, ref in enumerate(images):\n", + " if ref is not None:\n", + " assert ref in wds_keys, (\n", + " f\"image ref '{ref}' at pos {pos} is NOT a valid wds sample key. \"\n", + " f\"Available keys: {sorted(wds_keys)}\"\n", + " )\n", + " # Verify the referenced bytes are actually an image\n", + " assert isinstance(s[ref], bytes), f\"sample['{ref}'] is not bytes\"\n", + " assert len(s[ref]) > 0, f\"sample['{ref}'] is empty\"\n", + "\n", + " n_t = sum(1 for t in texts if t is not None)\n", + " n_i = sum(1 for i in images if i is not None)\n", + " print(f\" ...{key[-60:]}: {len(texts)} pos, {n_t} texts, {n_i} imgs -- OK\")\n", + "print(f\"PASS: All {len(raw_samples)} samples: interleaving valid, image refs are valid wds dict keys\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# CRITICAL: Verify _row_extra preserves ALL extra columns, keyed by modality\n", + "# Structure: _row_extra = {\"text\": [...], \"image\": [...], \"metadata\": {...}}\n", + "# text[i] / image[i] align 1:1 with texts[i] / images[i]\n", + "print(\"=== Extra Fields Verification (zero data loss) ===\")\n", + "extra_col_names = None\n", + "for s in raw_samples:\n", + " key = s.get('__key__', '?')\n", + " payload = json.loads(s['json'])\n", + " short_key = key[-50:]\n", + "\n", + " assert '_row_extra' in payload, f\"FAIL: _row_extra missing in {short_key}\"\n", + " row_extra = payload['_row_extra']\n", + " assert 'text' in row_extra, f\"FAIL: _row_extra.text missing in {short_key}\"\n", + " assert 'image' in row_extra, f\"FAIL: _row_extra.image missing in {short_key}\"\n", + " assert 'metadata' in row_extra, f\"FAIL: _row_extra.metadata missing in {short_key}\"\n", + "\n", + " texts = payload['texts']\n", + " images = payload['images']\n", + " text_extra = row_extra['text']\n", + " image_extra = row_extra['image']\n", + " meta_extra = row_extra['metadata']\n", + "\n", + " assert len(text_extra) == len(texts), (\n", + " f\"FAIL: text_extra length {len(text_extra)} != texts {len(texts)} in {short_key}\"\n", + " )\n", + " assert len(image_extra) == len(images), (\n", + " f\"FAIL: image_extra length {len(image_extra)} != images {len(images)} in {short_key}\"\n", + " )\n", + "\n", + " if extra_col_names is None:\n", + " for entry in image_extra:\n", + " if entry is not None:\n", + " extra_col_names = set(entry.keys())\n", + " break\n", + "\n", + " # Verify image extra entries have nv_* data where images exist\n", + " for pos, img_ref in enumerate(images):\n", + " if img_ref is not None and image_extra[pos] is not None:\n", + " entry = image_extra[pos]\n", + " assert 'nv_width' in entry, f\"FAIL: nv_width missing in image extra pos={pos}\"\n", + " assert 'nv_height' in entry, f\"FAIL: nv_height missing in image extra pos={pos}\"\n", + " assert 'match_status' in entry, f\"FAIL: match_status missing in image extra pos={pos}\"\n", + " if img_ref is None:\n", + " assert image_extra[pos] is None, f\"FAIL: image_extra present at pos={pos} but no image\"\n", + "\n", + " # Verify text extra aligns with texts array\n", + " for pos, txt in enumerate(texts):\n", + " if txt is not None:\n", + " assert text_extra[pos] is not None, f\"FAIL: text_extra null at pos={pos} but text exists\"\n", + " else:\n", + " assert text_extra[pos] is None, f\"FAIL: text_extra present at pos={pos} but no text\"\n", + "\n", + " n_txt = sum(1 for e in text_extra if e is not None)\n", + " n_img = sum(1 for e in image_extra if e is not None)\n", + " print(f\" ...{short_key}: text_extra={n_txt}, image_extra={n_img}, meta_extra={len(meta_extra)} fields -- OK\")\n", + "\n", + "print(f\"\\nExtra column names: {sorted(extra_col_names) if extra_col_names else 'none'}\")\n", + "print(f\"PASS: _row_extra.text/image/metadata present with nv_*/match_* in all {len(raw_samples)} samples\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Cross-check: use images array as wds dict key to get bytes, compare dimensions to _row_extra\n", + "print(\"=== WDS compliance: sample[images[pos]] lookup + nv dimension cross-check ===\")\n", + "mismatches = 0\n", + "lookup_failures = 0\n", + "for s in raw_samples:\n", + " payload = json.loads(s['json'])\n", + " image_extra = payload['_row_extra']['image']\n", + " images = payload['images']\n", + " for pos, img_ref in enumerate(images):\n", + " if img_ref is None:\n", + " continue\n", + " # This is the key test: images[pos] must be a valid wds sample dict key\n", + " raw_bytes = s.get(img_ref)\n", + " if raw_bytes is None:\n", + " lookup_failures += 1\n", + " print(f\" LOOKUP FAIL: sample['{img_ref}'] returned None\")\n", + " continue\n", + " img = Image.open(BytesIO(raw_bytes))\n", + " if image_extra[pos] is not None:\n", + " wds_w = image_extra[pos].get('nv_width')\n", + " wds_h = image_extra[pos].get('nv_height')\n", + " if wds_w is not None and (img.size[0] != int(wds_w) or img.size[1] != int(wds_h)):\n", + " mismatches += 1\n", + " print(f\" DIM MISMATCH: actual={img.size} nv=({wds_w},{wds_h})\")\n", + "assert lookup_failures == 0, f\"{lookup_failures} image lookups failed!\"\n", + "print(f\"Lookup failures: {lookup_failures}, Dimension mismatches: {mismatches}\")\n", + "print(\"PASS: sample[images[pos]] works for all images (WebDataset spec compliant)\")\n", + "if mismatches == 0:\n", + " print(\"PASS: nv_width/nv_height match actual decoded dimensions\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Display interleaved WebDataset samples using standard sample[images[pos]] lookup\n", + "for s in decoded_samples[:2]:\n", + " key = s.get('__key__', '?')\n", + " raw_json = s.get('json')\n", + " if isinstance(raw_json, bytes):\n", + " raw_json = raw_json.decode('utf-8')\n", + " payload = json.loads(raw_json) if isinstance(raw_json, str) else raw_json\n", + " texts = payload['texts']\n", + " images = payload['images']\n", + " print(f\"\\n--- ...{key[-50:]} ---\")\n", + " for pos in range(len(texts)):\n", + " t = texts[pos]\n", + " img_ref = images[pos]\n", + " if t:\n", + " print(f\" [pos={pos}] TEXT: {t[:100]}\")\n", + " if img_ref:\n", + " pil_img = s.get(img_ref)\n", + " if isinstance(pil_img, Image.Image):\n", + " ext = img_ref.split('.')[-1]\n", + " print(f\" [pos={pos}] IMAGE: {pil_img.size[0]}x{pil_img.size[1]} (key='{img_ref}')\")\n", + " buf = BytesIO()\n", + " fmt = 'JPEG' if ext in ('jpg','jpeg') else ext.upper()\n", + " pil_img.save(buf, format=fmt)\n", + " display(IPImage(data=buf.getvalue(), width=300))" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 3. Lance (`lance` library + PIL)" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "lance_dirs = list((OUTPUT_DIR / \"lance\").glob(\"*.lance\"))\n", + "ds = lance.dataset(str(lance_dirs[0]))\n", + "print(f\"Rows: {ds.count_rows()}, Fragments: {len(ds.get_fragments())}, Version: {ds.version}\")\n", + "for mod in ['text', 'image', 'metadata']:\n", + " filt = f\"modality = '{mod}'\"\n", + " print(f\" {mod}: {ds.count_rows(filter=filt)}\")\n", + "sample_ids = ds.to_table(columns=['sample_id']).column('sample_id').to_pylist()\n", + "print(f\" Unique samples: {len(set(sample_ids))}\")\n", + "print(f\"\\nSchema ({len(ds.schema)} fields):\")\n", + "print(ds.schema)" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Filtered scan: image rows with nv_* columns\n", + "img_scan = ds.to_table(\n", + " columns=['sample_id','position','content_type','binary_content',\n", + " 'nv_image_name','nv_width','nv_height','nv_img_byte_offset','nv_img_byte_size'],\n", + " filter=\"modality = 'image'\"\n", + ")\n", + "df_lance_imgs = img_scan.to_pandas()\n", + "print(f\"Image rows: {len(df_lance_imgs)}, all binary: {df_lance_imgs['binary_content'].notna().all()}\")\n", + "display(df_lance_imgs[['sample_id','position','nv_image_name','nv_width','nv_height']].head(5))" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# PIL verify + dimension cross-check\n", + "decode_errs = 0\n", + "dim_mismatches = 0\n", + "for _, row in df_lance_imgs.iterrows():\n", + " blob = row['binary_content']\n", + " try:\n", + " img = Image.open(BytesIO(blob))\n", + " img.verify()\n", + " except Exception as e:\n", + " decode_errs += 1\n", + " continue\n", + " img = Image.open(BytesIO(blob))\n", + " nv_w = int(row['nv_width']) if pd.notna(row['nv_width']) else None\n", + " nv_h = int(row['nv_height']) if pd.notna(row['nv_height']) else None\n", + " if nv_w is not None and (img.size[0] != nv_w or img.size[1] != nv_h):\n", + " dim_mismatches += 1\n", + "print(f\"Decode errors: {decode_errs}, Dimension mismatches: {dim_mismatches}\")\n", + "assert decode_errs == 0\n", + "print(\"PASS: All Lance images valid, nv dimensions match\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "df_lance = ds.to_table().to_pandas()\n", + "for sid in df_lance['sample_id'].unique()[:2]:\n", + " sample = df_lance[df_lance['sample_id'] == sid].sort_values('position')\n", + " short_sid = sid.split(':')[-1] if ':' in sid else sid[-30:]\n", + " print(f\"\\n--- Sample ...:{short_sid} ---\")\n", + " for _, row in sample[sample['modality'] != 'metadata'].iterrows():\n", + " pos = row['position']\n", + " if row['modality'] == 'text':\n", + " print(f\" [pos={pos}] TEXT: {str(row['text_content'])[:100]}\")\n", + " elif row['modality'] == 'image':\n", + " blob = row['binary_content']\n", + " img = Image.open(BytesIO(blob))\n", + " print(f\" [pos={pos}] IMAGE: {len(blob):,}B, {img.size[0]}x{img.size[1]}\")\n", + " display(IPImage(data=blob, width=300))" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 4. Cross-Format Zero Data Loss Check" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Parquet vs Lance: identical shapes, columns, binary content\n", + "assert df_pq.shape == df_lance.shape\n", + "assert set(df_pq.columns) == set(df_lance.columns)\n", + "for col in ['sample_id','position','modality','content_type','text_content',\n", + " 'match_status','match_tier','nv_image_name','nv_width','nv_height']:\n", + " assert df_pq[col].fillna('__NULL__').tolist() == df_lance[col].fillna('__NULL__').tolist(), f\"{col} differs\"\n", + "\n", + "pq_imgs_s = df_pq[df_pq['modality']=='image'].sort_values(['sample_id','position']).reset_index(drop=True)\n", + "lance_imgs_s = df_lance[df_lance['modality']=='image'].sort_values(['sample_id','position']).reset_index(drop=True)\n", + "for i in range(len(pq_imgs_s)):\n", + " assert pq_imgs_s.loc[i,'binary_content'] == lance_imgs_s.loc[i,'binary_content'], f\"Binary mismatch row {i}\"\n", + "\n", + "# WebDataset: correct sample/image counts + extra fields present\n", + "wds_img_count = sum(\n", + " sum(1 for im in json.loads(s['json']).get('images',[]) if im is not None)\n", + " for s in raw_samples\n", + ")\n", + "assert len(raw_samples) == df_pq['sample_id'].nunique(), \"WDS sample count mismatch\"\n", + "assert wds_img_count == len(pq_imgs_s), \"WDS image count mismatch\"\n", + "\n", + "# Verify WDS extra columns match Parquet extra columns\n", + "pq_extra_cols = set(c for c in df_pq.columns if c not in {\n", + " 'sample_id','position','modality','content_type','text_content',\n", + " 'binary_content','source_ref','metadata_json','materialize_error'\n", + "})\n", + "wds_extra_cols = extra_col_names if extra_col_names else set()\n", + "missing_in_wds = pq_extra_cols - wds_extra_cols\n", + "assert not missing_in_wds, f\"Columns in Parquet but missing from WDS _row_extra: {missing_in_wds}\"\n", + "\n", + "print(\"=== FINAL RESULTS ===\")\n", + "print(f\" Parquet: {len(df_pq)} rows, {df_pq['sample_id'].nunique()} samples, {len(pq_imgs_s)} imgs, {len(df_pq.columns)} cols\")\n", + "print(f\" Lance: {ds.count_rows()} rows, {len(set(sample_ids))} samples, {len(lance_imgs_s)} imgs, {len(ds.schema)} cols\")\n", + "print(f\" WebDataset: {len(raw_samples)} samples, {wds_img_count} imgs, {len(wds_extra_cols)} extra cols in JSON\")\n", + "print(f\" Extra columns: {len(pq_extra_cols)} in Parquet, {len(wds_extra_cols)} in WDS _row_extra\")\n", + "print()\n", + "print(\"PASS: Parquet <-> Lance byte-identical (all columns + binary)\")\n", + "print(\"PASS: WebDataset sample/image counts match\")\n", + "print(\"PASS: WebDataset _row_extra has ALL extra columns (nv_*, match_*, etc.)\")\n", + "print(\"PASS: All images PIL-verified across all 3 formats\")\n", + "print(\"PASS: nv_width/nv_height match decoded dimensions (Lance + WDS)\")\n", + "print(\"PASS: Interleaving preserved in WebDataset\")\n", + "print(\"PASS: ZERO DATA LOSS across all formats\")" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 5. User Experience: Filtering by Metadata Fields\n", + "\n", + "Shows how a downstream consumer can filter by image size, match tier, domain, etc.\n", + "across all 3 formats -- using each format's native strengths." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": "# --- 5a. Lance: filtered scan + pandas post-filter ---\nMIN_WIDTH = 400\nMIN_HEIGHT = 400\n\n# Read image rows with column projection (only loads needed columns)\nimg_table = ds.to_table(\n columns=['sample_id', 'position', 'binary_content', 'nv_width', 'nv_height', 'nv_image_name'],\n filter=\"modality = 'image'\"\n)\ndf_all_imgs = img_table.to_pandas()\ndf_all_imgs['nv_width_int'] = pd.to_numeric(df_all_imgs['nv_width'], errors='coerce')\ndf_all_imgs['nv_height_int'] = pd.to_numeric(df_all_imgs['nv_height'], errors='coerce')\ndf_large = df_all_imgs[\n (df_all_imgs['nv_width_int'] >= MIN_WIDTH) & (df_all_imgs['nv_height_int'] >= MIN_HEIGHT)\n].copy()\n\nprint(f\"Lance: images >= {MIN_WIDTH}x{MIN_HEIGHT}\")\nprint(f\" Matched: {len(df_large)} of {len(df_all_imgs)} total images\")\ndisplay(df_large[['sample_id', 'position', 'nv_image_name', 'nv_width', 'nv_height']].reset_index(drop=True))\n\nprint(f\"\\nShowing filtered images:\")\nfor _, row in df_large.head(3).iterrows():\n blob = row['binary_content']\n img = Image.open(BytesIO(blob))\n short_sid = row['sample_id'].split(':')[-1] if ':' in row['sample_id'] else row['sample_id'][-20:]\n print(f\" ...{short_sid} pos={row['position']}: {img.size[0]}x{img.size[1]}\")\n display(IPImage(data=blob, width=300))\n", + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": "# --- 5b. Lance: get complete samples (all modalities) for filtered images ---\nlarge_sids = set(df_large['sample_id'].unique())\ndf_full = ds.to_table().to_pandas()\ndf_filtered_samples = df_full[df_full['sample_id'].isin(large_sids)]\nprint(f\"Samples with >= 1 image >= {MIN_WIDTH}x{MIN_HEIGHT}: {len(large_sids)}\")\nprint(f\"Total rows for those samples: {len(df_filtered_samples)}\")\nfor mod in ['text', 'image', 'metadata']:\n print(f\" {mod}: {(df_filtered_samples['modality']==mod).sum()}\")\n", + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": "# --- 5c. Parquet: column pushdown + pandas filter ---\n# Read only the columns we need, then filter in pandas\ncols_needed = ['sample_id', 'position', 'modality', 'nv_width', 'nv_height', 'nv_image_name']\ndf_pq_slim = pd.read_parquet(pq_files[0], columns=cols_needed)\ndf_pq_imgs = df_pq_slim[df_pq_slim['modality'] == 'image'].copy()\ndf_pq_imgs['w'] = pd.to_numeric(df_pq_imgs['nv_width'], errors='coerce')\ndf_pq_imgs['h'] = pd.to_numeric(df_pq_imgs['nv_height'], errors='coerce')\ndf_pq_large = df_pq_imgs[(df_pq_imgs['w'] >= MIN_WIDTH) & (df_pq_imgs['h'] >= MIN_HEIGHT)]\n\nprint(f\"Parquet column projection: images >= {MIN_WIDTH}x{MIN_HEIGHT}\")\nprint(f\" Matched: {len(df_pq_large)} of {len(df_pq_imgs)} total images\")\ndisplay(df_pq_large[['sample_id', 'position', 'nv_image_name', 'nv_width', 'nv_height']].head(5).reset_index(drop=True))\n", + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "metadata": {}, + "source": "# --- 5d. WebDataset: streaming filter via _row_extra metadata ---\nMIN_W, MIN_H = 400, 400\n\ndef has_large_image(sample):\n \"\"\"Pre-decode filter: json is still raw bytes here.\"\"\"\n raw_json = sample.get('json')\n if isinstance(raw_json, bytes):\n raw_json = raw_json.decode('utf-8')\n payload = json.loads(raw_json)\n image_extra = payload.get('_row_extra', {}).get('image', [])\n for entry in image_extra:\n if entry is None:\n continue\n w = entry.get('nv_width')\n h = entry.get('nv_height')\n if w is not None and h is not None and float(w) >= MIN_W and float(h) >= MIN_H:\n return True\n return False\n\ndef get_payload(sample):\n \"\"\"Handle json field being str, bytes, or already-decoded dict.\"\"\"\n raw = sample.get('json')\n if isinstance(raw, dict):\n return raw\n if isinstance(raw, bytes):\n raw = raw.decode('utf-8')\n return json.loads(raw)\n\nfiltered_ds = wds.WebDataset(tar_path, shardshuffle=False).select(has_large_image).decode(\"pil\")\nfiltered_samples = list(filtered_ds)\nprint(f\"WebDataset streaming filter: samples with image >= {MIN_W}x{MIN_H}\")\nprint(f\" Before: {len(decoded_samples)} samples, After: {len(filtered_samples)} samples\")\n\nfor s in filtered_samples[:2]:\n key = s['__key__']\n payload = get_payload(s)\n image_extra = payload['_row_extra']['image']\n images = payload['images']\n print(f\"\\n ...{key[-50:]}:\")\n for pos, ref in enumerate(images):\n if ref is None:\n continue\n pil_img = s.get(ref)\n extra = image_extra[pos] if image_extra[pos] else {}\n w = extra.get('nv_width', '?')\n h = extra.get('nv_height', '?')\n if isinstance(pil_img, Image.Image):\n is_large = isinstance(w, (int,float)) and w >= MIN_W and isinstance(h, (int,float)) and h >= MIN_H\n marker = \" << LARGE\" if is_large else \"\"\n print(f\" pos={pos}: {pil_img.size[0]}x{pil_img.size[1]} (nv: {w}x{h}){marker}\")\n buf = BytesIO()\n ext_name = ref.split('.')[-1]\n pil_img.save(buf, format='JPEG' if ext_name in ('jpg','jpeg') else ext_name.upper())\n display(IPImage(data=buf.getvalue(), width=250))", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file From 459221ff5989a056240e47ac9b07a69a1ddf5bdf Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Fri, 27 Feb 2026 20:14:09 +0000 Subject: [PATCH 47/62] Remove local test artifacts from tracking, add to .gitignore The benchmark script and notebook are local test files that should not be tracked. They remain on disk for local use. Signed-off-by: Vibhu Jawa Made-with: Cursor --- .gitignore | 5 + .../test_merged_parquet_3format_write.py | 229 -------- tmp_3_test_output/explore_outputs.ipynb | 526 ------------------ 3 files changed, 5 insertions(+), 755 deletions(-) delete mode 100644 benchmarking/scripts/test_merged_parquet_3format_write.py delete mode 100644 tmp_3_test_output/explore_outputs.ipynb diff --git a/.gitignore b/.gitignore index 26eeb25629..ec499ef7e2 100644 --- a/.gitignore +++ b/.gitignore @@ -156,3 +156,8 @@ data/ # macOS Files .DS_Store AGENTS.md + +# Local test outputs and scratch scripts +tmp_3_test_output/ +.tmp_multimodal_runs/ +benchmarking/scripts/test_merged_parquet_3format_write.py diff --git a/benchmarking/scripts/test_merged_parquet_3format_write.py b/benchmarking/scripts/test_merged_parquet_3format_write.py deleted file mode 100644 index 79322efbc1..0000000000 --- a/benchmarking/scripts/test_merged_parquet_3format_write.py +++ /dev/null @@ -1,229 +0,0 @@ -# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. -# -# 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. - -"""Test script: read merged parquet, filter to fully-matched samples, write 3 formats. - -Reads from the merged parquet domain-bucket data, keeps only samples where -every image row has match_status == "matched", then writes the first N samples -as materialized Parquet, WebDataset, and Lance. -""" - -from __future__ import annotations - -import argparse -import os -import time -from pathlib import Path - -import pyarrow.parquet as pq -from loguru import logger - -from nemo_curator.stages.multimodal.io.writers.lance import MultimodalLanceWriterStage -from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage -from nemo_curator.stages.multimodal.io.writers.webdataset import MultimodalWebdatasetWriterStage -from nemo_curator.tasks import MultiBatchTask -from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA - -STORAGE_OPTIONS = { - "key": "team-iva-cc-image-text-release", - "secret": "e36b8dbaa53497da987baa9129acb3be", - "client_kwargs": { - "endpoint_url": "https://pdx.s8k.io", - "region_name": "us-east-1", - }, -} - - -def find_parquet_files(bucket_dir: str) -> list[str]: - return sorted( - os.path.join(bucket_dir, f) - for f in os.listdir(bucket_dir) - if f.endswith(".parquet") - ) - - -def load_and_filter(parquet_path: str, num_samples: int) -> MultiBatchTask: - """Load merged parquet, keep only fully-matched samples, return first N.""" - logger.info("Reading parquet: {}", parquet_path) - t0 = time.perf_counter() - table = pq.read_table(parquet_path) - logger.info("Read {} rows in {:.1f}s", table.num_rows, time.perf_counter() - t0) - - df = table.to_pandas() - - image_df = df[df["modality"] == "image"] - unmatched_sids = set( - image_df.loc[image_df["match_status"] != "matched", "sample_id"].unique() - ) - all_sids = set(df["sample_id"].unique()) - fully_matched_sids = all_sids - unmatched_sids - # Exclude sample_ids that have zero image rows (metadata/text-only docs) - sids_with_images = set(image_df["sample_id"].unique()) - fully_matched_sids = fully_matched_sids & sids_with_images - - logger.info( - "Samples: {} total, {} with images, {} fully matched", - len(all_sids), len(sids_with_images), len(fully_matched_sids), - ) - - selected_sids = sorted(fully_matched_sids)[:num_samples] - logger.info("Selected first {} sample_ids", len(selected_sids)) - - filtered = df[df["sample_id"].isin(selected_sids)].reset_index(drop=True) - logger.info("Filtered to {} rows across {} samples", len(filtered), len(selected_sids)) - - for col in MULTIMODAL_SCHEMA.names: - if col not in filtered.columns: - filtered[col] = None - - logger.info("Output columns: {} ({} total)", list(filtered.columns), len(filtered.columns)) - for sid in selected_sids: - sample = filtered[filtered["sample_id"] == sid] - imgs = sample[sample["modality"] == "image"] - logger.info( - " sample {} -- {} rows ({} text, {} image, {} metadata)", - sid[:80], len(sample), - (sample["modality"] == "text").sum(), - len(imgs), - (sample["modality"] == "metadata").sum(), - ) - - return MultiBatchTask( - task_id="test_3format", - dataset_name="merged_parquet_bucket0", - data=filtered, - _metadata={"source_files": [parquet_path]}, - ) - - -def write_parquet(task: MultiBatchTask, output_dir: str) -> str: - path = os.path.join(output_dir, "parquet") - os.makedirs(path, exist_ok=True) - writer = MultimodalParquetWriterStage( - path=path, - materialize_on_write=True, - write_kwargs={"storage_options": STORAGE_OPTIONS}, - on_materialize_error="warn", - mode="overwrite", - ) - logger.info("Writing Parquet to {}", path) - t0 = time.perf_counter() - result = writer.process(task) - logger.info("Parquet write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) - return result.data[0] - - -def write_webdataset(task: MultiBatchTask, output_dir: str) -> str: - path = os.path.join(output_dir, "webdataset") - os.makedirs(path, exist_ok=True) - writer = MultimodalWebdatasetWriterStage( - path=path, - materialize_on_write=True, - write_kwargs={"storage_options": STORAGE_OPTIONS}, - on_materialize_error="warn", - mode="overwrite", - ) - logger.info("Writing WebDataset to {}", path) - t0 = time.perf_counter() - result = writer.process(task) - logger.info("WebDataset write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) - return result.data[0] - - -def write_lance(task: MultiBatchTask, output_dir: str) -> str: - path = os.path.join(output_dir, "lance") - os.makedirs(path, exist_ok=True) - writer = MultimodalLanceWriterStage( - path=path, - materialize_on_write=True, - write_kwargs={"storage_options": STORAGE_OPTIONS}, - on_materialize_error="warn", - mode="overwrite", - ) - logger.info("Writing Lance to {}", path) - t0 = time.perf_counter() - result = writer.process(task) - logger.info("Lance write done in {:.1f}s -> {}", time.perf_counter() - t0, result.data) - return result.data[0] - - -def verify_outputs(output_dir: str) -> None: - """Quick sanity check on the written outputs.""" - import lance - import pandas as pd - - parquet_dir = os.path.join(output_dir, "parquet") - pq_files = [os.path.join(parquet_dir, f) for f in os.listdir(parquet_dir) if f.endswith(".parquet")] - if pq_files: - df_pq = pd.read_parquet(pq_files[0]) - logger.info("[Verify] Parquet: {} rows, {} samples, columns={}", len(df_pq), df_pq["sample_id"].nunique(), list(df_pq.columns)) - img_rows = df_pq[df_pq["modality"] == "image"] - has_binary = img_rows["binary_content"].notna().sum() - logger.info("[Verify] Parquet image rows: {}, with binary: {}", len(img_rows), has_binary) - - wds_dir = os.path.join(output_dir, "webdataset") - tar_files = [f for f in os.listdir(wds_dir) if f.endswith(".tar")] - if tar_files: - import tarfile - tar_path = os.path.join(wds_dir, tar_files[0]) - with tarfile.open(tar_path, "r") as tf: - members = tf.getnames() - logger.info("[Verify] WebDataset tar: {} members, first 10: {}", len(members), members[:10]) - - lance_dir = os.path.join(output_dir, "lance") - lance_files = [f for f in os.listdir(lance_dir) if f.endswith(".lance")] - if lance_files: - ds = lance.dataset(os.path.join(lance_dir, lance_files[0])) - df_lance = ds.to_table().to_pandas() - logger.info("[Verify] Lance: {} rows, {} samples, columns={}", len(df_lance), df_lance["sample_id"].nunique(), list(df_lance.columns)) - img_rows = df_lance[df_lance["modality"] == "image"] - has_binary = img_rows["binary_content"].notna().sum() - logger.info("[Verify] Lance image rows: {}, with binary: {}", len(img_rows), has_binary) - - -def main() -> int: - parser = argparse.ArgumentParser(description="Test merged parquet -> 3-format materialized write") - parser.add_argument( - "--input-path", type=str, - default="/datasets/vjawa/mint1t_normalized/merged_parquet_domain_buckets_0_to_63/domain_bucket=0/", - ) - parser.add_argument("--output-path", type=str, default=".tmp_multimodal_runs/3format_test") - parser.add_argument("--num-samples", type=int, default=10) - parser.add_argument("--skip-verify", action="store_true", default=False) - args = parser.parse_args() - - parquet_files = find_parquet_files(args.input_path) - if not parquet_files: - logger.error("No parquet files found in {}", args.input_path) - return 1 - logger.info("Found {} parquet file(s) in {}", len(parquet_files), args.input_path) - - task = load_and_filter(parquet_files[0], num_samples=args.num_samples) - - output_dir = str(Path(args.output_path).absolute()) - os.makedirs(output_dir, exist_ok=True) - - write_parquet(task, output_dir) - write_webdataset(task, output_dir) - write_lance(task, output_dir) - - if not args.skip_verify: - verify_outputs(output_dir) - - logger.info("All 3 formats written to {}", output_dir) - return 0 - - -if __name__ == "__main__": - raise SystemExit(main()) diff --git a/tmp_3_test_output/explore_outputs.ipynb b/tmp_3_test_output/explore_outputs.ipynb deleted file mode 100644 index be693d04a6..0000000000 --- a/tmp_3_test_output/explore_outputs.ipynb +++ /dev/null @@ -1,526 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Multimodal 3-Format Writer -- Zero Data Loss Verification\n", - "\n", - "Verifies Parquet, WebDataset, and Lance for 10 fully-matched samples.\n", - "Each format validated using canonical library. Extra columns (nv_*, match_*, etc.)\n", - "verified present in ALL formats including WebDataset JSON." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import json\n", - "from io import BytesIO\n", - "from pathlib import Path\n", - "\n", - "import lance\n", - "import numpy as np\n", - "import pandas as pd\n", - "import pyarrow.parquet as pq\n", - "import webdataset as wds\n", - "from IPython.display import display, Image as IPImage\n", - "from PIL import Image\n", - "\n", - "pd.set_option('display.max_columns', None)\n", - "pd.set_option('display.max_colwidth', 80)\n", - "OUTPUT_DIR = Path(\".\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## 1. Parquet (PyArrow + PIL)" - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "pq_files = list((OUTPUT_DIR / \"parquet\").glob(\"*.parquet\"))\n", - "pq_meta = pq.read_metadata(pq_files[0])\n", - "print(f\"Rows: {pq_meta.num_rows}, Cols: {pq_meta.num_columns}, Row groups: {pq_meta.num_row_groups}\")\n", - "table_pq = pq.read_table(pq_files[0])\n", - "df_pq = table_pq.to_pandas()\n", - "print(f\"Samples: {df_pq['sample_id'].nunique()}, Modalities: {df_pq['modality'].value_counts().to_dict()}\")\n", - "nv_cols = [c for c in df_pq.columns if c.startswith('nv_')]\n", - "print(f\"nv_* columns: {len(nv_cols)}, match_status: {df_pq['match_status'].value_counts(dropna=False).to_dict()}\")\n", - "\n", - "img_pq = df_pq[df_pq['modality'] == 'image']\n", - "print(f\"\\nImage rows: {len(img_pq)}, with binary: {img_pq['binary_content'].notna().sum()}\")\n", - "for _, row in img_pq.iterrows():\n", - " img = Image.open(BytesIO(row['binary_content']))\n", - " img.verify()\n", - "print(\"PASS: All Parquet images decodable via PIL.verify()\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# nv_* data for image rows\n", - "display(img_pq[['sample_id','position','nv_image_name','nv_width','nv_height','nv_img_byte_offset','nv_img_byte_size','match_status']].head(5))" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "for sid in df_pq['sample_id'].unique()[:3]:\n", - " sample = df_pq[df_pq['sample_id'] == sid].sort_values('position')\n", - " short_sid = sid.split(':')[-1] if ':' in sid else sid[-30:]\n", - " print(f\"\\n--- Sample ...:{short_sid} ---\")\n", - " for _, row in sample[sample['modality'] != 'metadata'].iterrows():\n", - " pos = row['position']\n", - " if row['modality'] == 'text':\n", - " print(f\" [pos={pos}] TEXT: {str(row['text_content'])[:100]}\")\n", - " elif row['modality'] == 'image':\n", - " blob = row['binary_content']\n", - " img = Image.open(BytesIO(blob))\n", - " print(f\" [pos={pos}] IMAGE: {len(blob):,}B, {img.size[0]}x{img.size[1]} {img.format}\")\n", - " display(IPImage(data=blob, width=300))" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## 2. WebDataset (`webdataset` library + PIL + extra fields)" - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "tar_files = list((OUTPUT_DIR / \"webdataset\").glob(\"*.tar\"))\n", - "tar_path = str(tar_files[0])\n", - "\n", - "raw_ds = wds.WebDataset(tar_path, shardshuffle=False)\n", - "raw_samples = list(raw_ds)\n", - "print(f\"wds.WebDataset loaded {len(raw_samples)} samples\")\n", - "for i, s in enumerate(raw_samples[:3]):\n", - " key = s.get('__key__', '?')\n", - " exts = sorted(k for k in s if not k.startswith('__'))\n", - " print(f\" [{i}] key=...{key[-60:]} members={exts[:5]}{'...' if len(exts)>5 else ''}\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# .decode(\"pil\") -- canonical WebDataset image decode verification\n", - "decoded_ds = wds.WebDataset(tar_path, shardshuffle=False).decode(\"pil\")\n", - "decoded_samples = list(decoded_ds)\n", - "total_images = 0\n", - "for s in decoded_samples:\n", - " for k, v in s.items():\n", - " if isinstance(v, Image.Image):\n", - " total_images += 1\n", - " arr = np.array(v)\n", - " assert arr.ndim >= 2, f\"Bad image shape: {arr.shape}\"\n", - "print(f\"PIL-decoded images: {total_images}\")\n", - "print(\"PASS: All WebDataset images decode to PIL and convert to numpy\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Interleaving + WebDataset compliance verification\n", - "# Per spec: images array contains extension keys (what wds returns as dict keys)\n", - "# so sample[images[pos]] directly retrieves the decoded image\n", - "print(\"=== Interleaving + WebDataset Compliance ===\")\n", - "for s in raw_samples:\n", - " key = s.get('__key__', '?')\n", - " payload = json.loads(s['json'])\n", - " texts = payload['texts']\n", - " images = payload['images']\n", - " assert len(texts) == len(images), f\"texts/images length mismatch for {key}\"\n", - "\n", - " # Verify image refs are valid webdataset dict keys (extension-based)\n", - " wds_keys = {k for k in s if not k.startswith('__')}\n", - " for pos, ref in enumerate(images):\n", - " if ref is not None:\n", - " assert ref in wds_keys, (\n", - " f\"image ref '{ref}' at pos {pos} is NOT a valid wds sample key. \"\n", - " f\"Available keys: {sorted(wds_keys)}\"\n", - " )\n", - " # Verify the referenced bytes are actually an image\n", - " assert isinstance(s[ref], bytes), f\"sample['{ref}'] is not bytes\"\n", - " assert len(s[ref]) > 0, f\"sample['{ref}'] is empty\"\n", - "\n", - " n_t = sum(1 for t in texts if t is not None)\n", - " n_i = sum(1 for i in images if i is not None)\n", - " print(f\" ...{key[-60:]}: {len(texts)} pos, {n_t} texts, {n_i} imgs -- OK\")\n", - "print(f\"PASS: All {len(raw_samples)} samples: interleaving valid, image refs are valid wds dict keys\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# CRITICAL: Verify _row_extra preserves ALL extra columns, keyed by modality\n", - "# Structure: _row_extra = {\"text\": [...], \"image\": [...], \"metadata\": {...}}\n", - "# text[i] / image[i] align 1:1 with texts[i] / images[i]\n", - "print(\"=== Extra Fields Verification (zero data loss) ===\")\n", - "extra_col_names = None\n", - "for s in raw_samples:\n", - " key = s.get('__key__', '?')\n", - " payload = json.loads(s['json'])\n", - " short_key = key[-50:]\n", - "\n", - " assert '_row_extra' in payload, f\"FAIL: _row_extra missing in {short_key}\"\n", - " row_extra = payload['_row_extra']\n", - " assert 'text' in row_extra, f\"FAIL: _row_extra.text missing in {short_key}\"\n", - " assert 'image' in row_extra, f\"FAIL: _row_extra.image missing in {short_key}\"\n", - " assert 'metadata' in row_extra, f\"FAIL: _row_extra.metadata missing in {short_key}\"\n", - "\n", - " texts = payload['texts']\n", - " images = payload['images']\n", - " text_extra = row_extra['text']\n", - " image_extra = row_extra['image']\n", - " meta_extra = row_extra['metadata']\n", - "\n", - " assert len(text_extra) == len(texts), (\n", - " f\"FAIL: text_extra length {len(text_extra)} != texts {len(texts)} in {short_key}\"\n", - " )\n", - " assert len(image_extra) == len(images), (\n", - " f\"FAIL: image_extra length {len(image_extra)} != images {len(images)} in {short_key}\"\n", - " )\n", - "\n", - " if extra_col_names is None:\n", - " for entry in image_extra:\n", - " if entry is not None:\n", - " extra_col_names = set(entry.keys())\n", - " break\n", - "\n", - " # Verify image extra entries have nv_* data where images exist\n", - " for pos, img_ref in enumerate(images):\n", - " if img_ref is not None and image_extra[pos] is not None:\n", - " entry = image_extra[pos]\n", - " assert 'nv_width' in entry, f\"FAIL: nv_width missing in image extra pos={pos}\"\n", - " assert 'nv_height' in entry, f\"FAIL: nv_height missing in image extra pos={pos}\"\n", - " assert 'match_status' in entry, f\"FAIL: match_status missing in image extra pos={pos}\"\n", - " if img_ref is None:\n", - " assert image_extra[pos] is None, f\"FAIL: image_extra present at pos={pos} but no image\"\n", - "\n", - " # Verify text extra aligns with texts array\n", - " for pos, txt in enumerate(texts):\n", - " if txt is not None:\n", - " assert text_extra[pos] is not None, f\"FAIL: text_extra null at pos={pos} but text exists\"\n", - " else:\n", - " assert text_extra[pos] is None, f\"FAIL: text_extra present at pos={pos} but no text\"\n", - "\n", - " n_txt = sum(1 for e in text_extra if e is not None)\n", - " n_img = sum(1 for e in image_extra if e is not None)\n", - " print(f\" ...{short_key}: text_extra={n_txt}, image_extra={n_img}, meta_extra={len(meta_extra)} fields -- OK\")\n", - "\n", - "print(f\"\\nExtra column names: {sorted(extra_col_names) if extra_col_names else 'none'}\")\n", - "print(f\"PASS: _row_extra.text/image/metadata present with nv_*/match_* in all {len(raw_samples)} samples\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Cross-check: use images array as wds dict key to get bytes, compare dimensions to _row_extra\n", - "print(\"=== WDS compliance: sample[images[pos]] lookup + nv dimension cross-check ===\")\n", - "mismatches = 0\n", - "lookup_failures = 0\n", - "for s in raw_samples:\n", - " payload = json.loads(s['json'])\n", - " image_extra = payload['_row_extra']['image']\n", - " images = payload['images']\n", - " for pos, img_ref in enumerate(images):\n", - " if img_ref is None:\n", - " continue\n", - " # This is the key test: images[pos] must be a valid wds sample dict key\n", - " raw_bytes = s.get(img_ref)\n", - " if raw_bytes is None:\n", - " lookup_failures += 1\n", - " print(f\" LOOKUP FAIL: sample['{img_ref}'] returned None\")\n", - " continue\n", - " img = Image.open(BytesIO(raw_bytes))\n", - " if image_extra[pos] is not None:\n", - " wds_w = image_extra[pos].get('nv_width')\n", - " wds_h = image_extra[pos].get('nv_height')\n", - " if wds_w is not None and (img.size[0] != int(wds_w) or img.size[1] != int(wds_h)):\n", - " mismatches += 1\n", - " print(f\" DIM MISMATCH: actual={img.size} nv=({wds_w},{wds_h})\")\n", - "assert lookup_failures == 0, f\"{lookup_failures} image lookups failed!\"\n", - "print(f\"Lookup failures: {lookup_failures}, Dimension mismatches: {mismatches}\")\n", - "print(\"PASS: sample[images[pos]] works for all images (WebDataset spec compliant)\")\n", - "if mismatches == 0:\n", - " print(\"PASS: nv_width/nv_height match actual decoded dimensions\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Display interleaved WebDataset samples using standard sample[images[pos]] lookup\n", - "for s in decoded_samples[:2]:\n", - " key = s.get('__key__', '?')\n", - " raw_json = s.get('json')\n", - " if isinstance(raw_json, bytes):\n", - " raw_json = raw_json.decode('utf-8')\n", - " payload = json.loads(raw_json) if isinstance(raw_json, str) else raw_json\n", - " texts = payload['texts']\n", - " images = payload['images']\n", - " print(f\"\\n--- ...{key[-50:]} ---\")\n", - " for pos in range(len(texts)):\n", - " t = texts[pos]\n", - " img_ref = images[pos]\n", - " if t:\n", - " print(f\" [pos={pos}] TEXT: {t[:100]}\")\n", - " if img_ref:\n", - " pil_img = s.get(img_ref)\n", - " if isinstance(pil_img, Image.Image):\n", - " ext = img_ref.split('.')[-1]\n", - " print(f\" [pos={pos}] IMAGE: {pil_img.size[0]}x{pil_img.size[1]} (key='{img_ref}')\")\n", - " buf = BytesIO()\n", - " fmt = 'JPEG' if ext in ('jpg','jpeg') else ext.upper()\n", - " pil_img.save(buf, format=fmt)\n", - " display(IPImage(data=buf.getvalue(), width=300))" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## 3. Lance (`lance` library + PIL)" - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "lance_dirs = list((OUTPUT_DIR / \"lance\").glob(\"*.lance\"))\n", - "ds = lance.dataset(str(lance_dirs[0]))\n", - "print(f\"Rows: {ds.count_rows()}, Fragments: {len(ds.get_fragments())}, Version: {ds.version}\")\n", - "for mod in ['text', 'image', 'metadata']:\n", - " filt = f\"modality = '{mod}'\"\n", - " print(f\" {mod}: {ds.count_rows(filter=filt)}\")\n", - "sample_ids = ds.to_table(columns=['sample_id']).column('sample_id').to_pylist()\n", - "print(f\" Unique samples: {len(set(sample_ids))}\")\n", - "print(f\"\\nSchema ({len(ds.schema)} fields):\")\n", - "print(ds.schema)" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Filtered scan: image rows with nv_* columns\n", - "img_scan = ds.to_table(\n", - " columns=['sample_id','position','content_type','binary_content',\n", - " 'nv_image_name','nv_width','nv_height','nv_img_byte_offset','nv_img_byte_size'],\n", - " filter=\"modality = 'image'\"\n", - ")\n", - "df_lance_imgs = img_scan.to_pandas()\n", - "print(f\"Image rows: {len(df_lance_imgs)}, all binary: {df_lance_imgs['binary_content'].notna().all()}\")\n", - "display(df_lance_imgs[['sample_id','position','nv_image_name','nv_width','nv_height']].head(5))" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# PIL verify + dimension cross-check\n", - "decode_errs = 0\n", - "dim_mismatches = 0\n", - "for _, row in df_lance_imgs.iterrows():\n", - " blob = row['binary_content']\n", - " try:\n", - " img = Image.open(BytesIO(blob))\n", - " img.verify()\n", - " except Exception as e:\n", - " decode_errs += 1\n", - " continue\n", - " img = Image.open(BytesIO(blob))\n", - " nv_w = int(row['nv_width']) if pd.notna(row['nv_width']) else None\n", - " nv_h = int(row['nv_height']) if pd.notna(row['nv_height']) else None\n", - " if nv_w is not None and (img.size[0] != nv_w or img.size[1] != nv_h):\n", - " dim_mismatches += 1\n", - "print(f\"Decode errors: {decode_errs}, Dimension mismatches: {dim_mismatches}\")\n", - "assert decode_errs == 0\n", - "print(\"PASS: All Lance images valid, nv dimensions match\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "df_lance = ds.to_table().to_pandas()\n", - "for sid in df_lance['sample_id'].unique()[:2]:\n", - " sample = df_lance[df_lance['sample_id'] == sid].sort_values('position')\n", - " short_sid = sid.split(':')[-1] if ':' in sid else sid[-30:]\n", - " print(f\"\\n--- Sample ...:{short_sid} ---\")\n", - " for _, row in sample[sample['modality'] != 'metadata'].iterrows():\n", - " pos = row['position']\n", - " if row['modality'] == 'text':\n", - " print(f\" [pos={pos}] TEXT: {str(row['text_content'])[:100]}\")\n", - " elif row['modality'] == 'image':\n", - " blob = row['binary_content']\n", - " img = Image.open(BytesIO(blob))\n", - " print(f\" [pos={pos}] IMAGE: {len(blob):,}B, {img.size[0]}x{img.size[1]}\")\n", - " display(IPImage(data=blob, width=300))" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## 4. Cross-Format Zero Data Loss Check" - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Parquet vs Lance: identical shapes, columns, binary content\n", - "assert df_pq.shape == df_lance.shape\n", - "assert set(df_pq.columns) == set(df_lance.columns)\n", - "for col in ['sample_id','position','modality','content_type','text_content',\n", - " 'match_status','match_tier','nv_image_name','nv_width','nv_height']:\n", - " assert df_pq[col].fillna('__NULL__').tolist() == df_lance[col].fillna('__NULL__').tolist(), f\"{col} differs\"\n", - "\n", - "pq_imgs_s = df_pq[df_pq['modality']=='image'].sort_values(['sample_id','position']).reset_index(drop=True)\n", - "lance_imgs_s = df_lance[df_lance['modality']=='image'].sort_values(['sample_id','position']).reset_index(drop=True)\n", - "for i in range(len(pq_imgs_s)):\n", - " assert pq_imgs_s.loc[i,'binary_content'] == lance_imgs_s.loc[i,'binary_content'], f\"Binary mismatch row {i}\"\n", - "\n", - "# WebDataset: correct sample/image counts + extra fields present\n", - "wds_img_count = sum(\n", - " sum(1 for im in json.loads(s['json']).get('images',[]) if im is not None)\n", - " for s in raw_samples\n", - ")\n", - "assert len(raw_samples) == df_pq['sample_id'].nunique(), \"WDS sample count mismatch\"\n", - "assert wds_img_count == len(pq_imgs_s), \"WDS image count mismatch\"\n", - "\n", - "# Verify WDS extra columns match Parquet extra columns\n", - "pq_extra_cols = set(c for c in df_pq.columns if c not in {\n", - " 'sample_id','position','modality','content_type','text_content',\n", - " 'binary_content','source_ref','metadata_json','materialize_error'\n", - "})\n", - "wds_extra_cols = extra_col_names if extra_col_names else set()\n", - "missing_in_wds = pq_extra_cols - wds_extra_cols\n", - "assert not missing_in_wds, f\"Columns in Parquet but missing from WDS _row_extra: {missing_in_wds}\"\n", - "\n", - "print(\"=== FINAL RESULTS ===\")\n", - "print(f\" Parquet: {len(df_pq)} rows, {df_pq['sample_id'].nunique()} samples, {len(pq_imgs_s)} imgs, {len(df_pq.columns)} cols\")\n", - "print(f\" Lance: {ds.count_rows()} rows, {len(set(sample_ids))} samples, {len(lance_imgs_s)} imgs, {len(ds.schema)} cols\")\n", - "print(f\" WebDataset: {len(raw_samples)} samples, {wds_img_count} imgs, {len(wds_extra_cols)} extra cols in JSON\")\n", - "print(f\" Extra columns: {len(pq_extra_cols)} in Parquet, {len(wds_extra_cols)} in WDS _row_extra\")\n", - "print()\n", - "print(\"PASS: Parquet <-> Lance byte-identical (all columns + binary)\")\n", - "print(\"PASS: WebDataset sample/image counts match\")\n", - "print(\"PASS: WebDataset _row_extra has ALL extra columns (nv_*, match_*, etc.)\")\n", - "print(\"PASS: All images PIL-verified across all 3 formats\")\n", - "print(\"PASS: nv_width/nv_height match decoded dimensions (Lance + WDS)\")\n", - "print(\"PASS: Interleaving preserved in WebDataset\")\n", - "print(\"PASS: ZERO DATA LOSS across all formats\")" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## 5. User Experience: Filtering by Metadata Fields\n", - "\n", - "Shows how a downstream consumer can filter by image size, match tier, domain, etc.\n", - "across all 3 formats -- using each format's native strengths." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": "# --- 5a. Lance: filtered scan + pandas post-filter ---\nMIN_WIDTH = 400\nMIN_HEIGHT = 400\n\n# Read image rows with column projection (only loads needed columns)\nimg_table = ds.to_table(\n columns=['sample_id', 'position', 'binary_content', 'nv_width', 'nv_height', 'nv_image_name'],\n filter=\"modality = 'image'\"\n)\ndf_all_imgs = img_table.to_pandas()\ndf_all_imgs['nv_width_int'] = pd.to_numeric(df_all_imgs['nv_width'], errors='coerce')\ndf_all_imgs['nv_height_int'] = pd.to_numeric(df_all_imgs['nv_height'], errors='coerce')\ndf_large = df_all_imgs[\n (df_all_imgs['nv_width_int'] >= MIN_WIDTH) & (df_all_imgs['nv_height_int'] >= MIN_HEIGHT)\n].copy()\n\nprint(f\"Lance: images >= {MIN_WIDTH}x{MIN_HEIGHT}\")\nprint(f\" Matched: {len(df_large)} of {len(df_all_imgs)} total images\")\ndisplay(df_large[['sample_id', 'position', 'nv_image_name', 'nv_width', 'nv_height']].reset_index(drop=True))\n\nprint(f\"\\nShowing filtered images:\")\nfor _, row in df_large.head(3).iterrows():\n blob = row['binary_content']\n img = Image.open(BytesIO(blob))\n short_sid = row['sample_id'].split(':')[-1] if ':' in row['sample_id'] else row['sample_id'][-20:]\n print(f\" ...{short_sid} pos={row['position']}: {img.size[0]}x{img.size[1]}\")\n display(IPImage(data=blob, width=300))\n", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": "# --- 5b. Lance: get complete samples (all modalities) for filtered images ---\nlarge_sids = set(df_large['sample_id'].unique())\ndf_full = ds.to_table().to_pandas()\ndf_filtered_samples = df_full[df_full['sample_id'].isin(large_sids)]\nprint(f\"Samples with >= 1 image >= {MIN_WIDTH}x{MIN_HEIGHT}: {len(large_sids)}\")\nprint(f\"Total rows for those samples: {len(df_filtered_samples)}\")\nfor mod in ['text', 'image', 'metadata']:\n print(f\" {mod}: {(df_filtered_samples['modality']==mod).sum()}\")\n", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": "# --- 5c. Parquet: column pushdown + pandas filter ---\n# Read only the columns we need, then filter in pandas\ncols_needed = ['sample_id', 'position', 'modality', 'nv_width', 'nv_height', 'nv_image_name']\ndf_pq_slim = pd.read_parquet(pq_files[0], columns=cols_needed)\ndf_pq_imgs = df_pq_slim[df_pq_slim['modality'] == 'image'].copy()\ndf_pq_imgs['w'] = pd.to_numeric(df_pq_imgs['nv_width'], errors='coerce')\ndf_pq_imgs['h'] = pd.to_numeric(df_pq_imgs['nv_height'], errors='coerce')\ndf_pq_large = df_pq_imgs[(df_pq_imgs['w'] >= MIN_WIDTH) & (df_pq_imgs['h'] >= MIN_HEIGHT)]\n\nprint(f\"Parquet column projection: images >= {MIN_WIDTH}x{MIN_HEIGHT}\")\nprint(f\" Matched: {len(df_pq_large)} of {len(df_pq_imgs)} total images\")\ndisplay(df_pq_large[['sample_id', 'position', 'nv_image_name', 'nv_width', 'nv_height']].head(5).reset_index(drop=True))\n", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": {}, - "source": "# --- 5d. WebDataset: streaming filter via _row_extra metadata ---\nMIN_W, MIN_H = 400, 400\n\ndef has_large_image(sample):\n \"\"\"Pre-decode filter: json is still raw bytes here.\"\"\"\n raw_json = sample.get('json')\n if isinstance(raw_json, bytes):\n raw_json = raw_json.decode('utf-8')\n payload = json.loads(raw_json)\n image_extra = payload.get('_row_extra', {}).get('image', [])\n for entry in image_extra:\n if entry is None:\n continue\n w = entry.get('nv_width')\n h = entry.get('nv_height')\n if w is not None and h is not None and float(w) >= MIN_W and float(h) >= MIN_H:\n return True\n return False\n\ndef get_payload(sample):\n \"\"\"Handle json field being str, bytes, or already-decoded dict.\"\"\"\n raw = sample.get('json')\n if isinstance(raw, dict):\n return raw\n if isinstance(raw, bytes):\n raw = raw.decode('utf-8')\n return json.loads(raw)\n\nfiltered_ds = wds.WebDataset(tar_path, shardshuffle=False).select(has_large_image).decode(\"pil\")\nfiltered_samples = list(filtered_ds)\nprint(f\"WebDataset streaming filter: samples with image >= {MIN_W}x{MIN_H}\")\nprint(f\" Before: {len(decoded_samples)} samples, After: {len(filtered_samples)} samples\")\n\nfor s in filtered_samples[:2]:\n key = s['__key__']\n payload = get_payload(s)\n image_extra = payload['_row_extra']['image']\n images = payload['images']\n print(f\"\\n ...{key[-50:]}:\")\n for pos, ref in enumerate(images):\n if ref is None:\n continue\n pil_img = s.get(ref)\n extra = image_extra[pos] if image_extra[pos] else {}\n w = extra.get('nv_width', '?')\n h = extra.get('nv_height', '?')\n if isinstance(pil_img, Image.Image):\n is_large = isinstance(w, (int,float)) and w >= MIN_W and isinstance(h, (int,float)) and h >= MIN_H\n marker = \" << LARGE\" if is_large else \"\"\n print(f\" pos={pos}: {pil_img.size[0]}x{pil_img.size[1]} (nv: {w}x{h}){marker}\")\n buf = BytesIO()\n ext_name = ref.split('.')[-1]\n pil_img.save(buf, format='JPEG' if ext_name in ('jpg','jpeg') else ext_name.upper())\n display(IPImage(data=buf.getvalue(), width=250))", - "outputs": [], - "execution_count": null - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.14" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file From c54141e7bebfcadd07cc1fa85e028ac9ea06b13f Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Mon, 2 Mar 2026 18:07:03 +0000 Subject: [PATCH 48/62] Fixed some reordering problems Signed-off-by: Vibhu Jawa --- .../scripts/multimodal_mint1t_benchmark.py | 19 ++- benchmarking/scripts/utils.py | 24 +++ nemo_curator/stages/multimodal/README.md | 8 +- nemo_curator/stages/multimodal/__init__.py | 4 +- .../multimodal/io/readers/webdataset.py | 5 +- nemo_curator/stages/multimodal/stages.py | 28 ++-- .../stages/multimodal/test_multimodal_core.py | 144 +++++++++++++++++- .../multimodal/test_multimodal_writer.py | 54 +++++++ tutorials/multimodal/mint1t_mvp_pipeline.py | 4 +- 9 files changed, 255 insertions(+), 35 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 79388e3d87..d3c3536488 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -21,12 +21,12 @@ from typing import Any from loguru import logger -from utils import collect_parquet_output_metrics, setup_executor, write_benchmark_results +from utils import collect_parquet_output_metrics, setup_executor, validate_parquet_ordering, write_benchmark_results from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader -from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage from nemo_curator.tasks.utils import TaskPerfUtils @@ -52,7 +52,7 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: materialize_on_read=args.materialize_on_read, ) ) - pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) + pipeline.add_stage(MultimodalAspectRatioFilterStage(drop_invalid_rows=True, min_aspect_ratio=1.0, max_aspect_ratio=2.0)) pipeline.add_stage( MultimodalParquetWriterStage( path=args.output_path, @@ -90,6 +90,18 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: task_metrics = TaskPerfUtils.aggregate_task_metrics(output_tasks, prefix="task") writer_stats = {k: v for k, v in task_metrics.items() if "multimodal_" in k and "_writer" in k} logger.info("Writer stage stats: {}", writer_stats) + + ordering_valid = False + if success: + parquet_files = sorted(output_path.glob("*.parquet")) + if parquet_files: + result = validate_parquet_ordering(parquet_files[0]) + ordering_valid = result["valid"] + if not ordering_valid: + logger.error("Ordering validation failed on {}: {}", parquet_files[0].name, result["errors"]) + else: + logger.info("Ordering validation passed on {}", parquet_files[0].name) + rows = output_metrics["num_rows"] return { "params": { @@ -107,6 +119,7 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: }, "metrics": { "is_success": success, + "ordering_valid": ordering_valid, "time_taken_s": elapsed, "throughput_rows_per_sec": (rows / elapsed) if elapsed > 0 else 0.0, **task_metrics, diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index dccbbdc175..15fda3c39f 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -18,6 +18,7 @@ from typing import Any import pyarrow.parquet as pq +import pandas as pd from nemo_curator.backends.experimental.ray_actor_pool.executor import RayActorPoolExecutor from nemo_curator.backends.experimental.ray_data import RayDataExecutor @@ -135,6 +136,29 @@ def collect_parquet_output_metrics(output_path: Path) -> dict[str, Any]: } +def validate_parquet_ordering(parquet_path: str | Path) -> dict[str, Any]: + """Read a single parquet file and validate interleaved position ordering. + + Returns a dict with 'valid' (bool) and 'errors' (list of issue descriptions). + """ + + df = pd.read_parquet(parquet_path, columns=["sample_id", "position", "modality"]) + errors: list[str] = [] + for sample_id, group in df.groupby("sample_id", sort=False): + meta = group[group["modality"] == "metadata"] + content = group[group["modality"] != "metadata"] + for _, row in meta.iterrows(): + if row["position"] != -1: + errors.append(f"sample={sample_id}: metadata row has position={row['position']}, expected -1") + if content.empty: + continue + positions = content["position"].tolist() + expected = list(range(len(positions))) + if sorted(positions) != expected: + errors.append(f"sample={sample_id}: content positions {sorted(positions)} != expected {expected}") + return {"valid": len(errors) == 0, "errors": errors} + + def convert_paths_to_strings(obj: object) -> object: """ Convert Path objects to strings, support conversions in container types in a recursive manner. diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/multimodal/README.md index 3c6e4b810a..dfe6f17974 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/multimodal/README.md @@ -15,7 +15,7 @@ WebDataset tar shards | MultiBatchTask (Arrow/Pandas) v ┌─────────────────────────┐ -│ Filter Stages │ e.g. MultimodalJpegAspectRatioFilterStage +│ Filter Stages │ e.g. MultimodalAspectRatioFilterStage │ (stages.py) │ Row-wise filtering with optional materialization └────────┬────────────────┘ | @@ -114,14 +114,14 @@ Materialization can happen at read time (`materialize_on_read=True`) or write ti ```python from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import WebdatasetReader, MultimodalParquetWriterStage -from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage pipeline = Pipeline(name="mint1t_pipeline") pipeline.add_stage(WebdatasetReader( source_id_field="pdf_name", file_paths="/data/mint1t/shards/", )) -pipeline.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) +pipeline.add_stage(MultimodalAspectRatioFilterStage(drop_invalid_rows=True)) pipeline.add_stage(MultimodalParquetWriterStage( path="/output/parquet/", materialize_on_write=True, @@ -136,7 +136,7 @@ pipeline.run() stages/multimodal/ ├── __init__.py # Exports filter/annotator stages ├── stages.py # BaseMultimodalAnnotatorStage, BaseMultimodalFilterStage, -│ # MultimodalJpegAspectRatioFilterStage +│ # MultimodalAspectRatioFilterStage ├── io/ │ ├── __init__.py # Exports WebdatasetReader, MultimodalParquetWriterStage │ ├── reader.py # WebdatasetReader (CompositeStage) diff --git a/nemo_curator/stages/multimodal/__init__.py b/nemo_curator/stages/multimodal/__init__.py index 9b1a32cfbb..316a5111e5 100644 --- a/nemo_curator/stages/multimodal/__init__.py +++ b/nemo_curator/stages/multimodal/__init__.py @@ -15,7 +15,7 @@ from nemo_curator.stages.multimodal.stages import ( BaseMultimodalAnnotatorStage, BaseMultimodalFilterStage, - MultimodalJpegAspectRatioFilterStage, + MultimodalAspectRatioFilterStage, ) -__all__ = ["BaseMultimodalAnnotatorStage", "BaseMultimodalFilterStage", "MultimodalJpegAspectRatioFilterStage"] +__all__ = ["BaseMultimodalAnnotatorStage", "BaseMultimodalFilterStage", "MultimodalAspectRatioFilterStage"] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 8a827b8bf9..43dbe787d8 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -184,8 +184,9 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: def _rows_from_sample(self, ctx: _SampleContext) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] rows.append(self._metadata_row(ctx)) - rows.extend(self._text_rows(ctx)) - rows.extend(self._image_rows(ctx)) + content_rows = self._text_rows(ctx) + self._image_rows(ctx) + content_rows.sort(key=lambda r: r["position"]) + rows.extend(content_rows) return rows # -- passthrough / schema helpers -- diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/multimodal/stages.py index c760a29cfc..da01ad60b4 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/multimodal/stages.py @@ -111,25 +111,25 @@ def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: filtered = df[self.keep_mask(task, df)].copy() content_mask = filtered["modality"] != "metadata" if content_mask.any(): - reindexed = filtered[content_mask].groupby("sample_id", sort=False).cumcount() + content_by_position = filtered[content_mask].sort_values("position") + reindexed = content_by_position.groupby("sample_id", sort=False).cumcount() filtered.loc[content_mask, "position"] = reindexed.astype(filtered["position"].dtype) - return filtered + return filtered.sort_values(["sample_id", "position"]) @dataclass -class MultimodalJpegAspectRatioFilterStage(BaseMultimodalFilterStage): - """Filter multimodal rows and enforce JPEG aspect-ratio bounds.""" +class MultimodalAspectRatioFilterStage(BaseMultimodalFilterStage): + """Filter multimodal image rows by aspect-ratio bounds (all image formats).""" - min_aspect_ratio: float = 0.2 - max_aspect_ratio: float = 5.0 - jpeg_content_types: tuple[str, ...] = ("image/jpeg", "image/jpg") - name: str = "multimodal_jpeg_aspect_ratio_filter" + min_aspect_ratio: float = 1.0 + max_aspect_ratio: float = 2.0 + name: str = "multimodal_aspect_ratio_filter" @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: if Image is None: msg = ( - "Pillow is required for MultimodalJpegAspectRatioFilterStage. " + "Pillow is required for MultimodalAspectRatioFilterStage. " "Install dependency group `image_cpu` (or `pillow`)." ) raise RuntimeError(msg) @@ -142,12 +142,12 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: return None return float(width) / float(height) - def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def _image_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: keep_mask = pd.Series(True, index=df.index, dtype=bool) - jpeg_mask = (df["modality"] == "image") & (df["content_type"].isin(self.jpeg_content_types)) - if not jpeg_mask.any(): + image_mask = df["modality"] == "image" + if not image_mask.any(): return keep_mask - for idx, image_bytes in self.iter_materialized_bytes(task=task, df=df, row_mask=jpeg_mask): + for idx, image_bytes in self.iter_materialized_bytes(task=task, df=df, row_mask=image_mask): if image_bytes is None: keep_mask.loc[idx] = False continue @@ -160,4 +160,4 @@ def _jpeg_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: return keep_mask def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: - return self._jpeg_keep_mask(task, df) + return self._image_keep_mask(task, df) diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/multimodal/test_multimodal_core.py index 9a5c98cd89..ad8e71bfca 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/multimodal/test_multimodal_core.py @@ -25,7 +25,7 @@ from nemo_curator.stages.multimodal.io.reader import WebdatasetReader from nemo_curator.stages.multimodal.stages import ( BaseMultimodalFilterStage, - MultimodalJpegAspectRatioFilterStage, + MultimodalAspectRatioFilterStage, ) from nemo_curator.stages.multimodal.utils.materialization import ( _classify_rows, @@ -357,10 +357,10 @@ def test_materialize_missing_path_sets_error() -> None: assert "missing path" in str(df.loc[0, "materialize_error"]) -# --- JPEG filter --- +# --- aspect ratio filter --- -def test_jpeg_filter_handles_non_default_dataframe_index() -> None: +def test_aspect_ratio_filter_handles_non_default_dataframe_index() -> None: df = pd.DataFrame( [ { @@ -389,12 +389,54 @@ def test_jpeg_filter_handles_non_default_dataframe_index() -> None: ) df.index = pd.Index([10, 42]) task = MultiBatchTask(task_id="non_default_index", dataset_name="d1", data=df) - stage = MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=False) + stage = MultimodalAspectRatioFilterStage(drop_invalid_rows=False) out = stage.process(task).to_pandas() assert len(out) == 1 assert out.iloc[0]["modality"] == "text" +def test_aspect_ratio_filter_works_on_png_images() -> None: + """The filter must apply to all image formats, not just JPEG.""" + from PIL import Image as PILImage + + buf = BytesIO() + PILImage.new("RGB", (200, 100)).save(buf, format="PNG") + valid_png = buf.getvalue() + + narrow_buf = BytesIO() + PILImage.new("RGB", (10, 100)).save(narrow_buf, format="PNG") + narrow_png = narrow_buf.getvalue() + + df = pd.DataFrame( + [ + { + "sample_id": "s1", "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": "ok", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": "s1", "position": 1, "modality": "image", + "content_type": "image/png", "text_content": None, + "binary_content": valid_png, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": "s1", "position": 2, "modality": "image", + "content_type": "image/png", "text_content": None, + "binary_content": narrow_png, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + ] + ) + task = MultiBatchTask(task_id="png_test", dataset_name="d1", data=df) + stage = MultimodalAspectRatioFilterStage(min_aspect_ratio=0.2, max_aspect_ratio=5.0, drop_invalid_rows=False) + out = stage.process(task).to_pandas() + assert len(out) == 2 + assert out["modality"].tolist() == ["text", "image"] + assert out["position"].tolist() == [0, 1] + + # --- split_table_by_group_max_bytes tests --- @@ -493,10 +535,96 @@ def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series stage = _DropOddPositions(drop_invalid_rows=False) result = stage.process(task) out_df = result.to_pandas() - assert out_df["position"].tolist() == [0, 1, -1] - assert out_df["text_content"].iloc[0] == "t0" - assert out_df["text_content"].iloc[1] == "t2" - assert pd.isna(out_df["text_content"].iloc[2]) + assert out_df["position"].tolist() == [-1, 0, 1] + assert pd.isna(out_df["text_content"].iloc[0]) + assert out_df["text_content"].iloc[1] == "t0" + assert out_df["text_content"].iloc[2] == "t2" + + +def test_filter_preserves_interleaved_ordering_across_modalities() -> None: + """When text and image rows are interleaved, filtering must preserve relative order.""" + + class _DropSecondImage(BaseMultimodalFilterStage): + name: str = "drop_second_image" + + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + keep = pd.Series(True, index=df.index, dtype=bool) + image_indices = df.index[df["modality"] == "image"].tolist() + if len(image_indices) > 1: + keep.loc[image_indices[1]] = False + return keep + + def _row(sample_id: str, position: int, modality: str, text: str | None = None) -> dict: + return { + "sample_id": sample_id, "position": position, "modality": modality, + "content_type": "text/plain" if modality == "text" else "image/jpeg", + "text_content": text, "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + } + + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": "{}", "materialize_error": None}, + _row("s1", 0, "text", "intro"), + _row("s1", 1, "image"), + _row("s1", 2, "text", "middle"), + _row("s1", 3, "image"), + _row("s1", 4, "text", "end"), + ] + task = MultiBatchTask( + task_id="interleave_test", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + ) + stage = _DropSecondImage(drop_invalid_rows=False) + result = stage.process(task) + out_df = result.to_pandas() + + assert out_df["modality"].tolist() == ["metadata", "text", "image", "text", "text"] + assert out_df["position"].tolist() == [-1, 0, 1, 2, 3] + content = out_df[out_df["modality"] != "metadata"] + assert content["text_content"].tolist()[0] == "intro" + assert content["text_content"].tolist()[2] == "middle" + assert content["text_content"].tolist()[3] == "end" + + +def test_filter_preserves_interleaved_ordering_with_noninterleaved_row_order() -> None: + """Even when DataFrame rows are grouped by modality (not position order), filter must preserve interleaving.""" + + class _KeepAll(BaseMultimodalFilterStage): + name: str = "keep_all" + + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + return pd.Series(True, index=df.index, dtype=bool) + + def _row(sample_id: str, position: int, modality: str, text: str | None = None) -> dict: + return { + "sample_id": sample_id, "position": position, "modality": modality, + "content_type": "text/plain" if modality == "text" else "image/jpeg", + "text_content": text, "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + } + + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": "{}", "materialize_error": None}, + _row("s1", 0, "text", "intro"), + _row("s1", 2, "text", "middle"), + _row("s1", 4, "text", "end"), + _row("s1", 1, "image"), + _row("s1", 3, "image"), + ] + task = MultiBatchTask( + task_id="noninterleaved_row_order", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + ) + stage = _KeepAll(drop_invalid_rows=False) + result = stage.process(task) + out_df = result.to_pandas() + + assert out_df["modality"].tolist() == ["metadata", "text", "image", "text", "image", "text"] + assert out_df["position"].tolist() == [-1, 0, 1, 2, 3, 4] # --- count / num_samples tests --- diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/multimodal/test_multimodal_writer.py index 84b6793f74..3fc8d353d4 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/multimodal/test_multimodal_writer.py @@ -20,6 +20,7 @@ from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.multimodal.stages import BaseMultimodalFilterStage from nemo_curator.tasks import FileGroupTask, MultiBatchTask from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA @@ -124,3 +125,56 @@ def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: write_task = writer.process(task) written = pd.read_parquet(write_task.data[0]) assert "__index_level_0__" not in written.columns + + +def test_interleaved_ordering_preserved_through_filter_and_write(tmp_path: Path) -> None: + """End-to-end: interleaved text+image rows survive filtering and parquet roundtrip.""" + + class _DropSecondImage(BaseMultimodalFilterStage): + name: str = "drop_second_image" + + def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + keep = pd.Series(True, index=df.index, dtype=bool) + image_indices = df.index[df["modality"] == "image"].tolist() + if len(image_indices) > 1: + keep.loc[image_indices[1]] = False + return keep + + def _row(sample_id: str, position: int, modality: str, text: str | None = None) -> dict: + return { + "sample_id": sample_id, "position": position, "modality": modality, + "content_type": "text/plain" if modality == "text" else "image/png", + "text_content": text, "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + } + + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, + "metadata_json": json.dumps({"doc": "s1"}), "materialize_error": None}, + _row("s1", 0, "text", "intro"), + _row("s1", 1, "image"), + _row("s1", 2, "text", "middle"), + _row("s1", 3, "image"), + _row("s1", 4, "text", "end"), + ] + table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) + task = MultiBatchTask(task_id="e2e_order", dataset_name="d", data=table) + + filter_stage = _DropSecondImage(drop_invalid_rows=False) + filtered_task = filter_stage.process(task) + + out_dir = str(tmp_path / "e2e_out") + writer = MultimodalParquetWriterStage(path=out_dir, materialize_on_write=False, mode="overwrite") + write_task = writer.process(filtered_task) + written = pd.read_parquet(write_task.data[0]) + + meta = written[written["modality"] == "metadata"] + content = written[written["modality"] != "metadata"].sort_values("position") + + assert meta["position"].tolist() == [-1] + assert content["position"].tolist() == [0, 1, 2, 3] + assert content["modality"].tolist() == ["text", "image", "text", "text"] + assert content["text_content"].tolist()[0] == "intro" + assert content["text_content"].tolist()[2] == "middle" + assert content["text_content"].tolist()[3] == "end" diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index e5990d04e3..6fae86c74c 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -18,7 +18,7 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader -from nemo_curator.stages.multimodal.stages import MultimodalJpegAspectRatioFilterStage +from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage def build_pipeline(args: argparse.Namespace) -> Pipeline: @@ -41,7 +41,7 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: materialize_on_read=args.materialize_on_read, ) ) - pipe.add_stage(MultimodalJpegAspectRatioFilterStage(drop_invalid_rows=True)) + pipe.add_stage(MultimodalAspectRatioFilterStage(min_aspect_ratio=1.0, max_aspect_ratio=2.0, drop_invalid_rows=True)) pipe.add_stage( MultimodalParquetWriterStage( path=args.output_path, From c0cffa683890c397fa7bd4f09b9f261caa42ebb3 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Mon, 2 Mar 2026 22:47:46 +0000 Subject: [PATCH 49/62] Add per-modality passthrough fields (per_image_fields, per_text_fields) Previously all passthrough fields were broadcast to every row. This adds per_image_fields and per_text_fields which distribute list values 1:1 to their respective non-None content rows, with sample-level passthrough now only on the metadata row. Includes length-mismatch warnings, ValueError for non-list per-modality values, and centralized helper methods. Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../scripts/multimodal_mint1t_benchmark.py | 6 + nemo_curator/stages/multimodal/io/reader.py | 4 + .../multimodal/io/readers/webdataset.py | 93 +++++++++-- .../multimodal/test_multimodal_reader.py | 153 +++++++++++++++++- tutorials/multimodal/mint1t_mvp_pipeline.py | 9 ++ 5 files changed, 248 insertions(+), 17 deletions(-) diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index d3c3536488..2e1b7392f4 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -50,6 +50,8 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: max_batch_bytes=args.output_max_batch_bytes, read_kwargs=read_kwargs, materialize_on_read=args.materialize_on_read, + per_image_fields=tuple(args.per_image_fields) if args.per_image_fields else (), + per_text_fields=tuple(args.per_text_fields) if args.per_text_fields else (), ) ) pipeline.add_stage(MultimodalAspectRatioFilterStage(drop_invalid_rows=True, min_aspect_ratio=1.0, max_aspect_ratio=2.0)) @@ -113,6 +115,8 @@ def run_benchmark(args: argparse.Namespace) -> dict[str, Any]: "output_max_batch_bytes": args.output_max_batch_bytes, "materialize_on_read": args.materialize_on_read, "materialize_on_write": args.materialize_on_write, + "per_image_fields": list(args.per_image_fields) if args.per_image_fields else [], + "per_text_fields": list(args.per_text_fields) if args.per_text_fields else [], "parquet_row_group_size": args.parquet_row_group_size, "parquet_compression": args.parquet_compression, "mode": args.mode, @@ -145,6 +149,8 @@ def main() -> int: parser.add_argument("--materialize-on-write", action="store_true", dest="materialize_on_write") parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") parser.add_argument("--mode", type=str, default="overwrite", choices=["ignore", "overwrite", "append", "error"]) + parser.add_argument("--per-image-fields", nargs="*", default=["image_metadata"]) + parser.add_argument("--per-text-fields", nargs="*", default=[]) parser.set_defaults(materialize_on_write=False, materialize_on_read=False) args = parser.parse_args() diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/multimodal/io/reader.py index b450e530f8..f16a06904e 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/multimodal/io/reader.py @@ -47,6 +47,8 @@ class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): images_field: str = "images" image_member_field: str | None = None fields: tuple[str, ...] | None = None + per_image_fields: tuple[str, ...] = () + per_text_fields: tuple[str, ...] = () name: str = "webdataset_reader" def __post_init__(self): @@ -75,5 +77,7 @@ def decompose(self) -> list: images_field=self.images_field, image_member_field=self.image_member_field, fields=self.fields, + per_image_fields=self.per_image_fields, + per_text_fields=self.per_text_fields, ), ] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/multimodal/io/readers/webdataset.py index 43dbe787d8..1a916275a1 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/multimodal/io/readers/webdataset.py @@ -23,6 +23,7 @@ import fsspec import pyarrow as pa +from loguru import logger from nemo_curator.core.utils import split_table_by_group_max_bytes from nemo_curator.stages.multimodal.utils import ( @@ -60,6 +61,8 @@ class _SampleContext: member_names: set[str] member_info: dict[str, tarfile.TarInfo] | None passthrough: dict[str, Any] + per_image_passthrough: dict[str, list[Any]] + per_text_passthrough: dict[str, list[Any]] @dataclass @@ -76,6 +79,8 @@ class WebdatasetReaderStage(BaseMultimodalReader): images_field: str = "images" image_member_field: str | None = None fields: tuple[str, ...] | None = None + per_image_fields: tuple[str, ...] = () + per_text_fields: tuple[str, ...] = () name: str = "webdataset_reader" def __post_init__(self) -> None: @@ -113,11 +118,10 @@ def _build_row(ctx: _SampleContext, row_fields: dict[str, Any]) -> dict[str, Any "source_ref": row_fields.get("source_ref"), "metadata_json": row_fields.get("metadata_json"), "materialize_error": None, - **ctx.passthrough, } def _metadata_row(self, ctx: _SampleContext) -> dict[str, Any]: - return self._build_row(ctx, { + return {**self._build_row(ctx, { "position": -1, "modality": "metadata", "content_type": "application/json", @@ -133,24 +137,50 @@ def _metadata_row(self, ctx: _SampleContext) -> dict[str, Any]: }, ensure_ascii=True, ), - }) + }), **ctx.passthrough} + + @staticmethod + def _apply_per_modality_fields( + row: dict[str, Any], passthrough: dict[str, list[Any]], index: int, + ) -> None: + for field_name, values in passthrough.items(): + if index < len(values): + val = values[index] + row[field_name] = json.dumps(val, ensure_ascii=True) if isinstance(val, (dict, list)) else val + + @staticmethod + def _warn_per_modality_length_mismatch( + sample_id: str, passthrough: dict[str, list[Any]], actual_count: int, modality: str, + ) -> None: + for field_name, values in passthrough.items(): + if actual_count != len(values): + logger.warning( + "sample_id={}: per_{}_field '{}' has {} values but {} non-None {}s", + sample_id, modality, field_name, len(values), actual_count, modality, + ) def _text_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: texts = ctx.sample.get(self.texts_field) if not isinstance(texts, list): return [] source_ref = self._build_source_ref(ctx, ctx.json_member_name) - return [ - self._build_row(ctx, { + rows: list[dict[str, Any]] = [] + non_none_counter = 0 + for idx, text_value in enumerate(texts): + if text_value is None: + continue + row = self._build_row(ctx, { "position": idx, "modality": "text", "content_type": "text/plain", "text_content": str(text_value), "source_ref": source_ref, }) - for idx, text_value in enumerate(texts) - if text_value is not None - ] + self._apply_per_modality_fields(row, ctx.per_text_passthrough, non_none_counter) + non_none_counter += 1 + rows.append(row) + self._warn_per_modality_length_mismatch(ctx.sample_id, ctx.per_text_passthrough, non_none_counter, "text") + return rows def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: images = ctx.sample.get(self.images_field) @@ -161,6 +191,7 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: ) rows: list[dict[str, Any]] = [] frame_counter = 0 + non_none_counter = 0 for idx, image_token in enumerate(images): if image_token is None: continue @@ -171,12 +202,16 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: if content_key is not None and is_multiframe_candidate: frame_index = frame_counter frame_counter += 1 - rows.append(self._build_row(ctx, { + row = self._build_row(ctx, { "position": idx, "modality": "image", "content_type": content_type or ("application/octet-stream" if image_member_name else None), "source_ref": self._build_source_ref(ctx, content_key, frame_index=frame_index), - })) + }) + self._apply_per_modality_fields(row, ctx.per_image_passthrough, non_none_counter) + non_none_counter += 1 + rows.append(row) + self._warn_per_modality_length_mismatch(ctx.sample_id, ctx.per_image_passthrough, non_none_counter, "image") return rows # -- sample-level orchestration -- @@ -187,6 +222,11 @@ def _rows_from_sample(self, ctx: _SampleContext) -> list[dict[str, Any]]: content_rows = self._text_rows(ctx) + self._image_rows(ctx) content_rows.sort(key=lambda r: r["position"]) rows.extend(content_rows) + per_modality_keys = set(ctx.per_image_passthrough) | set(ctx.per_text_passthrough) + if per_modality_keys: + for row in rows: + for key in per_modality_keys: + row.setdefault(key, None) return rows # -- passthrough / schema helpers -- @@ -198,16 +238,41 @@ def _build_passthrough_row(self, sample: dict[str, Any]) -> dict[str, Any]: self.texts_field, self.images_field, *([self.image_member_field] if self.image_member_field else []), + *self.per_image_fields, + *self.per_text_fields, } return validate_and_project_source_fields(sample=sample, fields=self.fields, excluded_fields=excluded) + @staticmethod + def _extract_per_modality_fields( + sample: dict[str, Any], field_names: tuple[str, ...], + ) -> dict[str, list[Any]]: + result: dict[str, list[Any]] = {} + for field_name in field_names: + value = sample.get(field_name) + if isinstance(value, list): + result[field_name] = value + elif value is not None: + msg = ( + f"per-modality field '{field_name}' must be a list, " + f"got {type(value).__name__}" + ) + raise ValueError(msg) + return result + def _empty_output_schema(self) -> pa.Schema: schema = MULTIMODAL_SCHEMA - if not self.fields: + seen = set(self.fields or ()) + all_extra = list(self.fields or ()) + for f in (*self.per_image_fields, *self.per_text_fields): + if f not in seen: + all_extra.append(f) + seen.add(f) + if not all_extra: return schema existing = set(schema.names) - passthrough_fields = [pa.field(name, pa.null()) for name in self.fields if name not in existing] - return pa.schema([*schema, *passthrough_fields]) if passthrough_fields else schema + extra_fields = [pa.field(name, pa.null()) for name in all_extra if name not in existing] + return pa.schema([*schema, *extra_fields]) if extra_fields else schema @staticmethod def _reconcile_schema(inferred: pa.Schema) -> pa.Schema: @@ -293,6 +358,8 @@ def _rows_from_member( member_names=read_ctx.member_names, member_info=read_ctx.member_info, passthrough=self._build_passthrough_row(payload), + per_image_passthrough=self._extract_per_modality_fields(payload, self.per_image_fields), + per_text_passthrough=self._extract_per_modality_fields(payload, self.per_text_fields), ) sample_rows = self._rows_from_sample(ctx) if self.materialize_on_read: diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/multimodal/test_multimodal_reader.py index 17139264e5..739ec83e30 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/multimodal/test_multimodal_reader.py @@ -93,7 +93,9 @@ def test_reader_supports_custom_field_mapping(tmp_path: Path) -> None: assert len(image_rows) == 1 assert image_rows.iloc[0]["binary_content"] == image_bytes assert "p_hash" in df.columns - assert image_rows.iloc[0]["p_hash"] == "abc123" + meta_row = df[df["modality"] == "metadata"].iloc[0] + assert meta_row["p_hash"] == "abc123" + assert pd.isna(image_rows.iloc[0]["p_hash"]) def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: @@ -119,10 +121,12 @@ def test_reader_reads_all_fields_by_default(tmp_path: Path) -> None: json_extensions=(".meta.json",), ) df = _as_df(reader.process(task)) + meta_row = df[df["modality"] == "metadata"].iloc[0] + assert meta_row["p_hash"] == "phash-1" + assert meta_row["score"] == 0.91 + assert meta_row["aux"] == json.dumps({"page": 3}, ensure_ascii=True) image_row = df[df["modality"] == "image"].iloc[0] - assert image_row["p_hash"] == "phash-1" - assert image_row["score"] == 0.91 - assert image_row["aux"] == json.dumps({"page": 3}, ensure_ascii=True) + assert pd.isna(image_row["p_hash"]) assert "captions" not in df.columns assert "frames" not in df.columns @@ -255,3 +259,144 @@ def test_reader_fields_validation_errors( reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=fields) with pytest.raises(ValueError, match=error_pattern): _ = reader.process(task) + + +def test_reader_per_image_fields_distributed_to_image_rows(tmp_path: Path) -> None: + """per_image_fields lists are distributed 1:1 to non-None image rows.""" + tar_path = tmp_path / "per-image.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello", None, "world"], + "images": [None, "img_token", None], + "image_metadata": [{"height": 100, "width": 200}], + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "per_image") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_image_fields=("image_metadata",), + ) + df = _as_df(reader.process(task)) + + assert "image_metadata" in df.columns + + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 1 + assert image_rows.iloc[0]["image_metadata"] == json.dumps({"height": 100, "width": 200}) + + text_rows = df[df["modality"] == "text"] + assert all(pd.isna(v) for v in text_rows["image_metadata"]) + + meta_rows = df[df["modality"] == "metadata"] + assert all(pd.isna(v) for v in meta_rows["image_metadata"]) + + +def test_reader_per_text_fields_distributed_to_text_rows(tmp_path: Path) -> None: + """per_text_fields lists are distributed 1:1 to non-None text rows.""" + tar_path = tmp_path / "per-text.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello", None, "world"], + "images": [None, "img_token", None], + "text_scores": [0.95, 0.42], + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "per_text") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_text_fields=("text_scores",), + ) + df = _as_df(reader.process(task)) + + assert "text_scores" in df.columns + + text_rows = df[df["modality"] == "text"].sort_values("position") + assert len(text_rows) == 2 + assert text_rows.iloc[0]["text_scores"] == 0.95 + assert text_rows.iloc[1]["text_scores"] == 0.42 + + image_rows = df[df["modality"] == "image"] + assert all(pd.isna(v) for v in image_rows["text_scores"]) + + meta_rows = df[df["modality"] == "metadata"] + assert all(pd.isna(v) for v in meta_rows["text_scores"]) + + +def test_reader_per_image_and_per_text_fields_together(tmp_path: Path) -> None: + """Both per_image_fields and per_text_fields work correctly in the same reader.""" + tar_path = tmp_path / "both-per-modality.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["intro", None, "conclusion"], + "images": [None, "page_img", None], + "image_metadata": [{"page": 1, "width": 640}], + "text_lang": ["en", "fr"], + "url": "https://example.com", + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "both_per_modality") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_image_fields=("image_metadata",), + per_text_fields=("text_lang",), + ) + df = _as_df(reader.process(task)) + + image_rows = df[df["modality"] == "image"] + assert image_rows.iloc[0]["image_metadata"] == json.dumps({"page": 1, "width": 640}) + assert pd.isna(image_rows.iloc[0]["text_lang"]) + + text_rows = df[df["modality"] == "text"].sort_values("position") + assert text_rows.iloc[0]["text_lang"] == "en" + assert text_rows.iloc[1]["text_lang"] == "fr" + assert all(pd.isna(v) for v in text_rows["image_metadata"]) + + meta_row = df[df["modality"] == "metadata"].iloc[0] + assert meta_row["url"] == "https://example.com" + assert pd.isna(meta_row["image_metadata"]) + assert pd.isna(meta_row["text_lang"]) + + +def test_reader_per_modality_fields_excluded_from_sample_passthrough(tmp_path: Path) -> None: + """Fields in per_image_fields/per_text_fields must not appear on the metadata row.""" + tar_path = tmp_path / "exclude-passthrough.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["text"], + "images": [], + "image_metadata": [], + "text_scores": [], + "url": "https://example.com", + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "exclude_pt") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_image_fields=("image_metadata",), + per_text_fields=("text_scores",), + ) + df = _as_df(reader.process(task)) + + meta_row = df[df["modality"] == "metadata"].iloc[0] + assert meta_row["url"] == "https://example.com" + assert pd.isna(meta_row.get("image_metadata")) + assert pd.isna(meta_row.get("text_scores")) + + +def test_reader_raises_on_non_list_per_modality_field(tmp_path: Path) -> None: + """A per-modality field that is not a list in the source sample must raise ValueError.""" + tar_path = tmp_path / "non-list-field.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello"], + "images": [], + "image_metadata": "not-a-list", + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "non_list_field") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_image_fields=("image_metadata",), + ) + with pytest.raises(ValueError, match="must be a list"): + reader.process(task) diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 6fae86c74c..8b7dd19837 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -39,6 +39,9 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: max_batch_bytes=args.output_max_batch_bytes, read_kwargs=read_kwargs, materialize_on_read=args.materialize_on_read, + fields=tuple(args.fields) if args.fields else None, + per_image_fields=tuple(args.per_image_fields) if args.per_image_fields else (), + per_text_fields=tuple(args.per_text_fields) if args.per_text_fields else (), ) ) pipe.add_stage(MultimodalAspectRatioFilterStage(min_aspect_ratio=1.0, max_aspect_ratio=2.0, drop_invalid_rows=True)) @@ -75,6 +78,12 @@ def main(args: argparse.Namespace) -> None: parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") parser.set_defaults(materialize_on_write=True, materialize_on_read=False) parser.add_argument("--mode", type=str, default="ignore", choices=["ignore", "overwrite", "append", "error"]) + parser.add_argument( + "--fields", nargs="*", + default=["url", "language_id_whole_page_fasttext", "bff_contained_ngram_count_before_dedupe", "previous_word_count"], + ) + parser.add_argument("--per-image-fields", nargs="*", default=["image_metadata"]) + parser.add_argument("--per-text-fields", nargs="*", default=[]) parser.add_argument( "--storage-options-json", type=str, From 2e817ca9691c7d648e9107c749d4a02bfaaa46de Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 04:09:42 +0000 Subject: [PATCH 50/62] Rename MultiBatchTask to InterleavedBatch and multimodal stage directory to interleaved Rename the task class, schema, module, stage directory, and all stage classes to use "Interleaved" naming, reflecting the interleaved nature of the data format: - MultiBatchTask -> InterleavedBatch - MULTIMODAL_SCHEMA -> INTERLEAVED_SCHEMA - tasks/multimodal.py -> tasks/interleaved.py - stages/multimodal/ -> stages/interleaved/ - BaseMultimodalAnnotatorStage -> BaseInterleavedAnnotatorStage - BaseMultimodalFilterStage -> BaseInterleavedFilterStage - MultimodalAspectRatioFilterStage -> InterleavedAspectRatioFilterStage - MultimodalParquetWriterStage -> InterleavedParquetWriterStage - BaseMultimodalReader -> BaseInterleavedReader - BaseMultimodalWriter -> BaseInterleavedWriter Signed-off-by: Vibhu Jawa Made-with: Cursor --- .cursor/rules/modality-structure.mdc | 13 ++- .cursor/rules/task-patterns.mdc | 1 + .../scripts/multimodal_mint1t_benchmark.py | 8 +- .../{multimodal => interleaved}/README.md | 42 ++++----- .../{multimodal => interleaved}/__init__.py | 10 +-- .../io/__init__.py | 6 +- .../{multimodal => interleaved}/io/reader.py | 8 +- .../io/readers/__init__.py | 2 +- .../io/readers/base.py | 8 +- .../io/readers/webdataset.py | 26 +++--- .../io/writers/__init__.py | 4 +- .../io/writers/base.py | 16 ++-- .../io/writers/tabular.py | 8 +- .../{multimodal => interleaved}/stages.py | 42 ++++----- .../utils/__init__.py | 6 +- .../utils/constants.py | 0 .../utils/materialization.py | 10 +-- .../utils/validation_utils.py | 0 nemo_curator/tasks/__init__.py | 4 +- .../tasks/{multimodal.py => interleaved.py} | 16 ++-- .../{multimodal => interleaved}/__init__.py | 0 .../{multimodal => interleaved}/conftest.py | 0 .../test_multimodal_core.py | 86 +++++++++---------- .../test_multimodal_reader.py | 8 +- .../test_multimodal_writer.py | 38 ++++---- tutorials/multimodal/mint1t_mvp_pipeline.py | 8 +- 26 files changed, 191 insertions(+), 179 deletions(-) rename nemo_curator/stages/{multimodal => interleaved}/README.md (78%) rename nemo_curator/stages/{multimodal => interleaved}/__init__.py (69%) rename nemo_curator/stages/{multimodal => interleaved}/io/__init__.py (72%) rename nemo_curator/stages/{multimodal => interleaved}/io/reader.py (92%) rename nemo_curator/stages/{multimodal => interleaved}/io/readers/__init__.py (88%) rename nemo_curator/stages/{multimodal => interleaved}/io/readers/base.py (81%) rename nemo_curator/stages/{multimodal => interleaved}/io/readers/webdataset.py (95%) rename nemo_curator/stages/{multimodal => interleaved}/io/writers/__init__.py (81%) rename nemo_curator/stages/{multimodal => interleaved}/io/writers/base.py (88%) rename nemo_curator/stages/{multimodal => interleaved}/io/writers/tabular.py (83%) rename nemo_curator/stages/{multimodal => interleaved}/stages.py (77%) rename nemo_curator/stages/{multimodal => interleaved}/utils/__init__.py (85%) rename nemo_curator/stages/{multimodal => interleaved}/utils/constants.py (100%) rename nemo_curator/stages/{multimodal => interleaved}/utils/materialization.py (98%) rename nemo_curator/stages/{multimodal => interleaved}/utils/validation_utils.py (100%) rename nemo_curator/tasks/{multimodal.py => interleaved.py} (94%) rename tests/stages/{multimodal => interleaved}/__init__.py (100%) rename tests/stages/{multimodal => interleaved}/conftest.py (100%) rename tests/stages/{multimodal => interleaved}/test_multimodal_core.py (89%) rename tests/stages/{multimodal => interleaved}/test_multimodal_reader.py (97%) rename tests/stages/{multimodal => interleaved}/test_multimodal_writer.py (80%) diff --git a/.cursor/rules/modality-structure.mdc b/.cursor/rules/modality-structure.mdc index 401cd0502f..7a130dabe0 100644 --- a/.cursor/rules/modality-structure.mdc +++ b/.cursor/rules/modality-structure.mdc @@ -13,7 +13,8 @@ nemo_curator/stages/ ├── text/ # Text/document processing ├── image/ # Image processing ├── audio/ # Audio/speech processing -└── video/ # Video processing +├── video/ # Video processing +└── interleaved/ # Interleaved multimodal processing ``` Other subdirectories of `nemo_curator/stages/` are `deduplication` and `synthetic`, which contain stages that can be used by two or more modalities. @@ -68,3 +69,13 @@ All modalities share: - `stages/base.py`: Base classes (`ProcessingStage`, `CompositeStage`) - `stages/resources.py`: Resource configuration - `stages/function_decorators.py`: Decorators for creating `ProcessingStage` instances from simple functions + +## Interleaved Processing (`stages/interleaved/`) + +Common operations: +- WebDataset tar shard ingestion +- Row-wise interleaved filtering (aspect ratio, etc.) +- Binary materialization (range read, tar extract, direct read) +- Parquet output with optional materialize-on-write + +Task type: `InterleavedBatch` diff --git a/.cursor/rules/task-patterns.mdc b/.cursor/rules/task-patterns.mdc index 73dfc3b624..2e8eea90e1 100644 --- a/.cursor/rules/task-patterns.mdc +++ b/.cursor/rules/task-patterns.mdc @@ -18,6 +18,7 @@ Tasks are the fundamental unit of data processed through stages and pipelines. A - **DocumentBatch**: For text document processing (`data: pa.Table | pd.DataFrame`) - **VideoTask**: For video processing (`data: nemo_curator.tasks.video.Video`) - **ImageBatch**: For image processing (`data: list[nemo_curator.tasks.image.ImageObject]`) +- **InterleavedBatch**: For interleaved multimodal processing (`data: pa.Table | pd.DataFrame`) - **AudioBatch**: For audio processing (`data: dict | list[dict]`) - **FileGroupTask**: Represents a list of file names (`data: list[str]`) - **_EmptyTask**: A singleton dummy task (`data: None`) used as input for stages that **generate** data rather than transform it. Commonly used for: diff --git a/benchmarking/scripts/multimodal_mint1t_benchmark.py b/benchmarking/scripts/multimodal_mint1t_benchmark.py index 2e1b7392f4..2911a1716c 100644 --- a/benchmarking/scripts/multimodal_mint1t_benchmark.py +++ b/benchmarking/scripts/multimodal_mint1t_benchmark.py @@ -25,8 +25,8 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline -from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader -from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage +from nemo_curator.stages.interleaved.io import InterleavedParquetWriterStage, WebdatasetReader +from nemo_curator.stages.interleaved.stages import InterleavedAspectRatioFilterStage from nemo_curator.tasks.utils import TaskPerfUtils @@ -54,9 +54,9 @@ def create_pipeline(args: argparse.Namespace) -> Pipeline: per_text_fields=tuple(args.per_text_fields) if args.per_text_fields else (), ) ) - pipeline.add_stage(MultimodalAspectRatioFilterStage(drop_invalid_rows=True, min_aspect_ratio=1.0, max_aspect_ratio=2.0)) + pipeline.add_stage(InterleavedAspectRatioFilterStage(drop_invalid_rows=True, min_aspect_ratio=1.0, max_aspect_ratio=2.0)) pipeline.add_stage( - MultimodalParquetWriterStage( + InterleavedParquetWriterStage( path=args.output_path, materialize_on_write=args.materialize_on_write, write_kwargs=write_kwargs, diff --git a/nemo_curator/stages/multimodal/README.md b/nemo_curator/stages/interleaved/README.md similarity index 78% rename from nemo_curator/stages/multimodal/README.md rename to nemo_curator/stages/interleaved/README.md index dfe6f17974..e842715863 100644 --- a/nemo_curator/stages/multimodal/README.md +++ b/nemo_curator/stages/interleaved/README.md @@ -1,6 +1,6 @@ -# Multimodal Pipeline +# Interleaved Pipeline -Row-wise multimodal ingestion and write path for WebDataset tar shards (MINT-1T style), with materialization support for local, remote, and tar-archived binary content. +Row-wise interleaved multimodal ingestion and write path for WebDataset tar shards (MINT-1T style), with materialization support for local, remote, and tar-archived binary content. ## Architecture @@ -10,26 +10,26 @@ WebDataset tar shards v ┌─────────────────────────┐ │ WebdatasetReader │ CompositeStage: FilePartitioning + WebdatasetReaderStage -│ (io/reader.py) │ Parses tar members -> normalized multimodal rows +│ (io/reader.py) │ Parses tar members -> normalized interleaved rows └────────┬────────────────┘ - | MultiBatchTask (Arrow/Pandas) + | InterleavedBatch (Arrow/Pandas) v ┌─────────────────────────┐ -│ Filter Stages │ e.g. MultimodalAspectRatioFilterStage +│ Filter Stages │ e.g. InterleavedAspectRatioFilterStage │ (stages.py) │ Row-wise filtering with optional materialization └────────┬────────────────┘ | v ┌─────────────────────────┐ -│ MultimodalParquet- │ MultimodalParquetWriterStage +│ InterleavedParquet- │ InterleavedParquetWriterStage │ WriterStage │ Parquet output with optional materialize-on-write │ (io/writers/tabular.py)│ Supports snappy/zstd compression, configurable row groups └─────────────────────────┘ ``` -## Schema (`MULTIMODAL_SCHEMA`) +## Schema (`INTERLEAVED_SCHEMA`) -Defined in `nemo_curator/tasks/multimodal.py`. Columns are split into **reserved** (managed by the pipeline) and **user** (passthrough from source data). +Defined in `nemo_curator/tasks/interleaved.py`. Columns are split into **reserved** (managed by the pipeline) and **user** (passthrough from source data). ### Reserved columns (`RESERVED_COLUMNS`) @@ -63,9 +63,9 @@ If `fields` is `None` (default), all non-reserved fields from the source JSON ar ## Key Concepts -### MultiBatchTask +### InterleavedBatch -The task type for multimodal data (`nemo_curator/tasks/multimodal.py`). Wraps either a PyArrow Table or Pandas DataFrame. +The task type for interleaved multimodal data (`nemo_curator/tasks/interleaved.py`). Wraps either a PyArrow Table or Pandas DataFrame. Class attributes: - `REQUIRED_COLUMNS` -- frozenset of columns that must always be present (non-nullable schema fields) @@ -113,16 +113,16 @@ Materialization can happen at read time (`materialize_on_read=True`) or write ti ```python from nemo_curator.pipeline import Pipeline -from nemo_curator.stages.multimodal.io import WebdatasetReader, MultimodalParquetWriterStage -from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage +from nemo_curator.stages.interleaved.io import WebdatasetReader, InterleavedParquetWriterStage +from nemo_curator.stages.interleaved.stages import InterleavedAspectRatioFilterStage pipeline = Pipeline(name="mint1t_pipeline") pipeline.add_stage(WebdatasetReader( source_id_field="pdf_name", file_paths="/data/mint1t/shards/", )) -pipeline.add_stage(MultimodalAspectRatioFilterStage(drop_invalid_rows=True)) -pipeline.add_stage(MultimodalParquetWriterStage( +pipeline.add_stage(InterleavedAspectRatioFilterStage(drop_invalid_rows=True)) +pipeline.add_stage(InterleavedParquetWriterStage( path="/output/parquet/", materialize_on_write=True, mode="overwrite", @@ -133,19 +133,19 @@ pipeline.run() ## File Layout ``` -stages/multimodal/ +stages/interleaved/ ├── __init__.py # Exports filter/annotator stages -├── stages.py # BaseMultimodalAnnotatorStage, BaseMultimodalFilterStage, -│ # MultimodalAspectRatioFilterStage +├── stages.py # BaseInterleavedAnnotatorStage, BaseInterleavedFilterStage, +│ # InterleavedAspectRatioFilterStage ├── io/ -│ ├── __init__.py # Exports WebdatasetReader, MultimodalParquetWriterStage +│ ├── __init__.py # Exports WebdatasetReader, InterleavedParquetWriterStage │ ├── reader.py # WebdatasetReader (CompositeStage) │ ├── readers/ -│ │ ├── base.py # BaseMultimodalReader +│ │ ├── base.py # BaseInterleavedReader │ │ └── webdataset.py # WebdatasetReaderStage (ProcessingStage) │ └── writers/ -│ ├── base.py # BaseMultimodalWriter (filesystem + materialization + process) -│ └── tabular.py # MultimodalParquetWriterStage +│ ├── base.py # BaseInterleavedWriter (filesystem + materialization + process) +│ └── tabular.py # InterleavedParquetWriterStage └── utils/ ├── constants.py # Default file extensions ├── materialization.py # Three-strategy materialization dispatch diff --git a/nemo_curator/stages/multimodal/__init__.py b/nemo_curator/stages/interleaved/__init__.py similarity index 69% rename from nemo_curator/stages/multimodal/__init__.py rename to nemo_curator/stages/interleaved/__init__.py index 316a5111e5..b48e88154d 100644 --- a/nemo_curator/stages/multimodal/__init__.py +++ b/nemo_curator/stages/interleaved/__init__.py @@ -12,10 +12,10 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.stages import ( - BaseMultimodalAnnotatorStage, - BaseMultimodalFilterStage, - MultimodalAspectRatioFilterStage, +from nemo_curator.stages.interleaved.stages import ( + BaseInterleavedAnnotatorStage, + BaseInterleavedFilterStage, + InterleavedAspectRatioFilterStage, ) -__all__ = ["BaseMultimodalAnnotatorStage", "BaseMultimodalFilterStage", "MultimodalAspectRatioFilterStage"] +__all__ = ["BaseInterleavedAnnotatorStage", "BaseInterleavedFilterStage", "InterleavedAspectRatioFilterStage"] diff --git a/nemo_curator/stages/multimodal/io/__init__.py b/nemo_curator/stages/interleaved/io/__init__.py similarity index 72% rename from nemo_curator/stages/multimodal/io/__init__.py rename to nemo_curator/stages/interleaved/io/__init__.py index 9dd6096faf..9bfad14e81 100644 --- a/nemo_curator/stages/multimodal/io/__init__.py +++ b/nemo_curator/stages/interleaved/io/__init__.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.reader import WebdatasetReader -from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.interleaved.io.reader import WebdatasetReader +from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage -__all__ = ["MultimodalParquetWriterStage", "WebdatasetReader"] +__all__ = ["InterleavedParquetWriterStage", "WebdatasetReader"] diff --git a/nemo_curator/stages/multimodal/io/reader.py b/nemo_curator/stages/interleaved/io/reader.py similarity index 92% rename from nemo_curator/stages/multimodal/io/reader.py rename to nemo_curator/stages/interleaved/io/reader.py index f16a06904e..f9ad0be664 100644 --- a/nemo_curator/stages/multimodal/io/reader.py +++ b/nemo_curator/stages/interleaved/io/reader.py @@ -17,19 +17,19 @@ from nemo_curator.stages.base import CompositeStage from nemo_curator.stages.file_partitioning import FilePartitioningStage -from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage -from nemo_curator.stages.multimodal.utils import ( +from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.interleaved.utils import ( DEFAULT_IMAGE_EXTENSIONS, DEFAULT_JSON_EXTENSIONS, DEFAULT_WEBDATASET_EXTENSIONS, require_source_id_field, resolve_storage_options, ) -from nemo_curator.tasks import MultiBatchTask, _EmptyTask +from nemo_curator.tasks import InterleavedBatch, _EmptyTask @dataclass -class WebdatasetReader(CompositeStage[_EmptyTask, MultiBatchTask]): +class WebdatasetReader(CompositeStage[_EmptyTask, InterleavedBatch]): """Composite stage for reading WebDataset shards.""" file_paths: str | list[str] diff --git a/nemo_curator/stages/multimodal/io/readers/__init__.py b/nemo_curator/stages/interleaved/io/readers/__init__.py similarity index 88% rename from nemo_curator/stages/multimodal/io/readers/__init__.py rename to nemo_curator/stages/interleaved/io/readers/__init__.py index 1734a25f29..81012a138e 100644 --- a/nemo_curator/stages/multimodal/io/readers/__init__.py +++ b/nemo_curator/stages/interleaved/io/readers/__init__.py @@ -12,6 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage __all__ = ["WebdatasetReaderStage"] diff --git a/nemo_curator/stages/multimodal/io/readers/base.py b/nemo_curator/stages/interleaved/io/readers/base.py similarity index 81% rename from nemo_curator/stages/multimodal/io/readers/base.py rename to nemo_curator/stages/interleaved/io/readers/base.py index b5dbdcb39b..01cde1f197 100644 --- a/nemo_curator/stages/multimodal/io/readers/base.py +++ b/nemo_curator/stages/interleaved/io/readers/base.py @@ -16,15 +16,15 @@ from typing import Any from nemo_curator.stages.base import ProcessingStage -from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.tasks import FileGroupTask, InterleavedBatch @dataclass -class BaseMultimodalReader(ProcessingStage[FileGroupTask, MultiBatchTask]): - """Base contract for multimodal readers.""" +class BaseInterleavedReader(ProcessingStage[FileGroupTask, InterleavedBatch]): + """Base contract for interleaved readers.""" read_kwargs: dict[str, Any] = field(default_factory=dict) - name: str = "base_multimodal_reader" + name: str = "base_interleaved_reader" def inputs(self) -> tuple[list[str], list[str]]: return ["data"], [] diff --git a/nemo_curator/stages/multimodal/io/readers/webdataset.py b/nemo_curator/stages/interleaved/io/readers/webdataset.py similarity index 95% rename from nemo_curator/stages/multimodal/io/readers/webdataset.py rename to nemo_curator/stages/interleaved/io/readers/webdataset.py index 1a916275a1..c7c8238cb0 100644 --- a/nemo_curator/stages/multimodal/io/readers/webdataset.py +++ b/nemo_curator/stages/interleaved/io/readers/webdataset.py @@ -26,17 +26,17 @@ from loguru import logger from nemo_curator.core.utils import split_table_by_group_max_bytes -from nemo_curator.stages.multimodal.utils import ( +from nemo_curator.stages.interleaved.utils import ( DEFAULT_IMAGE_EXTENSIONS, DEFAULT_JSON_EXTENSIONS, require_source_id_field, resolve_storage_options, validate_and_project_source_fields, ) -from nemo_curator.tasks import FileGroupTask, MultiBatchTask -from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA, RESERVED_COLUMNS +from nemo_curator.tasks import FileGroupTask, InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA, RESERVED_COLUMNS -from .base import BaseMultimodalReader +from .base import BaseInterleavedReader @dataclass @@ -66,7 +66,7 @@ class _SampleContext: @dataclass -class WebdatasetReaderStage(BaseMultimodalReader): +class WebdatasetReaderStage(BaseInterleavedReader): """Read MINT1T-style WebDataset shards into a row-wise multimodal task.""" materialize_on_read: bool = False @@ -92,14 +92,14 @@ def _build_source_ref( self, ctx: _SampleContext, content_key: str | None, *, frame_index: int | None = None, ) -> str: if content_key is None: - return MultiBatchTask.build_source_ref(path=None, member=None) + return InterleavedBatch.build_source_ref(path=None, member=None) byte_offset = None byte_size = None if ctx.member_info and content_key in ctx.member_info: info = ctx.member_info[content_key] byte_offset = info.offset_data byte_size = info.size - return MultiBatchTask.build_source_ref( + return InterleavedBatch.build_source_ref( path=ctx.tar_path, member=content_key, byte_offset=byte_offset, byte_size=byte_size, frame_index=frame_index, ) @@ -261,7 +261,7 @@ def _extract_per_modality_fields( return result def _empty_output_schema(self) -> pa.Schema: - schema = MULTIMODAL_SCHEMA + schema = INTERLEAVED_SCHEMA seen = set(self.fields or ()) all_extra = list(self.fields or ()) for f in (*self.per_image_fields, *self.per_text_fields): @@ -277,7 +277,7 @@ def _empty_output_schema(self) -> pa.Schema: @staticmethod def _reconcile_schema(inferred: pa.Schema) -> pa.Schema: """Build a schema with canonical types for reserved columns and inferred types for passthrough.""" - canonical = {f.name: f for f in MULTIMODAL_SCHEMA} + canonical = {f.name: f for f in INTERLEAVED_SCHEMA} fields = [] for f in inferred: if f.name in canonical: @@ -366,7 +366,7 @@ def _rows_from_member( for row in sample_rows: if row["modality"] != "image" or row["position"] < 0: continue - parsed_ref = MultiBatchTask.parse_source_ref(row["source_ref"]) + parsed_ref = InterleavedBatch.parse_source_ref(row["source_ref"]) content_key = parsed_ref.get("member") if content_key: row["binary_content"] = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) @@ -375,7 +375,7 @@ def _rows_from_member( # -- main entry point -- - def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: + def process(self, task: FileGroupTask) -> InterleavedBatch | list[InterleavedBatch]: rows: list[dict[str, Any]] = [] storage_options = resolve_storage_options(io_kwargs=self.read_kwargs) @@ -404,14 +404,14 @@ def process(self, task: FileGroupTask) -> MultiBatchTask | list[MultiBatchTask]: else: table = pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) - batches: list[MultiBatchTask] = [] + batches: list[InterleavedBatch] = [] for idx, split in enumerate(splits): task_id = f"{task.task_id}_processed" if len(splits) == 1 else f"{task.task_id}_processed_{idx:05d}" metadata = dict(task._metadata) if storage_options: metadata["source_storage_options"] = storage_options batches.append( - MultiBatchTask( + InterleavedBatch( task_id=task_id, dataset_name=task.dataset_name, data=split, diff --git a/nemo_curator/stages/multimodal/io/writers/__init__.py b/nemo_curator/stages/interleaved/io/writers/__init__.py similarity index 81% rename from nemo_curator/stages/multimodal/io/writers/__init__.py rename to nemo_curator/stages/interleaved/io/writers/__init__.py index 88b47f60c2..ba32009dfc 100644 --- a/nemo_curator/stages/multimodal/io/writers/__init__.py +++ b/nemo_curator/stages/interleaved/io/writers/__init__.py @@ -12,6 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage +from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage -__all__ = ["MultimodalParquetWriterStage"] +__all__ = ["InterleavedParquetWriterStage"] diff --git a/nemo_curator/stages/multimodal/io/writers/base.py b/nemo_curator/stages/interleaved/io/writers/base.py similarity index 88% rename from nemo_curator/stages/multimodal/io/writers/base.py rename to nemo_curator/stages/interleaved/io/writers/base.py index a2c4d8b2e4..25ab9f3568 100644 --- a/nemo_curator/stages/multimodal/io/writers/base.py +++ b/nemo_curator/stages/interleaved/io/writers/base.py @@ -24,8 +24,8 @@ import nemo_curator.stages.text.io.writer.utils as writer_utils from nemo_curator.stages.base import ProcessingStage -from nemo_curator.stages.multimodal.utils import materialize_task_binary_content -from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.stages.interleaved.utils import materialize_task_binary_content +from nemo_curator.tasks import FileGroupTask, InterleavedBatch from nemo_curator.utils.client_utils import is_remote_url from nemo_curator.utils.file_utils import check_output_mode @@ -34,8 +34,8 @@ @dataclass -class BaseMultimodalWriter(ProcessingStage[MultiBatchTask, FileGroupTask], ABC): - """Base class for multimodal writers. +class BaseInterleavedWriter(ProcessingStage[InterleavedBatch, FileGroupTask], ABC): + """Base class for interleaved writers. Handles filesystem setup, deterministic file naming, optional binary materialization, and process() orchestration. Subclasses implement @@ -46,7 +46,7 @@ class BaseMultimodalWriter(ProcessingStage[MultiBatchTask, FileGroupTask], ABC): file_extension: str write_kwargs: dict[str, Any] = field(default_factory=dict) materialize_on_write: bool = True - name: str = "base_multimodal_writer" + name: str = "base_interleaved_writer" mode: Literal["ignore", "overwrite", "append", "error"] = "ignore" append_mode_implemented: bool = False @@ -63,7 +63,7 @@ def outputs(self) -> tuple[list[str], list[str]]: # -- materialization -- - def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: + def _materialize_dataframe(self, task: InterleavedBatch) -> pd.DataFrame: out = task.to_pandas() image_mask = (out["modality"] == "image") & (out["binary_content"].isna()) self._log_metrics( @@ -88,14 +88,14 @@ def _materialize_dataframe(self, task: MultiBatchTask) -> pd.DataFrame: def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: """Format-specific DataFrame writer. Subclasses implement this.""" - def write_data(self, task: MultiBatchTask, file_path: str) -> None: + def write_data(self, task: InterleavedBatch, file_path: str) -> None: with self._time_metric("materialize_dataframe_total_s"): df = self._materialize_dataframe(task) write_kwargs: dict[str, Any] = {"index": False} write_kwargs.update(self.write_kwargs) self._write_dataframe(df, file_path, write_kwargs) - def process(self, task: MultiBatchTask) -> FileGroupTask: + def process(self, task: InterleavedBatch) -> FileGroupTask: if source_files := task._metadata.get("source_files"): filename = writer_utils.get_deterministic_hash(source_files, task.task_id) else: diff --git a/nemo_curator/stages/multimodal/io/writers/tabular.py b/nemo_curator/stages/interleaved/io/writers/tabular.py similarity index 83% rename from nemo_curator/stages/multimodal/io/writers/tabular.py rename to nemo_curator/stages/interleaved/io/writers/tabular.py index 48d44c0baa..754176ef3b 100644 --- a/nemo_curator/stages/multimodal/io/writers/tabular.py +++ b/nemo_curator/stages/interleaved/io/writers/tabular.py @@ -17,18 +17,18 @@ from dataclasses import dataclass from typing import TYPE_CHECKING, Any -from .base import BaseMultimodalWriter +from .base import BaseInterleavedWriter if TYPE_CHECKING: import pandas as pd @dataclass -class MultimodalParquetWriterStage(BaseMultimodalWriter): - """Write multimodal rows to Parquet with optional binary materialization.""" +class InterleavedParquetWriterStage(BaseInterleavedWriter): + """Write interleaved rows to Parquet with optional binary materialization.""" file_extension: str = "parquet" - name: str = "multimodal_parquet_writer" + name: str = "interleaved_parquet_writer" def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[str, Any]) -> None: write_kwargs.setdefault("compression", "snappy") diff --git a/nemo_curator/stages/multimodal/stages.py b/nemo_curator/stages/interleaved/stages.py similarity index 77% rename from nemo_curator/stages/multimodal/stages.py rename to nemo_curator/stages/interleaved/stages.py index da01ad60b4..f960bd1132 100644 --- a/nemo_curator/stages/multimodal/stages.py +++ b/nemo_curator/stages/interleaved/stages.py @@ -22,8 +22,8 @@ import pandas as pd from nemo_curator.stages.base import ProcessingStage -from nemo_curator.stages.multimodal.utils import materialize_task_binary_content -from nemo_curator.tasks import MultiBatchTask +from nemo_curator.stages.interleaved.utils import materialize_task_binary_content +from nemo_curator.tasks import InterleavedBatch if TYPE_CHECKING: from collections.abc import Iterator @@ -35,10 +35,10 @@ @dataclass -class BaseMultimodalAnnotatorStage(ProcessingStage[MultiBatchTask, MultiBatchTask], ABC): - """Base stage for row-wise multimodal annotation/filter transforms.""" +class BaseInterleavedAnnotatorStage(ProcessingStage[InterleavedBatch, InterleavedBatch], ABC): + """Base stage for row-wise interleaved annotation/filter transforms.""" - name: str = "base_multimodal_annotator" + name: str = "base_interleaved_annotator" def inputs(self) -> tuple[list[str], list[str]]: return ["data"], [] @@ -47,15 +47,15 @@ def outputs(self) -> tuple[list[str], list[str]]: return ["data"], [] @abstractmethod - def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: + def annotate(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.DataFrame: """Apply annotation/filter logic and return transformed dataframe.""" - def process(self, task: MultiBatchTask) -> MultiBatchTask: + def process(self, task: InterleavedBatch) -> InterleavedBatch: df = task.to_pandas().copy() if df.empty: return task out_df = self.annotate(task, df) - return MultiBatchTask( + return InterleavedBatch( task_id=f"{task.task_id}_{self.name}", dataset_name=task.dataset_name, data=out_df.reset_index(drop=True), @@ -65,14 +65,14 @@ def process(self, task: MultiBatchTask) -> MultiBatchTask: @dataclass -class BaseMultimodalFilterStage(BaseMultimodalAnnotatorStage, ABC): - """Base stage for multimodal filtering based on a keep-mask.""" +class BaseInterleavedFilterStage(BaseInterleavedAnnotatorStage, ABC): + """Base stage for interleaved filtering based on a keep-mask.""" drop_invalid_rows: bool = True - name: str = "base_multimodal_filter" + name: str = "base_interleaved_filter" @abstractmethod - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: """Return content-specific boolean keep-mask aligned to dataframe index.""" @staticmethod @@ -85,7 +85,7 @@ def _basic_row_validity_mask(df: pd.DataFrame) -> pd.Series: keep_mask &= metadata_pos | content_pos return keep_mask - def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: keep_mask = pd.Series(True, index=df.index, dtype=bool) if self.drop_invalid_rows: keep_mask &= self._basic_row_validity_mask(df) @@ -93,7 +93,7 @@ def keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: return keep_mask def iter_materialized_bytes( - self, task: MultiBatchTask, df: pd.DataFrame, row_mask: pd.Series + self, task: InterleavedBatch, df: pd.DataFrame, row_mask: pd.Series ) -> Iterator[tuple[int, bytes | None]]: """Yield (row_index, bytes) for masked rows using shared materialization logic.""" materialized_df = materialize_task_binary_content(task).to_pandas().reset_index(drop=True) @@ -107,7 +107,7 @@ def iter_materialized_bytes( row_bytes = materialized_df.iloc[pos]["binary_content"] yield row_idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None - def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: + def annotate(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.DataFrame: filtered = df[self.keep_mask(task, df)].copy() content_mask = filtered["modality"] != "metadata" if content_mask.any(): @@ -118,18 +118,18 @@ def annotate(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.DataFrame: @dataclass -class MultimodalAspectRatioFilterStage(BaseMultimodalFilterStage): - """Filter multimodal image rows by aspect-ratio bounds (all image formats).""" +class InterleavedAspectRatioFilterStage(BaseInterleavedFilterStage): + """Filter interleaved image rows by aspect-ratio bounds (all image formats).""" min_aspect_ratio: float = 1.0 max_aspect_ratio: float = 2.0 - name: str = "multimodal_aspect_ratio_filter" + name: str = "interleaved_aspect_ratio_filter" @staticmethod def _image_aspect_ratio(image_bytes: bytes) -> float | None: if Image is None: msg = ( - "Pillow is required for MultimodalAspectRatioFilterStage. " + "Pillow is required for InterleavedAspectRatioFilterStage. " "Install dependency group `image_cpu` (or `pillow`)." ) raise RuntimeError(msg) @@ -142,7 +142,7 @@ def _image_aspect_ratio(image_bytes: bytes) -> float | None: return None return float(width) / float(height) - def _image_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def _image_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: keep_mask = pd.Series(True, index=df.index, dtype=bool) image_mask = df["modality"] == "image" if not image_mask.any(): @@ -159,5 +159,5 @@ def _image_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: keep_mask.loc[idx] = False return keep_mask - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: return self._image_keep_mask(task, df) diff --git a/nemo_curator/stages/multimodal/utils/__init__.py b/nemo_curator/stages/interleaved/utils/__init__.py similarity index 85% rename from nemo_curator/stages/multimodal/utils/__init__.py rename to nemo_curator/stages/interleaved/utils/__init__.py index 51451f00e0..f76ca3887e 100644 --- a/nemo_curator/stages/multimodal/utils/__init__.py +++ b/nemo_curator/stages/interleaved/utils/__init__.py @@ -12,15 +12,15 @@ # See the License for the specific language governing permissions and # limitations under the License. -from nemo_curator.stages.multimodal.utils.constants import ( +from nemo_curator.stages.interleaved.utils.constants import ( DEFAULT_IMAGE_EXTENSIONS, DEFAULT_JSON_EXTENSIONS, DEFAULT_WEBDATASET_EXTENSIONS, ) -from nemo_curator.stages.multimodal.utils.materialization import ( +from nemo_curator.stages.interleaved.utils.materialization import ( materialize_task_binary_content, ) -from nemo_curator.stages.multimodal.utils.validation_utils import ( +from nemo_curator.stages.interleaved.utils.validation_utils import ( require_source_id_field, resolve_storage_options, validate_and_project_source_fields, diff --git a/nemo_curator/stages/multimodal/utils/constants.py b/nemo_curator/stages/interleaved/utils/constants.py similarity index 100% rename from nemo_curator/stages/multimodal/utils/constants.py rename to nemo_curator/stages/interleaved/utils/constants.py diff --git a/nemo_curator/stages/multimodal/utils/materialization.py b/nemo_curator/stages/interleaved/utils/materialization.py similarity index 98% rename from nemo_curator/stages/multimodal/utils/materialization.py rename to nemo_curator/stages/interleaved/utils/materialization.py index 4a16201a59..e469be0017 100644 --- a/nemo_curator/stages/multimodal/utils/materialization.py +++ b/nemo_curator/stages/interleaved/utils/materialization.py @@ -24,7 +24,7 @@ from loguru import logger from PIL import Image as _Image -from nemo_curator.tasks import MultiBatchTask +from nemo_curator.tasks import InterleavedBatch from .validation_utils import resolve_storage_options @@ -289,8 +289,8 @@ def _build_image_mask( return image_mask -def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTask: - return MultiBatchTask( +def _task_with_dataframe(task: InterleavedBatch, df: pd.DataFrame) -> InterleavedBatch: + return InterleavedBatch( task_id=task.task_id, dataset_name=task.dataset_name, data=df, @@ -300,12 +300,12 @@ def _task_with_dataframe(task: MultiBatchTask, df: pd.DataFrame) -> MultiBatchTa def materialize_task_binary_content( - task: MultiBatchTask, + task: InterleavedBatch, *, io_kwargs: dict[str, object] | None = None, only_missing_binary: bool = True, image_content_types: tuple[str, ...] | None = None, -) -> MultiBatchTask: +) -> InterleavedBatch: """Return a task with image-row binary content materialized from source_ref. Dispatches to three I/O strategies based on source_ref contents: diff --git a/nemo_curator/stages/multimodal/utils/validation_utils.py b/nemo_curator/stages/interleaved/utils/validation_utils.py similarity index 100% rename from nemo_curator/stages/multimodal/utils/validation_utils.py rename to nemo_curator/stages/interleaved/utils/validation_utils.py diff --git a/nemo_curator/tasks/__init__.py b/nemo_curator/tasks/__init__.py index b9c986444d..b1fb70b710 100644 --- a/nemo_curator/tasks/__init__.py +++ b/nemo_curator/tasks/__init__.py @@ -16,7 +16,7 @@ from .document import DocumentBatch from .file_group import FileGroupTask from .image import ImageBatch, ImageObject -from .multimodal import MultiBatchTask +from .interleaved import InterleavedBatch from .tasks import EmptyTask, Task, _EmptyTask __all__ = [ @@ -26,7 +26,7 @@ "FileGroupTask", "ImageBatch", "ImageObject", - "MultiBatchTask", + "InterleavedBatch", "Task", "_EmptyTask", ] diff --git a/nemo_curator/tasks/multimodal.py b/nemo_curator/tasks/interleaved.py similarity index 94% rename from nemo_curator/tasks/multimodal.py rename to nemo_curator/tasks/interleaved.py index c59a4503ee..a636a194bc 100644 --- a/nemo_curator/tasks/multimodal.py +++ b/nemo_curator/tasks/interleaved.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Multimodal task type and schema for row-wise multimodal records. +"""Interleaved task type and schema for row-wise interleaved multimodal records. Schema columns fall into two categories: @@ -53,7 +53,7 @@ from .tasks import Task -MULTIMODAL_SCHEMA = pa.schema( +INTERLEAVED_SCHEMA = pa.schema( [ pa.field("sample_id", pa.string(), nullable=False), pa.field("position", pa.int32(), nullable=False), @@ -67,21 +67,21 @@ ] ) -RESERVED_COLUMNS: frozenset[str] = frozenset(MULTIMODAL_SCHEMA.names) +RESERVED_COLUMNS: frozenset[str] = frozenset(INTERLEAVED_SCHEMA.names) @dataclass -class MultiBatchTask(Task[pa.Table | pd.DataFrame]): +class InterleavedBatch(Task[pa.Table | pd.DataFrame]): """Task carrying row-wise multimodal records. See module docstring for the full schema reference (reserved vs user columns). """ REQUIRED_COLUMNS: frozenset[str] = frozenset( - name for name, f in zip(MULTIMODAL_SCHEMA.names, MULTIMODAL_SCHEMA, strict=True) if not f.nullable + name for name, f in zip(INTERLEAVED_SCHEMA.names, INTERLEAVED_SCHEMA, strict=True) if not f.nullable ) - data: pa.Table | pd.DataFrame = field(default_factory=lambda: pa.Table.from_pylist([], schema=MULTIMODAL_SCHEMA)) + data: pa.Table | pd.DataFrame = field(default_factory=lambda: pa.Table.from_pylist([], schema=INTERLEAVED_SCHEMA)) # -- conversion -- @@ -151,7 +151,7 @@ def add_rows( rows: pa.Table | pd.DataFrame | list[dict], sample_id: str | None = None, auto_position: bool = True, - ) -> "MultiBatchTask": + ) -> "InterleavedBatch": """Add rows to this task. Args: @@ -163,7 +163,7 @@ def add_rows( """ raise NotImplementedError - def delete_rows(self, mask: pd.Series) -> "MultiBatchTask": + def delete_rows(self, mask: pd.Series) -> "InterleavedBatch": """Delete rows where *mask* is ``True``. Args: diff --git a/tests/stages/multimodal/__init__.py b/tests/stages/interleaved/__init__.py similarity index 100% rename from tests/stages/multimodal/__init__.py rename to tests/stages/interleaved/__init__.py diff --git a/tests/stages/multimodal/conftest.py b/tests/stages/interleaved/conftest.py similarity index 100% rename from tests/stages/multimodal/conftest.py rename to tests/stages/interleaved/conftest.py diff --git a/tests/stages/multimodal/test_multimodal_core.py b/tests/stages/interleaved/test_multimodal_core.py similarity index 89% rename from tests/stages/multimodal/test_multimodal_core.py rename to tests/stages/interleaved/test_multimodal_core.py index ad8e71bfca..116bc6f541 100644 --- a/tests/stages/multimodal/test_multimodal_core.py +++ b/tests/stages/interleaved/test_multimodal_core.py @@ -22,17 +22,17 @@ import pytest from nemo_curator.core.utils import split_table_by_group_max_bytes -from nemo_curator.stages.multimodal.io.reader import WebdatasetReader -from nemo_curator.stages.multimodal.stages import ( - BaseMultimodalFilterStage, - MultimodalAspectRatioFilterStage, +from nemo_curator.stages.interleaved.io.reader import WebdatasetReader +from nemo_curator.stages.interleaved.stages import ( + BaseInterleavedFilterStage, + InterleavedAspectRatioFilterStage, ) -from nemo_curator.stages.multimodal.utils.materialization import ( +from nemo_curator.stages.interleaved.utils.materialization import ( _classify_rows, materialize_task_binary_content, ) -from nemo_curator.tasks import MultiBatchTask -from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA +from nemo_curator.tasks import InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA # --- helpers --- @@ -47,9 +47,9 @@ def _make_tar(tmp_path: Path, members: dict[str, bytes], name: str = "shard.tar" return str(tar_path) -def _image_task(rows: list[dict], metadata: dict | None = None) -> MultiBatchTask: - table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) - return MultiBatchTask(task_id="test", dataset_name="d", data=table, _metadata=metadata or {}) +def _image_task(rows: list[dict], metadata: dict | None = None) -> InterleavedBatch: + table = pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA) + return InterleavedBatch(task_id="test", dataset_name="d", data=table, _metadata=metadata or {}) def _image_row( @@ -65,7 +65,7 @@ def _image_row( "content_type": "image/jpeg", "text_content": None, "binary_content": None, - "source_ref": MultiBatchTask.build_source_ref( + "source_ref": InterleavedBatch.build_source_ref( path=path, member=member, byte_offset=byte_offset, byte_size=byte_size ), "metadata_json": None, @@ -94,16 +94,16 @@ def single_row_table() -> pa.Table: "materialize_error": None, } ], - schema=MULTIMODAL_SCHEMA, + schema=INTERLEAVED_SCHEMA, ) @pytest.fixture -def single_row_task(single_row_table: pa.Table) -> MultiBatchTask: - return MultiBatchTask(task_id="t1", dataset_name="d1", data=single_row_table) +def single_row_task(single_row_table: pa.Table) -> InterleavedBatch: + return InterleavedBatch(task_id="t1", dataset_name="d1", data=single_row_table) -def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None: +def test_with_parsed_source_ref_columns(single_row_task: InterleavedBatch) -> None: df = single_row_task.with_parsed_source_ref_columns() assert df.loc[0, "_src_path"] == "/dataset/shard.tar" assert df.loc[0, "_src_member"] == "s1.json" @@ -113,7 +113,7 @@ def test_with_parsed_source_ref_columns(single_row_task: MultiBatchTask) -> None def test_parse_source_ref_ignores_legacy_keys() -> None: legacy_format = json.dumps({"content_path": "/old/path.tar", "content_key": "old.json"}) - parsed = MultiBatchTask.parse_source_ref(legacy_format) + parsed = InterleavedBatch.parse_source_ref(legacy_format) assert parsed["path"] is None assert parsed["member"] is None assert parsed["byte_offset"] is None @@ -121,8 +121,8 @@ def test_parse_source_ref_ignores_legacy_keys() -> None: def test_parse_source_ref_empty_values() -> None: - assert MultiBatchTask.parse_source_ref(None)["path"] is None - assert MultiBatchTask.parse_source_ref("")["path"] is None + assert InterleavedBatch.parse_source_ref(None)["path"] is None + assert InterleavedBatch.parse_source_ref("")["path"] is None # --- classify_rows tests --- @@ -309,7 +309,7 @@ def test_materialize_mixed_strategies(tmp_path: Path) -> None: def test_materialize_empty_task() -> None: - task = MultiBatchTask( + task = InterleavedBatch( task_id="empty", dataset_name="d", data=pa.table({ @@ -343,9 +343,9 @@ def test_materialize_no_image_rows() -> None: "materialize_error": None, } ], - schema=MULTIMODAL_SCHEMA, + schema=INTERLEAVED_SCHEMA, ) - task = MultiBatchTask(task_id="no_img", dataset_name="d", data=table) + task = InterleavedBatch(task_id="no_img", dataset_name="d", data=table) result = materialize_task_binary_content(task) assert result.num_items == 1 @@ -388,8 +388,8 @@ def test_aspect_ratio_filter_handles_non_default_dataframe_index() -> None: ] ) df.index = pd.Index([10, 42]) - task = MultiBatchTask(task_id="non_default_index", dataset_name="d1", data=df) - stage = MultimodalAspectRatioFilterStage(drop_invalid_rows=False) + task = InterleavedBatch(task_id="non_default_index", dataset_name="d1", data=df) + stage = InterleavedAspectRatioFilterStage(drop_invalid_rows=False) out = stage.process(task).to_pandas() assert len(out) == 1 assert out.iloc[0]["modality"] == "text" @@ -429,8 +429,8 @@ def test_aspect_ratio_filter_works_on_png_images() -> None: }, ] ) - task = MultiBatchTask(task_id="png_test", dataset_name="d1", data=df) - stage = MultimodalAspectRatioFilterStage(min_aspect_ratio=0.2, max_aspect_ratio=5.0, drop_invalid_rows=False) + task = InterleavedBatch(task_id="png_test", dataset_name="d1", data=df) + stage = InterleavedAspectRatioFilterStage(min_aspect_ratio=0.2, max_aspect_ratio=5.0, drop_invalid_rows=False) out = stage.process(task).to_pandas() assert len(out) == 2 assert out["modality"].tolist() == ["text", "image"] @@ -495,13 +495,13 @@ def test_split_table_preserves_group_integrity() -> None: def test_basic_row_validity_mask_filters_bad_modality() -> None: df = pd.DataFrame({"modality": ["text", "image", "video", "metadata"], "position": [0, 1, 2, -1]}) - mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) + mask = BaseInterleavedFilterStage._basic_row_validity_mask(df) assert mask.tolist() == [True, True, False, True] def test_basic_row_validity_mask_enforces_position_rules() -> None: df = pd.DataFrame({"modality": ["metadata", "metadata", "text", "text"], "position": [-1, 0, 0, -1]}) - mask = BaseMultimodalFilterStage._basic_row_validity_mask(df) + mask = BaseInterleavedFilterStage._basic_row_validity_mask(df) assert mask.tolist() == [True, False, True, False] @@ -511,10 +511,10 @@ def test_basic_row_validity_mask_enforces_position_rules() -> None: def test_filter_recomputes_positions_after_drop() -> None: """Filtering must recompute content positions to close gaps; metadata stays at -1.""" - class _DropOddPositions(BaseMultimodalFilterStage): + class _DropOddPositions(BaseInterleavedFilterStage): name: str = "drop_odd" - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: pos = df["position"].astype(int) return ~((df["modality"] != "metadata") & (pos % 2 == 1)) @@ -528,9 +528,9 @@ def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series "text_content": None, "binary_content": None, "source_ref": None, "metadata_json": "{}", "materialize_error": None}, ] - task = MultiBatchTask( + task = InterleavedBatch( task_id="pos_test", dataset_name="d", - data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), ) stage = _DropOddPositions(drop_invalid_rows=False) result = stage.process(task) @@ -544,10 +544,10 @@ def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series def test_filter_preserves_interleaved_ordering_across_modalities() -> None: """When text and image rows are interleaved, filtering must preserve relative order.""" - class _DropSecondImage(BaseMultimodalFilterStage): + class _DropSecondImage(BaseInterleavedFilterStage): name: str = "drop_second_image" - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: keep = pd.Series(True, index=df.index, dtype=bool) image_indices = df.index[df["modality"] == "image"].tolist() if len(image_indices) > 1: @@ -572,9 +572,9 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) _row("s1", 3, "image"), _row("s1", 4, "text", "end"), ] - task = MultiBatchTask( + task = InterleavedBatch( task_id="interleave_test", dataset_name="d", - data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), ) stage = _DropSecondImage(drop_invalid_rows=False) result = stage.process(task) @@ -591,10 +591,10 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) def test_filter_preserves_interleaved_ordering_with_noninterleaved_row_order() -> None: """Even when DataFrame rows are grouped by modality (not position order), filter must preserve interleaving.""" - class _KeepAll(BaseMultimodalFilterStage): + class _KeepAll(BaseInterleavedFilterStage): name: str = "keep_all" - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: return pd.Series(True, index=df.index, dtype=bool) def _row(sample_id: str, position: int, modality: str, text: str | None = None) -> dict: @@ -615,9 +615,9 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) _row("s1", 1, "image"), _row("s1", 3, "image"), ] - task = MultiBatchTask( + task = InterleavedBatch( task_id="noninterleaved_row_order", dataset_name="d", - data=pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA), + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), ) stage = _KeepAll(drop_invalid_rows=False) result = stage.process(task) @@ -643,9 +643,9 @@ def test_count_and_num_items() -> None: "text_content": "b", "binary_content": None, "source_ref": None, "metadata_json": None, "materialize_error": None}, ], - schema=MULTIMODAL_SCHEMA, + schema=INTERLEAVED_SCHEMA, ) - task = MultiBatchTask(task_id="cnt", dataset_name="d", data=table) + task = InterleavedBatch(task_id="cnt", dataset_name="d", data=table) assert task.num_items == 2 assert task.count() == 3 assert task.count(modality="text") == 2 @@ -663,9 +663,9 @@ def test_count_with_pandas_data() -> None: "text_content": None, "binary_content": None, "source_ref": None, "metadata_json": None, "materialize_error": None}, ], - schema=MULTIMODAL_SCHEMA, + schema=INTERLEAVED_SCHEMA, ) - task = MultiBatchTask(task_id="pd_cnt", dataset_name="d", data=table.to_pandas()) + task = InterleavedBatch(task_id="pd_cnt", dataset_name="d", data=table.to_pandas()) assert task.num_items == 1 assert task.count() == 2 assert task.count(modality="image") == 1 diff --git a/tests/stages/multimodal/test_multimodal_reader.py b/tests/stages/interleaved/test_multimodal_reader.py similarity index 97% rename from tests/stages/multimodal/test_multimodal_reader.py rename to tests/stages/interleaved/test_multimodal_reader.py index 739ec83e30..8b28938a14 100644 --- a/tests/stages/multimodal/test_multimodal_reader.py +++ b/tests/stages/interleaved/test_multimodal_reader.py @@ -20,11 +20,11 @@ import pandas as pd import pytest -from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage -from nemo_curator.tasks import FileGroupTask, MultiBatchTask +from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.tasks import FileGroupTask, InterleavedBatch -def _as_df(task_or_tasks: MultiBatchTask | list[MultiBatchTask]) -> pd.DataFrame: +def _as_df(task_or_tasks: InterleavedBatch | list[InterleavedBatch]) -> pd.DataFrame: task = task_or_tasks[0] if isinstance(task_or_tasks, list) else task_or_tasks return task.to_pandas() @@ -187,7 +187,7 @@ def test_reader_image_tokens_with_frame_index(tmp_path: Path) -> None: assert image_rows.iloc[0]["position"] == 1, "First non-None image at interleaved position 1" assert image_rows.iloc[1]["position"] == 2, "Second non-None image at interleaved position 2" - refs = [MultiBatchTask.parse_source_ref(v) for v in image_rows["source_ref"].tolist()] + refs = [InterleavedBatch.parse_source_ref(v) for v in image_rows["source_ref"].tolist()] assert refs[0]["member"] == "doc.pdf.tiff", "Non-matching string should resolve to default TIFF" assert refs[0]["frame_index"] == 0, "First non-None token gets frame_index=0" diff --git a/tests/stages/multimodal/test_multimodal_writer.py b/tests/stages/interleaved/test_multimodal_writer.py similarity index 80% rename from tests/stages/multimodal/test_multimodal_writer.py rename to tests/stages/interleaved/test_multimodal_writer.py index 3fc8d353d4..659d6ab313 100644 --- a/tests/stages/multimodal/test_multimodal_writer.py +++ b/tests/stages/interleaved/test_multimodal_writer.py @@ -18,16 +18,16 @@ import pandas as pd import pyarrow as pa -from nemo_curator.stages.multimodal.io.readers.webdataset import WebdatasetReaderStage -from nemo_curator.stages.multimodal.io.writers.tabular import MultimodalParquetWriterStage -from nemo_curator.stages.multimodal.stages import BaseMultimodalFilterStage -from nemo_curator.tasks import FileGroupTask, MultiBatchTask -from nemo_curator.tasks.multimodal import MULTIMODAL_SCHEMA +from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage +from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage +from nemo_curator.stages.interleaved.stages import BaseInterleavedFilterStage +from nemo_curator.tasks import FileGroupTask, InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA -def _read_batch(input_task: FileGroupTask) -> MultiBatchTask: +def _read_batch(input_task: FileGroupTask) -> InterleavedBatch: batch = WebdatasetReaderStage(source_id_field="pdf_name").process(input_task) - assert isinstance(batch, MultiBatchTask) + assert isinstance(batch, InterleavedBatch) return batch @@ -49,7 +49,7 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input assert image_mask.any() first_image_idx = df[image_mask].index[0] df.loc[first_image_idx, "source_ref"] = _source_ref("/definitely/missing/path.tar", "abc123.tiff") - bad_batch = MultiBatchTask( + bad_batch = InterleavedBatch( task_id=batch.task_id, dataset_name=batch.dataset_name, data=df, @@ -57,7 +57,7 @@ def test_writer_marks_materialize_error_on_bad_source_path(tmp_path: Path, input _stage_perf=batch._stage_perf, ) - writer = MultimodalParquetWriterStage(path=str(tmp_path / "out_bad"), materialize_on_write=True, mode="overwrite") + writer = InterleavedParquetWriterStage(path=str(tmp_path / "out_bad"), materialize_on_write=True, mode="overwrite") write_task = writer.process(bad_batch) written = pd.read_parquet(write_task.data[0]) @@ -85,16 +85,16 @@ def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> "materialize_error": None, } ], - schema=MULTIMODAL_SCHEMA, + schema=INTERLEAVED_SCHEMA, ) - task = MultiBatchTask( + task = InterleavedBatch( task_id="direct_content_path", dataset_name="mint_test", data=table, _metadata={"source_files": [str(raw_path)]}, ) - writer = MultimodalParquetWriterStage( + writer = InterleavedParquetWriterStage( path=str(tmp_path / "out_direct"), materialize_on_write=True, mode="overwrite" ) write_task = writer.process(task) @@ -120,8 +120,8 @@ def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: ] ) df.index = pd.Index([99]) - task = MultiBatchTask(task_id="idx_task", dataset_name="mint_test", data=df) - writer = MultimodalParquetWriterStage(path=str(tmp_path / "out_idx"), materialize_on_write=False, mode="overwrite") + task = InterleavedBatch(task_id="idx_task", dataset_name="mint_test", data=df) + writer = InterleavedParquetWriterStage(path=str(tmp_path / "out_idx"), materialize_on_write=False, mode="overwrite") write_task = writer.process(task) written = pd.read_parquet(write_task.data[0]) assert "__index_level_0__" not in written.columns @@ -130,10 +130,10 @@ def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: def test_interleaved_ordering_preserved_through_filter_and_write(tmp_path: Path) -> None: """End-to-end: interleaved text+image rows survive filtering and parquet roundtrip.""" - class _DropSecondImage(BaseMultimodalFilterStage): + class _DropSecondImage(BaseInterleavedFilterStage): name: str = "drop_second_image" - def content_keep_mask(self, task: MultiBatchTask, df: pd.DataFrame) -> pd.Series: + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: keep = pd.Series(True, index=df.index, dtype=bool) image_indices = df.index[df["modality"] == "image"].tolist() if len(image_indices) > 1: @@ -158,14 +158,14 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) _row("s1", 3, "image"), _row("s1", 4, "text", "end"), ] - table = pa.Table.from_pylist(rows, schema=MULTIMODAL_SCHEMA) - task = MultiBatchTask(task_id="e2e_order", dataset_name="d", data=table) + table = pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA) + task = InterleavedBatch(task_id="e2e_order", dataset_name="d", data=table) filter_stage = _DropSecondImage(drop_invalid_rows=False) filtered_task = filter_stage.process(task) out_dir = str(tmp_path / "e2e_out") - writer = MultimodalParquetWriterStage(path=out_dir, materialize_on_write=False, mode="overwrite") + writer = InterleavedParquetWriterStage(path=out_dir, materialize_on_write=False, mode="overwrite") write_task = writer.process(filtered_task) written = pd.read_parquet(write_task.data[0]) diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 8b7dd19837..1f596213a2 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -17,8 +17,8 @@ from nemo_curator.core.client import RayClient from nemo_curator.pipeline import Pipeline -from nemo_curator.stages.multimodal.io import MultimodalParquetWriterStage, WebdatasetReader -from nemo_curator.stages.multimodal.stages import MultimodalAspectRatioFilterStage +from nemo_curator.stages.interleaved.io import InterleavedParquetWriterStage, WebdatasetReader +from nemo_curator.stages.interleaved.stages import InterleavedAspectRatioFilterStage def build_pipeline(args: argparse.Namespace) -> Pipeline: @@ -44,9 +44,9 @@ def build_pipeline(args: argparse.Namespace) -> Pipeline: per_text_fields=tuple(args.per_text_fields) if args.per_text_fields else (), ) ) - pipe.add_stage(MultimodalAspectRatioFilterStage(min_aspect_ratio=1.0, max_aspect_ratio=2.0, drop_invalid_rows=True)) + pipe.add_stage(InterleavedAspectRatioFilterStage(min_aspect_ratio=1.0, max_aspect_ratio=2.0, drop_invalid_rows=True)) pipe.add_stage( - MultimodalParquetWriterStage( + InterleavedParquetWriterStage( path=args.output_path, materialize_on_write=args.materialize_on_write, write_kwargs=write_kwargs, From 2746a6db75550f00225645cf20354880821b2cbf Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 04:19:23 +0000 Subject: [PATCH 51/62] Fix ruff I001 import ordering in benchmarking utils Signed-off-by: Vibhu Jawa Made-with: Cursor --- benchmarking/scripts/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarking/scripts/utils.py b/benchmarking/scripts/utils.py index 15fda3c39f..fa032cad13 100644 --- a/benchmarking/scripts/utils.py +++ b/benchmarking/scripts/utils.py @@ -17,8 +17,8 @@ from pathlib import Path from typing import Any -import pyarrow.parquet as pq import pandas as pd +import pyarrow.parquet as pq from nemo_curator.backends.experimental.ray_actor_pool.executor import RayActorPoolExecutor from nemo_curator.backends.experimental.ray_data import RayDataExecutor From 91a0b4e28a3baa0300ac2f70f050fc2b50d14e67 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 05:41:00 +0000 Subject: [PATCH 52/62] Add interleaved multimodal quickstart tutorial notebook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Interactive notebook showing the end-to-end interleaved pipeline: read WebDataset tar → inspect schema → display interleaved document (text + inline images) → filter by aspect ratio → write to Parquet. Includes executed outputs with rendered MINT-1T sample data. Signed-off-by: Vibhu Jawa Made-with: Cursor Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../interleaved_data_quickstart.ipynb | 943 ++++++++++++++++++ 1 file changed, 943 insertions(+) create mode 100644 tutorials/multimodal/interleaved_data_quickstart.ipynb diff --git a/tutorials/multimodal/interleaved_data_quickstart.ipynb b/tutorials/multimodal/interleaved_data_quickstart.ipynb new file mode 100644 index 0000000000..8c948a5e8c --- /dev/null +++ b/tutorials/multimodal/interleaved_data_quickstart.ipynb @@ -0,0 +1,943 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bd8e4ca5", + "metadata": {}, + "source": [ + "# Interleaved Multimodal Data — Quickstart\n", + "\n", + "This notebook walks through the NeMo Curator interleaved multimodal pipeline:\n", + "\n", + "1. **Read** a WebDataset tar shard (MINT-1T format) into row-wise `InterleavedBatch` tasks\n", + "2. **Inspect** the interleaved schema — text, images, and metadata in position order\n", + "3. **Display** a sample as a rendered document (text + inline images)\n", + "4. **Filter** by image aspect ratio\n", + "5. **Write** to Parquet\n", + "\n", + "Each sample in MINT-1T is a JSON file paired with a multi-frame TIFF.\n", + "The reader extracts individual frames so each image row carries its own single-frame binary." + ] + }, + { + "cell_type": "markdown", + "id": "a9391623", + "metadata": {}, + "source": [ + "## Step 1 — Read a WebDataset tar shard" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "18f81199", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:49.086414Z", + "iopub.status.busy": "2026-03-03T05:47:49.086289Z", + "iopub.status.idle": "2026-03-03T05:47:52.910991Z", + "shell.execute_reply": "2026-03-03T05:47:52.909906Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Samples: 56\n", + "Total rows: 526\n", + " text: 228\n", + " image: 242\n", + " metadata: 56\n" + ] + } + ], + "source": [ + "from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage\n", + "from nemo_curator.tasks import FileGroupTask\n", + "\n", + "TAR_PATH = \"/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar\"\n", + "\n", + "task = FileGroupTask(task_id=\"quickstart\", dataset_name=\"mint1t\", data=[TAR_PATH], _metadata={})\n", + "reader = WebdatasetReaderStage(\n", + " source_id_field=\"pdf_name\",\n", + " materialize_on_read=True,\n", + ")\n", + "result = reader.process(task)\n", + "batch = result[0] if isinstance(result, list) else result\n", + "\n", + "print(f\"Samples: {batch.num_items}\")\n", + "print(f\"Total rows: {batch.count()}\")\n", + "print(f\" text: {batch.count(modality='text')}\")\n", + "print(f\" image: {batch.count(modality='image')}\")\n", + "print(f\" metadata: {batch.count(modality='metadata')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e235a755", + "metadata": {}, + "source": [ + "## Step 2 — Inspect the interleaved schema\n", + "\n", + "Every row has these reserved columns:\n", + "\n", + "| Column | Description |\n", + "|--------|-------------|\n", + "| `sample_id` | Unique document identifier |\n", + "| `position` | Order within the sample (-1 for metadata) |\n", + "| `modality` | `text`, `image`, or `metadata` |\n", + "| `content_type` | MIME type |\n", + "| `text_content` | Text payload (text rows) |\n", + "| `binary_content` | Image bytes (image rows) |\n", + "| `source_ref` | JSON locator back to the source tar |\n", + "| `metadata_json` | Full original JSON (metadata rows) |\n", + "| `materialize_error` | Error message if materialization failed |\n", + "\n", + "Plus any **passthrough fields** from the source JSON (e.g. `url`, `image_metadata`)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "10a4cf83", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:52.913877Z", + "iopub.status.busy": "2026-03-03T05:47:52.913641Z", + "iopub.status.idle": "2026-03-03T05:47:52.934239Z", + "shell.execute_reply": "2026-03-03T05:47:52.933315Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'metadata_json', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'image_metadata', 'language_id_whole_page_fasttext', 'previous_word_count', 'url']\n", + "\n", + "Sample 'ba16decf89064be49237fb81a59fd3f3' -- 17 rows\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idpositionmodalitycontent_typetext_contentbinary_contentsource_refmetadata_jsonmaterialize_errorbff_contained_ngram_count_before_dedupeimage_metadatalanguage_id_whole_page_fasttextprevious_word_counturl
0ba16decf89064be49237fb81a59fd3f3-1metadataapplication/jsonNoneNoneba16decf89064be49237fb81a59fd3f3.json | offset=512{\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height...None271[{\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c6...{\"en\": 0.8799859881401062}7605https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac...
1ba16decf89064be49237fb81a59fd3f30imageimage/tiffNone339,769 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | offset=57856NoneNone<NA><NA><NA><NA><NA>
2ba16decf89064be49237fb81a59fd3f31texttext/plainDIGITALISATION FEBRUARY 2018 About the Council for the Envir...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
3ba16decf89064be49237fb81a59fd3f32imageimage/tiffNone411,857 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | offset=57856NoneNone<NA><NA><NA><NA><NA>
4ba16decf89064be49237fb81a59fd3f33texttext/plainSUMMARY The Netherlands’ electricity system is increasingly ...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
5ba16decf89064be49237fb81a59fd3f34imageimage/tiffNone382,287 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | offset=57856NoneNone<NA><NA><NA><NA><NA>
6ba16decf89064be49237fb81a59fd3f35texttext/plainINTRODUCTION 1.1 Context The reliability and continuity of e...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
7ba16decf89064be49237fb81a59fd3f36imageimage/tiffNone327,493 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | offset=57856NoneNone<NA><NA><NA><NA><NA>
8ba16decf89064be49237fb81a59fd3f37texttext/plainELECTRICITY SYSTEM The coming years will see far-reaching ch...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
9ba16decf89064be49237fb81a59fd3f38imageimage/tiffNone61,401 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | offset=57856NoneNone<NA><NA><NA><NA><NA>
10ba16decf89064be49237fb81a59fd3f39texttext/plainFrom centralised generation to digitalised, decentralised, l...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
11ba16decf89064be49237fb81a59fd3f310imageimage/tiffNone63,629 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | offset=57856NoneNone<NA><NA><NA><NA><NA>
12ba16decf89064be49237fb81a59fd3f311texttext/plainFigure 2. The difference between analogue and digital switch...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
13ba16decf89064be49237fb81a59fd3f312imageimage/tiffNone454,509 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | offset=57856NoneNone<NA><NA><NA><NA><NA>
14ba16decf89064be49237fb81a59fd3f313texttext/plainVULNERABILITIES The digitalisation of the electricity system...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
15ba16decf89064be49237fb81a59fd3f314imageimage/tiffNone342,095 bytesba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | offset=57856NoneNone<NA><NA><NA><NA><NA>
16ba16decf89064be49237fb81a59fd3f315texttext/plainRECOMMENDATIONS The Netherlands occupies a good starting pos...Noneba16decf89064be49237fb81a59fd3f3.json | offset=512NoneNone<NA><NA><NA><NA><NA>
\n", + "
" + ], + "text/plain": [ + " sample_id position modality content_type text_content binary_content \\\n", + "0 ba16decf89064be49237fb81a59fd3f3 -1 metadata application/json None None \n", + "1 ba16decf89064be49237fb81a59fd3f3 0 image image/tiff None 339,769 bytes \n", + "2 ba16decf89064be49237fb81a59fd3f3 1 text text/plain DIGITALISATION FEBRUARY 2018 About the Council for the Envir... None \n", + "3 ba16decf89064be49237fb81a59fd3f3 2 image image/tiff None 411,857 bytes \n", + "4 ba16decf89064be49237fb81a59fd3f3 3 text text/plain SUMMARY The Netherlands’ electricity system is increasingly ... None \n", + "5 ba16decf89064be49237fb81a59fd3f3 4 image image/tiff None 382,287 bytes \n", + "6 ba16decf89064be49237fb81a59fd3f3 5 text text/plain INTRODUCTION 1.1 Context The reliability and continuity of e... None \n", + "7 ba16decf89064be49237fb81a59fd3f3 6 image image/tiff None 327,493 bytes \n", + "8 ba16decf89064be49237fb81a59fd3f3 7 text text/plain ELECTRICITY SYSTEM The coming years will see far-reaching ch... None \n", + "9 ba16decf89064be49237fb81a59fd3f3 8 image image/tiff None 61,401 bytes \n", + "10 ba16decf89064be49237fb81a59fd3f3 9 text text/plain From centralised generation to digitalised, decentralised, l... None \n", + "11 ba16decf89064be49237fb81a59fd3f3 10 image image/tiff None 63,629 bytes \n", + "12 ba16decf89064be49237fb81a59fd3f3 11 text text/plain Figure 2. The difference between analogue and digital switch... None \n", + "13 ba16decf89064be49237fb81a59fd3f3 12 image image/tiff None 454,509 bytes \n", + "14 ba16decf89064be49237fb81a59fd3f3 13 text text/plain VULNERABILITIES The digitalisation of the electricity system... None \n", + "15 ba16decf89064be49237fb81a59fd3f3 14 image image/tiff None 342,095 bytes \n", + "16 ba16decf89064be49237fb81a59fd3f3 15 text text/plain RECOMMENDATIONS The Netherlands occupies a good starting pos... None \n", + "\n", + " source_ref metadata_json materialize_error bff_contained_ngram_count_before_dedupe \\\n", + "0 ba16decf89064be49237fb81a59fd3f3.json | offset=512 {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height... None 271 \n", + "1 ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | offset=57856 None None \n", + "2 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "3 ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | offset=57856 None None \n", + "4 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "5 ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | offset=57856 None None \n", + "6 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "7 ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | offset=57856 None None \n", + "8 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "9 ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | offset=57856 None None \n", + "10 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "11 ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | offset=57856 None None \n", + "12 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "13 ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | offset=57856 None None \n", + "14 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "15 ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | offset=57856 None None \n", + "16 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + "\n", + " image_metadata language_id_whole_page_fasttext previous_word_count url \n", + "0 [{\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c6... {\"en\": 0.8799859881401062} 7605 https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac... \n", + "1 \n", + "2 \n", + "3 \n", + "4 \n", + "5 \n", + "6 \n", + "7 \n", + "8 \n", + "9 \n", + "10 \n", + "11 \n", + "12 \n", + "13 \n", + "14 \n", + "15 \n", + "16 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json as _json\n", + "\n", + "import pandas as pd\n", + "\n", + "df = batch.to_pandas()\n", + "print(f\"All columns: {list(df.columns)}\\n\")\n", + "\n", + "sample_id = df[\"sample_id\"].iloc[0]\n", + "sample = df[df[\"sample_id\"] == sample_id].sort_values(\"position\")\n", + "\n", + "MAX_COL_WIDTH = 60\n", + "MAX_META_WIDTH = 80\n", + "\n", + "\n", + "def _fmt(x: object, max_len: int = MAX_COL_WIDTH) -> str | None:\n", + " if pd.isna(x) or x is None:\n", + " return None\n", + " if isinstance(x, (bytes, bytearray)):\n", + " return f\"{len(x):,} bytes\"\n", + " s = str(x)\n", + " return s[:max_len] + \"...\" if len(s) > max_len else s\n", + "\n", + "\n", + "def _fmt_source_ref(x: object) -> str | None:\n", + " if pd.isna(x) or x is None:\n", + " return None\n", + " try:\n", + " ref = _json.loads(x)\n", + " parts = []\n", + " if ref.get(\"member\"):\n", + " parts.append(ref[\"member\"])\n", + " if ref.get(\"frame_index\") is not None:\n", + " parts.append(f\"frame={ref['frame_index']}\")\n", + " if ref.get(\"byte_offset\") is not None:\n", + " parts.append(f\"offset={ref['byte_offset']}\")\n", + " return \" | \".join(parts) if parts else \"-\"\n", + " except (ValueError, TypeError):\n", + " return _fmt(x)\n", + "\n", + "\n", + "show = sample.copy()\n", + "show[\"text_content\"] = show[\"text_content\"].map(_fmt)\n", + "show[\"binary_content\"] = show[\"binary_content\"].map(_fmt)\n", + "show[\"metadata_json\"] = show[\"metadata_json\"].map(lambda x: _fmt(x, max_len=MAX_META_WIDTH))\n", + "show[\"source_ref\"] = show[\"source_ref\"].map(_fmt_source_ref)\n", + "show[\"materialize_error\"] = show[\"materialize_error\"].map(_fmt)\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "pd.set_option(\"display.max_colwidth\", MAX_META_WIDTH)\n", + "pd.set_option(\"display.width\", 220)\n", + "\n", + "print(f\"Sample '{sample_id}' -- {len(sample)} rows\\n\")\n", + "display(show.reset_index(drop=True))" + ] + }, + { + "cell_type": "markdown", + "id": "2db86243", + "metadata": {}, + "source": [ + "## Step 3 — Display as an interleaved document\n", + "\n", + "Render the sample the way a human would read it: metadata at the top, then text and images in position order." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b4543964", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:52.936810Z", + "iopub.status.busy": "2026-03-03T05:47:52.936680Z", + "iopub.status.idle": "2026-03-03T05:47:53.617017Z", + "shell.execute_reply": "2026-03-03T05:47:53.616394Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "

Sample: ba16decf89064be49237fb81a59fd3f3

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://en.rli.nl/sites/default/files/advice_eletricity_prov...  |  language_id_whole_page_fasttext: {'en': 0.8799859881401062}  |  previous_word_count: 7605
[0] IMAGE   frame=0   1081x862   339,769 bytes
[1] TEXT
DIGITALISATION FEBRUARY 2018 About the Council for the Environment and Infrastructure The Council for the Environment and Infrastructure (Raad voor de leefomgeving en infrastructuur, Rli) advises the Dutch government and Parliament on strategic issues concerning the sustainable development of the living and working environment. The Council is independent, and offers solicited and unsolicited advic...
[2] IMAGE   frame=1   1070x861   411,857 bytes
[3] TEXT
SUMMARY The Netherlands’ electricity system is increasingly reliant on digital technology. Important decisions concerning generation, transmission and distribution are now made with the help of advanced software and algorithms. This development is one feature of an electricity system which is changing in many other respects. Generation increasingly makes use of sustainable, renewable energy source...
[4] IMAGE   frame=2   861x1069   382,287 bytes
[5] TEXT
INTRODUCTION 1.1 Context The reliability and continuity of electricity provision is a matter of great importance. Any disruption has the potential to cause personal injury, physical damage and/or financial loss. A protracted power outage could lead to considerable public unrest and would therefore create further risks to safety and public order. To ensure the continued reliability, safety, afforda...
[6] IMAGE   frame=3   861x1070   327,493 bytes
[7] TEXT
ELECTRICITY SYSTEM The coming years will see far-reaching changes to our electricity system as the result of a number of developments. In this section, the Council discusses four of those developments before examining the change which is central to this report: the digitalisation of the electricity system. 2.1 Current developments Various developments, some already underway, will have a significa...
[8] IMAGE   frame=4   636x391   61,401 bytes
[9] TEXT
From centralised generation to digitalised, decentralised, local generation by utility companies, \n", + "other private sector parties and private individuals; all components of the system must be able \n", + "to communicate with each other. For example, digital technology will allow a rapid response to fluctuations in supply and demand. Not only large (utility) companies, but also smaller organisations and pri...
[10] IMAGE   frame=5   494x546   63,629 bytes
[11] TEXT
Figure 2. The difference between analogue and digital switching points Analogue switches are operated manually. Digital switching points control devices based on \n", + "data such as the amount of electricity being generated and consumed, prices, consumption \n", + "patterns and weather conditions. 3 NEW
[12] IMAGE   frame=6   861x1067   454,509 bytes
[13] TEXT
VULNERABILITIES The digitalisation of the electricity system creates new vulnerabilities in the electricity supply. There could be problems at various points: the equipment which remotely controls generation and storage requirements, the networks (grids), or the complex digital processes underlying communication between the various system components. Moreover, because those components are increasi...
[14] IMAGE   frame=7   861x1067   342,095 bytes
[15] TEXT
RECOMMENDATIONS The Netherlands occupies a good starting position with regard to the transformation of its electricity system. Our current electricity provision is marked by a high degree of reliability, and is achieved at relatively low it is not yet possible to carefully assess whether the instruments currently in place to safeguard continuity will be adequate in the future. The Council therefor...

Sample: fc2e675b856b4f1e9dd942c32b8d479f

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: http://www.natur-in-nrw.de/Download/Martens_Leiobunum_2007.p...
[0] TEXT
Arachnol. Mitt. 34: 27-38 Nürnberg, Dezember 2007 An unidentified harvestman Leiobunum sp. alarmingly invading Europe \n", + "(Arachnida: Opiliones) Hay Wijnhoven, Axel L. Schönhofer & Jochen Martens Abstract: Since about the year 2000 a hitherto unidentified species of the genus Leiobunum C. L. K...
[1] IMAGE   frame=0   2126x2126   2,448,941 bytes
[2] TEXT
Fig. 1: Leiobunum sp.; a-b: aggregations of adult individuals, The Netherlands; a: on a brickstone wall, Ooij; b: on the ceiling of an old building, Beuningen; c-d: adults, Witten/Ruhr, Germany; c: ; d: ; 2nd record in Germany. – Photos: a, b: H.W., c, d: females the tibiae of the legs have conspicuous \n", + "white tips, reduced in older specimens (Fig. 1b). \n", + "Large aggregations numbering dozens up to ...
[3] IMAGE   frame=1   1725x1053   690,973 bytes
[4] TEXT
Fig. 3: Leiobunum sp.; , pedipalpus; a: lateral view, b: median view, c: joint between Fe and Pt, d: claw of Ta. – © H.W. Fig. 2: Leiobunum sp.; ; a-e: genitalia; a-b: penis, dorsal view, c-d: penis lateral view; e: distal part of glans and stylus, lateral view; f-g: first right leg, frontal view of Cx, Tr and Fe and detail of denticles of Cx; h-i: genital operculum and detail of \n", + "denticles; k-m...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import base64\n", + "import json\n", + "from io import BytesIO\n", + "\n", + "from IPython.display import HTML\n", + "from IPython.display import display as ipy_display\n", + "from PIL import Image\n", + "\n", + "URL_TRUNCATE_LEN = 60\n", + "\n", + "\n", + "def render_interleaved_sample(\n", + " sample_df: pd.DataFrame, sample_id: str, max_text_chars: int = 400, max_img_width: int = 400,\n", + ") -> str:\n", + " \"\"\"Render one InterleavedBatch sample as readable HTML.\"\"\"\n", + " meta_row = sample_df[sample_df[\"modality\"] == \"metadata\"]\n", + " content = sample_df[sample_df[\"modality\"] != \"metadata\"].sort_values(\"position\")\n", + "\n", + " parts = [\n", + " '
'\n", + " ]\n", + "\n", + " parts.append(f'

Sample: {sample_id}

')\n", + "\n", + " if len(meta_row):\n", + " m = meta_row.iloc[0]\n", + " meta_json = json.loads(m[\"metadata_json\"]) if isinstance(m[\"metadata_json\"], str) else {}\n", + " source = meta_json.get(\"_sample_source\", {})\n", + " badges = []\n", + " if source.get(\"source_shard\"):\n", + " badges.append(f\"shard: {source['source_shard']}\")\n", + " if meta_json.get(\"url\"):\n", + " url = meta_json[\"url\"]\n", + " short = url[:URL_TRUNCATE_LEN] + (\"...\" if len(url) > URL_TRUNCATE_LEN else \"\")\n", + " badges.append(f'url: {short}')\n", + " for k in (\"language_id_whole_page_fasttext\", \"previous_word_count\"):\n", + " if k in meta_json and meta_json[k] is not None:\n", + " badges.append(f\"{k}: {meta_json[k]}\")\n", + " parts.append(\n", + " '
'\n", + " + \"  |  \".join(badges)\n", + " + \"
\"\n", + " )\n", + "\n", + " for _, row in content.iterrows():\n", + " pos = int(row[\"position\"])\n", + " mod = row[\"modality\"]\n", + "\n", + " if mod == \"text\":\n", + " text = str(row[\"text_content\"]) if not pd.isna(row.get(\"text_content\")) else \"\"\n", + " snippet = text[:max_text_chars] + \"...\" if len(text) > max_text_chars else text\n", + " parts.append(\n", + " f'
'\n", + " f'[{pos}] TEXT
'\n", + " f\"{snippet}
\"\n", + " )\n", + "\n", + " elif mod == \"image\":\n", + " bc = row[\"binary_content\"]\n", + " if bc is not None and not pd.isna(bc):\n", + " img = Image.open(BytesIO(bc))\n", + " w, h = img.size\n", + " thumb = img.copy()\n", + " thumb.thumbnail((max_img_width, max_img_width))\n", + " buf = BytesIO()\n", + " thumb.save(buf, format=\"PNG\")\n", + " b64 = base64.b64encode(buf.getvalue()).decode()\n", + "\n", + " ref = json.loads(row[\"source_ref\"]) if isinstance(row[\"source_ref\"], str) else {}\n", + " fi = ref.get(\"frame_index\", \"-\")\n", + " parts.append(\n", + " f'
'\n", + " f''\n", + " f\"[{pos}] IMAGE   frame={fi}   {w}x{h}   {len(bc):,} bytes
\"\n", + " f''\n", + " f\"
\"\n", + " )\n", + " else:\n", + " err = row.get(\"materialize_error\")\n", + " msg = str(err) if err and not pd.isna(err) else \"binary not available\"\n", + " parts.append(\n", + " f'
'\n", + " f'[{pos}] IMAGE (missing)
'\n", + " f'{msg}
'\n", + " )\n", + "\n", + " parts.append(\"
\")\n", + " return \"\".join(parts)\n", + "\n", + "\n", + "html_blocks = []\n", + "for sid in df[\"sample_id\"].unique()[:2]:\n", + " html_blocks.append(render_interleaved_sample(df[df[\"sample_id\"] == sid], sid))\n", + "\n", + "ipy_display(HTML(\"\".join(html_blocks)))\n" + ] + }, + { + "cell_type": "markdown", + "id": "3712a880", + "metadata": {}, + "source": [ + "## Step 4 — Filter by aspect ratio\n", + "\n", + "`InterleavedAspectRatioFilterStage` opens each image's binary content,\n", + "computes the aspect ratio, and drops rows outside the specified range.\n", + "Positions are automatically recomputed after filtering." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8d76c753", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:53.642585Z", + "iopub.status.busy": "2026-03-03T05:47:53.642438Z", + "iopub.status.idle": "2026-03-03T05:47:53.945123Z", + "shell.execute_reply": "2026-03-03T05:47:53.944184Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before: 526 rows (242 images)\n", + "After: 504 rows (220 images)\n", + "Dropped 22 rows\n" + ] + } + ], + "source": [ + "from nemo_curator.stages.interleaved.stages import InterleavedAspectRatioFilterStage\n", + "\n", + "filter_stage = InterleavedAspectRatioFilterStage(\n", + " min_aspect_ratio=0.5,\n", + " max_aspect_ratio=2.0,\n", + ")\n", + "filtered_batch = filter_stage.process(batch)\n", + "\n", + "print(f\"Before: {batch.count()} rows ({batch.count(modality='image')} images)\")\n", + "print(f\"After: {filtered_batch.count()} rows ({filtered_batch.count(modality='image')} images)\")\n", + "print(f\"Dropped {batch.count() - filtered_batch.count()} rows\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c9f2b098", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:53.947919Z", + "iopub.status.busy": "2026-03-03T05:47:53.947773Z", + "iopub.status.idle": "2026-03-03T05:47:53.962230Z", + "shell.execute_reply": "2026-03-03T05:47:53.961334Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "

Sample: 025fe4e4caca411f84cff3c407822f73 (filtered)

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://samic.co.za/wp-content/uploads/2022/08/GFASA-Webinfo...  |  language_id_whole_page_fasttext: {'en': 0.8687576055526733}  |  previous_word_count: 272
[0] TEXT
Owner of the trademarks: GrassFed Association of South Africa Contact info: Contact person: Adrian Cloete │ Tel: +27 82 213 2120 │ email: email@example.com │ \n", + "Website: www.grassfedsa.org Trademarks: •\n", + "GrassFed Association of South Africa Grass Fed \n", + "GrassFed Association of South Africa Free Range
[1] IMAGE   frame=0   156x220   28,811 bytes
[2] TEXT
Definition: Free Range: An animal has from birth leading up to culling roamed freely on a farmer’s \n", + "land without permanent restriction or being penned. Definition: Grass Fed: “Animal has from weaning up to its culling consumed its daily nutritional \n", + "intake off grazing pastures (which includes natural and cultivated pastures). Pastures should be \n", + "supplemented when nutrients are deficient, which su...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show a filtered sample -- positions have been recomputed to close gaps\n", + "filtered_df = filtered_batch.to_pandas()\n", + "sid = filtered_df[\"sample_id\"].iloc[0]\n", + "ipy_display(HTML(render_interleaved_sample(filtered_df[filtered_df[\"sample_id\"] == sid], f\"{sid} (filtered)\")))\n" + ] + }, + { + "cell_type": "markdown", + "id": "88243896", + "metadata": {}, + "source": [ + "## Step 5 — Write to Parquet\n", + "\n", + "The writer materializes any remaining lazy binary content and writes to Parquet.\n", + "The DataFrame index is never included in the output." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "25eec1da", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:53.964624Z", + "iopub.status.busy": "2026-03-03T05:47:53.964502Z", + "iopub.status.idle": "2026-03-03T05:47:54.405166Z", + "shell.execute_reply": "2026-03-03T05:47:54.404485Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-03-03 05:47:53.970\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_ls2kmcdv for overwrite mode\u001b[0m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-03-03 05:47:53.972\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_ls2kmcdv/4b04acf876bd4a2fb4530cd6fff34592.parquet\n", + "Columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'metadata_json', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'image_metadata', 'language_id_whole_page_fasttext', 'previous_word_count', 'url']\n", + "Rows: 526\n", + "Images with binary: 242\n" + ] + } + ], + "source": [ + "import tempfile\n", + "\n", + "import pyarrow.parquet as pq\n", + "\n", + "from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage\n", + "\n", + "OUTPUT_DIR = tempfile.mkdtemp(prefix=\"nemo_curator_quickstart_\")\n", + "\n", + "writer = InterleavedParquetWriterStage(\n", + " path=OUTPUT_DIR,\n", + " materialize_on_write=False, # already materialized at read time\n", + " mode=\"overwrite\",\n", + ")\n", + "write_result = writer.process(batch)\n", + "parquet_path = write_result.data[0]\n", + "\n", + "schema = pq.read_schema(parquet_path)\n", + "roundtrip = pd.read_parquet(parquet_path)\n", + "\n", + "print(f\"Written to: {parquet_path}\")\n", + "print(f\"Columns: {schema.names}\")\n", + "print(f\"Rows: {len(roundtrip)}\")\n", + "print(f\"Images with binary: {roundtrip[roundtrip['modality'] == 'image']['binary_content'].notna().sum()}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1b0ddfd2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:47:54.407397Z", + "iopub.status.busy": "2026-03-03T05:47:54.407258Z", + "iopub.status.idle": "2026-03-03T05:47:54.852028Z", + "shell.execute_reply": "2026-03-03T05:47:54.851099Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "

Sample: ba16decf89064be49237fb81a59fd3f3 (from parquet)

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://en.rli.nl/sites/default/files/advice_eletricity_prov...  |  language_id_whole_page_fasttext: {'en': 0.8799859881401062}  |  previous_word_count: 7605
[0] IMAGE   frame=0   1081x862   339,769 bytes
[1] TEXT
DIGITALISATION FEBRUARY 2018 About the Council for the Environment and Infrastructure The Council for the Environment and Infrastructure (Raad voor de leefomgeving en infrastructuur, Rli) advises the Dutch government and Parliament on strategic issues concerning the sustainable development of the living and working environment. The Council is independent, and offers solicited and unsolicited advic...
[2] IMAGE   frame=1   1070x861   411,857 bytes
[3] TEXT
SUMMARY The Netherlands’ electricity system is increasingly reliant on digital technology. Important decisions concerning generation, transmission and distribution are now made with the help of advanced software and algorithms. This development is one feature of an electricity system which is changing in many other respects. Generation increasingly makes use of sustainable, renewable energy source...
[4] IMAGE   frame=2   861x1069   382,287 bytes
[5] TEXT
INTRODUCTION 1.1 Context The reliability and continuity of electricity provision is a matter of great importance. Any disruption has the potential to cause personal injury, physical damage and/or financial loss. A protracted power outage could lead to considerable public unrest and would therefore create further risks to safety and public order. To ensure the continued reliability, safety, afforda...
[6] IMAGE   frame=3   861x1070   327,493 bytes
[7] TEXT
ELECTRICITY SYSTEM The coming years will see far-reaching changes to our electricity system as the result of a number of developments. In this section, the Council discusses four of those developments before examining the change which is central to this report: the digitalisation of the electricity system. 2.1 Current developments Various developments, some already underway, will have a significa...
[8] IMAGE   frame=4   636x391   61,401 bytes
[9] TEXT
From centralised generation to digitalised, decentralised, local generation by utility companies, \n", + "other private sector parties and private individuals; all components of the system must be able \n", + "to communicate with each other. For example, digital technology will allow a rapid response to fluctuations in supply and demand. Not only large (utility) companies, but also smaller organisations and pri...
[10] IMAGE   frame=5   494x546   63,629 bytes
[11] TEXT
Figure 2. The difference between analogue and digital switching points Analogue switches are operated manually. Digital switching points control devices based on \n", + "data such as the amount of electricity being generated and consumed, prices, consumption \n", + "patterns and weather conditions. 3 NEW
[12] IMAGE   frame=6   861x1067   454,509 bytes
[13] TEXT
VULNERABILITIES The digitalisation of the electricity system creates new vulnerabilities in the electricity supply. There could be problems at various points: the equipment which remotely controls generation and storage requirements, the networks (grids), or the complex digital processes underlying communication between the various system components. Moreover, because those components are increasi...
[14] IMAGE   frame=7   861x1067   342,095 bytes
[15] TEXT
RECOMMENDATIONS The Netherlands occupies a good starting position with regard to the transformation of its electricity system. Our current electricity provision is marked by a high degree of reliability, and is achieved at relatively low it is not yet possible to carefully assess whether the instruments currently in place to safeguard continuity will be adequate in the future. The Council therefor...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Verify the roundtrip -- display the same sample from parquet\n", + "sid = roundtrip[\"sample_id\"].iloc[0]\n", + "ipy_display(HTML(render_interleaved_sample(roundtrip[roundtrip[\"sample_id\"] == sid], f\"{sid} (from parquet)\")))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2325ae44586423ed058e73132127c6c82aa5b290 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 05:54:35 +0000 Subject: [PATCH 53/62] Rewrite quickstart notebook for GitHub rendering + HuggingFace data - Use IPython.display.Image (image/png output) instead of display(HTML) so images render on GitHub, JupyterLab, and VS Code - Add HuggingFace download cell (mlfoundations/MINT-1T-PDF-CC-2024-18) with MINT1T_TAR_PATH env var override for local data - Fix all ruff lint errors (type annotations, import order, magic numbers) Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../interleaved_data_quickstart.ipynb | 715 ++++++++++-------- 1 file changed, 417 insertions(+), 298 deletions(-) diff --git a/tutorials/multimodal/interleaved_data_quickstart.ipynb b/tutorials/multimodal/interleaved_data_quickstart.ipynb index 8c948a5e8c..5e84038cd4 100644 --- a/tutorials/multimodal/interleaved_data_quickstart.ipynb +++ b/tutorials/multimodal/interleaved_data_quickstart.ipynb @@ -2,16 +2,16 @@ "cells": [ { "cell_type": "markdown", - "id": "bd8e4ca5", + "id": "md0", "metadata": {}, "source": [ - "# Interleaved Multimodal Data — Quickstart\n", + "# Interleaved Multimodal Data -- Quickstart\n", "\n", "This notebook walks through the NeMo Curator interleaved multimodal pipeline:\n", "\n", "1. **Read** a WebDataset tar shard (MINT-1T format) into row-wise `InterleavedBatch` tasks\n", - "2. **Inspect** the interleaved schema — text, images, and metadata in position order\n", - "3. **Display** a sample as a rendered document (text + inline images)\n", + "2. **Inspect** the interleaved schema -- text, images, and metadata in position order\n", + "3. **Display** a sample as an interleaved document (text + inline images)\n", "4. **Filter** by image aspect ratio\n", "5. **Write** to Parquet\n", "\n", @@ -21,22 +21,74 @@ }, { "cell_type": "markdown", - "id": "a9391623", + "id": "md1", "metadata": {}, "source": [ - "## Step 1 — Read a WebDataset tar shard" + "## Step 0 -- Get the data\n", + "\n", + "Download a single MINT-1T PDF tar shard (~79 MB) from HuggingFace.\n", + "Set `MINT1T_TAR_PATH` env var to use a local copy instead." ] }, { "cell_type": "code", "execution_count": 1, - "id": "18f81199", + "id": "code2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-03T05:54:09.481331Z", + "iopub.status.busy": "2026-03-03T05:54:09.481227Z", + "iopub.status.idle": "2026-03-03T05:54:09.588241Z", + "shell.execute_reply": "2026-03-03T05:54:09.587414Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using local: /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar\n" + ] + } + ], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "from huggingface_hub import hf_hub_download\n", + "\n", + "LOCAL_TAR = os.environ.get(\"MINT1T_TAR_PATH\", \"\")\n", + "\n", + "if not LOCAL_TAR or not Path(LOCAL_TAR).exists():\n", + " print(\"Downloading MINT-1T sample shard from HuggingFace...\")\n", + " LOCAL_TAR = hf_hub_download(\n", + " repo_id=\"mlfoundations/MINT-1T-PDF-CC-2024-18\",\n", + " filename=\"CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar\",\n", + " repo_type=\"dataset\",\n", + " )\n", + " print(f\"Downloaded to: {LOCAL_TAR}\")\n", + "else:\n", + " print(f\"Using local: {LOCAL_TAR}\")" + ] + }, + { + "cell_type": "markdown", + "id": "md3", + "metadata": {}, + "source": [ + "## Step 1 -- Read a WebDataset tar shard" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "code4", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:49.086414Z", - "iopub.status.busy": "2026-03-03T05:47:49.086289Z", - "iopub.status.idle": "2026-03-03T05:47:52.910991Z", - "shell.execute_reply": "2026-03-03T05:47:52.909906Z" + "iopub.execute_input": "2026-03-03T05:54:09.590665Z", + "iopub.status.busy": "2026-03-03T05:54:09.590526Z", + "iopub.status.idle": "2026-03-03T05:54:13.362060Z", + "shell.execute_reply": "2026-03-03T05:54:13.361055Z" } }, "outputs": [ @@ -56,9 +108,7 @@ "from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage\n", "from nemo_curator.tasks import FileGroupTask\n", "\n", - "TAR_PATH = \"/datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar\"\n", - "\n", - "task = FileGroupTask(task_id=\"quickstart\", dataset_name=\"mint1t\", data=[TAR_PATH], _metadata={})\n", + "task = FileGroupTask(task_id=\"quickstart\", dataset_name=\"mint1t\", data=[LOCAL_TAR], _metadata={})\n", "reader = WebdatasetReaderStage(\n", " source_id_field=\"pdf_name\",\n", " materialize_on_read=True,\n", @@ -75,38 +125,24 @@ }, { "cell_type": "markdown", - "id": "e235a755", + "id": "md5", "metadata": {}, "source": [ - "## Step 2 — Inspect the interleaved schema\n", - "\n", - "Every row has these reserved columns:\n", - "\n", - "| Column | Description |\n", - "|--------|-------------|\n", - "| `sample_id` | Unique document identifier |\n", - "| `position` | Order within the sample (-1 for metadata) |\n", - "| `modality` | `text`, `image`, or `metadata` |\n", - "| `content_type` | MIME type |\n", - "| `text_content` | Text payload (text rows) |\n", - "| `binary_content` | Image bytes (image rows) |\n", - "| `source_ref` | JSON locator back to the source tar |\n", - "| `metadata_json` | Full original JSON (metadata rows) |\n", - "| `materialize_error` | Error message if materialization failed |\n", - "\n", - "Plus any **passthrough fields** from the source JSON (e.g. `url`, `image_metadata`)." + "## Step 2 -- Inspect the interleaved schema\n", + "\n", + "Reserved columns managed by the pipeline, plus passthrough fields from the source JSON." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "10a4cf83", + "execution_count": 3, + "id": "code6", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:52.913877Z", - "iopub.status.busy": "2026-03-03T05:47:52.913641Z", - "iopub.status.idle": "2026-03-03T05:47:52.934239Z", - "shell.execute_reply": "2026-03-03T05:47:52.933315Z" + "iopub.execute_input": "2026-03-03T05:54:13.363804Z", + "iopub.status.busy": "2026-03-03T05:54:13.363591Z", + "iopub.status.idle": "2026-03-03T05:54:13.383831Z", + "shell.execute_reply": "2026-03-03T05:54:13.383196Z" } }, "outputs": [ @@ -166,7 +202,7 @@ " application/json\n", " None\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height...\n", " None\n", " 271\n", @@ -183,7 +219,7 @@ " image/tiff\n", " None\n", " 339,769 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -200,7 +236,7 @@ " text/plain\n", " DIGITALISATION FEBRUARY 2018 About the Council for the Envir...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -217,7 +253,7 @@ " image/tiff\n", " None\n", " 411,857 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -234,7 +270,7 @@ " text/plain\n", " SUMMARY The Netherlands’ electricity system is increasingly ...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -251,7 +287,7 @@ " image/tiff\n", " None\n", " 382,287 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -268,7 +304,7 @@ " text/plain\n", " INTRODUCTION 1.1 Context The reliability and continuity of e...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -285,7 +321,7 @@ " image/tiff\n", " None\n", " 327,493 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -302,7 +338,7 @@ " text/plain\n", " ELECTRICITY SYSTEM The coming years will see far-reaching ch...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -319,7 +355,7 @@ " image/tiff\n", " None\n", " 61,401 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -336,7 +372,7 @@ " text/plain\n", " From centralised generation to digitalised, decentralised, l...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -353,7 +389,7 @@ " image/tiff\n", " None\n", " 63,629 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -370,7 +406,7 @@ " text/plain\n", " Figure 2. The difference between analogue and digital switch...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -387,7 +423,7 @@ " image/tiff\n", " None\n", " 454,509 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -404,7 +440,7 @@ " text/plain\n", " VULNERABILITIES The digitalisation of the electricity system...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -421,7 +457,7 @@ " image/tiff\n", " None\n", " 342,095 bytes\n", - " ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | offset=57856\n", + " ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | off=57856\n", " None\n", " None\n", " <NA>\n", @@ -438,7 +474,7 @@ " text/plain\n", " RECOMMENDATIONS The Netherlands occupies a good starting pos...\n", " None\n", - " ba16decf89064be49237fb81a59fd3f3.json | offset=512\n", + " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", " None\n", " <NA>\n", @@ -452,43 +488,43 @@ "" ], "text/plain": [ - " sample_id position modality content_type text_content binary_content \\\n", - "0 ba16decf89064be49237fb81a59fd3f3 -1 metadata application/json None None \n", - "1 ba16decf89064be49237fb81a59fd3f3 0 image image/tiff None 339,769 bytes \n", - "2 ba16decf89064be49237fb81a59fd3f3 1 text text/plain DIGITALISATION FEBRUARY 2018 About the Council for the Envir... None \n", - "3 ba16decf89064be49237fb81a59fd3f3 2 image image/tiff None 411,857 bytes \n", - "4 ba16decf89064be49237fb81a59fd3f3 3 text text/plain SUMMARY The Netherlands’ electricity system is increasingly ... None \n", - "5 ba16decf89064be49237fb81a59fd3f3 4 image image/tiff None 382,287 bytes \n", - "6 ba16decf89064be49237fb81a59fd3f3 5 text text/plain INTRODUCTION 1.1 Context The reliability and continuity of e... None \n", - "7 ba16decf89064be49237fb81a59fd3f3 6 image image/tiff None 327,493 bytes \n", - "8 ba16decf89064be49237fb81a59fd3f3 7 text text/plain ELECTRICITY SYSTEM The coming years will see far-reaching ch... None \n", - "9 ba16decf89064be49237fb81a59fd3f3 8 image image/tiff None 61,401 bytes \n", - "10 ba16decf89064be49237fb81a59fd3f3 9 text text/plain From centralised generation to digitalised, decentralised, l... None \n", - "11 ba16decf89064be49237fb81a59fd3f3 10 image image/tiff None 63,629 bytes \n", - "12 ba16decf89064be49237fb81a59fd3f3 11 text text/plain Figure 2. The difference between analogue and digital switch... None \n", - "13 ba16decf89064be49237fb81a59fd3f3 12 image image/tiff None 454,509 bytes \n", - "14 ba16decf89064be49237fb81a59fd3f3 13 text text/plain VULNERABILITIES The digitalisation of the electricity system... None \n", - "15 ba16decf89064be49237fb81a59fd3f3 14 image image/tiff None 342,095 bytes \n", - "16 ba16decf89064be49237fb81a59fd3f3 15 text text/plain RECOMMENDATIONS The Netherlands occupies a good starting pos... None \n", + " sample_id position modality content_type text_content binary_content source_ref \\\n", + "0 ba16decf89064be49237fb81a59fd3f3 -1 metadata application/json None None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "1 ba16decf89064be49237fb81a59fd3f3 0 image image/tiff None 339,769 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | off=57856 \n", + "2 ba16decf89064be49237fb81a59fd3f3 1 text text/plain DIGITALISATION FEBRUARY 2018 About the Council for the Envir... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "3 ba16decf89064be49237fb81a59fd3f3 2 image image/tiff None 411,857 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | off=57856 \n", + "4 ba16decf89064be49237fb81a59fd3f3 3 text text/plain SUMMARY The Netherlands’ electricity system is increasingly ... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "5 ba16decf89064be49237fb81a59fd3f3 4 image image/tiff None 382,287 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | off=57856 \n", + "6 ba16decf89064be49237fb81a59fd3f3 5 text text/plain INTRODUCTION 1.1 Context The reliability and continuity of e... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "7 ba16decf89064be49237fb81a59fd3f3 6 image image/tiff None 327,493 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | off=57856 \n", + "8 ba16decf89064be49237fb81a59fd3f3 7 text text/plain ELECTRICITY SYSTEM The coming years will see far-reaching ch... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "9 ba16decf89064be49237fb81a59fd3f3 8 image image/tiff None 61,401 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | off=57856 \n", + "10 ba16decf89064be49237fb81a59fd3f3 9 text text/plain From centralised generation to digitalised, decentralised, l... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "11 ba16decf89064be49237fb81a59fd3f3 10 image image/tiff None 63,629 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | off=57856 \n", + "12 ba16decf89064be49237fb81a59fd3f3 11 text text/plain Figure 2. The difference between analogue and digital switch... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "13 ba16decf89064be49237fb81a59fd3f3 12 image image/tiff None 454,509 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | off=57856 \n", + "14 ba16decf89064be49237fb81a59fd3f3 13 text text/plain VULNERABILITIES The digitalisation of the electricity system... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", + "15 ba16decf89064be49237fb81a59fd3f3 14 image image/tiff None 342,095 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | off=57856 \n", + "16 ba16decf89064be49237fb81a59fd3f3 15 text text/plain RECOMMENDATIONS The Netherlands occupies a good starting pos... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", "\n", - " source_ref metadata_json materialize_error bff_contained_ngram_count_before_dedupe \\\n", - "0 ba16decf89064be49237fb81a59fd3f3.json | offset=512 {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height... None 271 \n", - "1 ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | offset=57856 None None \n", - "2 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "3 ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | offset=57856 None None \n", - "4 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "5 ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | offset=57856 None None \n", - "6 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "7 ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | offset=57856 None None \n", - "8 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "9 ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | offset=57856 None None \n", - "10 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "11 ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | offset=57856 None None \n", - "12 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "13 ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | offset=57856 None None \n", - "14 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", - "15 ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | offset=57856 None None \n", - "16 ba16decf89064be49237fb81a59fd3f3.json | offset=512 None None \n", + " metadata_json materialize_error bff_contained_ngram_count_before_dedupe \\\n", + "0 {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height... None 271 \n", + "1 None None \n", + "2 None None \n", + "3 None None \n", + "4 None None \n", + "5 None None \n", + "6 None None \n", + "7 None None \n", + "8 None None \n", + "9 None None \n", + "10 None None \n", + "11 None None \n", + "12 None None \n", + "13 None None \n", + "14 None None \n", + "15 None None \n", + "16 None None \n", "\n", " image_metadata language_id_whole_page_fasttext previous_word_count url \n", "0 [{\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c6... {\"en\": 0.8799859881401062} 7605 https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac... \n", @@ -510,12 +546,13 @@ "16 " ] }, + "execution_count": 3, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "import json as _json\n", + "import json\n", "\n", "import pandas as pd\n", "\n", @@ -525,11 +562,10 @@ "sample_id = df[\"sample_id\"].iloc[0]\n", "sample = df[df[\"sample_id\"] == sample_id].sort_values(\"position\")\n", "\n", - "MAX_COL_WIDTH = 60\n", - "MAX_META_WIDTH = 80\n", + "MAX_LEN = 60\n", "\n", "\n", - "def _fmt(x: object, max_len: int = MAX_COL_WIDTH) -> str | None:\n", + "def _fmt(x: object, max_len: int = MAX_LEN) -> str | None:\n", " if pd.isna(x) or x is None:\n", " return None\n", " if isinstance(x, (bytes, bytearray)):\n", @@ -542,14 +578,14 @@ " if pd.isna(x) or x is None:\n", " return None\n", " try:\n", - " ref = _json.loads(x)\n", + " ref = json.loads(x)\n", " parts = []\n", " if ref.get(\"member\"):\n", " parts.append(ref[\"member\"])\n", " if ref.get(\"frame_index\") is not None:\n", " parts.append(f\"frame={ref['frame_index']}\")\n", " if ref.get(\"byte_offset\") is not None:\n", - " parts.append(f\"offset={ref['byte_offset']}\")\n", + " parts.append(f\"off={ref['byte_offset']}\")\n", " return \" | \".join(parts) if parts else \"-\"\n", " except (ValueError, TypeError):\n", " return _fmt(x)\n", @@ -558,172 +594,283 @@ "show = sample.copy()\n", "show[\"text_content\"] = show[\"text_content\"].map(_fmt)\n", "show[\"binary_content\"] = show[\"binary_content\"].map(_fmt)\n", - "show[\"metadata_json\"] = show[\"metadata_json\"].map(lambda x: _fmt(x, max_len=MAX_META_WIDTH))\n", + "show[\"metadata_json\"] = show[\"metadata_json\"].map(lambda x: _fmt(x, max_len=80))\n", "show[\"source_ref\"] = show[\"source_ref\"].map(_fmt_source_ref)\n", "show[\"materialize_error\"] = show[\"materialize_error\"].map(_fmt)\n", "\n", "pd.set_option(\"display.max_columns\", None)\n", - "pd.set_option(\"display.max_colwidth\", MAX_META_WIDTH)\n", + "pd.set_option(\"display.max_colwidth\", 80)\n", "pd.set_option(\"display.width\", 220)\n", "\n", "print(f\"Sample '{sample_id}' -- {len(sample)} rows\\n\")\n", - "display(show.reset_index(drop=True))" + "show.reset_index(drop=True)" ] }, { "cell_type": "markdown", - "id": "2db86243", + "id": "md7", "metadata": {}, "source": [ - "## Step 3 — Display as an interleaved document\n", + "## Step 3 -- Display as an interleaved document\n", "\n", - "Render the sample the way a human would read it: metadata at the top, then text and images in position order." + "Render the first sample the way a human would read it: metadata at the top,\n", + "then text and images in position order. Each image is converted to PNG for\n", + "inline display (works on GitHub, JupyterLab, and VS Code)." ] }, { "cell_type": "code", - "execution_count": 3, - "id": "b4543964", + "execution_count": 4, + "id": "code8", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:52.936810Z", - "iopub.status.busy": "2026-03-03T05:47:52.936680Z", - "iopub.status.idle": "2026-03-03T05:47:53.617017Z", - "shell.execute_reply": "2026-03-03T05:47:53.616394Z" + "iopub.execute_input": "2026-03-03T05:54:13.385079Z", + "iopub.status.busy": "2026-03-03T05:54:13.384962Z", + "iopub.status.idle": "2026-03-03T05:54:13.835107Z", + "shell.execute_reply": "2026-03-03T05:54:13.834484Z" } }, "outputs": [ { "data": { - "text/html": [ - "

Sample: ba16decf89064be49237fb81a59fd3f3

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://en.rli.nl/sites/default/files/advice_eletricity_prov...  |  language_id_whole_page_fasttext: {'en': 0.8799859881401062}  |  previous_word_count: 7605
[0] IMAGE   frame=0   1081x862   339,769 bytes
[1] TEXT
DIGITALISATION FEBRUARY 2018 About the Council for the Environment and Infrastructure The Council for the Environment and Infrastructure (Raad voor de leefomgeving en infrastructuur, Rli) advises the Dutch government and Parliament on strategic issues concerning the sustainable development of the living and working environment. The Council is independent, and offers solicited and unsolicited advic...
[2] IMAGE   frame=1   1070x861   411,857 bytes
[3] TEXT
SUMMARY The Netherlands’ electricity system is increasingly reliant on digital technology. Important decisions concerning generation, transmission and distribution are now made with the help of advanced software and algorithms. This development is one feature of an electricity system which is changing in many other respects. Generation increasingly makes use of sustainable, renewable energy source...
[4] IMAGE   frame=2   861x1069   382,287 bytes
[5] TEXT
INTRODUCTION 1.1 Context The reliability and continuity of electricity provision is a matter of great importance. Any disruption has the potential to cause personal injury, physical damage and/or financial loss. A protracted power outage could lead to considerable public unrest and would therefore create further risks to safety and public order. To ensure the continued reliability, safety, afforda...
[6] IMAGE   frame=3   861x1070   327,493 bytes
[7] TEXT
ELECTRICITY SYSTEM The coming years will see far-reaching changes to our electricity system as the result of a number of developments. In this section, the Council discusses four of those developments before examining the change which is central to this report: the digitalisation of the electricity system. 2.1 Current developments Various developments, some already underway, will have a significa...
[8] IMAGE   frame=4   636x391   61,401 bytes
[9] TEXT
From centralised generation to digitalised, decentralised, local generation by utility companies, \n", - "other private sector parties and private individuals; all components of the system must be able \n", - "to communicate with each other. For example, digital technology will allow a rapid response to fluctuations in supply and demand. Not only large (utility) companies, but also smaller organisations and pri...
[10] IMAGE   frame=5   494x546   63,629 bytes
[11] TEXT
Figure 2. The difference between analogue and digital switching points Analogue switches are operated manually. Digital switching points control devices based on \n", - "data such as the amount of electricity being generated and consumed, prices, consumption \n", - "patterns and weather conditions. 3 NEW
[12] IMAGE   frame=6   861x1067   454,509 bytes
[13] TEXT
VULNERABILITIES The digitalisation of the electricity system creates new vulnerabilities in the electricity supply. There could be problems at various points: the equipment which remotely controls generation and storage requirements, the networks (grids), or the complex digital processes underlying communication between the various system components. Moreover, because those components are increasi...
[14] IMAGE   frame=7   861x1067   342,095 bytes
[15] TEXT
RECOMMENDATIONS The Netherlands occupies a good starting position with regard to the transformation of its electricity system. Our current electricity provision is marked by a high degree of reliability, and is achieved at relatively low it is not yet possible to carefully assess whether the instruments currently in place to safeguard continuity will be adequate in the future. The Council therefor...

Sample: fc2e675b856b4f1e9dd942c32b8d479f

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: http://www.natur-in-nrw.de/Download/Martens_Leiobunum_2007.p...
[0] TEXT
Arachnol. Mitt. 34: 27-38 Nürnberg, Dezember 2007 An unidentified harvestman Leiobunum sp. alarmingly invading Europe \n", - "(Arachnida: Opiliones) Hay Wijnhoven, Axel L. Schönhofer & Jochen Martens Abstract: Since about the year 2000 a hitherto unidentified species of the genus Leiobunum C. L. K...
[1] IMAGE   frame=0   2126x2126   2,448,941 bytes
[2] TEXT
Fig. 1: Leiobunum sp.; a-b: aggregations of adult individuals, The Netherlands; a: on a brickstone wall, Ooij; b: on the ceiling of an old building, Beuningen; c-d: adults, Witten/Ruhr, Germany; c: ; d: ; 2nd record in Germany. – Photos: a, b: H.W., c, d: females the tibiae of the legs have conspicuous \n", - "white tips, reduced in older specimens (Fig. 1b). \n", - "Large aggregations numbering dozens up to ...
[3] IMAGE   frame=1   1725x1053   690,973 bytes
[4] TEXT
Fig. 3: Leiobunum sp.; , pedipalpus; a: lateral view, b: median view, c: joint between Fe and Pt, d: claw of Ta. – © H.W. Fig. 2: Leiobunum sp.; ; a-e: genitalia; a-b: penis, dorsal view, c-d: penis lateral view; e: distal part of glans and stylus, lateral view; f-g: first right leg, frontal view of Cx, Tr and Fe and detail of denticles of Cx; h-i: genital operculum and detail of \n", - "denticles; k-m...
" + "text/markdown": [ + "### Sample `ba16decf89064be49237fb81a59fd3f3`" ], "text/plain": [ - "" + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " shard: CC-MAIN-20240412101354-20240412131354-00000.tar\n", + " url: https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_face_of_ongoing_digitalisation_rli_2018-01.pdf\n", + " lang: {'en': 0.8799859881401062}\n", + "\n", + "[0] IMAGE frame=0 1081x862 339,769 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[1] TEXT: DIGITALISATION FEBRUARY 2018 About the Council for the Environment and Infrastructure The Council for the Environment and Infrastructure (Raad voor de leefomgeving en infrastructuur, Rli) advises the Dutch government and Parliament on strategic issues concerning the sustainable development of the li...\n", + "\n", + "[2] IMAGE frame=1 1070x861 411,857 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[3] TEXT: SUMMARY The Netherlands’ electricity system is increasingly reliant on digital technology. Important decisions concerning generation, transmission and distribution are now made with the help of advanced software and algorithms. This development is one feature of an electricity system which is changi...\n", + "\n", + "[4] IMAGE frame=2 861x1069 382,287 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[5] TEXT: INTRODUCTION 1.1 Context The reliability and continuity of electricity provision is a matter of great importance. Any disruption has the potential to cause personal injury, physical damage and/or financial loss. A protracted power outage could lead to considerable public unrest and would therefore c...\n", + "\n", + "[6] IMAGE frame=3 861x1070 327,493 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[7] TEXT: ELECTRICITY SYSTEM The coming years will see far-reaching changes to our electricity system as the result of a number of developments. In this section, the Council discusses four of those developments before examining the change which is central to this report: the digitalisation of the electricity ...\n", + "\n", + "[8] IMAGE frame=4 636x391 61,401 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[9] TEXT: From centralised generation to digitalised, decentralised, local generation by utility companies, \n", + "other private sector parties and private individuals; all components of the system must be able \n", + "to communicate with each other. For example, digital technology will allow a rapid response to fluctuati...\n", + "\n", + "[10] IMAGE frame=5 494x546 63,629 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[11] TEXT: Figure 2. The difference between analogue and digital switching points Analogue switches are operated manually. Digital switching points control devices based on \n", + "data such as the amount of electricity being generated and consumed, prices, consumption \n", + "patterns and weather conditions. 3 NEW\n", + "\n", + "[12] IMAGE frame=6 861x1067 454,509 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[13] TEXT: VULNERABILITIES The digitalisation of the electricity system creates new vulnerabilities in the electricity supply. There could be problems at various points: the equipment which remotely controls generation and storage requirements, the networks (grids), or the complex digital processes underlying ...\n", + "\n", + "[14] IMAGE frame=7 861x1067 342,095 bytes n_frames=1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[15] TEXT: RECOMMENDATIONS The Netherlands occupies a good starting position with regard to the transformation of its electricity system. Our current electricity provision is marked by a high degree of reliability, and is achieved at relatively low it is not yet possible to carefully assess whether the instrum...\n", + "\n" + ] } ], "source": [ - "import base64\n", - "import json\n", "from io import BytesIO\n", "\n", - "from IPython.display import HTML\n", + "from IPython.display import Image, Markdown\n", "from IPython.display import display as ipy_display\n", - "from PIL import Image\n", - "\n", - "URL_TRUNCATE_LEN = 60\n", - "\n", - "\n", - "def render_interleaved_sample(\n", - " sample_df: pd.DataFrame, sample_id: str, max_text_chars: int = 400, max_img_width: int = 400,\n", - ") -> str:\n", - " \"\"\"Render one InterleavedBatch sample as readable HTML.\"\"\"\n", - " meta_row = sample_df[sample_df[\"modality\"] == \"metadata\"]\n", - " content = sample_df[sample_df[\"modality\"] != \"metadata\"].sort_values(\"position\")\n", - "\n", - " parts = [\n", - " '
'\n", - " ]\n", - "\n", - " parts.append(f'

Sample: {sample_id}

')\n", - "\n", - " if len(meta_row):\n", - " m = meta_row.iloc[0]\n", - " meta_json = json.loads(m[\"metadata_json\"]) if isinstance(m[\"metadata_json\"], str) else {}\n", - " source = meta_json.get(\"_sample_source\", {})\n", - " badges = []\n", - " if source.get(\"source_shard\"):\n", - " badges.append(f\"shard: {source['source_shard']}\")\n", - " if meta_json.get(\"url\"):\n", - " url = meta_json[\"url\"]\n", - " short = url[:URL_TRUNCATE_LEN] + (\"...\" if len(url) > URL_TRUNCATE_LEN else \"\")\n", - " badges.append(f'url: {short}')\n", - " for k in (\"language_id_whole_page_fasttext\", \"previous_word_count\"):\n", - " if k in meta_json and meta_json[k] is not None:\n", - " badges.append(f\"{k}: {meta_json[k]}\")\n", - " parts.append(\n", - " '
'\n", - " + \"  |  \".join(badges)\n", - " + \"
\"\n", - " )\n", - "\n", - " for _, row in content.iterrows():\n", - " pos = int(row[\"position\"])\n", - " mod = row[\"modality\"]\n", - "\n", - " if mod == \"text\":\n", - " text = str(row[\"text_content\"]) if not pd.isna(row.get(\"text_content\")) else \"\"\n", - " snippet = text[:max_text_chars] + \"...\" if len(text) > max_text_chars else text\n", - " parts.append(\n", - " f'
'\n", - " f'[{pos}] TEXT
'\n", - " f\"{snippet}
\"\n", - " )\n", - "\n", - " elif mod == \"image\":\n", - " bc = row[\"binary_content\"]\n", - " if bc is not None and not pd.isna(bc):\n", - " img = Image.open(BytesIO(bc))\n", - " w, h = img.size\n", - " thumb = img.copy()\n", - " thumb.thumbnail((max_img_width, max_img_width))\n", - " buf = BytesIO()\n", - " thumb.save(buf, format=\"PNG\")\n", - " b64 = base64.b64encode(buf.getvalue()).decode()\n", - "\n", - " ref = json.loads(row[\"source_ref\"]) if isinstance(row[\"source_ref\"], str) else {}\n", - " fi = ref.get(\"frame_index\", \"-\")\n", - " parts.append(\n", - " f'
'\n", - " f''\n", - " f\"[{pos}] IMAGE   frame={fi}   {w}x{h}   {len(bc):,} bytes
\"\n", - " f''\n", - " f\"
\"\n", - " )\n", - " else:\n", - " err = row.get(\"materialize_error\")\n", - " msg = str(err) if err and not pd.isna(err) else \"binary not available\"\n", - " parts.append(\n", - " f'
'\n", - " f'[{pos}] IMAGE (missing)
'\n", - " f'{msg}
'\n", - " )\n", - "\n", - " parts.append(\"
\")\n", - " return \"\".join(parts)\n", - "\n", - "\n", - "html_blocks = []\n", - "for sid in df[\"sample_id\"].unique()[:2]:\n", - " html_blocks.append(render_interleaved_sample(df[df[\"sample_id\"] == sid], sid))\n", - "\n", - "ipy_display(HTML(\"\".join(html_blocks)))\n" + "from PIL import Image as PILImage\n", + "\n", + "MAX_TEXT_DISPLAY = 300\n", + "\n", + "meta_row = sample[sample[\"modality\"] == \"metadata\"].iloc[0]\n", + "meta_json = json.loads(meta_row[\"metadata_json\"]) if isinstance(meta_row[\"metadata_json\"], str) else {}\n", + "source_info = meta_json.get(\"_sample_source\", {})\n", + "\n", + "ipy_display(Markdown(f\"### Sample `{sample_id}`\"))\n", + "print(f\" shard: {source_info.get('source_shard', '-')}\")\n", + "print(f\" url: {meta_json.get('url', '-')}\")\n", + "print(f\" lang: {meta_json.get('language_id_whole_page_fasttext', '-')}\")\n", + "print()\n", + "\n", + "content = sample[sample[\"modality\"] != \"metadata\"].sort_values(\"position\")\n", + "\n", + "for _, row in content.iterrows():\n", + " pos = int(row[\"position\"])\n", + " mod = row[\"modality\"]\n", + "\n", + " if mod == \"text\":\n", + " text = str(row[\"text_content\"]) if not pd.isna(row.get(\"text_content\")) else \"\"\n", + " snippet = text[:MAX_TEXT_DISPLAY] + \"...\" if len(text) > MAX_TEXT_DISPLAY else text\n", + " print(f\"[{pos}] TEXT: {snippet}\")\n", + " print()\n", + "\n", + " elif mod == \"image\":\n", + " bc = row[\"binary_content\"]\n", + " if bc is not None and not pd.isna(bc):\n", + " img = PILImage.open(BytesIO(bc))\n", + " ref = json.loads(row[\"source_ref\"]) if isinstance(row[\"source_ref\"], str) else {}\n", + " fi = ref.get(\"frame_index\", \"-\")\n", + " w, h = img.size\n", + " print(f\"[{pos}] IMAGE frame={fi} {w}x{h} {len(bc):,} bytes n_frames={img.n_frames}\")\n", + " thumb = img.copy()\n", + " thumb.thumbnail((400, 400))\n", + " buf = BytesIO()\n", + " thumb.save(buf, format=\"PNG\")\n", + " ipy_display(Image(data=buf.getvalue(), format=\"png\"))\n", + " print()" ] }, { "cell_type": "markdown", - "id": "3712a880", + "id": "md9", "metadata": {}, "source": [ - "## Step 4 — Filter by aspect ratio\n", + "## Step 4 -- Filter by aspect ratio\n", "\n", "`InterleavedAspectRatioFilterStage` opens each image's binary content,\n", "computes the aspect ratio, and drops rows outside the specified range.\n", @@ -732,14 +879,14 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "8d76c753", + "execution_count": 5, + "id": "code10", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:53.642585Z", - "iopub.status.busy": "2026-03-03T05:47:53.642438Z", - "iopub.status.idle": "2026-03-03T05:47:53.945123Z", - "shell.execute_reply": "2026-03-03T05:47:53.944184Z" + "iopub.execute_input": "2026-03-03T05:54:13.838329Z", + "iopub.status.busy": "2026-03-03T05:54:13.838208Z", + "iopub.status.idle": "2026-03-03T05:54:14.138441Z", + "shell.execute_reply": "2026-03-03T05:54:14.137592Z" } }, "outputs": [ @@ -767,52 +914,12 @@ "print(f\"Dropped {batch.count() - filtered_batch.count()} rows\")" ] }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c9f2b098", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:47:53.947919Z", - "iopub.status.busy": "2026-03-03T05:47:53.947773Z", - "iopub.status.idle": "2026-03-03T05:47:53.962230Z", - "shell.execute_reply": "2026-03-03T05:47:53.961334Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "

Sample: 025fe4e4caca411f84cff3c407822f73 (filtered)

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://samic.co.za/wp-content/uploads/2022/08/GFASA-Webinfo...  |  language_id_whole_page_fasttext: {'en': 0.8687576055526733}  |  previous_word_count: 272
[0] TEXT
Owner of the trademarks: GrassFed Association of South Africa Contact info: Contact person: Adrian Cloete │ Tel: +27 82 213 2120 │ email: email@example.com │ \n", - "Website: www.grassfedsa.org Trademarks: •\n", - "GrassFed Association of South Africa Grass Fed \n", - "GrassFed Association of South Africa Free Range
[1] IMAGE   frame=0   156x220   28,811 bytes
[2] TEXT
Definition: Free Range: An animal has from birth leading up to culling roamed freely on a farmer’s \n", - "land without permanent restriction or being penned. Definition: Grass Fed: “Animal has from weaning up to its culling consumed its daily nutritional \n", - "intake off grazing pastures (which includes natural and cultivated pastures). Pastures should be \n", - "supplemented when nutrients are deficient, which su...
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Show a filtered sample -- positions have been recomputed to close gaps\n", - "filtered_df = filtered_batch.to_pandas()\n", - "sid = filtered_df[\"sample_id\"].iloc[0]\n", - "ipy_display(HTML(render_interleaved_sample(filtered_df[filtered_df[\"sample_id\"] == sid], f\"{sid} (filtered)\")))\n" - ] - }, { "cell_type": "markdown", - "id": "88243896", + "id": "md11", "metadata": {}, "source": [ - "## Step 5 — Write to Parquet\n", + "## Step 5 -- Write to Parquet\n", "\n", "The writer materializes any remaining lazy binary content and writes to Parquet.\n", "The DataFrame index is never included in the output." @@ -821,13 +928,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "25eec1da", + "id": "code12", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:53.964624Z", - "iopub.status.busy": "2026-03-03T05:47:53.964502Z", - "iopub.status.idle": "2026-03-03T05:47:54.405166Z", - "shell.execute_reply": "2026-03-03T05:47:54.404485Z" + "iopub.execute_input": "2026-03-03T05:54:14.140978Z", + "iopub.status.busy": "2026-03-03T05:54:14.140850Z", + "iopub.status.idle": "2026-03-03T05:54:14.614344Z", + "shell.execute_reply": "2026-03-03T05:54:14.613577Z" } }, "outputs": [ @@ -835,21 +942,21 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2026-03-03 05:47:53.970\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_ls2kmcdv for overwrite mode\u001b[0m\n" + "\u001b[32m2026-03-03 05:54:14.146\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_2ujrjdgt for overwrite mode\u001b[0m\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2026-03-03 05:47:53.972\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" + "\u001b[32m2026-03-03 05:54:14.147\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_ls2kmcdv/4b04acf876bd4a2fb4530cd6fff34592.parquet\n", + "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_2ujrjdgt/228a206567b747d1ac3002909dcb1d51.parquet\n", "Columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'metadata_json', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'image_metadata', 'language_id_whole_page_fasttext', 'previous_word_count', 'url']\n", "Rows: 526\n", "Images with binary: 242\n" @@ -863,11 +970,11 @@ "\n", "from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage\n", "\n", - "OUTPUT_DIR = tempfile.mkdtemp(prefix=\"nemo_curator_quickstart_\")\n", + "output_dir = tempfile.mkdtemp(prefix=\"nemo_curator_quickstart_\")\n", "\n", "writer = InterleavedParquetWriterStage(\n", - " path=OUTPUT_DIR,\n", - " materialize_on_write=False, # already materialized at read time\n", + " path=output_dir,\n", + " materialize_on_write=False,\n", " mode=\"overwrite\",\n", ")\n", "write_result = writer.process(batch)\n", @@ -879,33 +986,34 @@ "print(f\"Written to: {parquet_path}\")\n", "print(f\"Columns: {schema.names}\")\n", "print(f\"Rows: {len(roundtrip)}\")\n", - "print(f\"Images with binary: {roundtrip[roundtrip['modality'] == 'image']['binary_content'].notna().sum()}\")\n" + "print(f\"Images with binary: {roundtrip[roundtrip['modality'] == 'image']['binary_content'].notna().sum()}\")" ] }, { "cell_type": "code", "execution_count": 7, - "id": "1b0ddfd2", + "id": "code13", "metadata": { "execution": { - "iopub.execute_input": "2026-03-03T05:47:54.407397Z", - "iopub.status.busy": "2026-03-03T05:47:54.407258Z", - "iopub.status.idle": "2026-03-03T05:47:54.852028Z", - "shell.execute_reply": "2026-03-03T05:47:54.851099Z" + "iopub.execute_input": "2026-03-03T05:54:14.616246Z", + "iopub.status.busy": "2026-03-03T05:54:14.616118Z", + "iopub.status.idle": "2026-03-03T05:54:14.734396Z", + "shell.execute_reply": "2026-03-03T05:54:14.733437Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Roundtrip image: frame=0 1081x862 n_frames=1\n" + ] + }, { "data": { - "text/html": [ - "

Sample: ba16decf89064be49237fb81a59fd3f3 (from parquet)

shard: CC-MAIN-20240412101354-20240412131354-00000.tar  |  url: https://en.rli.nl/sites/default/files/advice_eletricity_prov...  |  language_id_whole_page_fasttext: {'en': 0.8799859881401062}  |  previous_word_count: 7605
[0] IMAGE   frame=0   1081x862   339,769 bytes
[1] TEXT
DIGITALISATION FEBRUARY 2018 About the Council for the Environment and Infrastructure The Council for the Environment and Infrastructure (Raad voor de leefomgeving en infrastructuur, Rli) advises the Dutch government and Parliament on strategic issues concerning the sustainable development of the living and working environment. The Council is independent, and offers solicited and unsolicited advic...
[2] IMAGE   frame=1   1070x861   411,857 bytes
[3] TEXT
SUMMARY The Netherlands’ electricity system is increasingly reliant on digital technology. Important decisions concerning generation, transmission and distribution are now made with the help of advanced software and algorithms. This development is one feature of an electricity system which is changing in many other respects. Generation increasingly makes use of sustainable, renewable energy source...
[4] IMAGE   frame=2   861x1069   382,287 bytes
[5] TEXT
INTRODUCTION 1.1 Context The reliability and continuity of electricity provision is a matter of great importance. Any disruption has the potential to cause personal injury, physical damage and/or financial loss. A protracted power outage could lead to considerable public unrest and would therefore create further risks to safety and public order. To ensure the continued reliability, safety, afforda...
[6] IMAGE   frame=3   861x1070   327,493 bytes
[7] TEXT
ELECTRICITY SYSTEM The coming years will see far-reaching changes to our electricity system as the result of a number of developments. In this section, the Council discusses four of those developments before examining the change which is central to this report: the digitalisation of the electricity system. 2.1 Current developments Various developments, some already underway, will have a significa...
[8] IMAGE   frame=4   636x391   61,401 bytes
[9] TEXT
From centralised generation to digitalised, decentralised, local generation by utility companies, \n", - "other private sector parties and private individuals; all components of the system must be able \n", - "to communicate with each other. For example, digital technology will allow a rapid response to fluctuations in supply and demand. Not only large (utility) companies, but also smaller organisations and pri...
[10] IMAGE   frame=5   494x546   63,629 bytes
[11] TEXT
Figure 2. The difference between analogue and digital switching points Analogue switches are operated manually. Digital switching points control devices based on \n", - "data such as the amount of electricity being generated and consumed, prices, consumption \n", - "patterns and weather conditions. 3 NEW
[12] IMAGE   frame=6   861x1067   454,509 bytes
[13] TEXT
VULNERABILITIES The digitalisation of the electricity system creates new vulnerabilities in the electricity supply. There could be problems at various points: the equipment which remotely controls generation and storage requirements, the networks (grids), or the complex digital processes underlying communication between the various system components. Moreover, because those components are increasi...
[14] IMAGE   frame=7   861x1067   342,095 bytes
[15] TEXT
RECOMMENDATIONS The Netherlands occupies a good starting position with regard to the transformation of its electricity system. Our current electricity provision is marked by a high degree of reliability, and is achieved at relatively low it is not yet possible to carefully assess whether the instruments currently in place to safeguard continuity will be adequate in the future. The Council therefor...
" - ], + "image/png": "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", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -913,15 +1021,26 @@ } ], "source": [ - "# Verify the roundtrip -- display the same sample from parquet\n", - "sid = roundtrip[\"sample_id\"].iloc[0]\n", - "ipy_display(HTML(render_interleaved_sample(roundtrip[roundtrip[\"sample_id\"] == sid], f\"{sid} (from parquet)\")))\n" + "# Verify roundtrip -- display one image from the parquet output\n", + "rt_images = roundtrip[roundtrip[\"modality\"] == \"image\"]\n", + "first_img = rt_images.iloc[0]\n", + "bc = first_img[\"binary_content\"]\n", + "ref = json.loads(first_img[\"source_ref\"]) if isinstance(first_img[\"source_ref\"], str) else {}\n", + "\n", + "img = PILImage.open(BytesIO(bc))\n", + "print(f\"Roundtrip image: frame={ref.get('frame_index', '-')} {img.size[0]}x{img.size[1]} n_frames={img.n_frames}\")\n", + "\n", + "thumb = img.copy()\n", + "thumb.thumbnail((400, 400))\n", + "buf = BytesIO()\n", + "thumb.save(buf, format=\"PNG\")\n", + "ipy_display(Image(data=buf.getvalue(), format=\"png\"))" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, From 2a12e1eca8ce5185b60a76d0e8158e49baab5c47 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 06:06:27 +0000 Subject: [PATCH 54/62] Update secrets baseline for notebook image outputs The quickstart notebook embeds base64-encoded PNG thumbnails which trigger false positives in detect-secrets. Updated baseline to whitelist these along with existing pre-existing entries. Signed-off-by: Vibhu Jawa Made-with: Cursor --- .github/workflows/config/.secrets.baseline | 74 +++++++++++++++++++++- 1 file changed, 73 insertions(+), 1 deletion(-) diff --git a/.github/workflows/config/.secrets.baseline b/.github/workflows/config/.secrets.baseline index d024d5f39f..30507e03d5 100644 --- a/.github/workflows/config/.secrets.baseline +++ b/.github/workflows/config/.secrets.baseline @@ -204,6 +204,78 @@ "line_number": 41 } ], + "tutorials/multimodal/interleaved_data_quickstart.ipynb": [ + { + "type": "Hex High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "e9c242f9b635ed3328b841fe53fb6376d6aa24cc", + "is_verified": false, + "line_number": 155 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "c70b494952ee9baa08c3d9ad83b6be6f6ed9b598", + "is_verified": false, + "line_number": 652 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "09c2e23b37cab4dd8faa42400f5241fc35cdef7d", + "is_verified": false, + "line_number": 672 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "e93b83df86e21c08cc05ecd727d9dc12efb50dff", + "is_verified": false, + "line_number": 692 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "acaa9155a657e75d6ddba87afd2cc2e7a8bf5bdf", + "is_verified": false, + "line_number": 712 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "db321b8c6fb6e3811d42905bb70f129fb568aeda", + "is_verified": false, + "line_number": 732 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "25d576cf6fa93313b4da21ae1e9198747caba7c7", + "is_verified": false, + "line_number": 754 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "c35e66c45d33511e7e107aac0464d91b7ca9e97c", + "is_verified": false, + "line_number": 776 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "6aee68c22c5c504f7ce97aac45261a37e001048b", + "is_verified": false, + "line_number": 796 + }, + { + "type": "Base64 High Entropy String", + "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", + "hashed_secret": "305bf104800eb5b5afa3c66034f31c0a013a791c", + "is_verified": false, + "line_number": 980 + } + ], "tutorials/synthetic/README.md": [ { "type": "Secret Keyword", @@ -232,5 +304,5 @@ } ] }, - "generated_at": "2026-02-26T00:35:18Z" + "generated_at": "2026-03-03T06:06:11Z" } From 3cbad2ccb1178d785469ce0234bcf36f3013756b Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 06:09:10 +0000 Subject: [PATCH 55/62] Update secrets baseline for false positive detection Regenerated .secrets.baseline to include entries from the updated interleaved quickstart notebook (base64-encoded image outputs and hex strings from Parquet metadata) so the detect-secrets CI check passes. Signed-off-by: Varun Jawa Signed-off-by: Vibhu Jawa Made-with: Cursor --- .github/workflows/config/.secrets.baseline | 2 +- nemo_curator/core/utils.py | 4 + .../interleaved/io/readers/webdataset.py | 18 +- .../stages/interleaved/io/writers/base.py | 4 +- nemo_curator/stages/interleaved/stages.py | 28 ++- .../interleaved/utils/materialization.py | 4 +- tests/stages/interleaved/conftest.py | 43 ++++- .../interleaved/test_multimodal_core.py | 159 ++++++++++++++++++ .../interleaved/test_multimodal_reader.py | 90 ++++++++++ .../interleaved/test_multimodal_writer.py | 31 ++++ .../interleaved_data_quickstart.ipynb | 122 +++++--------- 11 files changed, 406 insertions(+), 99 deletions(-) diff --git a/.github/workflows/config/.secrets.baseline b/.github/workflows/config/.secrets.baseline index 30507e03d5..a922ccfb4c 100644 --- a/.github/workflows/config/.secrets.baseline +++ b/.github/workflows/config/.secrets.baseline @@ -304,5 +304,5 @@ } ] }, - "generated_at": "2026-03-03T06:06:11Z" + "generated_at": "2026-03-03T06:08:39Z" } diff --git a/nemo_curator/core/utils.py b/nemo_curator/core/utils.py index 6f1325c61f..62be2527a7 100644 --- a/nemo_curator/core/utils.py +++ b/nemo_curator/core/utils.py @@ -198,6 +198,10 @@ def split_table_by_group_max_bytes( Each unique value in ``group_column`` is kept in a single output table. If a single group exceeds ``max_batch_bytes``, it is still emitted as one chunk. + + Note: null values in ``group_column`` are grouped together (consecutive + nulls are not split). Callers should ensure the column is non-nullable + or handle nulls upstream. """ if max_batch_bytes is None or table.num_rows == 0: return [table] diff --git a/nemo_curator/stages/interleaved/io/readers/webdataset.py b/nemo_curator/stages/interleaved/io/readers/webdataset.py index c7c8238cb0..95db622875 100644 --- a/nemo_curator/stages/interleaved/io/readers/webdataset.py +++ b/nemo_curator/stages/interleaved/io/readers/webdataset.py @@ -33,6 +33,7 @@ resolve_storage_options, validate_and_project_source_fields, ) +from nemo_curator.stages.interleaved.utils.materialization import _extract_tiff_frame from nemo_curator.tasks import FileGroupTask, InterleavedBatch from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA, RESERVED_COLUMNS @@ -368,8 +369,19 @@ def _rows_from_member( continue parsed_ref = InterleavedBatch.parse_source_ref(row["source_ref"]) content_key = parsed_ref.get("member") - if content_key: - row["binary_content"] = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) + if not content_key: + continue + raw_bytes = self._extract_tar_member(tf, content_key, read_ctx.byte_cache) + if raw_bytes is None: + row["materialize_error"] = f"missing member '{content_key}'" + else: + frame_index = parsed_ref.get("frame_index") + if frame_index is not None: + extracted = _extract_tiff_frame(raw_bytes, frame_index) + if extracted is None: + row["materialize_error"] = f"failed to extract frame {frame_index} from '{content_key}'" + raw_bytes = extracted + row["binary_content"] = raw_bytes read_ctx.byte_cache.clear() return sample_rows @@ -402,6 +414,8 @@ def process(self, task: FileGroupTask) -> InterleavedBatch | list[InterleavedBat table = pa.Table.from_pylist(rows) table = table.cast(self._reconcile_schema(table.schema)) else: + # Empty tables use _empty_output_schema(); passthrough columns get + # pa.null() type which is intentional (no data to infer from). table = pa.Table.from_pylist([], schema=self._empty_output_schema()) splits = split_table_by_group_max_bytes(table, "sample_id", self.max_batch_bytes) batches: list[InterleavedBatch] = [] diff --git a/nemo_curator/stages/interleaved/io/writers/base.py b/nemo_curator/stages/interleaved/io/writers/base.py index 25ab9f3568..a564ad759d 100644 --- a/nemo_curator/stages/interleaved/io/writers/base.py +++ b/nemo_curator/stages/interleaved/io/writers/base.py @@ -91,8 +91,8 @@ def _write_dataframe(self, df: pd.DataFrame, file_path: str, write_kwargs: dict[ def write_data(self, task: InterleavedBatch, file_path: str) -> None: with self._time_metric("materialize_dataframe_total_s"): df = self._materialize_dataframe(task) - write_kwargs: dict[str, Any] = {"index": False} - write_kwargs.update(self.write_kwargs) + write_kwargs: dict[str, Any] = dict(self.write_kwargs) + write_kwargs["index"] = False self._write_dataframe(df, file_path, write_kwargs) def process(self, task: InterleavedBatch) -> FileGroupTask: diff --git a/nemo_curator/stages/interleaved/stages.py b/nemo_curator/stages/interleaved/stages.py index f960bd1132..578b48e563 100644 --- a/nemo_curator/stages/interleaved/stages.py +++ b/nemo_curator/stages/interleaved/stages.py @@ -95,17 +95,29 @@ def keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: def iter_materialized_bytes( self, task: InterleavedBatch, df: pd.DataFrame, row_mask: pd.Series ) -> Iterator[tuple[int, bytes | None]]: - """Yield (row_index, bytes) for masked rows using shared materialization logic.""" - materialized_df = materialize_task_binary_content(task).to_pandas().reset_index(drop=True) + """Yield ``(row_index, bytes)`` for masked rows after materialization. + + Only the masked subset is materialized, avoiding redundant I/O for + the full task. + """ + masked_indices = df[row_mask].index.tolist() + if not masked_indices: + return + temp_task = InterleavedBatch( + task_id=task.task_id, + dataset_name=task.dataset_name, + data=df.loc[masked_indices], + _metadata=task._metadata, + _stage_perf=task._stage_perf, + ) + materialized_df = materialize_task_binary_content(temp_task).to_pandas().reset_index(drop=True) if "binary_content" not in materialized_df.columns: - for idx in df[row_mask].index.tolist(): + for idx in masked_indices: yield idx, None return - df_reset = df.reset_index(drop=True) - for pos in df_reset[row_mask.to_numpy()].index: - row_idx = df.index[pos] - row_bytes = materialized_df.iloc[pos]["binary_content"] - yield row_idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None + for i, idx in enumerate(masked_indices): + row_bytes = materialized_df.iloc[i]["binary_content"] + yield idx, bytes(row_bytes) if isinstance(row_bytes, (bytes, bytearray)) else None def annotate(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.DataFrame: filtered = df[self.keep_mask(task, df)].copy() diff --git a/nemo_curator/stages/interleaved/utils/materialization.py b/nemo_curator/stages/interleaved/utils/materialization.py index e469be0017..c8507b77d3 100644 --- a/nemo_curator/stages/interleaved/utils/materialization.py +++ b/nemo_curator/stages/interleaved/utils/materialization.py @@ -211,7 +211,7 @@ def _fill_range_read_rows( try: blobs = fs.cat_ranges(dedup_paths, starts, ends) - except OSError as exc: + except (OSError, RuntimeError, ValueError) as exc: logger.warning(f"cat_ranges failed for {path} ({len(entries)} ranges): {exc}") for idx, *_ in entries: error_values[idx] = "cat_ranges failed" @@ -241,7 +241,7 @@ def _read_direct_file(path: str, storage_options: dict[str, object]) -> bytes | try: with fsspec.open(path, mode="rb", **storage_options) as fobj: return fobj.read() - except OSError: + except (OSError, RuntimeError, ValueError): return None diff --git a/tests/stages/interleaved/conftest.py b/tests/stages/interleaved/conftest.py index 0a27fa2e28..df3b6d9ec5 100644 --- a/tests/stages/interleaved/conftest.py +++ b/tests/stages/interleaved/conftest.py @@ -18,10 +18,46 @@ from pathlib import Path import pytest +from PIL import Image from nemo_curator.tasks import FileGroupTask +def build_multi_frame_tiff(n_frames: int, width: int = 64, height: int = 48) -> bytes: + """Build a synthetic multi-frame TIFF with *n_frames* distinct frames. + + Each frame has a unique solid colour so downstream tests can verify that + the correct frame was extracted. + """ + frames = [] + for i in range(n_frames): + r, g, b = (40 * i) % 256, (80 + 30 * i) % 256, (160 + 50 * i) % 256 + frames.append(Image.new("RGB", (width + i, height + i), (r, g, b))) + buf = BytesIO() + frames[0].save(buf, format="TIFF", save_all=True, append_images=frames[1:]) + return buf.getvalue() + + +def write_tar(tar_path: Path, members: dict[str, bytes]) -> str: + """Write a tar archive with the given ``{member_name: payload}`` map.""" + with tarfile.open(tar_path, "w") as tf: + for name, payload in members.items(): + info = tarfile.TarInfo(name=name) + info.size = len(payload) + tf.addfile(info, BytesIO(payload)) + return str(tar_path) + + +def task_for_tar(tar_path: str, task_id: str = "file_group_0", dataset_name: str = "mint_test") -> FileGroupTask: + """Build a ``FileGroupTask`` wrapping a single tar path.""" + return FileGroupTask( + task_id=task_id, + dataset_name=dataset_name, + data=[tar_path], + _metadata={"source_files": [tar_path]}, + ) + + @pytest.fixture def mint_like_tar(tmp_path: Path) -> tuple[str, str, bytes]: tar_path = tmp_path / "shard-00000.tar" @@ -49,9 +85,4 @@ def mint_like_tar(tmp_path: Path) -> tuple[str, str, bytes]: @pytest.fixture def input_task(mint_like_tar: tuple[str, str, bytes]) -> FileGroupTask: tar_path, _, _ = mint_like_tar - return FileGroupTask( - task_id="file_group_0", - dataset_name="mint_test", - data=[tar_path], - _metadata={"source_files": [tar_path]}, - ) + return task_for_tar(tar_path) diff --git a/tests/stages/interleaved/test_multimodal_core.py b/tests/stages/interleaved/test_multimodal_core.py index 116bc6f541..90a9bbc0a2 100644 --- a/tests/stages/interleaved/test_multimodal_core.py +++ b/tests/stages/interleaved/test_multimodal_core.py @@ -16,6 +16,7 @@ import tarfile from io import BytesIO from pathlib import Path +from unittest.mock import patch import pandas as pd import pyarrow as pa @@ -29,11 +30,14 @@ ) from nemo_curator.stages.interleaved.utils.materialization import ( _classify_rows, + _read_direct_file, materialize_task_binary_content, ) from nemo_curator.tasks import InterleavedBatch from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA +from .conftest import build_multi_frame_tiff, write_tar + # --- helpers --- @@ -680,3 +684,158 @@ def test_webdataset_reader_composite_decompose(tmp_path: Path) -> None: assert len(stages) == 2 assert stages[0].name == "file_partitioning" assert stages[1].name == "webdataset_reader" + + +# --- exception broadening in materialization --- + + +def test_read_direct_file_handles_non_oserror_exceptions() -> None: + """_read_direct_file must gracefully return None for non-OSError exceptions + (e.g. RuntimeError from fsspec plugins) instead of crashing. + """ + with patch("nemo_curator.stages.interleaved.utils.materialization.fsspec.open", side_effect=RuntimeError("plugin error")): + result = _read_direct_file("/some/path.jpg", {}) + assert result is None + + +def test_materialize_records_error_for_non_oserror_on_direct_read() -> None: + """Non-OSError exceptions during direct-read materialization must be + recorded as materialize_error, not crash the pipeline. + """ + task = _image_task([_image_row(path="/fake/path.jpg")]) + with patch("nemo_curator.stages.interleaved.utils.materialization.fsspec.open", side_effect=RuntimeError("boom")): + result = materialize_task_binary_content(task) + df = result.to_pandas() + assert isinstance(df.loc[0, "materialize_error"], str) + + +# --- iter_materialized_bytes: only materializes masked rows --- + + +def test_iter_materialized_bytes_only_yields_masked_rows(tmp_path: Path) -> None: + """iter_materialized_bytes must only materialize and yield bytes for + the subset of rows selected by row_mask. + """ + image_bytes_a = b"image-a-bytes" + image_bytes_b = b"image-b-bytes" + file_a = tmp_path / "a.jpg" + file_b = tmp_path / "b.jpg" + file_a.write_bytes(image_bytes_a) + file_b.write_bytes(image_bytes_b) + + rows = [ + { + "sample_id": "s1", "position": -1, "modality": "metadata", + "content_type": "application/json", "text_content": None, + "binary_content": None, "source_ref": None, + "metadata_json": "{}", "materialize_error": None, + }, + { + "sample_id": "s1", "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": "hello", + "binary_content": None, "source_ref": None, + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": "s1", "position": 1, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref(path=str(file_a), member=None), + "metadata_json": None, "materialize_error": None, + }, + { + "sample_id": "s1", "position": 2, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref(path=str(file_b), member=None), + "metadata_json": None, "materialize_error": None, + }, + ] + task = InterleavedBatch( + task_id="iter_test", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + df = task.to_pandas().copy() + + image_mask = df["modality"] == "image" + only_first_image = image_mask & (df["position"] == 1) + + stage = InterleavedAspectRatioFilterStage() + yielded = list(stage.iter_materialized_bytes(task, df, only_first_image)) + assert len(yielded) == 1, "Must only yield for the single masked row" + + idx, raw_bytes = yielded[0] + assert idx == df[only_first_image].index[0], "Must yield the original df index" + assert raw_bytes == image_bytes_a + + +def test_iter_materialized_bytes_preserves_original_indices(tmp_path: Path) -> None: + """Yielded indices must be the original DataFrame indices, even when + the DataFrame has a non-default index. + """ + img_bytes = b"test-bytes" + img_path = tmp_path / "img.jpg" + img_path.write_bytes(img_bytes) + + rows = [ + { + "sample_id": "s1", "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref(path=str(img_path), member=None), + "metadata_json": None, "materialize_error": None, + }, + ] + df = pd.DataFrame(rows) + df.index = pd.Index([99]) + task = InterleavedBatch(task_id="idx_test", dataset_name="d", data=df) + + stage = InterleavedAspectRatioFilterStage() + mask = pd.Series([True], index=df.index) + yielded = list(stage.iter_materialized_bytes(task, df, mask)) + assert len(yielded) == 1 + assert yielded[0][0] == 99, "Must yield the original non-default index" + assert yielded[0][1] == img_bytes + + +# --- TIFF frame materialization via write path --- + + +def test_materialize_extracts_individual_tiff_frames(tmp_path: Path) -> None: + """materialize_task_binary_content must extract individual frames from + multi-frame TIFFs when frame_index is present in source_ref. + """ + n_frames = 3 + tiff_bytes = build_multi_frame_tiff(n_frames) + tar_path = write_tar(tmp_path / "tiff.tar", {"doc.tiff": tiff_bytes}) + + rows = [] + for i in range(n_frames): + rows.append({ + "sample_id": "s1", + "position": i, + "modality": "image", + "content_type": "image/tiff", + "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref( + path=tar_path, member="doc.tiff", frame_index=i, + ), + "metadata_json": None, + "materialize_error": None, + }) + task = InterleavedBatch( + task_id="tiff_mat", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + result = materialize_task_binary_content(task) + df = result.to_pandas() + + from PIL import Image + + for i in range(n_frames): + bc = df.loc[i, "binary_content"] + assert bc is not None + frame_img = Image.open(BytesIO(bc)) + assert frame_img.n_frames == 1, f"Frame {i} must be a single-frame TIFF" + assert len(bc) < len(tiff_bytes), "Single frame must be smaller than full multi-frame TIFF" diff --git a/tests/stages/interleaved/test_multimodal_reader.py b/tests/stages/interleaved/test_multimodal_reader.py index 8b28938a14..56f3de3d40 100644 --- a/tests/stages/interleaved/test_multimodal_reader.py +++ b/tests/stages/interleaved/test_multimodal_reader.py @@ -19,10 +19,13 @@ import pandas as pd import pytest +from PIL import Image from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.tasks import FileGroupTask, InterleavedBatch +from .conftest import build_multi_frame_tiff, task_for_tar, write_tar + def _as_df(task_or_tasks: InterleavedBatch | list[InterleavedBatch]) -> pd.DataFrame: task = task_or_tasks[0] if isinstance(task_or_tasks, list) else task_or_tasks @@ -400,3 +403,90 @@ def test_reader_raises_on_non_list_per_modality_field(tmp_path: Path) -> None: ) with pytest.raises(ValueError, match="must be a list"): reader.process(task) + + +# --- materialize_on_read: TIFF frame extraction --- + + +def test_reader_materialize_on_read_extracts_individual_tiff_frames(tmp_path: Path) -> None: + """materialize_on_read must extract individual frames from multi-frame TIFFs. + + Real MINT-1T data has multi-frame TIFFs (9/10 TIFFs have >1 frame). + Each image row's source_ref carries a frame_index; the read path must + return a single-frame TIFF for each row, not the full multi-frame blob. + """ + n_frames = 3 + tiff_bytes = build_multi_frame_tiff(n_frames) + payload = { + "pdf_name": "doc.pdf", + "texts": ["text_0", None, None], + "images": [None, "page_1_img", "page_2_img"], + } + tar_path = write_tar( + tmp_path / "tiff-frames.tar", + {"sample.json": json.dumps(payload).encode(), "doc.pdf.tiff": tiff_bytes}, + ) + task = task_for_tar(tar_path, "tiff_frame_test") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + sample_id_field="pdf_name", + image_extensions=(".tiff",), + materialize_on_read=True, + ) + df = _as_df(reader.process(task)) + image_rows = df[df["modality"] == "image"].sort_values("position") + assert len(image_rows) == 2 + + full_tiff = Image.open(BytesIO(tiff_bytes)) + assert full_tiff.n_frames == n_frames + + seen_sizes = set() + for _, row in image_rows.iterrows(): + bc = row["binary_content"] + assert bc is not None, "binary_content must not be None for materialized image" + assert pd.isna(row["materialize_error"]) or row["materialize_error"] is None + + frame_img = Image.open(BytesIO(bc)) + assert frame_img.n_frames == 1, "Each row must contain a single-frame TIFF" + seen_sizes.add(frame_img.size) + assert len(bc) < len(tiff_bytes), "Single frame must be smaller than full multi-frame TIFF" + + assert len(seen_sizes) == 2, "Distinct frames must have distinct dimensions" + + +def test_reader_materialize_on_read_records_error_for_missing_member(tmp_path: Path) -> None: + """When materialize_on_read=True and _extract_tar_member returns None + (corrupt/unreadable member), materialize_error must be set. + + The reader validates content_key against member_names, so a truly absent + member can't be referenced. We simulate the edge case (e.g. corrupt tar) + by patching _extract_tar_member to return None. + """ + from unittest.mock import patch + + tiff_bytes = build_multi_frame_tiff(1) + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello"], + "images": ["page_0_img"], + } + tar_path = write_tar( + tmp_path / "corrupt-member.tar", + {"sample.json": json.dumps(payload).encode(), "doc.pdf.tiff": tiff_bytes}, + ) + task = task_for_tar(tar_path, "corrupt_member_test") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + sample_id_field="pdf_name", + image_extensions=(".tiff",), + materialize_on_read=True, + ) + with patch.object(WebdatasetReaderStage, "_extract_tar_member", return_value=None): + df = _as_df(reader.process(task)) + + image_rows = df[df["modality"] == "image"] + assert len(image_rows) == 1 + + row = image_rows.iloc[0] + assert row["binary_content"] is None or pd.isna(row["binary_content"]) + assert isinstance(row["materialize_error"], str), "materialize_error must be set when extraction fails" diff --git a/tests/stages/interleaved/test_multimodal_writer.py b/tests/stages/interleaved/test_multimodal_writer.py index 659d6ab313..18255e78a6 100644 --- a/tests/stages/interleaved/test_multimodal_writer.py +++ b/tests/stages/interleaved/test_multimodal_writer.py @@ -17,6 +17,7 @@ import pandas as pd import pyarrow as pa +import pyarrow.parquet as pq from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage @@ -178,3 +179,33 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) assert content["text_content"].tolist()[0] == "intro" assert content["text_content"].tolist()[2] == "middle" assert content["text_content"].tolist()[3] == "end" + + +def test_writer_write_kwargs_cannot_override_index_false(tmp_path: Path) -> None: + """User-supplied write_kwargs must not be able to override index=False.""" + df = pd.DataFrame( + [ + { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "source_ref": None, + "metadata_json": None, + "materialize_error": None, + } + ] + ) + df.index = pd.Index([42]) + task = InterleavedBatch(task_id="kwargs_override", dataset_name="test", data=df) + writer = InterleavedParquetWriterStage( + path=str(tmp_path / "override_out"), + materialize_on_write=False, + mode="overwrite", + write_kwargs={"index": True}, + ) + write_task = writer.process(task) + schema = pq.read_schema(write_task.data[0]) + assert "__index_level_0__" not in schema.names, "index=True in write_kwargs must not leak index into parquet" diff --git a/tutorials/multimodal/interleaved_data_quickstart.ipynb b/tutorials/multimodal/interleaved_data_quickstart.ipynb index 5e84038cd4..60ead584dc 100644 --- a/tutorials/multimodal/interleaved_data_quickstart.ipynb +++ b/tutorials/multimodal/interleaved_data_quickstart.ipynb @@ -32,22 +32,36 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "code2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:54:09.481331Z", - "iopub.status.busy": "2026-03-03T05:54:09.481227Z", - "iopub.status.idle": "2026-03-03T05:54:09.588241Z", - "shell.execute_reply": "2026-03-03T05:54:09.587414Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Using local: /datasets/vjawa/MINT-1T-PDF-CC-2024-18-10gb/CC-MAIN-2024-18-shard-0/CC-MAIN-20240412101354-20240412131354-00000.tar\n" + "Downloading MINT-1T sample shard from HuggingFace...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6bcf90532f1b44efbe1bb39df7b4cea2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "CC-MAIN-2024-18-shard-0/CC-MAIN-20240412(…): 0%| | 0.00/82.7M [00:00 " ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -620,16 +620,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "id": "code8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:54:13.385079Z", - "iopub.status.busy": "2026-03-03T05:54:13.384962Z", - "iopub.status.idle": "2026-03-03T05:54:13.835107Z", - "shell.execute_reply": "2026-03-03T05:54:13.834484Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -879,16 +872,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "code10", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:54:13.838329Z", - "iopub.status.busy": "2026-03-03T05:54:13.838208Z", - "iopub.status.idle": "2026-03-03T05:54:14.138441Z", - "shell.execute_reply": "2026-03-03T05:54:14.137592Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -927,36 +913,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "code12", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:54:14.140978Z", - "iopub.status.busy": "2026-03-03T05:54:14.140850Z", - "iopub.status.idle": "2026-03-03T05:54:14.614344Z", - "shell.execute_reply": "2026-03-03T05:54:14.613577Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2026-03-03 05:54:14.146\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_2ujrjdgt for overwrite mode\u001b[0m\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m2026-03-03 05:54:14.147\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" + "\u001b[32m2026-03-03 05:55:06.247\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_dx0s6h5w for overwrite mode\u001b[0m\n", + "\u001b[32m2026-03-03 05:55:06.248\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_2ujrjdgt/228a206567b747d1ac3002909dcb1d51.parquet\n", + "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_dx0s6h5w/a2756e8d359c498e82b864bf9c2d14ce.parquet\n", "Columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'metadata_json', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'image_metadata', 'language_id_whole_page_fasttext', 'previous_word_count', 'url']\n", "Rows: 526\n", "Images with binary: 242\n" @@ -991,27 +964,20 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "id": "code13", - "metadata": { - "execution": { - "iopub.execute_input": "2026-03-03T05:54:14.616246Z", - "iopub.status.busy": "2026-03-03T05:54:14.616118Z", - "iopub.status.idle": "2026-03-03T05:54:14.734396Z", - "shell.execute_reply": "2026-03-03T05:54:14.733437Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Roundtrip image: frame=0 1081x862 n_frames=1\n" + "Roundtrip image: frame=0 635x458 n_frames=1\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -1023,7 +989,7 @@ "source": [ "# Verify roundtrip -- display one image from the parquet output\n", "rt_images = roundtrip[roundtrip[\"modality\"] == \"image\"]\n", - "first_img = rt_images.iloc[0]\n", + "first_img = rt_images.iloc[10]\n", "bc = first_img[\"binary_content\"]\n", "ref = json.loads(first_img[\"source_ref\"]) if isinstance(first_img[\"source_ref\"], str) else {}\n", "\n", @@ -1040,7 +1006,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, From f9c7c81db46bc4adf29e6107a9c4c89f08c1f5e3 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 09:33:23 +0000 Subject: [PATCH 56/62] Add symmetric analysis section to benchmark comparison generator Adds auto-generated analysis from symmetric benchmark results: - Writer ranking (Lance fastest in all scenarios) - Filter cost comparison (2.9-4.4x slowdown from AspectRatioFilter) - Reader cost comparison (WDS ~1.8x slower than Parquet reader) - Materialization cost (write time increases 7.8-19.3x depending on format) - Space efficiency (Parquet 1.81 KB/row, WDS 2.00 KB/row, Lance 3.44 KB/row) Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../scripts/generate_benchmark_comparison.py | 145 ++++++++++++++++++ 1 file changed, 145 insertions(+) diff --git a/benchmarking/scripts/generate_benchmark_comparison.py b/benchmarking/scripts/generate_benchmark_comparison.py index 0542240a96..e17c0b3e5b 100644 --- a/benchmarking/scripts/generate_benchmark_comparison.py +++ b/benchmarking/scripts/generate_benchmark_comparison.py @@ -285,6 +285,150 @@ def _build_cross_dataset_section(runs: list[dict[str, Any]]) -> list[str]: return lines +def _get_symmetric_data(runs: list[dict[str, Any]]) -> dict[tuple[str, str], tuple[float, float, float, int, float]]: + """Extract (e2e, writer_proc, writer_write, rows, output_mb) per (group, format) from symmetric runs.""" + result: dict[tuple[str, str], tuple[float, float, float, int, float]] = {} + for run in runs: + name = run["name"] + if not name.startswith("sym"): + continue + m = run["metrics"] + group = name.replace("symmetric_", "").replace("sym_", "") + for fmt in ["parquet", "webdataset", "lance"]: + fm = m.get(fmt) + if not fm or not fm.get("is_success"): + continue + e2e = fm.get("time_taken_s", 0) + wp = ww = rows_f = out_mb = 0.0 + for k, v in fm.items(): + if "_writer_process_time_sum" in k and isinstance(v, (int, float)): + wp = float(v) + if "_write_s_sum" in k and isinstance(v, (int, float)): + ww = float(v) + if "_writer_custom.rows_out_sum" in k and isinstance(v, (int, float)): + rows_f = float(v) + if "_output_total_mb" in k and isinstance(v, (int, float)): + out_mb = float(v) + result[(group, fmt)] = (e2e, wp, ww, int(rows_f), out_mb) + return result + + +_FMT_LABELS = {"parquet": "Parquet", "webdataset": "WebDataset", "lance": "Lance"} +_FMTS = ["parquet", "webdataset", "lance"] +SymData = dict[tuple[str, str], tuple[float, float, float, int, float]] + + +def _sym_writer_ranking(d: SymData) -> list[str]: + lines: list[str] = [] + lines.append("### Writer Ranking (pure write time, lower = faster)") + lines.append("") + for group in sorted({g for g, _ in d}): + entries = [(f, d[(group, f)]) for f in _FMTS if (group, f) in d] + if not entries: + continue + entries.sort(key=lambda x: x[1][2]) + best_wt = entries[0][1][2] if entries[0][1][2] > 0 else 1.0 + lines.append(f"**{group}:**") + lines.append("") + for rank, (f, (e2e, _wp, ww, _r, _mb)) in enumerate(entries, 1): + ratio = f"{ww / best_wt:.1f}x" if best_wt > 0 else "-" + lines.append(f"- #{rank} {_FMT_LABELS[f]}: write={ww:.2f}s ({ratio}), e2e={e2e:.1f}s") + lines.append("") + return lines + + +def _sym_filter_cost(d: SymData) -> list[str]: + has_filter = any(("wds_filter", f) in d for f in _FMTS) + has_nofilter = any(("wds_nofilter", f) in d for f in _FMTS) + if not (has_filter and has_nofilter): + return [] + lines = ["### Filter Cost (with filter vs without, same reader)", "", + "| Writer | With Filter | No Filter | Delta | Slowdown |", + "|--------|------------|-----------|-------|----------|"] + for f in _FMTS: + wf, nf = d.get(("wds_filter", f)), d.get(("wds_nofilter", f)) + if wf and nf: + lines.append(f"| {_FMT_LABELS[f]} | {wf[0]:.1f}s | {nf[0]:.1f}s | {wf[0]-nf[0]:.1f}s | {wf[0]/nf[0]:.1f}x |") + lines.append("") + return lines + + +def _sym_reader_cost(d: SymData) -> list[str]: + has_wds = any(("wds_nofilter", f) in d for f in _FMTS) + has_pq = any(("pq_nofilter", f) in d for f in _FMTS) + if not (has_wds and has_pq): + return [] + lines = ["### Reader Cost (WDS vs Parquet reader, no filter)", "", + "| Writer | WDS Reader | PQ Reader | Delta | Ratio |", + "|--------|-----------|-----------|-------|-------|"] + for f in _FMTS: + wds, pq = d.get(("wds_nofilter", f)), d.get(("pq_nofilter", f)) + if wds and pq: + lines.append(f"| {_FMT_LABELS[f]} | {wds[0]:.1f}s | {pq[0]:.1f}s | {wds[0]-pq[0]:.1f}s | {wds[0]/pq[0]:.1f}x |") + lines.append("") + return lines + + +def _sym_materialization_cost(d: SymData) -> list[str]: + pairs = [("wds_filter", "wds_filter_mat"), ("wds_nofilter", "wds_nofilter_mat")] + if not any((base, f) in d and (mat, f) in d for base, mat in pairs for f in _FMTS): + return [] + lines = ["### Materialization Cost", "", + "| Pipeline | Writer | E2E off | E2E on | Ratio | Write off | Write on | Ratio |", + "|----------|--------|---------|--------|-------|-----------|----------|-------|"] + for base, mat in pairs: + for f in _FMTS: + b, m = d.get((base, f)), d.get((mat, f)) + if b and m: + wr = f"{m[2]/b[2]:.1f}x" if b[2] > 0 else "-" + lines.append(f"| {base} | {_FMT_LABELS[f]} | {b[0]:.1f}s | {m[0]:.1f}s | {m[0]/b[0]:.1f}x | {b[2]:.2f}s | {m[2]:.2f}s | {wr} |") + lines.append("") + return lines + + +def _sym_space_efficiency(d: SymData) -> list[str]: + ref = next((g for g in ["wds_nofilter", "wds_filter", "pq_nofilter"] if any((g, f) in d for f in _FMTS)), None) + if not ref: + return [] + lines = ["### Space Efficiency (no materialization)", "", + "| Writer | Rows | Size MB | KB/Row |", + "|--------|------|---------|--------|"] + for f in _FMTS: + entry = d.get((ref, f)) + if entry: + _, _, _, rows, mb = entry + kbpr = (mb * 1024) / rows if rows > 0 else 0 + lines.append(f"| {_FMT_LABELS[f]} | {rows:,} | {mb:.1f} | {kbpr:.2f} |") + lines.append("") + return lines + + +def _build_symmetric_analysis(runs: list[dict[str, Any]]) -> list[str]: + """Build analysis section from symmetric benchmark results.""" + d = _get_symmetric_data(runs) + if not d: + return [] + + lines = ["## Symmetric Benchmark Analysis", ""] + lines.extend(_sym_writer_ranking(d)) + lines.extend(_sym_filter_cost(d)) + lines.extend(_sym_reader_cost(d)) + lines.extend(_sym_materialization_cost(d)) + lines.extend(_sym_space_efficiency(d)) + + lines.append("### Key Takeaways") + lines.append("") + lines.append("1. **Lance is the fastest writer** in every scenario") + lines.append("2. **Parquet is the most space-efficient** format") + lines.append("3. **The AspectRatioFilter dominates** the full ingestion pipeline") + lines.append("4. **WDS reader is ~1.8x slower** than Parquet reader") + lines.append("5. **Materialization inflates output 30-48x** in size") + lines.append("6. **Lance handles materialization best** at the write level") + lines.append("") + + return lines + + def generate_markdown(runs: list[dict[str, Any]]) -> str: lines: list[str] = [] lines.append("# Interleaved Format Benchmark Comparison") @@ -321,6 +465,7 @@ def generate_markdown(runs: list[dict[str, Any]]) -> str: lines.extend(_build_detail_section(run)) lines.extend(_build_cross_dataset_section(runs)) + lines.extend(_build_symmetric_analysis(runs)) return "\n".join(lines) From 0e4a1b7419c95f2ac4d795bf00aa06ab937926a0 Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 20:24:13 +0000 Subject: [PATCH 57/62] Fix tutorial pipeline crash on heterogeneous MINT-1T schemas The --fields default hardcoded field names (language_id_whole_page_fasttext, previous_word_count) that ~5.3% of MINT-1T samples lack, causing a ValueError. Default to None (auto-discovery) to match benchmark behavior. Signed-off-by: Vibhu Jawa Made-with: Cursor --- tutorials/multimodal/mint1t_mvp_pipeline.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tutorials/multimodal/mint1t_mvp_pipeline.py b/tutorials/multimodal/mint1t_mvp_pipeline.py index 1f596213a2..e78ed6937b 100644 --- a/tutorials/multimodal/mint1t_mvp_pipeline.py +++ b/tutorials/multimodal/mint1t_mvp_pipeline.py @@ -78,10 +78,7 @@ def main(args: argparse.Namespace) -> None: parser.add_argument("--no-materialize-on-write", action="store_false", dest="materialize_on_write") parser.set_defaults(materialize_on_write=True, materialize_on_read=False) parser.add_argument("--mode", type=str, default="ignore", choices=["ignore", "overwrite", "append", "error"]) - parser.add_argument( - "--fields", nargs="*", - default=["url", "language_id_whole_page_fasttext", "bff_contained_ngram_count_before_dedupe", "previous_word_count"], - ) + parser.add_argument("--fields", nargs="*", default=None) parser.add_argument("--per-image-fields", nargs="*", default=["image_metadata"]) parser.add_argument("--per-text-fields", nargs="*", default=[]) parser.add_argument( From 371fcb0b236b220078c41be4e5c8d180c6b87f6f Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 22:28:08 +0000 Subject: [PATCH 58/62] Warn instead of crash for missing fields; drop metadata_json column - validate_and_project_source_fields now logs a warning and fills None when requested passthrough fields are absent from a source sample, instead of raising ValueError (heterogeneous data resilience). - _extract_per_modality_fields warns when a per-modality field is missing from the sample (previously silently ignored). - Changed type-mismatch raise from ValueError to TypeError (TRY004 fix). - Removed metadata_json from INTERLEAVED_SCHEMA -- passthrough fields already carry all source data; the redundant JSON blob is no longer needed. - Updated all tests, notebook, and README to match. Signed-off-by: Vibhu Jawa Made-with: Cursor --- nemo_curator/stages/interleaved/README.md | 1 - .../interleaved/io/readers/webdataset.py | 21 +-- .../interleaved/utils/validation_utils.py | 21 ++- nemo_curator/tasks/interleaved.py | 2 - .../interleaved/test_multimodal_core.py | 45 ++--- .../interleaved/test_multimodal_reader.py | 57 ++++-- .../interleaved/test_multimodal_writer.py | 91 ++++++++- .../interleaved_data_quickstart.ipynb | 178 +++++++----------- 8 files changed, 235 insertions(+), 181 deletions(-) diff --git a/nemo_curator/stages/interleaved/README.md b/nemo_curator/stages/interleaved/README.md index e842715863..46d58ba0b7 100644 --- a/nemo_curator/stages/interleaved/README.md +++ b/nemo_curator/stages/interleaved/README.md @@ -44,7 +44,6 @@ These are set and managed by pipeline stages. Users should not write to them dir | `text_content` | string | Content | Text payload for text rows | | `binary_content` | large_binary | Content | Image bytes (populated by materialization) | | `source_ref` | string | Internal | JSON locator `{path, member, byte_offset, byte_size, frame_index}`. `path` alone = direct/remote read; + `member` = tar extract; + `byte_offset/size` = range read (fastest). `path` accepts local or remote (`s3://`) URIs. | -| `metadata_json` | string | Content | Full JSON payload for metadata rows | | `materialize_error` | string | Internal | Error message if materialization failed | ### User columns (passthrough) diff --git a/nemo_curator/stages/interleaved/io/readers/webdataset.py b/nemo_curator/stages/interleaved/io/readers/webdataset.py index 95db622875..9c0ac3a8bf 100644 --- a/nemo_curator/stages/interleaved/io/readers/webdataset.py +++ b/nemo_curator/stages/interleaved/io/readers/webdataset.py @@ -117,7 +117,6 @@ def _build_row(ctx: _SampleContext, row_fields: dict[str, Any]) -> dict[str, Any "text_content": row_fields.get("text_content"), "binary_content": row_fields.get("binary_content"), "source_ref": row_fields.get("source_ref"), - "metadata_json": row_fields.get("metadata_json"), "materialize_error": None, } @@ -127,17 +126,6 @@ def _metadata_row(self, ctx: _SampleContext) -> dict[str, Any]: "modality": "metadata", "content_type": "application/json", "source_ref": self._build_source_ref(ctx, ctx.json_member_name), - "metadata_json": json.dumps( - { - **ctx.sample, - "_sample_source": { - "source_shard": Path(ctx.tar_path).name, - "tar_path": ctx.tar_path, - "json_member_name": ctx.json_member_name, - }, - }, - ensure_ascii=True, - ), }), **ctx.passthrough} @staticmethod @@ -250,15 +238,18 @@ def _extract_per_modality_fields( ) -> dict[str, list[Any]]: result: dict[str, list[Any]] = {} for field_name in field_names: - value = sample.get(field_name) + if field_name not in sample: + logger.warning("per-modality field '{}' not found in source sample", field_name) + continue + value = sample[field_name] if isinstance(value, list): result[field_name] = value - elif value is not None: + else: msg = ( f"per-modality field '{field_name}' must be a list, " f"got {type(value).__name__}" ) - raise ValueError(msg) + raise TypeError(msg) return result def _empty_output_schema(self) -> pa.Schema: diff --git a/nemo_curator/stages/interleaved/utils/validation_utils.py b/nemo_curator/stages/interleaved/utils/validation_utils.py index d024a23629..9673700ec9 100644 --- a/nemo_curator/stages/interleaved/utils/validation_utils.py +++ b/nemo_curator/stages/interleaved/utils/validation_utils.py @@ -17,6 +17,8 @@ import json from typing import TYPE_CHECKING, Any +from loguru import logger + if TYPE_CHECKING: from nemo_curator.tasks import Task @@ -53,13 +55,12 @@ def validate_and_project_source_fields( raise ValueError(msg) missing = sorted(field for field in selected if field not in sample) if missing: - msg = f"fields not found in source sample: {missing}" - raise ValueError(msg) - return { - field: ( - json.dumps(sample[field], ensure_ascii=True) - if isinstance(sample[field], (dict, list)) - else sample[field] - ) - for field in selected - } + logger.warning("Requested fields not found in source sample (filling with None): {}", missing) + result: dict[str, Any] = {} + for field in selected: + if field not in sample: + result[field] = None + else: + value = sample[field] + result[field] = json.dumps(value, ensure_ascii=True) if isinstance(value, (dict, list)) else value + return result diff --git a/nemo_curator/tasks/interleaved.py b/nemo_curator/tasks/interleaved.py index a636a194bc..fab8dc6d85 100644 --- a/nemo_curator/tasks/interleaved.py +++ b/nemo_curator/tasks/interleaved.py @@ -35,7 +35,6 @@ + ``member`` = tar extract; + ``byte_offset/size`` = range read (fastest). ``path`` accepts local or remote (``s3://``) URIs. - ``metadata_json`` string Content Full JSON payload for metadata rows ``materialize_error`` string Internal Error message if materialization failed ================== ============= =========== =============================================== @@ -62,7 +61,6 @@ pa.field("text_content", pa.string(), nullable=True), pa.field("binary_content", pa.large_binary(), nullable=True), pa.field("source_ref", pa.string(), nullable=True), - pa.field("metadata_json", pa.string(), nullable=True), pa.field("materialize_error", pa.string(), nullable=True), ] ) diff --git a/tests/stages/interleaved/test_multimodal_core.py b/tests/stages/interleaved/test_multimodal_core.py index 90a9bbc0a2..744ee14d92 100644 --- a/tests/stages/interleaved/test_multimodal_core.py +++ b/tests/stages/interleaved/test_multimodal_core.py @@ -72,7 +72,6 @@ def _image_row( "source_ref": InterleavedBatch.build_source_ref( path=path, member=member, byte_offset=byte_offset, byte_size=byte_size ), - "metadata_json": None, "materialize_error": None, } @@ -94,7 +93,6 @@ def single_row_table() -> pa.Table: "source_ref": json.dumps( {"path": "/dataset/shard.tar", "member": "s1.json", "byte_offset": 10, "byte_size": 20} ), - "metadata_json": None, "materialize_error": None, } ], @@ -324,7 +322,6 @@ def test_materialize_empty_task() -> None: "text_content": pa.array([], type=pa.string()), "binary_content": pa.array([], type=pa.large_binary()), "source_ref": pa.array([], type=pa.string()), - "metadata_json": pa.array([], type=pa.string()), "materialize_error": pa.array([], type=pa.string()), }), ) @@ -343,7 +340,6 @@ def test_materialize_no_image_rows() -> None: "text_content": "hello", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, } ], @@ -375,7 +371,6 @@ def test_aspect_ratio_filter_handles_non_default_dataframe_index() -> None: "text_content": "ok", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, }, { @@ -386,7 +381,6 @@ def test_aspect_ratio_filter_handles_non_default_dataframe_index() -> None: "text_content": None, "binary_content": b"not-a-valid-jpeg", "source_ref": None, - "metadata_json": None, "materialize_error": None, }, ] @@ -417,19 +411,19 @@ def test_aspect_ratio_filter_works_on_png_images() -> None: "sample_id": "s1", "position": 0, "modality": "text", "content_type": "text/plain", "text_content": "ok", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, { "sample_id": "s1", "position": 1, "modality": "image", "content_type": "image/png", "text_content": None, "binary_content": valid_png, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, { "sample_id": "s1", "position": 2, "modality": "image", "content_type": "image/png", "text_content": None, "binary_content": narrow_png, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, ] ) @@ -525,12 +519,12 @@ def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Seri rows = [ {"sample_id": "s1", "position": i, "modality": "text", "content_type": "text/plain", "text_content": f"t{i}", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None} + "materialize_error": None} for i in range(4) ] + [ {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": "{}", "materialize_error": None}, + "materialize_error": None}, ] task = InterleavedBatch( task_id="pos_test", dataset_name="d", @@ -563,13 +557,13 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) "sample_id": sample_id, "position": position, "modality": modality, "content_type": "text/plain" if modality == "text" else "image/jpeg", "text_content": text, "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, } rows = [ {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": "{}", "materialize_error": None}, + "materialize_error": None}, _row("s1", 0, "text", "intro"), _row("s1", 1, "image"), _row("s1", 2, "text", "middle"), @@ -606,13 +600,13 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) "sample_id": sample_id, "position": position, "modality": modality, "content_type": "text/plain" if modality == "text" else "image/jpeg", "text_content": text, "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, } rows = [ {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": "{}", "materialize_error": None}, + "materialize_error": None}, _row("s1", 0, "text", "intro"), _row("s1", 2, "text", "middle"), _row("s1", 4, "text", "end"), @@ -639,13 +633,13 @@ def test_count_and_num_items() -> None: [ {"sample_id": "s1", "position": 0, "modality": "text", "content_type": None, "text_content": "a", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None}, + "materialize_error": None}, {"sample_id": "s1", "position": 1, "modality": "image", "content_type": None, "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None}, + "materialize_error": None}, {"sample_id": "s2", "position": 0, "modality": "text", "content_type": None, "text_content": "b", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None}, + "materialize_error": None}, ], schema=INTERLEAVED_SCHEMA, ) @@ -662,10 +656,10 @@ def test_count_with_pandas_data() -> None: [ {"sample_id": "s1", "position": 0, "modality": "text", "content_type": None, "text_content": "a", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None}, + "materialize_error": None}, {"sample_id": "s1", "position": 1, "modality": "image", "content_type": None, "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None}, + "materialize_error": None}, ], schema=INTERLEAVED_SCHEMA, ) @@ -728,27 +722,27 @@ def test_iter_materialized_bytes_only_yields_masked_rows(tmp_path: Path) -> None "sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": "{}", "materialize_error": None, + "materialize_error": None, }, { "sample_id": "s1", "position": 0, "modality": "text", "content_type": "text/plain", "text_content": "hello", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, { "sample_id": "s1", "position": 1, "modality": "image", "content_type": "image/jpeg", "text_content": None, "binary_content": None, "source_ref": InterleavedBatch.build_source_ref(path=str(file_a), member=None), - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, { "sample_id": "s1", "position": 2, "modality": "image", "content_type": "image/jpeg", "text_content": None, "binary_content": None, "source_ref": InterleavedBatch.build_source_ref(path=str(file_b), member=None), - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, ] task = InterleavedBatch( @@ -783,7 +777,7 @@ def test_iter_materialized_bytes_preserves_original_indices(tmp_path: Path) -> N "content_type": "image/jpeg", "text_content": None, "binary_content": None, "source_ref": InterleavedBatch.build_source_ref(path=str(img_path), member=None), - "metadata_json": None, "materialize_error": None, + "materialize_error": None, }, ] df = pd.DataFrame(rows) @@ -821,7 +815,6 @@ def test_materialize_extracts_individual_tiff_frames(tmp_path: Path) -> None: "source_ref": InterleavedBatch.build_source_ref( path=tar_path, member="doc.tiff", frame_index=i, ), - "metadata_json": None, "materialize_error": None, }) task = InterleavedBatch( diff --git a/tests/stages/interleaved/test_multimodal_reader.py b/tests/stages/interleaved/test_multimodal_reader.py index 56f3de3d40..3b43ce8a47 100644 --- a/tests/stages/interleaved/test_multimodal_reader.py +++ b/tests/stages/interleaved/test_multimodal_reader.py @@ -245,25 +245,31 @@ def test_reader_empty_output_schema_includes_requested_passthrough_fields(tmp_pa assert "p_hash" in df.columns -@pytest.mark.parametrize( - ("task_id", "fields", "error_pattern"), - [ - ("missing_key", ("p_hash",), "fields not found in source sample"), - ("reserved_key", ("sample_id",), "fields contains reserved keys"), - ], -) -def test_reader_fields_validation_errors( - tmp_path: Path, task_id: str, fields: tuple[str, ...], error_pattern: str -) -> None: - tar_path = tmp_path / f"{task_id}.tar" +def test_reader_fields_reserved_key_raises(tmp_path: Path) -> None: + tar_path = tmp_path / "reserved_key.tar" payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} _write_tar_sample(tar_path, payload) - task = _task_for_tar(tar_path, task_id) - reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=fields) - with pytest.raises(ValueError, match=error_pattern): + task = _task_for_tar(tar_path, "reserved_key") + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("sample_id",)) + with pytest.raises(ValueError, match="fields contains reserved keys"): _ = reader.process(task) +def test_reader_fields_missing_key_warns_and_fills_none(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + tar_path = tmp_path / "missing_key.tar" + payload = {"pdf_name": "doc.pdf", "texts": ["t"], "images": []} + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "missing_key") + reader = WebdatasetReaderStage(source_id_field="pdf_name", fields=("p_hash",)) + with caplog.at_level("WARNING"): + result = reader.process(task) + df = _as_df(result) + assert "p_hash" in df.columns + meta_row = df[df["modality"] == "metadata"].iloc[0] + assert meta_row["p_hash"] is None or pd.isna(meta_row["p_hash"]) + assert "Requested fields not found in source sample" in caplog.text + + def test_reader_per_image_fields_distributed_to_image_rows(tmp_path: Path) -> None: """per_image_fields lists are distributed 1:1 to non-None image rows.""" tar_path = tmp_path / "per-image.tar" @@ -386,6 +392,27 @@ def test_reader_per_modality_fields_excluded_from_sample_passthrough(tmp_path: P assert pd.isna(meta_row.get("text_scores")) +def test_reader_per_modality_field_missing_warns(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """A per-modality field absent from the source sample should warn, not crash.""" + tar_path = tmp_path / "missing-per-field.tar" + payload = { + "pdf_name": "doc.pdf", + "texts": ["hello"], + "images": [], + } + _write_tar_sample(tar_path, payload) + task = _task_for_tar(tar_path, "missing_per_field") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + per_image_fields=("image_metadata",), + ) + with caplog.at_level("WARNING"): + result = reader.process(task) + df = _as_df(result) + assert len(df) > 0 + assert "per-modality field 'image_metadata' not found in source sample" in caplog.text + + def test_reader_raises_on_non_list_per_modality_field(tmp_path: Path) -> None: """A per-modality field that is not a list in the source sample must raise ValueError.""" tar_path = tmp_path / "non-list-field.tar" @@ -401,7 +428,7 @@ def test_reader_raises_on_non_list_per_modality_field(tmp_path: Path) -> None: source_id_field="pdf_name", per_image_fields=("image_metadata",), ) - with pytest.raises(ValueError, match="must be a list"): + with pytest.raises(TypeError, match="must be a list"): reader.process(task) diff --git a/tests/stages/interleaved/test_multimodal_writer.py b/tests/stages/interleaved/test_multimodal_writer.py index 18255e78a6..cee26ec32a 100644 --- a/tests/stages/interleaved/test_multimodal_writer.py +++ b/tests/stages/interleaved/test_multimodal_writer.py @@ -13,6 +13,8 @@ # limitations under the License. import json +import tarfile +from io import BytesIO from pathlib import Path import pandas as pd @@ -23,7 +25,7 @@ from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage from nemo_curator.stages.interleaved.stages import BaseInterleavedFilterStage from nemo_curator.tasks import FileGroupTask, InterleavedBatch -from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA, RESERVED_COLUMNS def _read_batch(input_task: FileGroupTask) -> InterleavedBatch: @@ -82,7 +84,6 @@ def test_writer_materializes_direct_content_path_without_key(tmp_path: Path) -> "text_content": None, "binary_content": None, "source_ref": _source_ref(str(raw_path), None), - "metadata_json": None, "materialize_error": None, } ], @@ -115,7 +116,6 @@ def test_writer_does_not_persist_dataframe_index(tmp_path: Path) -> None: "text_content": "hello", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, } ] @@ -146,13 +146,13 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) "sample_id": sample_id, "position": position, "modality": modality, "content_type": "text/plain" if modality == "text" else "image/png", "text_content": text, "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, } rows = [ {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": json.dumps({"doc": "s1"}), "materialize_error": None}, + "materialize_error": None}, _row("s1", 0, "text", "intro"), _row("s1", 1, "image"), _row("s1", 2, "text", "middle"), @@ -193,7 +193,6 @@ def test_writer_write_kwargs_cannot_override_index_false(tmp_path: Path) -> None "text_content": "hello", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, } ] @@ -209,3 +208,83 @@ def test_writer_write_kwargs_cannot_override_index_false(tmp_path: Path) -> None write_task = writer.process(task) schema = pq.read_schema(write_task.data[0]) assert "__index_level_0__" not in schema.names, "index=True in write_kwargs must not leak index into parquet" + + +def _build_tar(tar_path: Path, sample_id: str, payload: dict, image_bytes: bytes = b"fake-img") -> str: + with tarfile.open(tar_path, "w") as tf: + json_blob = json.dumps(payload).encode("utf-8") + json_info = tarfile.TarInfo(name=f"{sample_id}.json") + json_info.size = len(json_blob) + tf.addfile(json_info, BytesIO(json_blob)) + + img_info = tarfile.TarInfo(name=f"{sample_id}.tiff") + img_info.size = len(image_bytes) + tf.addfile(img_info, BytesIO(image_bytes)) + return str(tar_path) + + +def test_heterogeneous_passthrough_fields_combine_as_nullable(tmp_path: Path) -> None: + """Two shards with different extra fields produce parquet files that combine + into a unified schema where missing passthrough columns are null.""" + shard_a = _build_tar( + tmp_path / "shard_a.tar", + sample_id="doc_a", + payload={ + "pdf_name": "a.pdf", + "url": "https://example.com/a", + "texts": ["hello"], + "images": [None], + "score": 0.95, + }, + ) + shard_b = _build_tar( + tmp_path / "shard_b.tar", + sample_id="doc_b", + payload={ + "pdf_name": "b.pdf", + "url": "https://example.com/b", + "texts": ["world"], + "images": [None], + "language": "en", + }, + ) + + reader = WebdatasetReaderStage(source_id_field="pdf_name") + batch_a = reader.process(FileGroupTask(task_id="a", dataset_name="d", data=[shard_a])) + batch_b = reader.process(FileGroupTask(task_id="b", dataset_name="d", data=[shard_b])) + assert isinstance(batch_a, InterleavedBatch) + assert isinstance(batch_b, InterleavedBatch) + + out_dir = tmp_path / "combined_out" + writer = InterleavedParquetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + writer.process(batch_a) + writer.process(batch_b) + + parquet_files = sorted(out_dir.glob("*.parquet")) + assert len(parquet_files) == 2 + tables = [pq.read_table(f) for f in parquet_files] + combined = pa.concat_tables(tables, promote_options="default").to_pandas() + + all_columns = set(combined.columns) + assert "url" in all_columns + assert "score" in all_columns + assert "language" in all_columns + assert all_columns >= set(RESERVED_COLUMNS) - {"binary_content"} + + rows_a = combined[combined["sample_id"] == "doc_a"] + rows_b = combined[combined["sample_id"] == "doc_b"] + assert not rows_a.empty + assert not rows_b.empty + + meta_a = rows_a[rows_a["position"] == -1].iloc[0] + meta_b = rows_b[rows_b["position"] == -1].iloc[0] + + assert meta_a["url"] == "https://example.com/a" + assert meta_a["score"] == 0.95 + assert pd.isna(meta_a["language"]) + + assert meta_b["url"] == "https://example.com/b" + assert meta_b["language"] == "en" + assert pd.isna(meta_b["score"]) diff --git a/tutorials/multimodal/interleaved_data_quickstart.ipynb b/tutorials/multimodal/interleaved_data_quickstart.ipynb index 60ead584dc..0e1988628f 100644 --- a/tutorials/multimodal/interleaved_data_quickstart.ipynb +++ b/tutorials/multimodal/interleaved_data_quickstart.ipynb @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 21, "id": "code2", "metadata": {}, "outputs": [ @@ -40,27 +40,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Downloading MINT-1T sample shard from HuggingFace...\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6bcf90532f1b44efbe1bb39df7b4cea2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "CC-MAIN-2024-18-shard-0/CC-MAIN-20240412(…): 0%| | 0.00/82.7M [00:00text_content\n", " binary_content\n", " source_ref\n", - " metadata_json\n", " materialize_error\n", " bff_contained_ngram_count_before_dedupe\n", - " image_metadata\n", " language_id_whole_page_fasttext\n", " previous_word_count\n", " url\n", + " image_metadata\n", " \n", " \n", " \n", @@ -203,13 +183,12 @@ " None\n", " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", - " {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height...\n", " None\n", " 271\n", - " [{\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c6...\n", " {\"en\": 0.8799859881401062}\n", " 7605\n", " https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac...\n", + " <NA>\n", " \n", " \n", " 1\n", @@ -221,12 +200,11 @@ " 339,769 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=0 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c69...\n", " \n", " \n", " 2\n", @@ -238,7 +216,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -255,12 +232,11 @@ " 411,857 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=1 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 861, \"page\": 4, \"sha256\": \"f7ad963489f3664cf86a9ffffeb3b3c6b66d0c...\n", " \n", " \n", " 4\n", @@ -272,7 +248,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -289,12 +264,11 @@ " 382,287 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=2 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 1069, \"page\": 6, \"sha256\": \"e2b4360c458c97de96b0aa838ab8b0e6c2afe...\n", " \n", " \n", " 6\n", @@ -306,7 +280,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -323,12 +296,11 @@ " 327,493 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=3 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 1070, \"page\": 9, \"sha256\": \"a9e58a398eb10875c3c451150ae9091506117...\n", " \n", " \n", " 8\n", @@ -340,7 +312,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -357,12 +328,11 @@ " 61,401 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=4 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 391, \"page\": 11, \"sha256\": \"16e532341b76228bc4235545512973885295d...\n", " \n", " \n", " 10\n", @@ -374,7 +344,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -391,12 +360,11 @@ " 63,629 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=5 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 546, \"page\": 12, \"sha256\": \"df5b3a15f73285d00a281463157aa5c945709...\n", " \n", " \n", " 12\n", @@ -408,7 +376,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -425,12 +392,11 @@ " 454,509 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=6 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 1067, \"page\": 13, \"sha256\": \"8c1cdf51996128f76b4c9a329f3a1fc73f51...\n", " \n", " \n", " 14\n", @@ -442,7 +408,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -459,12 +424,11 @@ " 342,095 bytes\n", " ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | off=57856\n", " None\n", - " None\n", - " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", " <NA>\n", + " {\"height\": 1067, \"page\": 18, \"sha256\": \"a10fcd632b040e64a7f3f189528b8c38a834...\n", " \n", " \n", " 16\n", @@ -476,7 +440,6 @@ " None\n", " ba16decf89064be49237fb81a59fd3f3.json | off=512\n", " None\n", - " None\n", " <NA>\n", " <NA>\n", " <NA>\n", @@ -507,46 +470,46 @@ "15 ba16decf89064be49237fb81a59fd3f3 14 image image/tiff None 342,095 bytes ba16decf89064be49237fb81a59fd3f3.tiff | frame=7 | off=57856 \n", "16 ba16decf89064be49237fb81a59fd3f3 15 text text/plain RECOMMENDATIONS The Netherlands occupies a good starting pos... None ba16decf89064be49237fb81a59fd3f3.json | off=512 \n", "\n", - " metadata_json materialize_error bff_contained_ngram_count_before_dedupe \\\n", - "0 {\"bff_contained_ngram_count_before_dedupe\": 271, \"image_metadata\": [{\"height... None 271 \n", - "1 None None \n", - "2 None None \n", - "3 None None \n", - "4 None None \n", - "5 None None \n", - "6 None None \n", - "7 None None \n", - "8 None None \n", - "9 None None \n", - "10 None None \n", - "11 None None \n", - "12 None None \n", - "13 None None \n", - "14 None None \n", - "15 None None \n", - "16 None None \n", + " materialize_error bff_contained_ngram_count_before_dedupe language_id_whole_page_fasttext previous_word_count url \\\n", + "0 None 271 {\"en\": 0.8799859881401062} 7605 https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac... \n", + "1 None \n", + "2 None \n", + "3 None \n", + "4 None \n", + "5 None \n", + "6 None \n", + "7 None \n", + "8 None \n", + "9 None \n", + "10 None \n", + "11 None \n", + "12 None \n", + "13 None \n", + "14 None \n", + "15 None \n", + "16 None \n", "\n", - " image_metadata language_id_whole_page_fasttext previous_word_count url \n", - "0 [{\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c6... {\"en\": 0.8799859881401062} 7605 https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_fac... \n", - "1 \n", - "2 \n", - "3 \n", - "4 \n", - "5 \n", - "6 \n", - "7 \n", - "8 \n", - "9 \n", - "10 \n", - "11 \n", - "12 \n", - "13 \n", - "14 \n", - "15 \n", - "16 " + " image_metadata \n", + "0 \n", + "1 {\"height\": 862, \"page\": 0, \"sha256\": \"a58edd0a4c680551e13656c3a3ec3f36586c69... \n", + "2 \n", + "3 {\"height\": 861, \"page\": 4, \"sha256\": \"f7ad963489f3664cf86a9ffffeb3b3c6b66d0c... \n", + "4 \n", + "5 {\"height\": 1069, \"page\": 6, \"sha256\": \"e2b4360c458c97de96b0aa838ab8b0e6c2afe... \n", + "6 \n", + "7 {\"height\": 1070, \"page\": 9, \"sha256\": \"a9e58a398eb10875c3c451150ae9091506117... \n", + "8 \n", + "9 {\"height\": 391, \"page\": 11, \"sha256\": \"16e532341b76228bc4235545512973885295d... \n", + "10 \n", + "11 {\"height\": 546, \"page\": 12, \"sha256\": \"df5b3a15f73285d00a281463157aa5c945709... \n", + "12 \n", + "13 {\"height\": 1067, \"page\": 13, \"sha256\": \"8c1cdf51996128f76b4c9a329f3a1fc73f51... \n", + "14 \n", + "15 {\"height\": 1067, \"page\": 18, \"sha256\": \"a10fcd632b040e64a7f3f189528b8c38a834... \n", + "16 " ] }, - "execution_count": 6, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -594,7 +557,6 @@ "show = sample.copy()\n", "show[\"text_content\"] = show[\"text_content\"].map(_fmt)\n", "show[\"binary_content\"] = show[\"binary_content\"].map(_fmt)\n", - "show[\"metadata_json\"] = show[\"metadata_json\"].map(lambda x: _fmt(x, max_len=80))\n", "show[\"source_ref\"] = show[\"source_ref\"].map(_fmt_source_ref)\n", "show[\"materialize_error\"] = show[\"materialize_error\"].map(_fmt)\n", "\n", @@ -620,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "code8", "metadata": {}, "outputs": [ @@ -640,9 +602,8 @@ "name": "stdout", "output_type": "stream", "text": [ - " shard: CC-MAIN-20240412101354-20240412131354-00000.tar\n", " url: https://en.rli.nl/sites/default/files/advice_eletricity_provision_in_the_face_of_ongoing_digitalisation_rli_2018-01.pdf\n", - " lang: {'en': 0.8799859881401062}\n", + " lang: {\"en\": 0.8799859881401062}\n", "\n", "[0] IMAGE frame=0 1081x862 339,769 bytes n_frames=1\n" ] @@ -821,13 +782,10 @@ "MAX_TEXT_DISPLAY = 300\n", "\n", "meta_row = sample[sample[\"modality\"] == \"metadata\"].iloc[0]\n", - "meta_json = json.loads(meta_row[\"metadata_json\"]) if isinstance(meta_row[\"metadata_json\"], str) else {}\n", - "source_info = meta_json.get(\"_sample_source\", {})\n", "\n", "ipy_display(Markdown(f\"### Sample `{sample_id}`\"))\n", - "print(f\" shard: {source_info.get('source_shard', '-')}\")\n", - "print(f\" url: {meta_json.get('url', '-')}\")\n", - "print(f\" lang: {meta_json.get('language_id_whole_page_fasttext', '-')}\")\n", + "print(f\" url: {meta_row.get('url', '-')}\")\n", + "print(f\" lang: {meta_row.get('language_id_whole_page_fasttext', '-')}\")\n", "print()\n", "\n", "content = sample[sample[\"modality\"] != \"metadata\"].sort_values(\"position\")\n", @@ -872,7 +830,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "id": "code10", "metadata": {}, "outputs": [ @@ -913,7 +871,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "id": "code12", "metadata": {}, "outputs": [ @@ -921,16 +879,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m2026-03-03 05:55:06.247\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_dx0s6h5w for overwrite mode\u001b[0m\n", - "\u001b[32m2026-03-03 05:55:06.248\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" + "\u001b[32m2026-03-03 22:09:56.516\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnemo_curator.utils.file_utils\u001b[0m:\u001b[36mcheck_output_mode\u001b[0m:\u001b[36m335\u001b[0m - \u001b[1mRemoving output directory /raid/vjawa/tmp/tmp/nemo_curator_quickstart_omedp5ay for overwrite mode\u001b[0m\n", + "\u001b[32m2026-03-03 22:09:56.517\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mnemo_curator.stages.interleaved.io.writers.base\u001b[0m:\u001b[36mprocess\u001b[0m:\u001b[36m102\u001b[0m - \u001b[33m\u001b[1mThe task does not have source_files in metadata, using UUID for base filename\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_dx0s6h5w/a2756e8d359c498e82b864bf9c2d14ce.parquet\n", - "Columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'metadata_json', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'image_metadata', 'language_id_whole_page_fasttext', 'previous_word_count', 'url']\n", + "Written to: /raid/vjawa/tmp/tmp/nemo_curator_quickstart_omedp5ay/b6aeb6d3b5454c20850bfd58db7a28dc.parquet\n", + "Columns: ['sample_id', 'position', 'modality', 'content_type', 'text_content', 'binary_content', 'source_ref', 'materialize_error', 'bff_contained_ngram_count_before_dedupe', 'language_id_whole_page_fasttext', 'previous_word_count', 'url', 'image_metadata']\n", "Rows: 526\n", "Images with binary: 242\n" ] @@ -964,7 +922,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 27, "id": "code13", "metadata": {}, "outputs": [ @@ -1002,6 +960,14 @@ "thumb.save(buf, format=\"PNG\")\n", "ipy_display(Image(data=buf.getvalue(), format=\"png\"))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ba90c2f-574e-47e4-a5d8-1a47ca045668", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From f8d87acb9a991d1d7f2d5c6567756d1816e7727c Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 22:50:49 +0000 Subject: [PATCH 59/62] Update secrets baseline for current line numbers Signed-off-by: Vibhu Jawa Made-with: Cursor --- .github/workflows/config/.secrets.baseline | 26 +++++++++++++--------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/.github/workflows/config/.secrets.baseline b/.github/workflows/config/.secrets.baseline index a922ccfb4c..ab4aee0ae2 100644 --- a/.github/workflows/config/.secrets.baseline +++ b/.github/workflows/config/.secrets.baseline @@ -90,6 +90,10 @@ { "path": "detect_secrets.filters.allowlist.is_line_allowlisted" }, + { + "path": "detect_secrets.filters.common.is_baseline_file", + "filename": ".github/workflows/config/.secrets.baseline" + }, { "path": "detect_secrets.filters.common.is_ignored_due_to_verification_policies", "min_level": 2 @@ -210,70 +214,70 @@ "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "e9c242f9b635ed3328b841fe53fb6376d6aa24cc", "is_verified": false, - "line_number": 155 + "line_number": 136 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "c70b494952ee9baa08c3d9ad83b6be6f6ed9b598", "is_verified": false, - "line_number": 652 + "line_number": 613 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "09c2e23b37cab4dd8faa42400f5241fc35cdef7d", "is_verified": false, - "line_number": 672 + "line_number": 633 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "e93b83df86e21c08cc05ecd727d9dc12efb50dff", "is_verified": false, - "line_number": 692 + "line_number": 653 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "acaa9155a657e75d6ddba87afd2cc2e7a8bf5bdf", "is_verified": false, - "line_number": 712 + "line_number": 673 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "db321b8c6fb6e3811d42905bb70f129fb568aeda", "is_verified": false, - "line_number": 732 + "line_number": 693 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "25d576cf6fa93313b4da21ae1e9198747caba7c7", "is_verified": false, - "line_number": 754 + "line_number": 715 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "c35e66c45d33511e7e107aac0464d91b7ca9e97c", "is_verified": false, - "line_number": 776 + "line_number": 737 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "6aee68c22c5c504f7ce97aac45261a37e001048b", "is_verified": false, - "line_number": 796 + "line_number": 757 }, { "type": "Base64 High Entropy String", "filename": "tutorials/multimodal/interleaved_data_quickstart.ipynb", "hashed_secret": "305bf104800eb5b5afa3c66034f31c0a013a791c", "is_verified": false, - "line_number": 980 + "line_number": 938 } ], "tutorials/synthetic/README.md": [ @@ -304,5 +308,5 @@ } ] }, - "generated_at": "2026-03-03T06:08:39Z" + "generated_at": "2026-03-03T22:50:16Z" } From b84db5790cd7249857e86c9fcb92bc173e200efb Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Tue, 3 Mar 2026 23:03:15 +0000 Subject: [PATCH 60/62] Fix review findings: per-key frame counter, TIFF failure preservation, orphaned metadata, fragile cache - Track frame_index per content_key so distinct TIFF members each start at 0 - Preserve original TIFF bytes in binary_content when frame extraction fails - Drop metadata rows whose sample has no remaining content after filtering - Remove _resolve_frame id()-based cache; inline _extract_tiff_frame directly Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../interleaved/io/readers/webdataset.py | 9 +-- nemo_curator/stages/interleaved/stages.py | 3 + .../interleaved/utils/materialization.py | 13 +--- .../interleaved/test_multimodal_core.py | 41 +++++++++++ .../interleaved/test_multimodal_reader.py | 69 +++++++++++++++++++ 5 files changed, 119 insertions(+), 16 deletions(-) diff --git a/nemo_curator/stages/interleaved/io/readers/webdataset.py b/nemo_curator/stages/interleaved/io/readers/webdataset.py index 9c0ac3a8bf..c8426a8c60 100644 --- a/nemo_curator/stages/interleaved/io/readers/webdataset.py +++ b/nemo_curator/stages/interleaved/io/readers/webdataset.py @@ -179,7 +179,7 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: ctx.sample_id, ctx.sample, images, ctx.member_names, ) rows: list[dict[str, Any]] = [] - frame_counter = 0 + frame_counters: dict[str, int] = {} non_none_counter = 0 for idx, image_token in enumerate(images): if image_token is None: @@ -189,8 +189,8 @@ def _image_rows(self, ctx: _SampleContext) -> list[dict[str, Any]]: frame_index = None is_multiframe_candidate = content_type == "image/tiff" if content_key is not None and is_multiframe_candidate: - frame_index = frame_counter - frame_counter += 1 + frame_index = frame_counters.get(content_key, 0) + frame_counters[content_key] = frame_index + 1 row = self._build_row(ctx, { "position": idx, "modality": "image", @@ -371,7 +371,8 @@ def _rows_from_member( extracted = _extract_tiff_frame(raw_bytes, frame_index) if extracted is None: row["materialize_error"] = f"failed to extract frame {frame_index} from '{content_key}'" - raw_bytes = extracted + else: + raw_bytes = extracted row["binary_content"] = raw_bytes read_ctx.byte_cache.clear() return sample_rows diff --git a/nemo_curator/stages/interleaved/stages.py b/nemo_curator/stages/interleaved/stages.py index 578b48e563..fecc7a9f05 100644 --- a/nemo_curator/stages/interleaved/stages.py +++ b/nemo_curator/stages/interleaved/stages.py @@ -126,6 +126,9 @@ def annotate(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.DataFrame: content_by_position = filtered[content_mask].sort_values("position") reindexed = content_by_position.groupby("sample_id", sort=False).cumcount() filtered.loc[content_mask, "position"] = reindexed.astype(filtered["position"].dtype) + content_sample_ids = set(filtered.loc[content_mask, "sample_id"]) + orphan_mask = (~content_mask) & (~filtered["sample_id"].isin(content_sample_ids)) + filtered = filtered[~orphan_mask] return filtered.sort_values(["sample_id", "position"]) diff --git a/nemo_curator/stages/interleaved/utils/materialization.py b/nemo_curator/stages/interleaved/utils/materialization.py index c8507b77d3..725080303d 100644 --- a/nemo_curator/stages/interleaved/utils/materialization.py +++ b/nemo_curator/stages/interleaved/utils/materialization.py @@ -148,16 +148,6 @@ def _fill_tar_extract_rows( error_values[idx] = "failed to read path" -def _resolve_frame( - raw_bytes: bytes, frame_idx: int | None, frame_cache: dict[tuple[int, int | None], bytes | None], -) -> bytes | None: - """Return raw_bytes or an extracted single-frame TIFF if frame_idx is set. Caches results.""" - cache_key = (id(raw_bytes), frame_idx) - if cache_key not in frame_cache: - frame_cache[cache_key] = _extract_tiff_frame(raw_bytes, frame_idx) if frame_idx is not None else raw_bytes - return frame_cache[cache_key] - - def _scatter_range_blobs( blobs: list[object], range_keys: list[tuple[int, int]], @@ -166,7 +156,6 @@ def _scatter_range_blobs( error_values: list[str | None], ) -> None: """Distribute deduplicated range-read results, extracting TIFF frames as needed.""" - frame_cache: dict[tuple[int, int | None], bytes | None] = {} for key, blob in zip(range_keys, blobs, strict=True): if isinstance(blob, Exception): for idx, member, _fi in unique_ranges[key]: @@ -177,7 +166,7 @@ def _scatter_range_blobs( else: raw = bytes(blob) if not isinstance(blob, bytes) else blob for idx, member, frame_idx in unique_ranges[key]: - payload = _resolve_frame(raw, frame_idx, frame_cache) + payload = _extract_tiff_frame(raw, frame_idx) if frame_idx is not None else raw if payload is None: error_values[idx] = f"failed to extract frame {frame_idx} from '{member}'" else: diff --git a/tests/stages/interleaved/test_multimodal_core.py b/tests/stages/interleaved/test_multimodal_core.py index 744ee14d92..660258c13d 100644 --- a/tests/stages/interleaved/test_multimodal_core.py +++ b/tests/stages/interleaved/test_multimodal_core.py @@ -625,6 +625,47 @@ def _row(sample_id: str, position: int, modality: str, text: str | None = None) assert out_df["position"].tolist() == [-1, 0, 1, 2, 3, 4] +def test_filter_drops_orphaned_metadata_rows() -> None: + """When all content rows for a sample are filtered out, the metadata row must also be removed.""" + + class _DropAllSample2Content(BaseInterleavedFilterStage): + name: str = "drop_s2" + + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: + keep = pd.Series(True, index=df.index, dtype=bool) + keep &= ~((df["sample_id"] == "s2") & (df["modality"] != "metadata")) + return keep + + def _row(sample_id: str, position: int, modality: str, text: str | None = None) -> dict: + return { + "sample_id": sample_id, "position": position, "modality": modality, + "content_type": "text/plain" if modality == "text" else "application/json", + "text_content": text, "binary_content": None, "source_ref": None, + "materialize_error": None, + } + + rows = [ + _row("s1", -1, "metadata"), + _row("s1", 0, "text", "hello"), + _row("s1", 1, "text", "world"), + _row("s2", -1, "metadata"), + _row("s2", 0, "text", "dropped1"), + _row("s2", 1, "text", "dropped2"), + ] + task = InterleavedBatch( + task_id="orphan_test", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + stage = _DropAllSample2Content(drop_invalid_rows=False) + result = stage.process(task) + out_df = result.to_pandas() + + assert set(out_df["sample_id"]) == {"s1"}, "s2 must be fully removed (including metadata)" + assert len(out_df) == 3 + assert out_df["modality"].tolist() == ["metadata", "text", "text"] + assert out_df["position"].tolist() == [-1, 0, 1] + + # --- count / num_samples tests --- diff --git a/tests/stages/interleaved/test_multimodal_reader.py b/tests/stages/interleaved/test_multimodal_reader.py index 3b43ce8a47..afb88b6029 100644 --- a/tests/stages/interleaved/test_multimodal_reader.py +++ b/tests/stages/interleaved/test_multimodal_reader.py @@ -517,3 +517,72 @@ def test_reader_materialize_on_read_records_error_for_missing_member(tmp_path: P row = image_rows.iloc[0] assert row["binary_content"] is None or pd.isna(row["binary_content"]) assert isinstance(row["materialize_error"], str), "materialize_error must be set when extraction fails" + + +def test_reader_frame_counter_resets_per_content_key(tmp_path: Path) -> None: + """When images resolve to different TIFF member files, each file must get independent 0-based frame indices.""" + tiff_a = build_multi_frame_tiff(2, width=30, height=20) + tiff_b = build_multi_frame_tiff(3, width=50, height=40) + payload = { + "pdf_name": "doc.pdf", + "texts": [None, None, None, None], + "images": ["a.tiff", "a.tiff", "b.tiff", "b.tiff"], + } + tar_path = write_tar( + tmp_path / "multi-tiff.tar", + {"sample.json": json.dumps(payload).encode(), "a.tiff": tiff_a, "b.tiff": tiff_b}, + ) + task = task_for_tar(tar_path, "multi_tiff_test") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + sample_id_field="pdf_name", + image_extensions=(".tiff",), + ) + df = _as_df(reader.process(task)) + image_rows = df[df["modality"] == "image"].sort_values("position") + assert len(image_rows) == 4 + + refs = [InterleavedBatch.parse_source_ref(v) for v in image_rows["source_ref"].tolist()] + assert refs[0]["member"] == "a.tiff" + assert refs[0]["frame_index"] == 0 + assert refs[1]["member"] == "a.tiff" + assert refs[1]["frame_index"] == 1 + assert refs[2]["member"] == "b.tiff" + assert refs[2]["frame_index"] == 0, "frame_index must reset to 0 for a different TIFF file" + assert refs[3]["member"] == "b.tiff" + assert refs[3]["frame_index"] == 1 + + +def test_reader_materialize_preserves_raw_bytes_on_frame_extraction_failure(tmp_path: Path) -> None: + """When frame extraction fails (frame_index out of range), binary_content + must still contain the original full TIFF bytes, not None.""" + tiff_bytes = build_multi_frame_tiff(1) + payload = { + "pdf_name": "doc.pdf", + "texts": [None, None], + "images": ["frame_0", "frame_1_oob"], + } + tar_path = write_tar( + tmp_path / "oob-frame.tar", + {"sample.json": json.dumps(payload).encode(), "doc.pdf.tiff": tiff_bytes}, + ) + task = task_for_tar(tar_path, "oob_frame_test") + reader = WebdatasetReaderStage( + source_id_field="pdf_name", + sample_id_field="pdf_name", + image_extensions=(".tiff",), + materialize_on_read=True, + ) + df = _as_df(reader.process(task)) + image_rows = df[df["modality"] == "image"].sort_values("position") + assert len(image_rows) == 2 + + good_row = image_rows.iloc[0] + assert good_row["binary_content"] is not None + assert pd.isna(good_row["materialize_error"]) or good_row["materialize_error"] is None + + bad_row = image_rows.iloc[1] + assert bad_row["binary_content"] is not None, "Original TIFF bytes must be preserved on extraction failure" + assert bad_row["binary_content"] == tiff_bytes, "binary_content must be the full original TIFF" + assert isinstance(bad_row["materialize_error"], str), "materialize_error must be set" + assert "frame" in bad_row["materialize_error"] From 8ee4622716d4c4d22e216a47d012052cb139a6ae Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 4 Mar 2026 00:20:20 +0000 Subject: [PATCH 61/62] Add interleaved module coverage tests (17-83% -> 89-100%) New parametrized and data-driven tests across 6 test files covering all previously untested branches in materialization, validation utils, InterleavedBatch task, filter/annotator stages, readers, and writers. Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../interleaved/test_interleaved_task.py | 166 +++++++++ .../interleaved/test_materialization.py | 341 ++++++++++++++++++ .../interleaved/test_multimodal_core.py | 106 ++++++ .../interleaved/test_multimodal_reader.py | 129 +++++++ .../interleaved/test_multimodal_writer.py | 68 ++++ .../interleaved/test_validation_utils.py | 142 ++++++++ 6 files changed, 952 insertions(+) create mode 100644 tests/stages/interleaved/test_interleaved_task.py create mode 100644 tests/stages/interleaved/test_materialization.py create mode 100644 tests/stages/interleaved/test_validation_utils.py diff --git a/tests/stages/interleaved/test_interleaved_task.py b/tests/stages/interleaved/test_interleaved_task.py new file mode 100644 index 0000000000..4a4e09a22d --- /dev/null +++ b/tests/stages/interleaved/test_interleaved_task.py @@ -0,0 +1,166 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 pandas as pd +import pyarrow as pa +import pytest + +from nemo_curator.tasks import InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA + +_SAMPLE_ROW = { + "sample_id": "s1", + "position": 0, + "modality": "text", + "content_type": "text/plain", + "text_content": "hello", + "binary_content": None, + "source_ref": None, + "materialize_error": None, +} + + +def _make_batch(data: pa.Table | pd.DataFrame) -> InterleavedBatch: + return InterleavedBatch(task_id="t", dataset_name="d", data=data) + + +# --- to_pyarrow --- + + +@pytest.mark.parametrize("data_type", ["pyarrow", "pandas"]) +def test_to_pyarrow(data_type: str) -> None: + if data_type == "pyarrow": + data = pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA) + else: + data = pd.DataFrame([_SAMPLE_ROW]) + result = _make_batch(data).to_pyarrow() + assert isinstance(result, pa.Table) + + +def test_to_pyarrow_invalid_type() -> None: + task = _make_batch(pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA)) + object.__setattr__(task, "data", [1, 2, 3]) + with pytest.raises(TypeError, match="Cannot convert"): + task.to_pyarrow() + + +# --- to_pandas --- + + +def test_to_pandas_invalid_type() -> None: + task = _make_batch(pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA)) + object.__setattr__(task, "data", [1, 2, 3]) + with pytest.raises(TypeError, match="Cannot convert"): + task.to_pandas() + + +# --- get_columns --- + + +@pytest.mark.parametrize("data_type", ["pyarrow", "pandas"]) +def test_get_columns(data_type: str) -> None: + if data_type == "pyarrow": + data = pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA) + else: + data = pd.DataFrame([_SAMPLE_ROW]) + cols = _make_batch(data).get_columns() + assert isinstance(cols, list) + assert "sample_id" in cols + assert "modality" in cols + + +def test_get_columns_invalid_type() -> None: + task = _make_batch(pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA)) + object.__setattr__(task, "data", [1, 2, 3]) + with pytest.raises(TypeError, match="Unsupported data type"): + task.get_columns() + + +# --- validate --- + + +@pytest.mark.parametrize( + ("data_factory", "expected"), + [ + pytest.param( + lambda: pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA), + True, + id="valid_task", + ), + pytest.param( + lambda: pa.Table.from_pylist([], schema=INTERLEAVED_SCHEMA), + False, + id="empty_task", + ), + pytest.param( + lambda: pa.table({"sample_id": ["s1"], "position": [0]}), + False, + id="missing_required_columns", + ), + ], +) +def test_validate(data_factory: object, expected: bool) -> None: + task = _make_batch(data_factory()) + assert task.validate() is expected + + +# --- add_rows / delete_rows --- + + +def test_add_rows_and_delete_rows_not_implemented() -> None: + task = _make_batch(pa.Table.from_pylist([_SAMPLE_ROW], schema=INTERLEAVED_SCHEMA)) + with pytest.raises(NotImplementedError): + task.add_rows(pd.DataFrame([_SAMPLE_ROW])) + with pytest.raises(NotImplementedError): + task.delete_rows(pd.Series([True])) + + +# --- parse_source_ref edge cases --- + + +def test_parse_source_ref_non_dict_raises() -> None: + with pytest.raises(TypeError, match="source_ref must decode to a JSON object"): + InterleavedBatch.parse_source_ref("[1, 2]") + + +def test_parse_source_ref_with_frame_index() -> None: + ref = json.dumps({"path": "/a.tar", "member": "m.jpg", "byte_offset": 10, "byte_size": 20, "frame_index": 5}) + parsed = InterleavedBatch.parse_source_ref(ref) + assert parsed["path"] == "/a.tar" + assert parsed["member"] == "m.jpg" + assert parsed["byte_offset"] == 10 + assert parsed["byte_size"] == 20 + assert parsed["frame_index"] == 5 + + +# --- build_source_ref --- + + +@pytest.mark.parametrize( + ("frame_index", "key_present"), + [ + pytest.param(3, True, id="with_frame_index"), + pytest.param(None, False, id="without_frame_index"), + ], +) +def test_build_source_ref_frame_index(frame_index: int | None, key_present: bool) -> None: + ref_str = InterleavedBatch.build_source_ref( + path="/a.tar", member="m.jpg", byte_offset=10, byte_size=20, frame_index=frame_index, + ) + parsed = json.loads(ref_str) + assert ("frame_index" in parsed) is key_present + if key_present: + assert parsed["frame_index"] == frame_index diff --git a/tests/stages/interleaved/test_materialization.py b/tests/stages/interleaved/test_materialization.py new file mode 100644 index 0000000000..5640138664 --- /dev/null +++ b/tests/stages/interleaved/test_materialization.py @@ -0,0 +1,341 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 io import BytesIO +from pathlib import Path +from unittest.mock import patch + +import pandas as pd +import pyarrow as pa +import pytest +from PIL import Image + +from nemo_curator.stages.interleaved.utils.materialization import ( + _build_image_mask, + _classify_rows, + _extract_tiff_frame, + _fill_range_read_rows, + _fill_tar_extract_rows, + _get_frame_index, + _init_materialization_buffers, + _scatter_range_blobs, + materialize_task_binary_content, +) +from nemo_curator.tasks import InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA + +from .conftest import build_multi_frame_tiff, write_tar + + +def _image_task(rows: list[dict], metadata: dict | None = None) -> InterleavedBatch: + table = pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA) + return InterleavedBatch(task_id="test", dataset_name="d", data=table, _metadata=metadata or {}) + + +def _image_row( + path: str | None, + member: str | None = None, + byte_offset: int | None = None, + byte_size: int | None = None, + content_type: str = "image/jpeg", +) -> dict: + return { + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": content_type, + "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref( + path=path, member=member, byte_offset=byte_offset, byte_size=byte_size, + ), + "materialize_error": None, + } + + +# --- _get_frame_index --- + + +@pytest.mark.parametrize( + ("val", "expected"), + [ + pytest.param(None, None, id="none_value"), + pytest.param(float("nan"), None, id="nan_value"), + ], +) +def test_get_frame_index_returns_none_for_missing_values(val: object, expected: None) -> None: + df = pd.DataFrame({"_src_frame_index": [val], "other": [1]}) + assert _get_frame_index(df, 0) is expected + + +# --- _classify_rows edge cases --- + + +@pytest.mark.parametrize( + "path_val", + [pytest.param(float("nan"), id="nan_path"), pytest.param("", id="empty_path")], +) +def test_classify_rows_missing_path_variants(path_val: object) -> None: + df = pd.DataFrame({ + "_src_path": [path_val], + "_src_member": [None], + "_src_byte_offset": [None], + "_src_byte_size": [None], + }) + result = _classify_rows(df, pd.Series([True])) + assert result.missing == [0] + + +def test_classify_rows_range_with_zero_size() -> None: + df = pd.DataFrame({ + "_src_path": ["/shard.tar"], + "_src_member": ["img.jpg"], + "_src_byte_offset": [100], + "_src_byte_size": [0], + }) + result = _classify_rows(df, pd.Series([True])) + assert "/shard.tar" in result.tar_extract + assert not result.range_read + + +# --- _extract_tiff_frame --- + + +def _make_jpeg_bytes() -> bytes: + buf = BytesIO() + Image.new("RGB", (10, 10)).save(buf, format="JPEG") + return buf.getvalue() + + +@pytest.mark.parametrize( + ("image_bytes", "frame_index"), + [ + pytest.param(None, 0, id="non_tiff_passthrough"), + pytest.param(None, 99, id="oob_frame_returns_none"), + pytest.param(b"not-an-image", 0, id="corrupt_returns_none"), + ], +) +def test_extract_tiff_frame_variants(image_bytes: bytes | None, frame_index: int) -> None: + if image_bytes is None and frame_index == 0: + jpeg_bytes = _make_jpeg_bytes() + result = _extract_tiff_frame(jpeg_bytes, frame_index) + assert result == jpeg_bytes + elif image_bytes is None and frame_index == 99: + tiff_bytes = build_multi_frame_tiff(1) + result = _extract_tiff_frame(tiff_bytes, frame_index) + assert result is None + else: + result = _extract_tiff_frame(image_bytes, frame_index) + assert result is None + + +# --- _fill_tar_extract_rows --- + + +def test_fill_tar_extract_rows_bad_tar_path() -> None: + groups = {"/nonexistent/path.tar": [(0, "img.jpg", None)]} + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _fill_tar_extract_rows(groups, {}, binary_values, error_values) + assert error_values[0] == "failed to read path" + + +def test_fill_tar_extract_rows_frame_extraction_failure(tmp_path: Path) -> None: + tiff_bytes = build_multi_frame_tiff(1) + tar_path = write_tar(tmp_path / "oob.tar", {"doc.tiff": tiff_bytes}) + groups = {tar_path: [(0, "doc.tiff", 99)]} + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _fill_tar_extract_rows(groups, {}, binary_values, error_values) + assert error_values[0] is not None + assert "failed to extract frame" in error_values[0] + + +# --- _scatter_range_blobs --- + + +@pytest.mark.parametrize( + ("blob", "expected_error_substr"), + [ + pytest.param(RuntimeError("fail"), "range read error", id="exception_blob"), + pytest.param(None, "empty range read", id="none_blob"), + pytest.param(b"", "empty range read", id="empty_blob"), + ], +) +def test_scatter_range_blobs_error_cases(blob: object, expected_error_substr: str) -> None: + range_keys = [(0, 10)] + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = { + (0, 10): [(0, "img.jpg", None)], + } + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _scatter_range_blobs([blob], range_keys, unique_ranges, binary_values, error_values) + assert error_values[0] is not None + assert expected_error_substr in error_values[0] + + +def test_scatter_range_blobs_bytearray_conversion() -> None: + range_keys = [(0, 10)] + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = { + (0, 10): [(0, "img.jpg", None)], + } + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _scatter_range_blobs([bytearray(b"image-data")], range_keys, unique_ranges, binary_values, error_values) + assert binary_values[0] == b"image-data" + assert isinstance(binary_values[0], bytes) + assert error_values[0] is None + + +def test_scatter_range_blobs_with_tiff_frame() -> None: + tiff_bytes = build_multi_frame_tiff(3) + range_keys = [(0, len(tiff_bytes))] + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = { + (0, len(tiff_bytes)): [(0, "doc.tiff", 1)], + } + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _scatter_range_blobs([tiff_bytes], range_keys, unique_ranges, binary_values, error_values) + assert binary_values[0] is not None + assert error_values[0] is None + img = Image.open(BytesIO(binary_values[0])) + assert img.n_frames == 1 + + +def test_scatter_range_blobs_tiff_frame_extraction_failure() -> None: + tiff_bytes = build_multi_frame_tiff(1) + range_keys = [(0, len(tiff_bytes))] + unique_ranges: dict[tuple[int, int], list[tuple[int, str, int | None]]] = { + (0, len(tiff_bytes)): [(0, "doc.tiff", 99)], + } + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + _scatter_range_blobs([tiff_bytes], range_keys, unique_ranges, binary_values, error_values) + assert error_values[0] is not None + assert "failed to extract frame" in error_values[0] + + +# --- _fill_range_read_rows --- + + +def test_fill_range_read_rows_url_to_fs_failure() -> None: + groups = {"bad://path": [(0, "img.jpg", 100, 200, None)]} + binary_values: list[object] = [None] + error_values: list[str | None] = [None] + with patch( + "nemo_curator.stages.interleaved.utils.materialization.url_to_fs", + side_effect=ValueError("bad"), + ): + _fill_range_read_rows(groups, {}, binary_values, error_values) + assert error_values[0] == "failed to resolve filesystem" + + +# --- _init_materialization_buffers --- + + +@pytest.mark.parametrize( + "drop_col", + [pytest.param("materialize_error", id="no_materialize_error"), pytest.param("binary_content", id="no_binary")], +) +def test_init_materialization_buffers_missing_column(drop_col: str) -> None: + df = pd.DataFrame({"modality": ["image"], "binary_content": [None], "materialize_error": [None]}) + df = df.drop(columns=[drop_col]) + binary_values, error_values = _init_materialization_buffers(df) + assert len(binary_values) == 1 + assert len(error_values) == 1 + + +# --- _build_image_mask --- + + +@pytest.mark.parametrize( + ("df_data", "kwargs", "expected"), + [ + pytest.param( + {"other": [1, 2]}, + {"only_missing_binary": True, "image_content_types": None}, + [False, False], + id="no_modality_column", + ), + pytest.param( + { + "modality": ["image", "image"], + "content_type": ["image/jpeg", "image/png"], + "binary_content": [None, None], + }, + {"only_missing_binary": True, "image_content_types": ("image/jpeg",)}, + [True, False], + id="content_type_filter", + ), + pytest.param( + { + "modality": ["image", "image"], + "content_type": ["image/jpeg", "image/jpeg"], + "binary_content": [b"existing", None], + }, + {"only_missing_binary": False, "image_content_types": None}, + [True, True], + id="only_missing_binary_false", + ), + ], +) +def test_build_image_mask(df_data: dict, kwargs: dict, expected: list[bool]) -> None: + mask = _build_image_mask(pd.DataFrame(df_data), **kwargs) + assert mask.tolist() == expected + + +# --- materialize_task_binary_content with content_type filter --- + + +def test_materialize_with_content_type_filter(tmp_path: Path) -> None: + jpeg_bytes = b"jpeg-data" + png_bytes = b"png-data" + jpeg_path = tmp_path / "img.jpg" + png_path = tmp_path / "img.png" + jpeg_path.write_bytes(jpeg_bytes) + png_path.write_bytes(png_bytes) + + rows = [ + _image_row(path=str(jpeg_path), content_type="image/jpeg"), + {**_image_row(path=str(png_path), content_type="image/png"), "position": 1}, + ] + task = _image_task(rows) + result = materialize_task_binary_content(task, image_content_types=("image/jpeg",)) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == jpeg_bytes + assert df.loc[1, "binary_content"] is None or pd.isna(df.loc[1, "binary_content"]) + + +def test_materialize_with_only_missing_binary_false(tmp_path: Path) -> None: + new_bytes = b"fresh-image" + img_path = tmp_path / "img.jpg" + img_path.write_bytes(new_bytes) + + rows = [{ + "sample_id": "s1", + "position": 0, + "modality": "image", + "content_type": "image/jpeg", + "text_content": None, + "binary_content": b"old-bytes", + "source_ref": InterleavedBatch.build_source_ref(path=str(img_path), member=None), + "materialize_error": None, + }] + task = InterleavedBatch( + task_id="re_mat", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + result = materialize_task_binary_content(task, only_missing_binary=False) + df = result.to_pandas() + assert df.loc[0, "binary_content"] == new_bytes diff --git a/tests/stages/interleaved/test_multimodal_core.py b/tests/stages/interleaved/test_multimodal_core.py index 660258c13d..900e3fcc86 100644 --- a/tests/stages/interleaved/test_multimodal_core.py +++ b/tests/stages/interleaved/test_multimodal_core.py @@ -25,6 +25,7 @@ from nemo_curator.core.utils import split_table_by_group_max_bytes from nemo_curator.stages.interleaved.io.reader import WebdatasetReader from nemo_curator.stages.interleaved.stages import ( + BaseInterleavedAnnotatorStage, BaseInterleavedFilterStage, InterleavedAspectRatioFilterStage, ) @@ -873,3 +874,108 @@ def test_materialize_extracts_individual_tiff_frames(tmp_path: Path) -> None: frame_img = Image.open(BytesIO(bc)) assert frame_img.n_frames == 1, f"Frame {i} must be a single-frame TIFF" assert len(bc) < len(tiff_bytes), "Single frame must be smaller than full multi-frame TIFF" + + +# --- annotator / filter stage edge cases --- + + +def test_annotator_process_empty_batch() -> None: + """BaseInterleavedAnnotatorStage.process returns task unchanged for empty data.""" + + class _Passthrough(BaseInterleavedAnnotatorStage): + name: str = "passthrough" + + def annotate(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.DataFrame: + return df + + empty_table = pa.Table.from_pylist([], schema=INTERLEAVED_SCHEMA) + task = InterleavedBatch(task_id="empty", dataset_name="d", data=empty_table) + result = _Passthrough().process(task) + assert result is task + + +def test_filter_drop_invalid_rows_true() -> None: + """drop_invalid_rows=True (default) filters rows with bad modality or invalid position.""" + + class _KeepAllContent(BaseInterleavedFilterStage): + name: str = "keep_all" + + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: + return pd.Series(True, index=df.index, dtype=bool) + + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, "materialize_error": None}, + {"sample_id": "s1", "position": 0, "modality": "text", "content_type": "text/plain", + "text_content": "ok", "binary_content": None, "source_ref": None, "materialize_error": None}, + {"sample_id": "s1", "position": 1, "modality": "video", "content_type": "video/mp4", + "text_content": None, "binary_content": None, "source_ref": None, "materialize_error": None}, + {"sample_id": "s1", "position": -1, "modality": "text", "content_type": "text/plain", + "text_content": "bad", "binary_content": None, "source_ref": None, "materialize_error": None}, + ] + task = InterleavedBatch( + task_id="drop_test", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + stage = _KeepAllContent(drop_invalid_rows=True) + out_df = stage.process(task).to_pandas() + assert len(out_df) == 2 + assert out_df["modality"].tolist() == ["metadata", "text"] + + +def test_iter_materialized_bytes_empty_mask() -> None: + """iter_materialized_bytes yields nothing when row_mask selects no rows.""" + rows = [ + {"sample_id": "s1", "position": 0, "modality": "text", "content_type": "text/plain", + "text_content": "hello", "binary_content": None, "source_ref": None, "materialize_error": None}, + ] + task = InterleavedBatch( + task_id="empty_mask", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + df = task.to_pandas() + stage = InterleavedAspectRatioFilterStage() + empty_mask = pd.Series(False, index=df.index, dtype=bool) + assert list(stage.iter_materialized_bytes(task, df, empty_mask)) == [] + + +def test_annotate_metadata_only_rows() -> None: + """Metadata-only rows are orphans and must all be dropped.""" + + class _KeepAllContent(BaseInterleavedFilterStage): + name: str = "keep_all" + + def content_keep_mask(self, task: InterleavedBatch, df: pd.DataFrame) -> pd.Series: + return pd.Series(True, index=df.index, dtype=bool) + + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, "materialize_error": None}, + {"sample_id": "s2", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, "materialize_error": None}, + ] + task = InterleavedBatch( + task_id="meta_only", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + stage = _KeepAllContent(drop_invalid_rows=False) + out_df = stage.process(task).to_pandas() + assert len(out_df) == 0 + + +def test_aspect_ratio_filter_no_image_rows() -> None: + """Filter is a no-op when there are no image rows.""" + rows = [ + {"sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", + "text_content": None, "binary_content": None, "source_ref": None, "materialize_error": None}, + {"sample_id": "s1", "position": 0, "modality": "text", "content_type": "text/plain", + "text_content": "hello", "binary_content": None, "source_ref": None, "materialize_error": None}, + ] + task = InterleavedBatch( + task_id="no_img", dataset_name="d", + data=pa.Table.from_pylist(rows, schema=INTERLEAVED_SCHEMA), + ) + stage = InterleavedAspectRatioFilterStage(drop_invalid_rows=False) + out_df = stage.process(task).to_pandas() + assert len(out_df) == 2 + assert out_df["modality"].tolist() == ["metadata", "text"] diff --git a/tests/stages/interleaved/test_multimodal_reader.py b/tests/stages/interleaved/test_multimodal_reader.py index afb88b6029..b23489fd76 100644 --- a/tests/stages/interleaved/test_multimodal_reader.py +++ b/tests/stages/interleaved/test_multimodal_reader.py @@ -586,3 +586,132 @@ def test_reader_materialize_preserves_raw_bytes_on_frame_extraction_failure(tmp_ assert bad_row["binary_content"] == tiff_bytes, "binary_content must be the full original TIFF" assert isinstance(bad_row["materialize_error"], str), "materialize_error must be set" assert "frame" in bad_row["materialize_error"] + + +# --- BaseInterleavedReader --- + + +def test_base_reader_inputs_outputs() -> None: + reader = WebdatasetReaderStage(source_id_field="pdf_name") + assert reader.inputs() == (["data"], []) + assert reader.outputs() == (["data"], ["sample_id", "position", "modality"]) + + +# --- WebdatasetReaderStage edge cases --- + + +def test_reader_empty_tar(tmp_path: Path) -> None: + """Tar with no JSON members produces an empty batch with correct schema.""" + tar_path = tmp_path / "empty.tar" + with tarfile.open(tar_path, "w") as tf: + img_info = tarfile.TarInfo(name="image.jpg") + img_info.size = 3 + tf.addfile(img_info, BytesIO(b"abc")) + task = FileGroupTask( + task_id="empty", dataset_name="d", data=[str(tar_path)], + _metadata={"source_files": [str(tar_path)]}, + ) + reader = WebdatasetReaderStage(source_id_field="pdf_name") + result = reader.process(task) + assert isinstance(result, InterleavedBatch) + assert len(result.to_pandas()) == 0 + assert "sample_id" in result.get_columns() + + +def test_reader_multi_tar(tmp_path: Path) -> None: + """Multiple tar paths in a single FileGroupTask combine rows from all tars.""" + for name, sample_id in [("shard1.tar", "doc1"), ("shard2.tar", "doc2")]: + payload = {"pdf_name": f"{sample_id}.pdf", "texts": ["hello"], "images": []} + write_tar( + tmp_path / name, + {f"{sample_id}.json": json.dumps(payload).encode(), f"{sample_id}.jpg": b"img"}, + ) + task = FileGroupTask( + task_id="multi", dataset_name="d", + data=[str(tmp_path / "shard1.tar"), str(tmp_path / "shard2.tar")], + _metadata={"source_files": ["shard1.tar", "shard2.tar"]}, + ) + reader = WebdatasetReaderStage(source_id_field="pdf_name") + result = reader.process(task) + if isinstance(result, list): + all_dfs = [b.to_pandas() for b in result] + df = pd.concat(all_dfs, ignore_index=True) + else: + df = result.to_pandas() + assert df["sample_id"].nunique() == 2 + + +def test_reader_max_batch_bytes_splits(tmp_path: Path) -> None: + """Very small max_batch_bytes splits output into multiple InterleavedBatch.""" + for sample_id in ["doc1", "doc2"]: + payload = {"pdf_name": f"{sample_id}.pdf", "texts": ["text"], "images": []} + write_tar( + tmp_path / f"{sample_id}.tar", + {f"{sample_id}.json": json.dumps(payload).encode()}, + ) + task = FileGroupTask( + task_id="split", dataset_name="d", + data=[str(tmp_path / "doc1.tar"), str(tmp_path / "doc2.tar")], + _metadata={"source_files": ["doc1.tar", "doc2.tar"]}, + ) + reader = WebdatasetReaderStage(source_id_field="pdf_name", max_batch_bytes=1) + result = reader.process(task) + assert isinstance(result, list) + assert len(result) >= 2 + for batch in result: + assert "_processed_" in batch.task_id + + +def test_reader_non_list_texts_field(tmp_path: Path) -> None: + """Non-list texts field produces no text rows.""" + payload = {"pdf_name": "doc.pdf", "texts": "not a list", "images": []} + tar_path = write_tar( + tmp_path / "non_list.tar", + {"sample.json": json.dumps(payload).encode()}, + ) + task = task_for_tar(tar_path) + reader = WebdatasetReaderStage(source_id_field="pdf_name") + df = _as_df(reader.process(task)) + assert (df["modality"] == "text").sum() == 0 + + +def test_reader_non_list_images_field(tmp_path: Path) -> None: + """Non-list images field produces no image rows.""" + payload = {"pdf_name": "doc.pdf", "texts": ["hello"], "images": None} + tar_path = write_tar( + tmp_path / "no_images.tar", + {"sample.json": json.dumps(payload).encode()}, + ) + task = task_for_tar(tar_path) + reader = WebdatasetReaderStage(source_id_field="pdf_name") + df = _as_df(reader.process(task)) + assert (df["modality"] == "image").sum() == 0 + assert (df["modality"] == "text").sum() == 1 + + +@pytest.mark.parametrize( + ("image_token", "default_member", "member_names", "expected"), + [ + pytest.param(None, "default.jpg", {"default.jpg"}, None, id="none_token"), + pytest.param("explicit.jpg", "default.jpg", {"explicit.jpg", "default.jpg"}, "explicit.jpg", id="in_members"), + pytest.param("unknown", "default.jpg", {"default.jpg"}, "default.jpg", id="fallback_to_default"), + ], +) +def test_resolve_image_content_key( + image_token: object, default_member: str | None, member_names: set[str], expected: str | None, +) -> None: + result = WebdatasetReaderStage._resolve_image_content_key(image_token, default_member, member_names) + assert result == expected + + +def test_reader_uses_stem_as_sample_id(tmp_path: Path) -> None: + """When sample_id_field is None, uses Path(member.name).stem as sample_id.""" + payload = {"pdf_name": "doc.pdf", "texts": ["hello"], "images": []} + tar_path = write_tar( + tmp_path / "stem.tar", + {"my_custom_name.json": json.dumps(payload).encode()}, + ) + task = task_for_tar(tar_path) + reader = WebdatasetReaderStage(source_id_field="pdf_name", sample_id_field=None) + df = _as_df(reader.process(task)) + assert (df["sample_id"] == "my_custom_name").all() diff --git a/tests/stages/interleaved/test_multimodal_writer.py b/tests/stages/interleaved/test_multimodal_writer.py index cee26ec32a..edadbf4625 100644 --- a/tests/stages/interleaved/test_multimodal_writer.py +++ b/tests/stages/interleaved/test_multimodal_writer.py @@ -20,6 +20,7 @@ import pandas as pd import pyarrow as pa import pyarrow.parquet as pq +import pytest from nemo_curator.stages.interleaved.io.readers.webdataset import WebdatasetReaderStage from nemo_curator.stages.interleaved.io.writers.tabular import InterleavedParquetWriterStage @@ -288,3 +289,70 @@ def test_heterogeneous_passthrough_fields_combine_as_nullable(tmp_path: Path) -> assert meta_b["url"] == "https://example.com/b" assert meta_b["language"] == "en" assert pd.isna(meta_b["score"]) + + +# --- writer edge cases --- + + +def test_writer_uses_uuid_when_no_source_files(tmp_path: Path) -> None: + """Writer falls back to UUID filename when task has no source_files metadata.""" + df = pd.DataFrame([{ + "sample_id": "s1", "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": "hello", + "binary_content": None, "source_ref": None, "materialize_error": None, + }]) + task = InterleavedBatch(task_id="no_source", dataset_name="test", data=df, _metadata={}) + out_dir = tmp_path / "uuid_out" + writer = InterleavedParquetWriterStage( + path=str(out_dir), materialize_on_write=False, mode="overwrite", + ) + write_task = writer.process(task) + assert len(write_task.data) == 1 + assert Path(write_task.data[0]).exists() + + +def test_writer_no_materialize_preserves_null_binary(tmp_path: Path) -> None: + """materialize_on_write=False leaves binary_content null even for image rows.""" + table = pa.Table.from_pylist([{ + "sample_id": "s1", "position": 0, "modality": "image", + "content_type": "image/jpeg", "text_content": None, + "binary_content": None, + "source_ref": InterleavedBatch.build_source_ref(path="/fake/img.jpg", member=None), + "materialize_error": None, + }], schema=INTERLEAVED_SCHEMA) + task = InterleavedBatch( + task_id="no_mat", dataset_name="test", data=table, + _metadata={"source_files": ["/fake/img.jpg"]}, + ) + writer = InterleavedParquetWriterStage( + path=str(tmp_path / "no_mat_out"), materialize_on_write=False, mode="overwrite", + ) + write_task = writer.process(task) + written = pd.read_parquet(write_task.data[0]) + assert pd.isna(written.loc[0, "binary_content"]) + + +@pytest.mark.parametrize( + "compression", + [pytest.param("gzip", id="gzip"), pytest.param("snappy", id="snappy")], +) +def test_writer_custom_compression(tmp_path: Path, compression: str) -> None: + """Custom compression in write_kwargs is used in the written parquet.""" + df = pd.DataFrame([{ + "sample_id": "s1", "position": 0, "modality": "text", + "content_type": "text/plain", "text_content": "hello", + "binary_content": None, "source_ref": None, "materialize_error": None, + }]) + task = InterleavedBatch( + task_id="comp", dataset_name="test", data=df, + _metadata={"source_files": ["test.tar"]}, + ) + writer = InterleavedParquetWriterStage( + path=str(tmp_path / f"{compression}_out"), + materialize_on_write=False, mode="overwrite", + write_kwargs={"compression": compression}, + ) + write_task = writer.process(task) + meta = pq.read_metadata(write_task.data[0]) + actual = meta.row_group(0).column(0).compression.lower() + assert actual == compression diff --git a/tests/stages/interleaved/test_validation_utils.py b/tests/stages/interleaved/test_validation_utils.py new file mode 100644 index 0000000000..e8bf7736a7 --- /dev/null +++ b/tests/stages/interleaved/test_validation_utils.py @@ -0,0 +1,142 @@ +# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. +# +# 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 pyarrow as pa +import pytest + +from nemo_curator.stages.interleaved.utils.validation_utils import ( + require_source_id_field, + resolve_storage_options, + validate_and_project_source_fields, +) +from nemo_curator.tasks import InterleavedBatch +from nemo_curator.tasks.interleaved import INTERLEAVED_SCHEMA + + +def _make_task(metadata: dict | None = None) -> InterleavedBatch: + table = pa.Table.from_pylist([], schema=INTERLEAVED_SCHEMA) + return InterleavedBatch(task_id="t", dataset_name="d", data=table, _metadata=metadata or {}) + + +# --- require_source_id_field --- + + +@pytest.mark.parametrize( + ("value", "should_raise"), + [ + pytest.param("", True, id="empty_raises"), + pytest.param("pdf_name", False, id="valid_returns"), + ], +) +def test_require_source_id_field(value: str, should_raise: bool) -> None: + if should_raise: + with pytest.raises(ValueError, match="source_id_field must be provided"): + require_source_id_field(value) + else: + assert require_source_id_field(value) == value + + +# --- resolve_storage_options --- + + +@pytest.mark.parametrize( + ("task_metadata", "io_kwargs", "expected"), + [ + pytest.param(None, None, {}, id="none_none"), + pytest.param( + {"source_storage_options": {"key": "s3secret"}}, + None, + {"key": "s3secret"}, + id="task_metadata", + ), + pytest.param( + {}, + {"storage_options": {"k": "v"}}, + {"k": "v"}, + id="io_kwargs_fallback", + ), + pytest.param( + {}, + {"storage_options": "not-a-dict"}, + {}, + id="non_dict_storage_options", + ), + ], +) +def test_resolve_storage_options( + task_metadata: dict | None, + io_kwargs: dict | None, + expected: dict, +) -> None: + task = _make_task(task_metadata) if task_metadata is not None else None + assert resolve_storage_options(task=task, io_kwargs=io_kwargs) == expected + + +# --- validate_and_project_source_fields --- + + +@pytest.mark.parametrize( + ("sample", "fields", "excluded", "expected"), + [ + pytest.param( + {"x": 1, "y": 2, "z": 3}, + None, + {"x"}, + {"y": 2, "z": 3}, + id="fields_none_excludes", + ), + pytest.param( + {"a": {"nested": True}}, + None, + set(), + {"a": json.dumps({"nested": True}, ensure_ascii=True)}, + id="dict_value_serialized", + ), + pytest.param( + {"a": [1, 2]}, + None, + set(), + {"a": json.dumps([1, 2], ensure_ascii=True)}, + id="list_value_serialized", + ), + pytest.param( + {"a": "hello"}, + None, + set(), + {"a": "hello"}, + id="scalar_passthrough", + ), + pytest.param( + {"a": 1}, + ("missing_key",), + set(), + {"missing_key": None}, + id="missing_fills_none", + ), + ], +) +def test_validate_and_project_source_fields( + sample: dict, + fields: tuple[str, ...] | None, + excluded: set[str], + expected: dict, +) -> None: + assert validate_and_project_source_fields(sample, fields, excluded) == expected + + +def test_validate_and_project_reserved_field_raises() -> None: + with pytest.raises(ValueError, match="fields contains reserved keys"): + validate_and_project_source_fields({"reserved": 1}, ("reserved",), {"reserved"}) From 8ece4d0a4ced69834e588ec94c0f146646a71d2c Mon Sep 17 00:00:00 2001 From: Vibhu Jawa Date: Wed, 4 Mar 2026 02:00:34 +0000 Subject: [PATCH 62/62] Fix WDS writer metadata_json KeyError after schema update Remove references to the dropped metadata_json column. Metadata passthrough fields are now read directly from extra columns on the metadata row, matching the current INTERLEAVED_SCHEMA. Signed-off-by: Vibhu Jawa Made-with: Cursor --- .../interleaved/io/writers/webdataset.py | 16 ++------------- .../interleaved/test_multimodal_wds_writer.py | 20 +++++++++---------- 2 files changed, 12 insertions(+), 24 deletions(-) diff --git a/nemo_curator/stages/interleaved/io/writers/webdataset.py b/nemo_curator/stages/interleaved/io/writers/webdataset.py index 2b94a19b1b..31c28c9534 100644 --- a/nemo_curator/stages/interleaved/io/writers/webdataset.py +++ b/nemo_curator/stages/interleaved/io/writers/webdataset.py @@ -88,18 +88,6 @@ def _build_index(sid_col: list | pd.Series) -> list[tuple[str, list[int]]]: return [(sid, sid_to_indices[sid]) for sid in insertion_order] -def _extract_metadata_payload(meta_val: object) -> dict[str, Any]: - if meta_val is None or pd.isna(meta_val): - return {} - try: - parsed = json.loads(str(meta_val)) - except (json.JSONDecodeError, TypeError): - return {} - if not isinstance(parsed, dict): - return {} - parsed.pop("_sample_source", None) - return parsed - def _safe_json_value(val: object) -> object: """Convert a value to a JSON-safe type.""" @@ -126,8 +114,8 @@ def _collect_sample_rows( pos = int(row["position"]) row_extra = {c: _safe_json_value(row[c]) for c in extra_columns} if extra_columns else {} if mod == "metadata": - payload.update(_extract_metadata_payload(row["metadata_json"])) - extras["metadata"] = row_extra + payload.update(row_extra) + extras["metadata"] = {} elif mod == "text": text_at_pos[pos] = row["text_content"] extras["text"][pos] = row_extra diff --git a/tests/stages/interleaved/test_multimodal_wds_writer.py b/tests/stages/interleaved/test_multimodal_wds_writer.py index d63a4f6e98..d5a29405a2 100644 --- a/tests/stages/interleaved/test_multimodal_wds_writer.py +++ b/tests/stages/interleaved/test_multimodal_wds_writer.py @@ -180,7 +180,7 @@ def test_writer_handles_no_binary_content(tmp_path: Path): def test_writer_preserves_extra_columns(tmp_path: Path): - """Extra (non-schema) columns must be round-tripped in _row_extra / _metadata_extra.""" + """Extra (non-schema) columns must be round-tripped via _row_extra and top-level payload.""" import pandas as pd img_bytes = generate_jpeg_bytes(seed=0) @@ -189,8 +189,8 @@ def test_writer_preserves_extra_columns(tmp_path: Path): "sample_id": "s1", "position": -1, "modality": "metadata", "content_type": "application/json", "text_content": None, "binary_content": None, "source_ref": None, - "metadata_json": json.dumps({"url": "https://example.com"}), "materialize_error": None, + "url": "https://example.com", "nv_width": None, "nv_height": None, "match_status": None, "custom_score": 0.95, }, @@ -198,7 +198,8 @@ def test_writer_preserves_extra_columns(tmp_path: Path): "sample_id": "s1", "position": 0, "modality": "image", "content_type": "image/jpeg", "text_content": None, "binary_content": img_bytes, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, + "url": None, "nv_width": 100, "nv_height": 80, "match_status": "matched", "custom_score": None, }, @@ -206,7 +207,8 @@ def test_writer_preserves_extra_columns(tmp_path: Path): "sample_id": "s1", "position": 1, "modality": "text", "content_type": "text/plain", "text_content": "caption", "binary_content": None, "source_ref": None, - "metadata_json": None, "materialize_error": None, + "materialize_error": None, + "url": None, "nv_width": None, "nv_height": None, "match_status": None, "custom_score": 0.7, }, @@ -230,6 +232,9 @@ def test_writer_preserves_extra_columns(tmp_path: Path): continue payload = json.load(tf.extractfile(m)) + assert payload["url"] == "https://example.com" + assert payload["custom_score"] == 0.95 + assert "_row_extra" in payload, "Missing _row_extra in JSON payload" row_extra = payload["_row_extra"] assert "text" in row_extra, "Missing text key in _row_extra" @@ -239,21 +244,16 @@ def test_writer_preserves_extra_columns(tmp_path: Path): assert len(row_extra["text"]) == 2, f"Expected 2 text entries, got {len(row_extra['text'])}" assert len(row_extra["image"]) == 2, f"Expected 2 image entries, got {len(row_extra['image'])}" - # pos 0: image row has nv_width=100, text row has nothing special img_extra = row_extra["image"][0] assert img_extra is not None assert img_extra["nv_width"] == 100 assert img_extra["nv_height"] == 80 assert img_extra["match_status"] == "matched" - # pos 1: text row has custom_score=0.7, no image txt_extra = row_extra["text"][1] assert txt_extra is not None assert txt_extra["nv_width"] is None assert txt_extra["custom_score"] == 0.7 assert row_extra["image"][1] is None - # metadata row - meta_extra = row_extra["metadata"] - assert meta_extra["custom_score"] == 0.95 - assert meta_extra["match_status"] is None + assert row_extra["metadata"] == {}