| import os |
| import tempfile |
| from pathlib import Path |
| from unittest import TestCase |
|
|
| import pyarrow as pa |
| import pytest |
|
|
| from datasets.arrow_dataset import Dataset |
| from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions |
| from datasets.info import DatasetInfo |
| from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo |
|
|
| from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases |
|
|
|
|
| class ReaderTest(BaseReader): |
| """ |
| Build a Dataset object out of Instruction instance(s). |
| This reader is made for testing. It mocks file reads. |
| """ |
|
|
| def _get_table_from_filename(self, filename_skip_take, in_memory=False): |
| """Returns a Dataset instance from given (filename, skip, take).""" |
| filename, skip, take = ( |
| filename_skip_take["filename"], |
| filename_skip_take["skip"] if "skip" in filename_skip_take else None, |
| filename_skip_take["take"] if "take" in filename_skip_take else None, |
| ) |
| open(os.path.join(filename), "wb").close() |
| pa_table = pa.Table.from_pydict({"filename": [Path(filename).name] * 100}) |
| if take == -1: |
| take = len(pa_table) - skip |
| if skip is not None and take is not None: |
| pa_table = pa_table.slice(skip, take) |
| return pa_table |
|
|
|
|
| class BaseReaderTest(TestCase): |
| def test_read(self): |
| name = "my_name" |
| train_info = SplitInfo(name="train", num_examples=100) |
| test_info = SplitInfo(name="test", num_examples=100) |
| split_infos = [train_info, test_info] |
| split_dict = SplitDict() |
| split_dict.add(train_info) |
| split_dict.add(test_info) |
| info = DatasetInfo(splits=split_dict) |
|
|
| with tempfile.TemporaryDirectory() as tmp_dir: |
| reader = ReaderTest(tmp_dir, info) |
|
|
| instructions = "test[:33%]" |
| dset = Dataset(**reader.read(name, instructions, split_infos)) |
| self.assertEqual(dset["filename"][0], f"{name}-test") |
| self.assertEqual(dset.num_rows, 33) |
| self.assertEqual(dset.num_columns, 1) |
|
|
| instructions1 = ["train", "test[:33%]"] |
| instructions2 = [Split.TRAIN, ReadInstruction.from_spec("test[:33%]")] |
| for instructions in [instructions1, instructions2]: |
| datasets_kwargs = [reader.read(name, instr, split_infos) for instr in instructions] |
| train_dset, test_dset = (Dataset(**dataset_kwargs) for dataset_kwargs in datasets_kwargs) |
| self.assertEqual(train_dset["filename"][0], f"{name}-train") |
| self.assertEqual(train_dset.num_rows, 100) |
| self.assertEqual(train_dset.num_columns, 1) |
| self.assertIsInstance(train_dset.split, NamedSplit) |
| self.assertEqual(str(train_dset.split), "train") |
| self.assertEqual(test_dset["filename"][0], f"{name}-test") |
| self.assertEqual(test_dset.num_rows, 33) |
| self.assertEqual(test_dset.num_columns, 1) |
| self.assertIsInstance(test_dset.split, NamedSplit) |
| self.assertEqual(str(test_dset.split), "test[:33%]") |
| del train_dset, test_dset |
|
|
| def test_read_sharded(self): |
| name = "my_name" |
| train_info = SplitInfo(name="train", num_examples=1000, shard_lengths=[100] * 10) |
| split_infos = [train_info] |
| split_dict = SplitDict() |
| split_dict.add(train_info) |
| info = DatasetInfo(splits=split_dict) |
|
|
| with tempfile.TemporaryDirectory() as tmp_dir: |
| reader = ReaderTest(tmp_dir, info) |
|
|
| instructions = "train[:33%]" |
| dset = Dataset(**reader.read(name, instructions, split_infos)) |
| self.assertEqual(dset["filename"][0], f"{name}-train-00000-of-00010") |
| self.assertEqual(dset["filename"][-1], f"{name}-train-00003-of-00010") |
| self.assertEqual(dset.num_rows, 330) |
| self.assertEqual(dset.num_columns, 1) |
|
|
| def test_read_files(self): |
| train_info = SplitInfo(name="train", num_examples=100) |
| test_info = SplitInfo(name="test", num_examples=100) |
| split_dict = SplitDict() |
| split_dict.add(train_info) |
| split_dict.add(test_info) |
| info = DatasetInfo(splits=split_dict) |
|
|
| with tempfile.TemporaryDirectory() as tmp_dir: |
| reader = ReaderTest(tmp_dir, info) |
|
|
| files = [ |
| {"filename": os.path.join(tmp_dir, "train")}, |
| {"filename": os.path.join(tmp_dir, "test"), "skip": 10, "take": 10}, |
| ] |
| dset = Dataset(**reader.read_files(files, original_instructions="train+test[10:20]")) |
| self.assertEqual(dset.num_rows, 110) |
| self.assertEqual(dset.num_columns, 1) |
| del dset |
|
|
|
|
| @pytest.mark.parametrize("in_memory", [False, True]) |
| def test_read_table(in_memory, dataset, arrow_file): |
| filename = arrow_file |
| with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase(): |
| table = ArrowReader.read_table(filename, in_memory=in_memory) |
| assert table.shape == dataset.data.shape |
| assert set(table.column_names) == set(dataset.data.column_names) |
| assert dict(table.to_pydict()) == dict(dataset.data.to_pydict()) |
|
|
|
|
| @pytest.mark.parametrize("in_memory", [False, True]) |
| def test_read_files(in_memory, dataset, arrow_file): |
| filename = arrow_file |
| reader = ArrowReader("", None) |
| with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase(): |
| dataset_kwargs = reader.read_files([{"filename": filename}], in_memory=in_memory) |
| assert dataset_kwargs.keys() == {"arrow_table", "info", "split"} |
| table = dataset_kwargs["arrow_table"] |
| assert table.shape == dataset.data.shape |
| assert set(table.column_names) == set(dataset.data.column_names) |
| assert dict(table.to_pydict()) == dict(dataset.data.to_pydict()) |
|
|
|
|
| def test_read_instruction_spec(): |
| assert ReadInstruction("train", to=10, unit="abs").to_spec() == "train[:10]" |
| assert ReadInstruction("train", from_=-80, to=10, unit="%").to_spec() == "train[-80%:10%]" |
|
|
| spec_train_test = "train+test" |
| assert ReadInstruction.from_spec(spec_train_test).to_spec() == spec_train_test |
|
|
| spec_train_abs = "train[2:10]" |
| assert ReadInstruction.from_spec(spec_train_abs).to_spec() == spec_train_abs |
|
|
| spec_train_pct = "train[15%:-20%]" |
| assert ReadInstruction.from_spec(spec_train_pct).to_spec() == spec_train_pct |
|
|
| spec_train_pct_rounding = "train[:10%](closest)" |
| assert ReadInstruction.from_spec(spec_train_pct_rounding).to_spec() == "train[:10%]" |
|
|
| spec_train_pct_rounding = "train[:10%](pct1_dropremainder)" |
| assert ReadInstruction.from_spec(spec_train_pct_rounding).to_spec() == spec_train_pct_rounding |
|
|
| spec_train_test_pct_rounding = "train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)" |
| assert ReadInstruction.from_spec(spec_train_test_pct_rounding).to_spec() == spec_train_test_pct_rounding |
|
|
|
|
| def test_make_file_instructions(): |
| name = "dummy" |
| split_infos = [SplitInfo(name="train", num_examples=100)] |
| instruction = "train[:33%]" |
| filetype_suffix = "arrow" |
| prefix_path = "prefix" |
|
|
| file_instructions = make_file_instructions(name, split_infos, instruction, filetype_suffix, prefix_path) |
| assert isinstance(file_instructions, FileInstructions) |
| assert file_instructions.num_examples == 33 |
| assert file_instructions.file_instructions == [ |
| {"filename": os.path.join(prefix_path, f"{name}-train.arrow"), "skip": 0, "take": 33} |
| ] |
|
|
| split_infos = [SplitInfo(name="train", num_examples=100, shard_lengths=[10] * 10)] |
| file_instructions = make_file_instructions(name, split_infos, instruction, filetype_suffix, prefix_path) |
| assert isinstance(file_instructions, FileInstructions) |
| assert file_instructions.num_examples == 33 |
| assert file_instructions.file_instructions == [ |
| {"filename": os.path.join(prefix_path, f"{name}-train-00000-of-00010.arrow"), "skip": 0, "take": -1}, |
| {"filename": os.path.join(prefix_path, f"{name}-train-00001-of-00010.arrow"), "skip": 0, "take": -1}, |
| {"filename": os.path.join(prefix_path, f"{name}-train-00002-of-00010.arrow"), "skip": 0, "take": -1}, |
| {"filename": os.path.join(prefix_path, f"{name}-train-00003-of-00010.arrow"), "skip": 0, "take": 3}, |
| ] |
|
|
|
|
| @pytest.mark.parametrize("name, expected_exception", [(None, TypeError), ("", ValueError)]) |
| def test_make_file_instructions_raises(name, expected_exception): |
| split_infos = [SplitInfo(name="train", num_examples=100)] |
| instruction = "train" |
| filetype_suffix = "arrow" |
| prefix_path = "prefix_path" |
| with pytest.raises(expected_exception): |
| _ = make_file_instructions(name, split_infos, instruction, filetype_suffix, prefix_path) |
|
|
