From 59068ed57ee7ebf3fecfad2847fe28965569ccaf Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Tue, 22 Jun 2021 19:25:44 +0200 Subject: [PATCH 01/11] add parquet loader, from_parquet, to_parquet --- .../source/package_reference/main_classes.rst | 7 +- src/datasets/arrow_dataset.py | 61 ++++++++ src/datasets/dataset_dict.py | 31 ++++ src/datasets/io/parquet.py | 102 +++++++++++++ src/datasets/packaged_modules/__init__.py | 2 + .../packaged_modules/parquet/__init__.py | 0 .../packaged_modules/parquet/parquet.py | 70 +++++++++ tests/conftest.py | 20 +++ tests/io/test_parquet.py | 134 ++++++++++++++++++ tests/test_arrow_dataset.py | 113 +++++++++++++++ tests/test_dataset_dict.py | 56 ++++++++ 11 files changed, 592 insertions(+), 4 deletions(-) create mode 100644 src/datasets/io/parquet.py create mode 100644 src/datasets/packaged_modules/parquet/__init__.py create mode 100644 src/datasets/packaged_modules/parquet/parquet.py create mode 100644 tests/io/test_parquet.py diff --git a/docs/source/package_reference/main_classes.rst b/docs/source/package_reference/main_classes.rst index c3e34ee0395..3b7d9a493b9 100644 --- a/docs/source/package_reference/main_classes.rst +++ b/docs/source/package_reference/main_classes.rst @@ -25,16 +25,15 @@ The base class :class:`datasets.Dataset` implements a Dataset backed by an Apach __getitem__, cleanup_cache_files, map, filter, select, sort, shuffle, train_test_split, shard, export, save_to_disk, load_from_disk, flatten_indices, - to_csv, to_pandas, to_dict, + to_csv, to_pandas, to_dict, to_json, to_parquet, add_faiss_index, add_faiss_index_from_external_arrays, save_faiss_index, load_faiss_index, add_elasticsearch_index, load_elasticsearch_index, list_indexes, get_index, drop_index, search, search_batch, get_nearest_examples, get_nearest_examples_batch, info, split, builder_name, citation, config_name, dataset_size, description, download_checksums, download_size, features, homepage, license, size_in_bytes, supervised_keys, version, - from_csv, from_json, from_text, + from_csv, from_json, from_parquet, from_text, prepare_for_task, align_labels_with_mapping, - to_json, .. autofunction:: datasets.concatenate_datasets @@ -56,7 +55,7 @@ It also has dataset transform methods like map or filter, to process all the spl flatten_, cast_, remove_columns_, rename_column_, flatten, cast, remove_columns, rename_column, class_encode_column, save_to_disk, load_from_disk, - from_csv, from_json, from_text, + from_csv, from_json, from_parquet, from_text, prepare_for_task, align_labels_with_mapping diff --git a/src/datasets/arrow_dataset.py b/src/datasets/arrow_dataset.py index 24d8aadfb60..231d571ee8b 100644 --- a/src/datasets/arrow_dataset.py +++ b/src/datasets/arrow_dataset.py @@ -519,6 +519,45 @@ def from_json( **kwargs, ).read() + @staticmethod + def from_parquet( + path_or_paths: Union[PathLike, List[PathLike]], + split: Optional[NamedSplit] = None, + features: Optional[Features] = None, + cache_dir: str = None, + keep_in_memory: bool = False, + columns: Optional[List[str]] = None, + **kwargs, + ): + """Create Dataset from Parquet file(s). + + Args: + path_or_paths (path-like or list of path-like): Path(s) of the Parquet file(s). + split (:class:`NamedSplit`, optional): Split name to be assigned to the dataset. + features (:class:`Features`, optional): Dataset features. + cache_dir (:obj:`str`, optional, default ``"~/datasets"``): Directory to cache data. + keep_in_memory (:obj:`bool`, default ``False``): Whether to copy the data in-memory. + columns (:obj:`List[str]`, optional): If not None, only these columns will be read from the file. + A column name may be a prefix of a nested field, e.g. 'a' will select + 'a.b', 'a.c', and 'a.d.e'. + **kwargs: Keyword arguments to be passed to :class:`ParquetConfig`. + + Returns: + :class:`Dataset` + """ + # Dynamic import to avoid circular dependency + from .io.parquet import ParquetDatasetReader + + return ParquetDatasetReader( + path_or_paths, + split=split, + features=features, + cache_dir=cache_dir, + keep_in_memory=keep_in_memory, + columns=columns, + **kwargs, + ).read() + @staticmethod def from_text( path_or_paths: Union[PathLike, List[PathLike]], @@ -2862,6 +2901,28 @@ def to_pandas( for offset in range(0, len(self), batch_size) ) + def to_parquet( + self, + path_or_buf: Union[PathLike, BinaryIO], + batch_size: Optional[int] = None, + **parquet_writer_kwargs, + ) -> int: + """Exports the dataset to parquet + + Args: + path_or_buf (``PathLike`` or ``FileOrBuffer``): Either a path to a file or a BinaryIO. + batch_size (Optional ``int``): Size of the batch to load in memory and write at once. + Defaults to :obj:`datasets.config.DEFAULT_MAX_BATCH_SIZE`. + parquet_writer_kwargs: Parameters to pass to pandas's :func:`pyarrow.parquet.ParquetWriter` + + Returns: + int: The number of characters or bytes written + """ + # Dynamic import to avoid circular dependency + from .io.parquet import ParquetDatasetWriter + + return ParquetDatasetWriter(self, path_or_buf, batch_size=batch_size, **parquet_writer_kwargs).write() + @transmit_format @fingerprint_transform(inplace=False) def add_column(self, name: str, column: Union[list, np.array], new_fingerprint: str): diff --git a/src/datasets/dataset_dict.py b/src/datasets/dataset_dict.py index 1d80ddb3166..be6decd072e 100644 --- a/src/datasets/dataset_dict.py +++ b/src/datasets/dataset_dict.py @@ -789,6 +789,37 @@ def from_json( path_or_paths, features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs ).read() + @staticmethod + def from_parquet( + path_or_paths: Dict[str, PathLike], + features: Optional[Features] = None, + cache_dir: str = None, + keep_in_memory: bool = False, + columns: Optional[List[str]] = None, + **kwargs, + ) -> "DatasetDict": + """Create DatasetDict from Parquet file(s). + + Args: + path_or_paths (dict of path-like): Path(s) of the CSV file(s). + features (:class:`Features`, optional): Dataset features. + cache_dir (str, optional, default="~/datasets"): Directory to cache data. + keep_in_memory (bool, default=False): Whether to copy the data in-memory. + columns (:obj:`List[str]`, optional): If not None, only these columns will be read from the file. + A column name may be a prefix of a nested field, e.g. 'a' will select + 'a.b', 'a.c', and 'a.d.e'. + **kwargs: Keyword arguments to be passed to :meth:`pandas.read_csv`. + + Returns: + :class:`DatasetDict` + """ + # Dynamic import to avoid circular dependency + from .io.parquet import ParquetDatasetReader + + return ParquetDatasetReader( + path_or_paths, features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs + ).read() + @staticmethod def from_text( path_or_paths: Dict[str, PathLike], diff --git a/src/datasets/io/parquet.py b/src/datasets/io/parquet.py new file mode 100644 index 00000000000..30f7f2f5c9f --- /dev/null +++ b/src/datasets/io/parquet.py @@ -0,0 +1,102 @@ +import os +from typing import BinaryIO, Optional, Union + +import pyarrow as pa +import pyarrow.parquet as pq + +from .. import Dataset, Features, NamedSplit, config +from ..formatting import query_table +from ..packaged_modules import _PACKAGED_DATASETS_MODULES +from ..packaged_modules.parquet.parquet import Parquet +from ..utils.typing import NestedDataStructureLike, PathLike +from .abc import AbstractDatasetReader + + +class ParquetDatasetReader(AbstractDatasetReader): + def __init__( + self, + path_or_paths: NestedDataStructureLike[PathLike], + split: Optional[NamedSplit] = None, + features: Optional[Features] = None, + cache_dir: str = None, + keep_in_memory: bool = False, + **kwargs, + ): + super().__init__( + path_or_paths, split=split, features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs + ) + path_or_paths = path_or_paths if isinstance(path_or_paths, dict) else {self.split: path_or_paths} + hash = _PACKAGED_DATASETS_MODULES["parquet"][1] + self.builder = Parquet( + cache_dir=cache_dir, + data_files=path_or_paths, + features=features, + hash=hash, + **kwargs, + ) + + def read(self): + download_config = None + download_mode = None + ignore_verifications = False + use_auth_token = None + base_path = None + + self.builder.download_and_prepare( + download_config=download_config, + download_mode=download_mode, + ignore_verifications=ignore_verifications, + # try_from_hf_gcs=try_from_hf_gcs, + base_path=base_path, + use_auth_token=use_auth_token, + ) + + # Build dataset for splits + dataset = self.builder.as_dataset( + split=self.split, ignore_verifications=ignore_verifications, in_memory=self.keep_in_memory + ) + return dataset + + +class ParquetDatasetWriter: + def __init__( + self, + dataset: Dataset, + path_or_buf: Union[PathLike, BinaryIO], + batch_size: Optional[int] = None, + **parquet_writer_kwargs, + ): + self.dataset = dataset + self.path_or_buf = path_or_buf + self.batch_size = batch_size + self.parquet_writer_kwargs = parquet_writer_kwargs + + def write(self) -> int: + batch_size = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE + + if isinstance(self.path_or_buf, (str, bytes, os.PathLike)): + with open(self.path_or_buf, "wb+") as buffer: + written = self._write(file_obj=buffer, batch_size=batch_size, **self.parquet_writer_kwargs) + else: + written = self._write(file_obj=self.path_or_buf, batch_size=batch_size, **self.parquet_writer_kwargs) + return written + + def _write(self, file_obj: BinaryIO, batch_size: int, **parquet_writer_kwargs) -> int: + """Writes the pyarrow table as Parquet to a binary file handle. + + Caller is responsible for opening and closing the handle. + """ + written = 0 + _ = parquet_writer_kwargs.pop("path_or_buf", None) + schema = pa.schema(self.dataset.features.type) + writer = pq.ParquetWriter(file_obj, schema=schema, **parquet_writer_kwargs) + + for offset in range(0, len(self.dataset), batch_size): + batch = query_table( + table=self.dataset._data, + key=slice(offset, offset + batch_size), + indices=self.dataset._indices if self.dataset._indices is not None else None, + ) + writer.write_table(batch) + written += batch.nbytes + return written diff --git a/src/datasets/packaged_modules/__init__.py b/src/datasets/packaged_modules/__init__.py index 4befdea6016..afd6518daa2 100644 --- a/src/datasets/packaged_modules/__init__.py +++ b/src/datasets/packaged_modules/__init__.py @@ -6,6 +6,7 @@ from .csv import csv from .json import json from .pandas import pandas +from .parquet import parquet from .text import text @@ -30,5 +31,6 @@ def hash_python_lines(lines: List[str]) -> str: "csv": (csv.__name__, hash_python_lines(inspect.getsource(csv).splitlines())), "json": (json.__name__, hash_python_lines(inspect.getsource(json).splitlines())), "pandas": (pandas.__name__, hash_python_lines(inspect.getsource(pandas).splitlines())), + "parquet": (parquet.__name__, hash_python_lines(inspect.getsource(parquet).splitlines())), "text": (text.__name__, hash_python_lines(inspect.getsource(text).splitlines())), } diff --git a/src/datasets/packaged_modules/parquet/__init__.py b/src/datasets/packaged_modules/parquet/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/datasets/packaged_modules/parquet/parquet.py b/src/datasets/packaged_modules/parquet/parquet.py new file mode 100644 index 00000000000..982ac8c9652 --- /dev/null +++ b/src/datasets/packaged_modules/parquet/parquet.py @@ -0,0 +1,70 @@ +# coding=utf-8 + +from dataclasses import dataclass +from typing import List, Optional + +import pyarrow as pa +import pyarrow.parquet as pq + +import datasets + + +logger = datasets.utils.logging.get_logger(__name__) + + +@dataclass +class ParquetConfig(datasets.BuilderConfig): + """BuilderConfig for Parquet.""" + + batch_size: int = 10_000 + columns: Optional[List[str]] = None + features: Optional[datasets.Features] = None + + +class Parquet(datasets.ArrowBasedBuilder): + BUILDER_CONFIG_CLASS = ParquetConfig + + def _info(self): + return datasets.DatasetInfo(features=self.config.features) + + def _split_generators(self, dl_manager): + """We handle string, list and dicts in datafiles""" + if not self.config.data_files: + raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}") + data_files = dl_manager.download_and_extract(self.config.data_files) + if isinstance(data_files, (str, list, tuple)): + files = data_files + if isinstance(files, str): + files = [files] + return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"files": files})] + splits = [] + for split_name, files in data_files.items(): + if isinstance(files, str): + files = [files] + splits.append(datasets.SplitGenerator(name=split_name, gen_kwargs={"files": files})) + return splits + + def _generate_tables(self, files): + schema = pa.schema(self.config.features.type) if self.config.features is not None else None + if self.config.features is not None and self.config.columns is not None: + if sorted([field.name for field in schema]) != sorted(self.config.columns): + raise ValueError( + f"Tried to load parquet data with columns '{self.config.columns}' with mismatching features '{self.config.features}'" + ) + for file_idx, file in enumerate(files): + with open(file, "rb") as f: + parquet_file = pq.ParquetFile(f) + try: + for batch_idx, record_batch in enumerate( + parquet_file.iter_batches(batch_size=self.config.batch_size, columns=self.config.columns) + ): + pa_table = pa.Table.from_batches([record_batch]) + if self.config.features is not None: + pa_table = pa.Table.from_arrays([pa_table[field.name] for field in schema], schema=schema) + # Uncomment for debugging (will print the Arrow table size and elements) + # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}") + # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows))) + yield f"{file_idx}_{batch_idx}", pa_table + except ValueError as e: + logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}") + raise diff --git a/tests/conftest.py b/tests/conftest.py index f930d986a07..7e4a860d046 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,6 +3,8 @@ import lzma import textwrap +import pyarrow as pa +import pyarrow.parquet as pq import pytest from datasets.arrow_dataset import Dataset @@ -164,6 +166,24 @@ def csv_path(tmp_path_factory): return path +@pytest.fixture(scope="session") +def parquet_path(tmp_path_factory): + path = str(tmp_path_factory.mktemp("data") / "dataset.parquet") + schema = pa.schema( + { + "col_1": pa.string(), + "col_2": pa.int64(), + "col_3": pa.float64(), + } + ) + with open(path, "wb") as f: + writer = pq.ParquetWriter(f, schema=schema) + pa_table = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(DATA))] for k in DATA[0]}, schema=schema) + writer.write_table(pa_table) + writer.close() + return path + + @pytest.fixture(scope="session") def json_list_of_dicts_path(tmp_path_factory): path = str(tmp_path_factory.mktemp("data") / "dataset.json") diff --git a/tests/io/test_parquet.py b/tests/io/test_parquet.py new file mode 100644 index 00000000000..a091e79dff1 --- /dev/null +++ b/tests/io/test_parquet.py @@ -0,0 +1,134 @@ +import pyarrow.parquet as pq +import pytest + +from datasets import Dataset, DatasetDict, Features, NamedSplit, Value +from datasets.io.parquet import ParquetDatasetReader, ParquetDatasetWriter + +from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases + + +def _check_parquet_dataset(dataset, expected_features): + assert isinstance(dataset, Dataset) + assert dataset.num_rows == 4 + assert dataset.num_columns == 3 + assert dataset.column_names == ["col_1", "col_2", "col_3"] + for feature, expected_dtype in expected_features.items(): + assert dataset.features[feature].dtype == expected_dtype + + +@pytest.mark.parametrize("keep_in_memory", [False, True]) +def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): + dataset = ParquetDatasetReader(parquet_path, cache_dir=cache_dir, keep_in_memory=keep_in_memory).read() + _check_parquet_dataset(dataset, expected_features) + + +@pytest.mark.parametrize( + "features", + [ + None, + {"col_1": "string", "col_2": "int64", "col_3": "float64"}, + {"col_1": "string", "col_2": "string", "col_3": "string"}, + {"col_1": "int32", "col_2": "int32", "col_3": "int32"}, + {"col_1": "float32", "col_2": "float32", "col_3": "float32"}, + ], +) +def test_dataset_from_parquet_features(features, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" + default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + expected_features = features.copy() if features else default_expected_features + features = ( + Features({feature: Value(dtype) for feature, dtype in features.items()}) if features is not None else None + ) + dataset = ParquetDatasetReader(parquet_path, features=features, cache_dir=cache_dir).read() + _check_parquet_dataset(dataset, expected_features) + + +@pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) +def test_dataset_from_parquet_split(split, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = ParquetDatasetReader(parquet_path, cache_dir=cache_dir, split=split).read() + _check_parquet_dataset(dataset, expected_features) + assert dataset.split == str(split) if split else "train" + + +@pytest.mark.parametrize("path_type", [str, list]) +def test_dataset_from_parquet_path_type(path_type, parquet_path, tmp_path): + if issubclass(path_type, str): + path = parquet_path + elif issubclass(path_type, list): + path = [parquet_path] + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = ParquetDatasetReader(path, cache_dir=cache_dir).read() + _check_parquet_dataset(dataset, expected_features) + + +def _check_parquet_datasetdict(dataset_dict, expected_features, splits=("train",)): + assert isinstance(dataset_dict, DatasetDict) + for split in splits: + dataset = dataset_dict[split] + assert dataset.num_rows == 4 + assert dataset.num_columns == 3 + assert dataset.column_names == ["col_1", "col_2", "col_3"] + for feature, expected_dtype in expected_features.items(): + assert dataset.features[feature].dtype == expected_dtype + + +@pytest.mark.parametrize("keep_in_memory", [False, True]) +def test_parquet_datasetdict_reader_keep_in_memory(keep_in_memory, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): + dataset = ParquetDatasetReader( + {"train": parquet_path}, cache_dir=cache_dir, keep_in_memory=keep_in_memory + ).read() + _check_parquet_datasetdict(dataset, expected_features) + + +@pytest.mark.parametrize( + "features", + [ + None, + {"col_1": "string", "col_2": "int64", "col_3": "float64"}, + {"col_1": "string", "col_2": "string", "col_3": "string"}, + {"col_1": "int32", "col_2": "int32", "col_3": "int32"}, + {"col_1": "float32", "col_2": "float32", "col_3": "float32"}, + ], +) +def test_parquet_datasetdict_reader_features(features, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" + default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + expected_features = features.copy() if features else default_expected_features + features = ( + Features({feature: Value(dtype) for feature, dtype in features.items()}) if features is not None else None + ) + dataset = ParquetDatasetReader({"train": parquet_path}, features=features, cache_dir=cache_dir).read() + _check_parquet_datasetdict(dataset, expected_features) + + +@pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) +def test_parquet_datasetdict_reader_split(split, parquet_path, tmp_path): + if split: + path = {split: parquet_path} + else: + split = "train" + path = {"train": parquet_path, "test": parquet_path} + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = ParquetDatasetReader(path, cache_dir=cache_dir).read() + _check_parquet_datasetdict(dataset, expected_features, splits=list(path.keys())) + assert all(dataset[split].split == split for split in path.keys()) + + +def test_parquer_write(dataset, tmp_path): + writer = ParquetDatasetWriter(dataset, tmp_path / "foo.parquet") + assert writer.write() > 0 + pf = pq.ParquetFile(tmp_path / "foo.parquet") + output_table = pf.read() + assert dataset.data.table == output_table diff --git a/tests/test_arrow_dataset.py b/tests/test_arrow_dataset.py index 23f917e8430..ed09e0ed982 100644 --- a/tests/test_arrow_dataset.py +++ b/tests/test_arrow_dataset.py @@ -1692,6 +1692,58 @@ def test_to_pandas(self, in_memory): for col_name in dset.column_names: self.assertEqual(len(dset_to_pandas[col_name]), dset.num_rows) + def test_to_parquet(self, in_memory): + with tempfile.TemporaryDirectory() as tmp_dir: + # File path argument + with self._create_dummy_dataset(in_memory, tmp_dir, multiple_columns=True) as dset: + file_path = os.path.join(tmp_dir, "test_path.parquet") + dset.to_parquet(path_or_buf=file_path) + + self.assertTrue(os.path.isfile(file_path)) + # self.assertEqual(bytes_written, os.path.getsize(file_path)) # because of compression, the number of bytes doesn't match + parquet_dset = pd.read_parquet(file_path) + + self.assertEqual(parquet_dset.shape, dset.shape) + self.assertListEqual(list(parquet_dset.columns), list(dset.column_names)) + + # File buffer argument + with self._create_dummy_dataset(in_memory, tmp_dir, multiple_columns=True) as dset: + file_path = os.path.join(tmp_dir, "test_buffer.parquet") + with open(file_path, "wb+") as buffer: + dset.to_parquet(path_or_buf=buffer) + + self.assertTrue(os.path.isfile(file_path)) + # self.assertEqual(bytes_written, os.path.getsize(file_path)) # because of compression, the number of bytes doesn't match + parquet_dset = pd.read_parquet(file_path) + + self.assertEqual(parquet_dset.shape, dset.shape) + self.assertListEqual(list(parquet_dset.columns), list(dset.column_names)) + + # After a select/shuffle transform + with self._create_dummy_dataset(in_memory, tmp_dir, multiple_columns=True) as dset: + dset = dset.select(range(0, len(dset), 2)).shuffle() + file_path = os.path.join(tmp_dir, "test_path.parquet") + dset.to_parquet(path_or_buf=file_path) + + self.assertTrue(os.path.isfile(file_path)) + # self.assertEqual(bytes_written, os.path.getsize(file_path)) # because of compression, the number of bytes doesn't match + parquet_dset = pd.read_parquet(file_path) + + self.assertEqual(parquet_dset.shape, dset.shape) + self.assertListEqual(list(parquet_dset.columns), list(dset.column_names)) + + # With array features + with self._create_dummy_dataset(in_memory, tmp_dir, array_features=True) as dset: + file_path = os.path.join(tmp_dir, "test_path.parquet") + dset.to_parquet(path_or_buf=file_path) + + self.assertTrue(os.path.isfile(file_path)) + # self.assertEqual(bytes_written, os.path.getsize(file_path)) # because of compression, the number of bytes doesn't match + parquet_dset = pd.read_parquet(file_path) + + self.assertEqual(parquet_dset.shape, dset.shape) + self.assertListEqual(list(parquet_dset.columns), list(dset.column_names)) + def test_train_test_split(self, in_memory): with tempfile.TemporaryDirectory() as tmp_dir: with self._create_dummy_dataset(in_memory, tmp_dir) as dset: @@ -2617,6 +2669,67 @@ def test_dataset_from_json_path_type(path_type, jsonl_path, tmp_path): _check_json_dataset(dataset, expected_features) +def _check_parquet_dataset(dataset, expected_features): + assert isinstance(dataset, Dataset) + assert dataset.num_rows == 4 + assert dataset.num_columns == 3 + assert dataset.column_names == ["col_1", "col_2", "col_3"] + for feature, expected_dtype in expected_features.items(): + assert dataset.features[feature].dtype == expected_dtype + + +@pytest.mark.parametrize("keep_in_memory", [False, True]) +def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): + dataset = Dataset.from_parquet(parquet_path, cache_dir=cache_dir, keep_in_memory=keep_in_memory) + _check_parquet_dataset(dataset, expected_features) + + +@pytest.mark.parametrize( + "features", + [ + None, + {"col_1": "string", "col_2": "int64", "col_3": "float64"}, + {"col_1": "string", "col_2": "string", "col_3": "string"}, + {"col_1": "int32", "col_2": "int32", "col_3": "int32"}, + {"col_1": "float32", "col_2": "float32", "col_3": "float32"}, + ], +) +def test_dataset_from_parquet_features(features, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" + default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + expected_features = features.copy() if features else default_expected_features + features = ( + Features({feature: Value(dtype) for feature, dtype in features.items()}) if features is not None else None + ) + dataset = Dataset.from_parquet(parquet_path, features=features, cache_dir=cache_dir) + _check_parquet_dataset(dataset, expected_features) + + +@pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) +def test_dataset_from_parquet_split(split, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = Dataset.from_parquet(parquet_path, cache_dir=cache_dir, split=split) + _check_parquet_dataset(dataset, expected_features) + assert dataset.split == str(split) if split else "train" + + +@pytest.mark.parametrize("path_type", [str, list]) +def test_dataset_from_parquet_path_type(path_type, parquet_path, tmp_path): + if issubclass(path_type, str): + path = parquet_path + elif issubclass(path_type, list): + path = [parquet_path] + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = Dataset.from_parquet(path, cache_dir=cache_dir) + _check_parquet_dataset(dataset, expected_features) + + def _check_text_dataset(dataset, expected_features): assert isinstance(dataset, Dataset) assert dataset.num_rows == 4 diff --git a/tests/test_dataset_dict.py b/tests/test_dataset_dict.py index a61c8bbc41c..aad3f4487b8 100644 --- a/tests/test_dataset_dict.py +++ b/tests/test_dataset_dict.py @@ -587,6 +587,62 @@ def test_datasetdict_from_json_splits(split, jsonl_path, tmp_path): assert all(dataset[split].split == split for split in path.keys()) +def _check_parquet_datasetdict(dataset_dict, expected_features, splits=("train",)): + assert isinstance(dataset_dict, DatasetDict) + for split in splits: + dataset = dataset_dict[split] + assert dataset.num_rows == 4 + assert dataset.num_columns == 3 + assert dataset.column_names == ["col_1", "col_2", "col_3"] + for feature, expected_dtype in expected_features.items(): + assert dataset.features[feature].dtype == expected_dtype + + +@pytest.mark.parametrize("keep_in_memory", [False, True]) +def test_datasetdict_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): + dataset = DatasetDict.from_parquet({"train": parquet_path}, cache_dir=cache_dir, keep_in_memory=keep_in_memory) + _check_parquet_datasetdict(dataset, expected_features) + + +@pytest.mark.parametrize( + "features", + [ + None, + {"col_1": "string", "col_2": "int64", "col_3": "float64"}, + {"col_1": "string", "col_2": "string", "col_3": "string"}, + {"col_1": "int32", "col_2": "int32", "col_3": "int32"}, + {"col_1": "float32", "col_2": "float32", "col_3": "float32"}, + ], +) +def test_datasetdict_from_parquet_features(features, parquet_path, tmp_path): + cache_dir = tmp_path / "cache" + # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" + default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + expected_features = features.copy() if features else default_expected_features + features = ( + Features({feature: Value(dtype) for feature, dtype in features.items()}) if features is not None else None + ) + dataset = DatasetDict.from_parquet({"train": parquet_path}, features=features, cache_dir=cache_dir) + _check_parquet_datasetdict(dataset, expected_features) + + +@pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) +def test_datasetdict_from_parquet_split(split, parquet_path, tmp_path): + if split: + path = {split: parquet_path} + else: + split = "train" + path = {"train": parquet_path, "test": parquet_path} + cache_dir = tmp_path / "cache" + expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} + dataset = DatasetDict.from_parquet(path, cache_dir=cache_dir) + _check_parquet_datasetdict(dataset, expected_features, splits=list(path.keys())) + assert all(dataset[split].split == split for split in path.keys()) + + def _check_text_datasetdict(dataset_dict, expected_features, splits=("train",)): assert isinstance(dataset_dict, DatasetDict) for split in splits: From e94a563695062d62762f41423f478bcf687f3923 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 23 Jun 2021 18:14:51 +0200 Subject: [PATCH 02/11] bump pyarrow to 2.0.0 --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 22412aaa119..df06677b0a2 100644 --- a/setup.py +++ b/setup.py @@ -73,9 +73,9 @@ # We use numpy>=1.17 to have np.random.Generator (Dataset shuffling) "numpy>=1.17", # Backend and serialization. - # Minimum 1.0.0 to avoid permission errors on windows when using the compute layer on memory mapped data + # Minimum 2.0.0 to support nested types in parquet format # pyarrow 4.0.0 introduced segfault bug, see: https://github.com/huggingface/datasets/pull/2268 - "pyarrow>=1.0.0,!=4.0.0", + "pyarrow>=2.0.0,!=4.0.0", # For smart caching dataset processing "dill", # For performance gains with apache arrow From d3eadd1d7b55a9a37d9f5ea2ce6c1b99c9e47491 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 23 Jun 2021 18:14:57 +0200 Subject: [PATCH 03/11] add dummy parquet data --- datasets/parquet/dummy/0.0.0/dummy_data.zip | Bin 0 -> 176817 bytes tests/test_dataset_common.py | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 datasets/parquet/dummy/0.0.0/dummy_data.zip diff --git a/datasets/parquet/dummy/0.0.0/dummy_data.zip b/datasets/parquet/dummy/0.0.0/dummy_data.zip new file mode 100644 index 0000000000000000000000000000000000000000..152bb8a720a1240449979ca1d7623368c67ea8f3 GIT binary patch literal 176817 zcmZ6yRZtvUw5^*23);cm-L-KE?hxGF-QC^Yp@HD;t_kiA!J!*>cRl~!b*pZjvmVx5 zPv7ILIma05mn;-C#+Uy&B1y~2|NHp=F2pY+UrgQX?7R$2ja-eG)l`wcz-{U-7{=)> z82(Rn^F;je75e_`moNVd`1QY_?_a)u*-ZTZLFXjjzTo`dAXjH2D|;qKBWEW!GuQv6 zlKn^1_>cNO_5Y#Tf~-8(Rk0rHlsiUSeT}!dqj$NZQU|R-i}uOpR`W}Y1@f|%h>Xpt z@~vh%akd@Fxr??#KYzm@q~;bNg`)kog$YM_H75Bv(K}s_f=eTZ+uDdS@z;lc=2md# z74ps|UGC;~DRB5UbIGhXQ+YKU^7&)+&>ZHvb7P`+baVjv_*coJU2TzSOF3 zdn(r6l<+Agd74f_U44P}t>&&GwzfhGXsw<+u0m(RPM>e)IC-45;3rTV#)!NR`MCV~ zbo?M$2Kf}6U|FzkbtimhveOey?|CV<8Tc0uJiKT>%C6x%`uWuT0GtlAaX$=;sMD91 zx{WdGmFexwpn}3vXE&ST%QCs2uU4} z2oYbae%ugqH{ReL1jq`y3Veby6m;(*ac0b1!pSPFSaVbdi$U>Og+$nrs%EOJa!#sK zR71si%9$??raUqE9Jl7`(piO>bEfQ+G19;!q~X-|>|w$=r%cp0E&_?z3V0yB4Y#V? zoVaMzi9|JrsSL5w0(`fL`scO)@ID{_zcUXl%QJ0Z@$}$^A zNlY}pLP=}khTEIJ76&JOesT9ClI#EzR}#C)S_U4HP#pVd8tvTdYCz>oyCts>Gk$<1 zp*%TiC5|qcLWh!{=!6xHhJO9c>gCv(H+Miw^1eAsmNvZHQij9k$SStglImWGmSU%W z2$hmFXVR%R(^|r%l$Na*$Q@e|X=SF$Fho&f<1L~lXVV}pZ?=%Bu!mv`sF8TW@~^2Qr}@V>q#Mz;=XPRg z+g;MRR;#z((S!=e3qQpbwa4O5hU+o-*{qH_#FS&lQRPv^(b=UIGG#ScC*D?yO`ZyQ z73ik;O~x3aaXJZNQbo+^h9mLRG6~NjPXcBlbg)L!EZ&*59Kf8&BD1dd@3y z36epIe_;PC8P3clc4M*aSPdgiB>Gs5XkPi)J*oEa!RkdWhMg_I;d;2>qoKW3wqWNA zo9^Q*;!|1H60$hN*K320$AT_>uC(1gc3c9fDV!%eR_dPc(XmKcTzY!K#JQv?lTed3 zllSDWO*(r+V0fq07O#w)d5NUlJ`1I?+}eGSB#@Q1kvu)1`A{5}-Qb@bVFm_DCpnMW z1nfSSrXK%JxE0z=_Regb+~;Iu_K!~o%J6L$`&6eGMrNt5PL}#7fY#h#1%0?!do@3S zfAU~fmb}dLEIUFx{yn;Sf=;KWd^`&KTQK|Ri6p-!E-7ox1Si*lud0FvXpubuckMXU zggmNWm24>75Ad3_RF2x`IMxtMnJ}jm z%3nf{W_xt))&+|BaWIYx%cDq`LAl&~D)Cvh`d|`V-)vE5?`5}E3w)tw30gg_BW<5 zJ697!Uve*aQXG@~jawy^xn)CYFUYPsTi?!ZM2_WGo=di^<+IJ>ExahP+1jeEx#dUv z^PnnoDmw*6Zy^l5Agu+P%o@fB^Wji6QHr9mWSZS&V=0@LqzWEXlyllN6?JQU&BtBE~sNkyJ zOuk?_fSsJ39jD5d7lCXT6LUQEVz0rpxqmz3(gaj)y!vb8W$_dg1oIhY)@O4FJ!7`} z^5nxv^HoAs+-e+IL#S`3@tnYX(a>vzSz(a}2uw0r(3%hdT(l-FFQ{M=O4g&Ak!)-9#CP z$O`Y0oT=F%14PNAM&yl}xiqo34L2GGOaBbG(eicwQeiG{<2o5Iy8v)Yh)z=@Oh*E) zqNv7OONSB1u53}5w-3k;evWspGs8Wa^h~fzDSY&>hzvR!d#o>VJ!QDPeJS0O<786M zQ&H{3us|4%j_c+#fnvo7o?pL#UW&bm~y$NPO#!!Zq__DV7KwT}GP~ zw)M}Q-*Nv&P?#8VFNq>xW*14%L}3N)B9uTh_eb7NaD*l$V0*2-yF8%@l#C$XIr6B} ziea!b1*!NFY zhQD>7cZkYq+1@-BX30`uY^3A(4UF4f>zk4zY#85yMH;jvL)+B|)UOxtUCiC@5m1^? zA6)o3T{fNB$8)k$TX~dhnmYF$tTKN$bmJgZlWED;0JtcNa!L`})=S4hH<8uWchEV_ z0oGR5KKoOGa+9F&bDXW#Bwui2c-vX?5{khp1AtGZk+m9B;P{jj@9g2xwX(IPU!1FE zhTNvpXM@eD(>Kzj#M2#=)^tajqatVY!Iz$tx(~iEYD*sWj$w=F_b{P@Nz=fkerKPl zkm>x*sA)*4bxE#%Toctcb`&HrW-pzdDq54d(IOW!JcuQ~8CpRvflR@y6|(M0T&N)! zSOXv5(nKEZ2qN^6U_wrIbA-lPQ;K0*fu^c05^Zf!Pd@Rr%f6>BYs6K zCaPR}m3Wi1%q5)i`mHM6Y4>KGx;x4JKjOG*Y%hGuicahF`O!fhK+RZmm#vpgYTQuE5qV(rB&NQyVGEyG1B%j(&mtJGEw6@oyWA#1TOdXb5y zCf{-;5JUL-jrV~2DPA(hXcf2fu8C&Y6xxS1%>p5vQW-lcc=n^XgayIWq>X16Kb+{z(v_ZXTs1S3J3i{rXU0qsDzA`3< z-p!`Ix8x_Ij-}|*@r=sixRUa!3{01}H*D~)k|0rKoy^8V z7y`>O^O93^q8sp0ADbW40+o@oqzPD6JV?huQGKob9by8G=yZl>e=$+g#D{r&j@&@w zN(0cC)HZwK+QV+2D1S7gtkMp-{*G`OYwz$oM;whKpBYOo1uaWQO6xE`3Z2B3EZVmI z?gzM|td9@U+ZS(ho3EfUapG;N&cw=(dDso~<8%M@9Vc~g-x9Rray)u1ji+Yowlv$N zTfB0aEYA~18@D=A*mEuaq^ELSF(Ocqc(HlXC8}VXcpF;M!6EaWAvg8g=mLp0|JwDM zOkmiv3r61`Fk}ks*}oxTqRespO+aO*D<;hr;Z}#wH-0aWvuFep7O=`4`gWB|tFFVM1gtGGqKZSFV!QoP$3wKuU9wW(g* zo}5;=R1nopogpH{a}eP?jWTggh3;+W>!~eNOf>a(GV1f{p1CNfQu)t(sp=P~k}+}< zwp1#A9m<$*zA+{m)x)T&;K_x==FIwJ(y+!t@wgPjbRClpWI$?P~+k>7sVHn?liPT}QPj zec==G=3ddPAdCauCXKd?3X4^^H()!)ugfA~?-h*5 zXY9nHDrNOTrzIIDA#5_KUMT2r^TFuIo8|iL#Qu(KHokNx=#}PY;|7VzoRHGrDG3uS zZS%Ayk>p`;Kb^XU;#MTZSvH2O(UNa(hIXAa^@iv*<0cd4BNTwS|BBMhXTBklY61KB z1Mlr;GwghIIgwTraxME*P>(P{*})g=Z(kGqfivBrH`bKjQC4(@j5NwLoYz&YgtoW~ zhcg8x5h)D3IBclG*aImB4jZD8h`FN>4%OPl$ulDNAjV)c9+-J`+5JU+?#7LZn1gbJ zuK?^NlOZex49PG=`crehC}nOeH!rbe2?m`kJ#p&F)wYXkqJNY9sG59NGYH&mpwU<} z@K??Pb`Qj|D+P|1oTe+U4)ifKj1c>MZvUb@xdnWBFxt2^tF~xv$q1%*eg<+BU*2`^ zq4D(nbjd$<9<9Z|LNq%xREjW?nepT2GK((NCB;IDfDS zugnPs#wA3#u+~@ieS8o0#inEkZ6#sA!+_-Y11^O21M(b+Z<{lRC}(J0{kcW~$n7U{PC zA%~f0eDDn8=4C8RcBNEZf7v%N5QIps{2kL$Ct^+ZIUp+|!MfwS?{4~bsLvO7XHW%| zWsKWBBHWBi`ir#ONs^i;Mrcm=Mf?ScNb({DkbA8-MJoCl{TXbL8IIyNdeZ(i&!cJQ z=-V`E%@!$ywy%uDf^lC;q`1PUb(y1!e@>Q+ zo@5y*zm)YamLSGXP5t1pCY&DidmcZR=ZU@j~oxTKJ93VOVtn-E~`DG+nQhRx>P1|4uj zsL6-m0mE>YNMcuTjXZz&}O(Ucys^Pk4TA2j14EP*aNoY@lw@G6u9Ot zoA;Hsr5&U64l$-^)i3`>BkByx{B*GUlEs&Z3lO_n!qDmueah!O^<8Js&IH9H=3Ct;FUNknla515Z8b7FL(nPHgt!FrhP%`|z zj*1_qKWCC;q@o$RL8}&7~C|i;l22S7Gx# z2X#|>_VW)$$2s#-<3A_T;Fo@5<~s)R-{MOr2+18TVsSZZ`FU81wq?;pBzV~XeJKN$)kP)*~uPyHqTHk&F!$gfL@;`eg{8VShts`hxQ+*({%RCa3tw*;7_o0R7=!DAJ>b zh&W7!+CqI9NNpZm7p7vzcFDQO{b0(iDIabI;{nWwmcmYXIyrZ(Ny!qQ?0bbgc$Z%# zpY^#x7+C3dkIMH|VWoII(-n5_1yvVw;-_3c7=*Mkl{SAl_Y;K<%6S@gDS47|_uo zrdGN<=Je{fqN4>$P1qi(H&L0#1i+OF@Gh}_Qt3}+7R~Mlt5z^ZHja7bl51)>AI_Nx z57|*+>XzQkfng{XdH!P5LeSvl{c~kc!|%BnLeXuqu%qb?6hhLDwvg>tCa#^;3Cy4m z;15ub?;7AB=5Q`w3lo#V_$tBQb-6}4^P{bT8@Nh%2rl3kFmM{1d5=8nue9`Pb^W2N z$06`m+ve?CR00hz_rI7$F|6Qyb%6fY{H~9sc_;-?QA0mo$@{g8X@FBVzQ0T{-F8%r z=UXtEZa4v3962TEL~pxX`7E0d4t5@fsw|QX13rIXjuhK#i8E7$IV2ahEJ>WDFk;Cz zn~eNQRRA}fSo~DlG~EV@KK|}A3xjvlmPyER3 zlCnd1ihygev{;7rdL(g7_q3n&;DzS@bUCr>E%LEZI7|iBsKsH1JvYYejn-{ibEmv| z{hwxnDLBHgWWW^8i42D5y6?SO2QY54XCYklZn&G)^~q+!#`@p*NWk2^222jD0gXTl2ZPe~ z_ext1+!P46|G7UK+Lqu`#5`&@jcb2%OFRBQeYB)1&ACjR2L0V>dfrmFZVG!oB+0_K zxbzu;Oxets@z!V4P%q2Ic*$3mZ^Bh~?f8r<`5W?y)tXT?ArV!Tb3Jz96D+Gm(JRc!QLKX2<+Pn+ee|#owe0nm zUv^1g-v(PE;Y;qsunFT(+)+xJ>&6NH(*%!9a%O|A=z`0LP>IqEVHDAZZtE9tou9l9 zAj=2IcWFH|6x7dj%!r5-h}F69jPnsgrL_;UAl0!KH}~RiVMfc# zI$a&08*9!~9}G(S9E^J1qj1|UC1>pbTpYNTJo-^0W1nx2M~l5+M0)w(7mcrf))NDW z+k8B(iM+_??Ub{ceHgocZArPbxIMbGSMm`~)>K=D_mYZXl;i76aNpqNHX<@D?+Fzz z8)jo04Ki#Uax7R&1l679;(5>cXNLbo7Np-$i*m29A4M?W9(Hgi(~IDJ^M3^W(xCf+ zhN6Yb%+MVF2~+KFR0cIQT1yvz3DWJ~THx~( zj3bil#~D!L&rt?vdwb0PWR>YVNB&i94x2j=`8x2c`O$%fkM(d2&zdPsS|po%Am~}NC`aE{PENG*AXItt-Ebq z?|cswECq48A{Md|0v4y|o-0Fw{ueAHvuG;0&DGLraE4&}>gpVS$TK zBd!>#PcArD)$cQ%nd^>Cd~5I9U0pt+xfNeP@?#QDZPZ{>JWcrwk9zo$D~7Ot^D2pv zp&BjMT1r@1RnM{3<#%oXKC%SD@Jus3yu68$Ux8=(Wd*V22t74vJXrC!S6-Vq?gRrP z&Pm?|daTbCX!Xyq7j~`v-fU1or4&=8=$Q+N&u2%8hZx$5zbv2!U0ozNwyecT_3H# zrnDF80H%Mu{PDjyuv3bX5MY{D0XTGZNCRwp%~Z)$>&_cH>K~fkVell-Q)de4ZNK0n zexeN>nkR4dJ$BO{PW;!LhahHm-qP2gFwrEILWHjLoi({4_UycnVq!zSkb``d5d#ZB ztgOxRsEL!aVm?-kFX&^$o&KHRTRd3nHy6mI8s(Z`h9nGL=}@ve@k00) z;u7qCY#+1NW=AZBCcva)a^Jns#_O0eHdo1^7cqE4CWFBJ6)_`m#w!Cz*`Z^BJe=P(+Z zs-zm;GrCiI1#hNAcoCA>doIN;!rVkTw#HyKU7<=!MC64q<3W;!gZeMI(%iOGVdI1? zyv2Zb1wZNx6Y?};UJNNrQ_-G!#@MTWtK*D6AsG3cpDe=>;RJ{uCo15*RdpdYQKe`* zDr$|8Z#BMvh~q1QSt^qUuS+tF>WBMmj2WnlPy6{~=o4N~nb1oZK}1t?e$yY`h^#%E zXp1~O4o|ZW$GDrtopJ6OB3k%L2>H$WJLEiTnm|$?W^8A7PC|4NoR2gGhnoYun2haf~5O9g0i&r#aKA&%|_5%>-f5XXD*Vd#nnS!-z>U=;h(mD zLXwmdM7**NLYgd(-_vXRSkG||j~L3bWh&quN+LSMHK!FhGN6kMi{pRZs`&#?^X{b9qFk2VouipKjVpRJ}4`RMNWGj~hYR zwioB>D~ZP?{)vC~u!f03)L927Vz)-fM3D_V1EH!ib!Imwl%8tvxa_vM#vLG4UNF)b zUdZNCwsWbPB2lCnv?UgK{Ivp5U7aL0X@aF(ssKTNG(EN&`+VdhEPYK@l(v08Ch0ys zmf1(mza^Blxv)?VXLi5N>sfl_e4Z!EX%<6o$_&{kXCC)1f4B|xf&KgDeVhYCh5^~i z+1nRw*!aM@n#dUsjfMPkM>W2fV_)50YxM6qqr1prLo;;!0)i-A`0p?z4!3WYJ-UL> zkKS46&((#+CAA+DTA#)W)20vbLp4M^n5>JM!5s)|=aflo#=MJK&+}G+ewSoh#X@w0hj<`)KO`-Fn) zh+T;VL%`u3NXtvI!au%}sZ6J1mJ`17tghwqyAShCTHYD3)1Qea1`IZK{Mx+y7cWmi zb+j(oAH12ny#|ru(_1IgwA~d2Sr>zQIFH;3PFxBf$8*w$(glW~u8fgYH9}&HL1@oA z;`Kx0_^Y~jww#`S{J`k#)mdIgUxIR1puq@NcRI>jG8gk zZzgi!;bA_cZ73%Yq@=5>``odyW;9TsLwZ2X$eVobC#iL=e@&5Ze^mi^XBcecS5}Q+ z4tR4ce(FttdZAps?JQx0-Tk-Gd%qCXB?0EQNZ!k%wR0z}Mw35V`T_y=yO{t(0SV+S zJK}E3N%owlpy}1=J%eE<-LH%*P{#qhaFD#oR3G5 zKR1{M_H7k7m3ip)d$T5#ro6MqdPZ&hY7G6043>5cvq6U{ge=p2KzUz=noNk!ejQG& zkw?euEV9FtBx31Y%t517?r0k?`&+T4$^-b@{Z1~pC%bXdHLF$U; zrv*^>%j|@}w(YS&mmE%7H`|>M2lBsvJV}Obx&Gsxgj>bU-3}Xd8dl)O+7#q z#DK@|%h~3c~)+?H#6+rZ48?5}yyx^`X0q zsYjN(@{AdDy42W+I-!J1IAPV&r|V!1VbAGHPE#PEYQgpluGBqsnodI4GPJ_r32MmT z570ew-M_XB{nx0qVO_Df%DMB_((-}{trph@H2+!&of}{_8}MiN=`Z-{y2m_+eGV~j zUEl=nPSEpt;|l&6mQS$WP9$ClPvG|1M*}UhcdY4Y!_rTyKuO-;B01n%NKv~2cVBq! z?od7Qt-Dg3N2}xybI07i2gj;i-%EL90w&UW8*Ak(^!WH3g2If@4WV{9guf|E3PU); zN!rT@ivN;+wPDh2ZqXCk5DOdyIx%lV7mFuUCt9Bl;okjMOag zW=B#HS(yscFTRG#o>${Cy5FoAA-506N`yLKkr9TrHEG*!K;2el4$ta{Wlk+1$3!XN z?6GBad*g7f?norB^~Nin7Lm$g)jB1fiI(HIgw^##j9@U_+8#M9e8*L5F#_6&wB<5Y zVSfAri^?lXI!kFeK^EuOwl zM$@@1#0KSSvFrFC#HJCj_ACMD>FAb)OKgm(d`J2!A~9JnnVBXKtl*l)qOz(?GrxLB z)|E>()mPe|c&igL#rL-eIC_v*!IZQ$Z29mFNV47zW7S)g*zY3M-c`OW>zgOW5;>oL z{CY_}Kl^X${l2w+7H{)xsLVuW@M@HsQG3#WA)Dn={x3^CJdMK*h`hmy>0Fiwz299= zOsEAWun?1$ObIz(Iz;pX(uki{L8F0@1kkpiJ{!Xx5iN8eIe5w83)K|r{3dUkB42v- zp>=HUqEQZluFNL0?pD6w4RyuNRzbfC`el>LT(Kw6j(6BHwY*<+;)4cNw;v;&zkT%+ zi(^4$rKP9ksWQo0asq5cf0o zmL|AA)TMuhv&OTOY6>`yHc9%YriO@(oG|(MZOXC2tFN+Eo?0>ObHxMT=Q?uJfuJmQ zNXl#r5-$M`qznzOsLBcNzz$DT(^zxL*iC~G5wf$+Df~=55WzO-5AX?MIvitW3 zZO={8{0Rw+mplHKDD)5WBFRaIJm-0}dkW3^{*>FJI<&I=!byjEIK~!UL5Xu94UQ7m z-s_Q-%SxU*cRn>wyAz5$&k=r%bg;hq^nWSG%0gY7-5yECpMKqrOsru+u-;*D#7c9> zFV(KuUq)7htAt^+FV-I5aERED2AJ^N<$Og^oAv zagSwTvBZKNsBV>IS2Sbrr{DfDgCdPt)!HkeR>7|0*0dugHwt9f*aIHH?72T!G1~Z6 zT?-u%dpb0FaEB1{s#1|AWl$SjAA&EC7@HmY;#d2(!hSSy@-yxHRa8f`;kT6}Mpsw0 zO7&8TT!jR-9MTmFwHKh4-WSGq(|EGMcPk(TR|Uya7$uDcY_@|umf ztZU30La}YH@vcnQZBvL*ykPz%{zdm1K&-%cf8~lE!Sk)GnR`f11PQi=GQFb=UHVKH z4xV>sDWCPvh5i>sh5`!?^}OQ$QY9x~XXE|y$xBAEfPSw2;+<{xI~ zh6V#vL9$0$N6smsyTScsSAPl6cwhcChFp4%;2(zxa9oH{%pn86ZpxQ5;rH~sBgg6> zMbA+v?>oodQe|wYauwxlZ9`sCGF6fE;-a1LqKOQSpE;CNuVASqL}a^dFq zczGY*&q!AchkK}DdH>+ot31UQg6|NCRh2^rks^A|MP&Za5vqAo_?GyHEf;d1ES%3; z?<;4LFvEGu6D5_|TYp3YG~lTx8RN(Q$n;eV2Bl7b$-R-TzruoiK!O^i=IqGSfdOa(O&6r=?X%j*wE`jMeybJ zHTzcbI%0{W(QKHne>6J!3cPJVot`qVhg#@Cl?sKwIHu_w0Xk7(?sSo~lbSbMNS2(OOaQpnF8(HpBBinFEIn_?vdgWQ?Hh(;1ZR*#p#`8 zLh!ToX4Qm6YIk`WnxJ+Vt7(Jh$Hpj>fm$o^C0k{BnA?zb&^UHD8UR^%m9H zv>I6Z7k_oZdsu36LKf2C-9=YXUbILf5=n}ofDk26=VCT_iH2X+Od>1rl-fA0444@D zSPc-xD~?I1a?|}Sb3V@eG$;;uv%Q}I;b=rNr$D3IALUas=;UGHA}bpjKf& zvcUYRg775e9sjgxX~QpCZT9TOOb2uvw5y4#nna61w!Ucl7+I4vHy}}x*yi#oZGmI) z=pGLB5Fw?>PRlTP15}B>IN_^w|25SI&FQ>=C(J!JgpFa+J5aay38*TKbckDHx#E9% z1q%%r!V+*ANfNeR9&XfIgkMQ8|5d6_2@!w_Q3#b# zL3t#SF2Gu&G=5^<$Te=QVGOImO#$@V-Igo$+7IrCz(yYi}PbwIar3j5;HX>K#DC>sOH zwIo_NhrZp~MDiy(-@we)epf&kcT#+yW<2wx7`bQWkm{OS~76MT*;)p@Jd)@{PVxB6Ho{G=qwpX<50ze(Q=d`W1%Q9aqu%3W6M4`y-y8WHzl zNp3aq%~Peg0q;A|`J@6tclBrt&-q(R$d(S*J=Y}m*GJVd-ZhRDosfrwN0@vUdxeuy zBZgkUPlyW}vS1z#C6fi|@He_e1TSY5zo;JyTA% z!|Z#<=<6lIF~HkAZC|0FQm4EsH0jw^JDoA;&+doB0VYMjo|9Mg_HQitXoT+fiAf>r_2?QL{j~S4OLDzUJv}y+Ni&tl8&9yOw_=Az<4Ao!A?o=KcpE>PwES+~#5a%&@a-zjWiBK@Uq! z9F2%K>86(KJmIq{Fip>P80Tp1o$zPespDXdVkfVD>IIDeoIu~ykV`bS`5phy-%W+W zTCj0y{%|$c%?zo65jufeb7R)eP^1tZzN6O8{Bfnut@A-TPkOOJo_w%Yyd4#&PUo1x zb_8f&w>Kp3oQ;K_sUih>p7NO|Me}Qgo1J_1RNeGWmJ)?Z5Hu$a1 zcY8ltVTZoj%Dy>D;9vZH8g8gAB3ML4TM^>b5MT%=uAKcQ<_J^p#P;ZTI06;jl?s zJW>^@`(+M%JhT5$^r?Tm0*W|klt!Ol1*0K9k%XjrZDfE|g&uveTrmO&; zLz|16s3%9}wX}ZtB9Re>HF1085YaFClS!5XZ0i)N%kT;aB_R(*vjNbKOFJ9AF%E?yBm7jS{LXCJUR+kbMdjIh2bN;KGzh%`L$BnN<#ne!aw40b`bNqAxi`enCUw5p&zcm&rp976e{8M`-=uzP`TvRrYnOIxYIZP-~ z&Ob|@5Tn*vN_(QTWE*zU4DD`KY)b;UNFnye^%K9EiAOEWjfAw(TN2l%@VzScc;TFDJl z2&PZ|Q*fpwEAAvhKVs-({_93WB}2{;oLapZD?V;e8;!zrPc!uMHWa^8>>d7Gx{$iW zUf-!y=aZDQfOZZXSxHDyY1Q4k1Z!oXZMUn#U;F1p{D!1VmTAmV_D`NGg=0!9b;oGB zPBqVE1q;I8tl+rx>co;rk{@HcOlVNMlBXt z?lJ(Jw(0muAtso}7|H;F}_0?|H<5061U4V)FYk8y|_T zBpene4&>Ja!5{lrB)& zX_XYjL+LYSX^F6^$*rELAdA8Uwn_VN`e`bKEfjkJ*1hPtc!GVuT-n{n;lD?RXtM;x=Y}vGmUx@&a(wf*{FF<8Y}l9)!J>zEPHbE&b`~L z{xF=ySlIk4(mQMbjk~1kdL*-L@hN))^<{C^LVU==JD)&@D}ULL8tY@Jbi4^;Ae!lLt|uKhH!|_c1`2{%Kz0=WqX|!DR|& zT|Z}T`24kN_E!O%n!~kFHBL6VYh40r9R2Se?ns)M0LUL?*LGNc%;Ny_*>TPTUCzS( zS0c`oVw8-#iaY$C!i1oYv zz2wW=A}Hzyo<1$;k1LDofuGr?T|K5w!MB8VrFfC~ukHWT+B4-(hrEoa>8>{gplGF9 z`;pPml!!Rf2Cz`W2l@+36tvKh3GJgt1@bbj$FpKlHYNK^E|%>>+Z@W)@=7tYyh2oui_n#O5PX1_*5Qy{W^!<+qZMvkp+$O#PTaqiL=#p zHfG|#?{x1_sK+nf5H62v4~u@JFp>TmyG-IKOQTXO6S_45NBm^8cLfsCH4YaY;~Vx< zAJ_eFo-)Rg7&MCuZcQ-T3^Wl+hC<<1=I_ZWY8TX0&w(bKUx=~kS(^2a{ zXLTZ{$!fk$Ma6>`{EV^9pa}w{7qG47hB6zEP7bIc6OS+*4q|74Q!x|DTH8FigKAh6 zqDRnuDE{oL+k95iCz!mx`9(2OdDzXY;`=&1bImL8Cm+6)eq{u9cBa;#qpkfVynA#{ zA5lXI*9xlR>dM6z7pn%#)vo}iFnD?b&J5sGXUm97QwSjxqG6o8=UiX>N&T$)OXW5h z!-&W7f`u*1(LM&x(B2UWTvhgurU7MqjBk@wSKf$KR#$T5Z-OBd{c1nbo!0Xa;Q>>) zuK@g%ipB3OO$0e$e88J|n4ice@Lv}e3o=|?&@pBo+%erF*u_tAK`2a7 zgGx=q;0R4QlSim{gd<`>7xT{JdcH){3qA&Kt}pG{w*#I8eU+CC%O^E{;%6iH2-_N+L+*AwmvFuF5+ka*q6LUDd7D#nv?iVX zq-VM*wztfkvfWiaF`qz4{tYGEKDy=j^zA@onJ{-L6sTf&4gXlnBv8-pdv`?X=*-M^ z+nItt>0CIj9o05{5fOFIU9~ir>Uzw;MzHa&9(y`{~{YqI43bHv&k0r{Dd$}`+ z*9Qht{^doTm`mOEAS`gU-#iH*A8jATO>#Ia!rC&Z$WB=v;!DUg}hFT#l( zA#jRV-}#@qMsSu2C>v>8lCELV92jas@XbyHxR4Q>ra<)|&8{0orfd;q!Yqsfh%V9P zm6mTRkbY*c(~m5Id}sd*{ZUxap@ajsF4?!ZB5}wDG@Zz2uA&0<1^-2V~e!ACyTq4PN*;J z131A=RsZcns|GKhw?TKhB6jZip|7*{G-l?-tw|Ai{qVLJ|i2^72!ti(q zz?&;g_A~4=&=evDL@fJ$Ghn|tTG_Gq2{~HZ&92^h^19FM!CxP6UqRW08Q$s({EF{^ z0c}P{Lx->hbYQ;vhTaNcA}KvqmFv#Q;9$=c-^L@VGbDrlpOmo2)#5OnZ6U@o~0PAgor_^zDS}Dt>YUxfC zUapl-CqFevC*y)G=A^sCdIuKg`EZPc?^jbN+!umcDNQSX1PcfUygEmAhwv5-1vBkZL_-G>#GGW z0)Cu`*R;UnN?6Us95QXwTXUew+BMj8HyU}F8-;l&NT9HtzhQ;HF|3S)%|mZ4gi}_C zj*w3b&P426&@mhe2C`x!yiscOG}s&3gXXko6RN|tb>u6%>jz_<)Ji3Gi((7&0&BKQ z#}DQX8P^xtd$j!E==gKs(sF)D!jg(JXXgkdG&s-wkM-8u1|GEH;z$^6P|ppz0@dre z7K(+cR3^hJ@0H#k1jQPDv@<*mc`MY|>7$taw^ICy$%32+TN=EYMdQ=c(U7Oq)|s1J zZkVEiS7_vKhgZ_$0%pH7hZ;)-1rZ!oNMbPZnHoqzgd!A)=lDA*NrOBUD+Q#3c)6d`p?}#3CkXUW zLw%_jFEx^Mr`SKFq%%T}7?r=n+)-RG&{$ani5$FMChrCsN>KwjLRVQlQ&tRbtDyr} zsRmRzsMhlR0C;r(TvSqugpa5w8Sn-1Pop@;Xr<+o3J69ql3H?`YvIBS*rCR&g(7Qd z_eLh8yQkcasF{m+y^<`}AeUv4hwstAKb$y&t@puiF-Q_hs{g?YTPuI)JcQq~sww4n z!Dz4412a>x6t62FKj?cuf)`WpbT^a3O3jt0oDaa^{*>E3?Laj!Ko3JSlxD8VWakA) zL`lyI;aTSus+Zm$#@poN^M>97!YjH(G*E_T;;Tc$UQTk?K=Tmi7nF+ccdhv(?VV_N zfR2s-V6L`#exu}q{WbIp$0Z;izbd!$Q~G4cruInGY=$Z20?L!I0u695G6t?qhb~pm zVkBBx$|)-S*-96DEOAyd#~qjZ*!^;ir9Y@h(^JzG{Q=Tq;^d0W9Wp^T^Dr`#GWMgH z%uu+agwh0-4r~1oY*kf8;o>AkB5DemP0S>iL1_*=T{1Bej-(|ItESH$G~rVbisOv) z#%7W?{2(SRQO?tqTD+i$qGG^yp9{3N!1o$!J!NOFIF)xGUd`6DgH=w~rEk_WM>!Yf zaIkR_E7rhav+!|G7bt*gzt^U-q8m&Vkk$<6HJsN+|1z4Zb=AXsHFA|vbwo$p(L!blA(tC$l#wfL}+i3UvsedV)+ zvJ6-|30^Z$%y?(I!en&2>g@fq{7{J1wJu6VXGXy@G5pC!%Zdz$pA0w6%y@QgkhJ^Y zrD^mlo90ts868Dw(EYM}cp(6nCh;yJd`Uy`A5ogD(8u=6uuX%Pw+f#iyK_~^CyGkO zuCJFwUwsg^)x$gGaDF)T&qWc~qgABze!_Z z6-CHJygF1v^y0t$*_!?=d}D&^5u4v3+nVT7NBgw3&63aCyLQrL7DWD)h~9O`&iqJi zEy-xvUq$~*HV=%5@(WzwAkSH;`vEA90oO2Uu(M4tBZdul`C7Hp0q=q{1Yf9-*LIj~lPaR%5fzTm zVn*Nd6`hWIMyxTSB0M3J8BFOK^b9{b(Wx{2S$p=JrN09?x_uNge!96D#&UvQ9LLsq z;jL-R^K-wTs~1s7RRHVqEnEvvrZB@SrBIq$55FL z=US-O?i>OS@}RV#*6=^Qkv&(a0K{ppcbBJpV|-iH^NjM zY1JdDK8ukU{uci7P~2v_}_VmP+9iGT6$CHO7v@o;k&{7@0nB`e360Lj%Lam+XGzKqSuRlzqi&!Y+Cqn983#R7T^6Q=>q)u zh~&Pdd_ZYhtP=!K=HS<6h1|VoS#vY2 z7^d|!h-L}YXxKgOgS54VQHmpc4!6(^aSK=B}+u90(Y zd)u5pQcT0%7`U#yc@}<^H>wX&5<54!Zw9rtyAA4ExoKMp{?m#i@pr`+biv;lhl_+8 zdA1**X(+iCz-RSjq}rrY8a}1$X$a|FOO{|K!98A~1YTAO*WtNA%pp0yvTonwu-ItJ z!zXpU4~hZd3i9IXO65}LPK&l23{|ozrKmen;N=RqywG|a2!K1vv1%+VuHn3O=1Ji` z;q6Qg>KDoeg)fkK;yS3Aq@_me7V$9~jS0Hh z;y-XVXzi24f*$3L4@-cmX)F9eO*)R$|uEtOufmGpP zVJAzO(H?c^9pn~vP*$^D3px$n8_U$7TKnzrCyW;RjT3i>kCWLPxf2bYl!pZI^Kqn) zl3!(F5>PvaDEzJorc%pFgTF?TvDFZ(gcjx5Thir!gN}b4;4BBXTNe5q6F`BZ~a963g45u=2Vw4Ho{ErE`A7mkn-%=_T z;;ME?&SwKI_}i>FBMbm&hv${fr)kVC zVe2y98xOz6Bad)}@hQf@)_DAolI&5#OXbW|#)f|ZCSGlp>g%DQT#;>?#JXK@p_tif zSf?n*e?*|VHHAnNL*Z!^HvEEi;>NCNT#MxEHY%=L24FH#$5Fuumx81}g>SHr5`Zl- zyWfI?99u8KdAGg;K2dn?-Ye4*n^PwTn1w5Nz{y*`Rnaz9VOY|0ke&ve}8l zW66~YAwpqh=Hu>a#c2lY4=bPL-;98P1f(Jqgv}cr>meChHWDL!*l*cmvvcX!op@LOvWbOrg zjO(7Fmb-6~x%!@2aF^pGPr$K9>0Cjdc{KseBl}0lTDQ&Rtb(Vkjx!DX14En!XSu0U zDH!mqOyW+SHSD` zn&}_@AZUwC|N5D8!U~w`BKHm9+b|RJPF*ics&koowK-Tn2Zt-Dng0;SQY0<6GxM1v zH0Z^o;dB${mVBo8D#hH?8kfJ(We#|o+P&~gf^H2&wcyqS`SdA7CvH#$%uB)(luYA| zCtywmxz|P&4W;6E`%GjmJFRQ)?#Jw@I0ip!=o2<2#e>}Be++E91b@dEa|-27UUiUc zWd4YM(%B0O+F7x=vMBAdNU}B-`j18pkTTGwRFv`q_2Oat32@m13J3WSm+cr}h+=IH zc(2g55{~&O(hJWxzd!p6kaT!eqpx>0OXhm~mlAgvscO&v4vt00m7(F+g(O&(V_Tj5 zBV5kqBSnq*H@!>Ikb*>y!$x)Z=GorMGrDNTpIN+ek} zYnd$S3)hB{KQr-XLrq@?yBELbA zlj{G@n{b6QEtm$!?QH!V#Sz6M{8159#lw07og_a*N10aYpmj9-nV|Oi#b&%XKU@qe zQ^?c=tW+`6p+JfABbn^9ynGrJHbya?@b8WT4Dve`u?mYx9oLmaiS)#WE5AhcGRx){ zrK|Ae5NayN%b0#W0(n}6513))Y$`X3)*v#?2z}%{kWCZQj@6j1L=bn>zF*+8Nb7kV z8?`VNo*PEBBc!L5eHX?gJri=2tR(SY)`@-bt(cB7b)D#HgR&~NHfZY0Q-(n{CrcN@ zy~$!Mv#ax2<`6dNpxH{5yF$3exqN155&*@UUgb;Pt6Wc~DWKG6ePmp@Csrp@ zQP@5dG#Vonqh5~~R1&-}sQCeenS7=V`ndR#Nb-o9jzknc*|35#_M5!u;N-?}f*Sfa zBcH+r?kZ}GR7W?@?Np{_XJwfscT2OEy5-#_>eU-mP^EM3gmpaYZ{(N7+TI8u8UqR? z7&JvNqGqCL1C0ZWRK&rL)9_;)f2q!J5zeca&A3F}eGgWvS+Nze&5)vpw^QT<>9=@% zSb$AVN}?L!;9PqY-YG$(-1MMhoMJ3IkO;;kri;za;xB8d+n^qtCduxBx9aLuL?%`l9AY#`njL&~yjcQM!CN~GR%Jysp8b9oh3wpKJzx>bOy z-Ee0{P9@``ZE_ANCn2(MWCUj%r4Y~$TEtdP-oP4T)>{&yjfT=-+ zRjF>m)zM%-G8e$a+v?>M6l$3PcphB$%c8|}I2p|(XwHOQ;p!=KDaVQttW-yqN=)ZO z3EnD@6WE4msDb@qG{IP@TJr{fJ>FsMYx}0+i>aTGuM&G+cdoO3S2=+72OI$ta)^uI zgi7cKq>Z)L@M4`^P2}z2humEE& zL@n~P5zfSu>PXB)Ykg8(&;x@|IH|9Rcq4lZHx5Hj493(E5iB|`W8XJY%XMI6hBcY3;l`L=EXdP z&v06QK&-E~r73cSD7mAY6>r#zJdQ_=$RE}j)^_Z(#o@k1$N`dy8HT6ovzfA|6w&UE zBj>br=A427nqT>=;}t3Jb|J;IP&(WkE}nrVY+KvAl^u}9%x3HB8Mk4TnCDo*a&q16 zC#=g;w2{R;$7c6uN$;cL$selV%<33qndEN)~ov!z1B4{G%F3 zH9?~uiRU-T%_~kN3k}&-))l7wWc-S~dldB==LyIdhwAKmEFraSApWkJ4CBJ9P1iMN z-({pB+6NeeC7gPrfJzR;(fC@>mt#_MZX+7j>xv%h(^iaqq7*z_yR(n$2zG!;Lo<>m{>W^82lR=DJ}4G>?WOIv7>}hQ#Dglv=Nc za!NRm%AY1e6^vEFKdX`C90fNz#ZOQ(E?EvQOHiq%I1c^Q0kO6b_eORPfYW2GR`Dm; zoMjy+^#S*2qyBY$(4umA1V9yj|D|H z5qVrmXE->NLf5Vs+ZE@Z&L~daoWSFiyKr^2@;n^1LgoSx`XiTfhP6jN=hoFKKS4g- z^B}}jmkK*Tn+wnAiAANSi|VOu?;1p-)o3l95_J^WL4-WzEI2cjqC{n4C|1~^Y~oW? z6;Hy_Y#6EPK12zCRA(j&R>>PR+K8MDOxbMt1oA=&s>K(l*tX--k%~ATb7hnHybZ8h z2iJMSm5zycTqJy{;apUrl{q!zk!YJozL=;OXiH=+I)^IGLxWZ;H_~qCd5ej)Os0g! z!oQF_W)HFtq7tlM1gfo=1%Z6Hvz4-du4QmY#n!miJPBn9X@xo_-u(}-(e3{TTVO|# zwoz_HmyO{i6*LtHdkVgc$9$RGBQ_Wy(@TQSl2e^>$M2EY8wukH9Ib>2gleicBNPqF z*B#aUEd8neg!&43Kk23>=cO9aq$mN0mUDS(u_Bd%n@R_!Q6x^YbWsm-xWtD1{DRc7 zV~h>eTMR?xO;)u)7jtR@{b9ii*e`i>@2}y|Jeb*r|5WMP`8T!j8OYV7^{_colR@$; zAU2Y@X-l%*M1>Y@xnVZNkL(PwUAzYwqhOo{_rs``FzL1@Vm{4|;xhpG#A_7LKGO($ z;i?v*bjh8Z+^FFg5H;s9*FvXhqFwWz5G!X*<3qc8pM>>Ks@q(30jCYlN0PMd8{V>i z$fxEaJDI}sxaXMIpVJIOlly__m zPo{G@b`G8uDNc~{3-=r0;Rw7VM4q$oA7+m%U^eW;ee@LSnj}a}g8T^KDW*#9-3}C$ zva_5Esai-*bzJAjHk18`zcF*kuk_8r|_O z3|`sW$7$;R3HYJTO>o8ts@NGV-Q3gxY;(Ia=yVnxMZJHio10w?;7x$X^>{%f#OFbj z8Rus9t=bB-)NDZkE<=Ni@$99%%H1+YV7FC zAs315PXk+i5ZgGtqn`$$8oX`{oR!jU$3S+eGKL8X$!xPEJ`c|*EuYhW+eL@Ba4ESm zhL6*5{d4W`x{hqBfkPAElUZ^t{VPl5j(#rKE-5@AWV#-oBnHe`IXV5!4Q_lg$oFWG zIV>=X)ivH=18hiS&G`^Jfmtj#m_d5Ep{&CUlg;GuL7a;U|57**&&kIL8LJm6V=r*+Y%1oO7*X>%8QTL^4qz1;wnxZ2#CkPWaGPg;z#dr_^wdLzM{H@iYUtmQETOWk3B3PWMmRcpz_BH-&5%TrqGG6#%hI6Ix z1RHEu-m%rF%~Er-@T>R;vjuJsRQ#y_f8SBF^r0n1f_xKfbCLz)$^HzuriLv#WF|B8 zOby(fL9E4SPIv%p@lor?4VhEM?9(XW?T8 z*p&v43}Obs4uZGFIxmuDhwU2k4n@3QE69p;W^UP3{Bv>l^K39+i?MlwYpAo2(V;r{ zV+rf01L|;%#72N`qxozlA(8NIE5)iqMannjg86UO@q8RP7OxBnJDl&}$UIos*3kf8 zaCnc2?25w!m+;poF^AI{vYAL`q-zwYmGEi=+~981R2+_(qWq|{(}kE!xEbN(U}X&6 zh#})CSn~v2F06c=5#hUN)W)Q--X_w9bH*ZkX#(e~rHZ>h$|Iw+%;Wf}D7aCCYRax@ zPd=5Ml?y+~&3pe&QFNg?rUio5n@%SRf#c0WnP#cb>n>@qihC|Y-M`K)j~GVSh$qg4EYJ6-$I;1#7a3$M(C&d83PI4kT9D|`$edb_>dAv4s^|>q%o$2`0{FUN&0b9-q(x9C@=%4XReTR3H!;@ouo0$C zz$ca1I9fjTe<9-R9DFQ8NYd838iKyw|2S8@8HOt1gbi~lye%E~jfM_Rh=j*AShtZz zy3$ILm<3f)*hFBf8+K`!Tv)6FVF(OLq?F*y0VLta3b02>SC^ASGqe>cN=S+UfBk6w zG3b6M+`nTPzBG;5Ps2c=%K8C*APRnKCvH7lnk3le1mJ#6!YRN$=^p+k70=WIYk@l^ zI5!q|j$mE|Z7Ub3ZR~!`&S4S{bv6{h$$8Xw_a20H0^0{6pXGWM@>?F`@ByW~Z?Zm$ z75z*{L80pCD#eK#smV>4x&+^96l;8<+uI61M^fwEjPhWnlNFn+7ee`TO++~S3`L8R z7PhVd?((e13~5R5GKX&)kr*D`(S?@NT(83K&?fORo+Xlgw zQq*p3>dw$Q%zmi`(vHA}*>sF_lA^c3^_Y&^9WOE-Bu-rDeCG6WsN&=vTy>CM$4EVK zP^X0nWx~6{HaL_H&uqoN+u`J+ayGb<`c!+FV}lZ&1pCi8aZMjT8D*V>~*nh2Kr4 z@FX~siL&+;;euFZMO?kt8>kVRn?v0&Y#eJh^Ix~F(X*nDyq_xM36Zup@!Q7k2WgyZ z!FY)Q3;>U-Sf3YKtm=ScKwr@0!?!j%8|UJo{eYaLaM+3F2>aB{V!IuF8RU3%9b{ti z&pK4g3^0}J!V9GZLWHo5|3#n=C79uunyHrF0JUAt!)UOY4(Q-16~xJjKaXyK&eHI9 zm(R3mJ!@`(oVBQ~b2xs#Ka~gn4TqWxIvJ%AI992(=VY7Ra9|SoPl^1ve2XF>=X#!W zU%qPxs>j09MH}j&6vKWMNuSc)wgjYfDpjai$b)a|!KvblHo^D| z{-6nZ0(kEh*ghOi8A50A&)V(};hw(p4+sVege zb@=v^x%fj6t^_Z?TVUO#!pVY)-uU=0+HkX8Jz z@kVNLc9+NA?UfUdL>L5sDm9JN_J6YS3ME`gfhI$8D3||lHf(g!u)dsw*GR{Cy1a=N z)0KF>kCyYhMHu-ozI~Km!Yfn72h`@8;C#F+U%oWZJSXUG@w>KEk0$y7YgUm-6J@EE zBe%YEU{E@+6Jp z0Sh#xv3`f5O}?+k%?vim_bmGSW}H46dGUlOWhQHHgWOo=-T3LDosKhzpFYTNvhrP~ zz@&>BfMG4F) zkkjTD3gD;ls9tJ=9}?k+)0Au!io*?|m#G89Y(`B?n3-2GPtN06a1d&i!uPxI4^!m% zs&khpW8|Ako?(2f$17RIi|}wRBvBm?1Lsz5gbf+cmJ3z~C1K35_;*|{!l!n{OZ16? z7|zw|!r$k?^G@h|Ni0S+p+Y!pulNWC=Fq@ik;Kfyr#bi%Gp9P%Te9pn9`@=PGi&yM za|7$G1tzz>qrN~9K_)&S&1P0F{SCv$O zxy44ZB&haz8{Nv^@-gzy2;aJ$f3I5^dKE4vbSBVWwzNG?_N0#{cv2I07T;@&X#9wXw{My&Z2TbwY( z*mcV4g(nI0jfCU-q3$SknLTmH>$j;_e)tXun_zuC4F?;lEZ zHoE<0x62*620W+hU@UMK7>=3GR~JK%Qju!#+&XFXFt!_$ZcUI*@b@z*s-$$m>M6|O z&|cgcD?BmiMFyFfUGVu(PVO)ERZHdDYL^sf?D`SjjwFZlhUM^O1k6c99{z(c*fbD` z#9h(U;3cc)$hdBE_%+sShg*^4H*IJnG;3gyk%!;Dz!+PtLCgD3gS_S{E?$yFMs#>&~6V_tpHO98)1I13{s1D>b_93gv zOz-ljwl}BnCY(tXFCr=DyS_q1m#TX{Y7oxKTamwKD-N1MmaYM~Mqk;(Hi%M1?>W{T z?EVklnawqOMQ1!b51c6PSnU=w;k}?jR5!caF4N*9z1{4ur8x3ooFW7d6yaAml6n~W z&7y{|Oe-wKgXK$W@V61dRQ~7*D<7JTM1>_>V4@+-ZrZam^cM{tGae)Ecu<+}x3y)j zqE_2ihFRqDfEya@R>77y7%X=&EF;3_Z2lF=TOsRd5cD{%PWXmjX=Ggi zQlJLAnu(4d3NE9x3Y>+e6cxUk6`H{GXB#EOc=B*5yz?BTAX4D;Na3MWeX);5{yt8L$T#}HohD|Suk@J3!1d$*#0rH&;5?ZrK3D$E~b0OwbHy6(PI^u zmB^K!3HJx@n2Dz=!wrtY2gGXp<`C2(Y=qreruJ;bXt>e8+liA2nY^9aP*9E6RAQz) z9K@HixO!JD@l6gbXT7bJy}zWwOKF{vgRZmSHACOjsLk?2y8AcY|A_YgSIWZ0iLUjqA_{+|#B1~T`CNB_b1mMloB_Xh*C{%TQJMC%or3Vp zfpEKujO#FsQ!_@pA++9dcDR^a;Ocub0dyr}W%3-4*+3a4-M zJKkmynKv6xi{(Fa!vf|1_e}dNckPB`ovCd$jBo&nF}x1%FQ-Un*)s?~aR}?@GFGm( zQG(TJFxHGbnz8u%{jSg89A(DvwagnIBUG)#&q-<#ePW&0=P~ncJcKyud+jDy6WdDTfuy7DYWeJxk1Z$iyWCqpa0heUQmpb71NYsuS zV}O-g_L46#j-LSz4yKxg$;^Hj?kpLj@MBAKGA?Br6-VsFmg&{KvzTFUfX0d@_(6cr zBkryep5V8}u&&nLZ9)$e@RmzE$S(wZ6%f4%#~Pf2Z~iO}#lGS2St@fFcBjJLl#xde z)652af>sW$jr3#%i$AEr@)8ZUkKCpu^pJ#0lT z>i`M|KViK;V9w6ZDx0r44J%Te9BkSQQ`9g(Zd1Nvlx8pPj)k=ba%T}gC)v4;KASKG z)pxvLy8u7d(1}{RRr~|Fdpq%cJIYtI@c(3>HYN^s9)#aVF{d~&(4shOy1xb<(@~Gz zr&O-UueauD%|U-sjr27XD_M8-8s)F6Fz-WVhDch83p2C*(Loi@z~Yc9@- zM2(7ZB2TvQYQN~ALo%p+HKGq(9r#L&rUcKKmz>kCco{b0jzai2M^2P8)ff~PMOPTJ zZV?|p0FSIt`z62R+{!!!;VrPf0=aNU4B>Vs&zVOl^>L+Q1bm>!s<<03L#~>wm%>v` z)^fPYA+yp``4%Zw6FekKx-8b00%-$$CZ_}T3Knqo>Fll(NU{I?C?0{C?bgks=htxy7nSV}@L z;ddLMR>g-7D{jN71Jq=$DDlu*WeZp$@osA4^Z0XK>wh?+{ML|;J@k9NOqa{kzDZJK zVIu{F5txfLy=SowQ@jU#Br-h$)pZTCy73JH$0JE?IdYWzzr9cX{?O}+L)Dd#lpwdB z-o;#pWhFur=Qrmb{eY3vbz>gxewtcgU)`-Y^fjWtNebZmG5^1Rc60}%?ql5&NpI83 zm$OI#_~J!2AcAsID1ioExjlxr9_v-GyV<=Go=Zoq4rL#BEm{c{=~1vBA>WLn64~?tq-GITaBpK zdxL>yv5kK@gZUBI2!3@vZ1@1xc19yVX~`|iWyK&=aMXlnkws}4@3Mh!< zM>C?Z_vSxjrO#=Hh7a&>Mo_Ot0jCG0W&>+8nY$fM=R!| zROKaPQ@kp!gVX?wu{la?%yN64M0IQ&=P|dyr!ndluiq8gESSsw6<>oXHLSlD`e6BT zlIpd<5-vO2yk;COw}peKnLM-D5skuCxO!+=w=!biY=+l;t$0_FVmW}Bgbg2aj>3M> zqQcEl#s*h|S#-H^idpaT);5`Qv2roI1?0m7@}2-+O~)^ch2kVRGxU8@RRG+7uKo)?+|hM}-UOxdEfOXmzQtn{~Il2LJ?iN8}FeSP=83Hd9hA0oteRe*xZJK9yM7Kr}z5I z=3EC8pY~KF-m{Dka?W<(I^gmv&i6r)Z;zG_Q7>&|ULYHkOh7(@eI<&#)28>E{cU0k z?j;i2pMA>dOr@^#eL#^qELEYeYJ9P6E7W!K@9>-EO$OfDEW0COv0E!oe z2w0>8&aiJZ(^X+A+J#I`4gM}#?Uu~hl!)QONqj~mnKzhENJBMD1@6+}{s3PCE4Gt- z`5M>Bdg9K5mI%1JThT_Y#WOEzn&FI5xaFL$9FCV+6_N0;*0L!Xw!D&D)arb%6T@Z= zn1F4QV4ju)DUPS5*Wxu%*`FNLQAx61iJD;I^K>=djfYiJI8U7jsgFY31u_#uAFZOs zvAQp_pME@JFx);&7pG9!d6QZ1{ElmN`S=_HYHe?V@TlozB&tc?H-tRAl%E$x>?XKp z&cyrQ(Axi9k@6M#po;&l0%#sXY!)(o`nFx^NtJu$6f9ZV&1lbryE z*QzzyKoS*M%*$!c2BnoT$(6^Y6NSIwO^tmVej!{q2-ZfM21ZkOv~JOe@U*&M2+Hop z<8zpE{0Kc$LzPDlsxjR&Vo4WT4ZpW=biKvP*?r)59{cr}kA~fuIR8P;=MUnC^^}9h zbV{$lqgGHPNh5I<)h|Em*zPK4gK zkk^?2z)>)i?x|e?*L)~3Xi~_SRs4~$SQ!Cc4!^jMbNSt8BY{ce-|yCpBp0XP%LdqK z!4E0%~g~COs5o@2uOQKo71CGa03mB>b%L!^N z`}3_YL)S1oQv(CfQn397R%xJ4$$HwmIZd6-K^`;P^GIT9Q8ojc|G%;JyVV)US;oM^ z6s}%s!;cM=yY|CU)9E$Le{gpS{53=FmgMN7@p(w3a*v#j2&444BN-gAaA&1()p-)n zXh#mb-A>Bv)f<)jS-%%&WQz~t%4M#D2cL&5oluEYHX6oaE5KSHHOd zNX>51=ZAl(&<~U3jE8X%Z{2U2n#$3r(CtM5Q(Qa}Ed#Xh{bZ{hnejsK*b1Y;(LZjKwaWOwb360P2 zuni0e+6KvQwlh(5R%SoW|Bzz44-JW|*H>{hyc*e=BSpBc+g-NE(k=uK)0loD)_S0F z4Lq+wUQIr@ZQ;JwFP&%M_Rt}SH7z6UPgDHe9F4=N(3XU+TCICV^j+{K$u9oZ0zMBWBwK-Y+$cHNYl3;qu2!pmFZ$Sm)@b+M z*uye^!=)tpJ*iQ>b77-FU1#^ZVY6DXL(qg?)dX14YzbB%aYJ-YH6r@M&|8YkPc8i@S5o4ZBO?ul6PB%@3q~@-iV*WIX*^S+*e^iCY-Rs z!g_ev$efW|sU?gt`fGi`fXl;gpO5B1_bzBu;YaoQ<~p;x#ZNW{@z~j+?XXY2PJQm+ zWM7nR4EZyHd7CoJZzrw!-nIv7=%1?&mo zX-|^zwR~I)F>>&-055(9HjU;wbS#E>*)XuohVffEe9S>v*@a1rgvBbjJ^)r>&Y8+>wc&h{g|SU4PpiFZ+Dt90Xn3vPq`rEYO^qebqV9@^Kn-lKyr@BIG2Cd$DEo znh5(`#nT(oEZc{}!YYy=-wb!P5~Ac*48SbKDk>HX-m@oh)?}_uY=x)gb2s>%Q0zKwB}#QNHwULivto1gUOYsH zTJfxn~EWO4BT&%DA=^(zKyFF3ZlSE>ZPa1zA0tin2zyTP64O4tFr&Lfny$+W1X& zvSc)TnjR+5pb0I<`p@Ck8raPN=21OdH1Nofv!x&XT6}yJ>vjpN)J;CI27ZjD9{PeV zCmq4p`KZN~0*-DzJ#X8wk-2Q=I%@~tz(K-h#ax>O6~T8kkj3|YMM_j1{|I)ch978J zlV{qVK!2d;6|0tYd-2z$LZid}0GVrI3hAGa z?G`JrI|{31{kTgttw%B^~W(mt=D6g{CMgnt4geg zMx*th&`(|OZE(QN4!n>sCW?J?FTpOiFo{o!K~g9U_$9r+;DvdnKDlsUmiSRcNVAm5 zf)BKOvsTdvliq-jUodGh;eDV!lQ<1tjIrgzBX9O5!H+?<&JMPLF){o{$(+AY(rm({ z3a{}9-%#0Z_ye?hcr6}RsJRBw2OrA~@^=iQtV7eSc6mJ#|CERy&Br&tfd}5C;?(p6 zX6JbE)%THEusU~Rp2KTY_-s5ZiP`rxzPFN@MHl<5G7O>hRE)XGs+|!O*qv^&b)aef z_>K!QQ{lk{p$L3H%|m%|k&%gowPpxwaVw`5{r({Im^#NY1#O=6Q8D1i4Z-G4O8@1uvuHN~`CG7(4{}(s@PzZ4jc*3Hk3dY^uI}UE<1Rc0tX$w-? zK-{RocBAYu;Y!E5{HO^0M=2}$;Tbg_yti3UXgmm3j7&Q_mX>r3~h+PYv17Uiu5KZIJ{he?R zx}Ra*hvwrORE$M&dg?pyo(>*NPd<@_8c(Oey8p5C<$+C9+y8f9qLXBDn%t(-blQfQ zwkd5Pp)E}pWD8KBNClKt1eqk$WN4BJnWUu%V#F$_AgH)Kw~7@})Q5^IE>%%bQPhX~ z@~WcZzUzC><#&ef?+>wUlF7`y=X{o#d(UZsFIq{W@xfS0Ijd;{Rh9uvvLHHqL4=#xm21v~MS!x>x8f8mMB*m~(;UhtJ`%Y8vD+>jFfB zZM*3-2UCVW{rf0cH|$pLU|Yxgf|#zYL7374{FU(U(Zc3u!M2DFH!^MXo(UKZ&(si! z8O=uZivNvc+v?%E0{HwRq}ZOhp{JRZQ2qhDv<&{H{V#@IKpB-kG4m0NWgFYpd~jr7 z$U+k0wcQMJWW=Sl@N=`-LZx{$OeyyS%I$<8F}&gx z7hOQ>$B0(~tQik$f~JVFhoEB)^cRK9XI?_3Szqm_0}eECVZGNP!j~TJ1Dlww!jlEU zQ7M_Ei`?R4m5ygBT4rNfCsqnI4zpoWYsJ2Qa>aIy1L__+c?bUGN|;y%R&!77)K#!? zJW;)6+vsf%!pj0Ljc*w5UE>jV^27*ntUn8L%Ps58=W^G&pn5yaFN86L!b5pjzC!F% z;av}~=b{_Y3y#;2CNOS*7wYHyOvGI_TF$}eyXBn-ZO0#h{wjLMN;rptP;C9N;h)w9 zSl9#CB=E%*1zb~$4@w34uj!$$9B5;BHl_RL!w*)o9e9h6USC4G1GU6@7R06FuQDI` zMzs$J!rKRTG9{>-?mPs?oUGmz^auxd;d*NI!E;sSP3K#Ju(SjovC|>w-?S&hbP8W3 zAXe5nkxsF~D=R_QFd#-e3MT}T#zWSCzKxR_8;AKp6p`x3Fx!g5|M@5;3@;8lrEENx zp?BU-muw-DYkI>hP6{>)3mh}IjliE;z*!>%c5xDVb64%OMI&fq0jp)i!cpQWg>c*~ zbJTSUd{s|huR&YZKJ56&eD(UX;OzqV(LLEZayaM{T|YqORJduJGEFX_wzuH&M5q~WX@!S3z^8+vWaFY5O06Pz&^O@aG$je+whMuU%uXU5e2Dnr z3VZ)-(v=rMY~!>{0$zR>ozepF?SBkUZ)}k7cWq?w;pWe}2Ss?TT`V7K zE*j~zk$Uk@u45H*HKK!Z8eF}uV$Z#n`$PS7$qJb1pm*|gtw*@a1`l*{eNw=GIlM2D zMEm*7eBt0K*NiPc1)7P)M|u&^sn?JZw1tfv0dZDo3Li zx_n_iPC03&F>>gAR_hV2&->05Har61d0aean47roDHkJtME4fHK2a{%p+~RFhn7+aJZY32n`-N_7AKnUI zTo2Aeu*@p#Xk~=XeNdOTK1vgXaQ0}2Q<%iT?trkZmAM@57$dy9LrpM+-tRWis!Nz% zRF@1P#1ltmWG_wUMHMejqaPi%Qt>@m37-1PQ4aCQu?a;R99#Olj^_LEcmhX z6W=u0%r{?8d}~96i!bI5J}=Y-=*>ZKGzZb86{Q!zH#X%buyR7rGd#0d|e>Aw|VJNy7F1krL5fe^DUGy;w7grqXh3{f8bD`MDi*+@j$Le>Gha--0C zC(hC48^jBbGk1w7Wp3iwm~_Uar*Lt_@D3Ns_5KG;?{$yEWZzlhJ3%KZg^x2?C}V^NbfAE9`-oSG^;?tC1ww?QwuR74}y4ax$wnGy50${8E{iO^SXF{ z2g!-40{E7LO`UZ2Be1WHsIC}{o5MuSF59QW9e}?$0~Z4!FsZn#OJ6I6GkPyQK9zny z4vtO47(9Iy@Fz-a%zLnIRfug5c@=J*0K44qxnyp_e7hMsILl7@bILopo?44p)i2hcO}gmgJJ?L1 z@%ieafA^E25$fM;Ooi`?83hN_|1%8RNgVz5o7HH|3f2Qt?Y~kU3tpfC5E87~OIJ*2e}?{+fLn_f zrMzsZ92J*c$ZSA@I`KX1=h4aC?CNx5pv2tt9XHbutPxIpdd5FTI9>~#J!x-yk5Dbr z<1VI?PwMM5KzsMIU6{rRwcNlg7$bx>SC`IpEQ4R1<}582az(VjExcU7wgxJ$yOmj0 zcc|6$*Ak7IEvf#;GZIO)x1- zIF7e@?Nf znAjh*c=j*x^yCsLvx6^LNR3O0w(k=0vL2coy-RBh)HM$ z&t5_c?fLb4R*+o9W8>vl0)?l@<}JYWGlZ2j`DftcwQ$0nSH;k!oSM<;J$6PLew9b$ zRfRFj++C8U1|;$6Vs>>7`kbMg;C9!9d%}%Rl9J=}p5;RcrBA3Gg;G#RdfB!heQUzd z0@!sGz1Y!i7e4H4KMDgj`rBx@RbjP=Wk0h)xO=)|2T|p}YS~Gnyvf~Vc)e{+ffk>S z7iarW@-y|MtK!$&#~N8(k4j2bYHJL9ueA9Bs6tf946sB(k-GF;Dyn4B?@5t_q9qY> z;`rV!Eu)%Hf#78>uuMr&y*HK66|(}Rl1S=CR#LTCJS!#fDCUQ=h>(V)q@oft{%NzH zs}@Q0Nrs|DB`quU>bXP|4}`}{r~4#4Rdk#<{!&A|&+M0jx>y~yY z8FMiseuJS#av3e#C&l%IYWZcpSqvwu;+NwUtW6`(;d>Ov(JDhvs`ye$@3Cxhn{`kl z-OSp0ErnMY$>?T50m*X3>{v!g25`_a_*NsUq#~+Rw9ly|5_&I_^r%u=iKzzjUw2gN z>QXbzpc^sL(6Y={qRVxMPS&|H?^@ufW|gqn6BI93&6qvxQz|AzA*cQgDQDqI#7+X6^qyA$>;5s%x_nPKIK+%JSpF zgqk&^K0Sv+pk(mC*?30J#Td@@2vhEiD?O^@yR}S>1|X&r~HE0@6W zQ?j{?^_xkLS!!#P6pkQ>8-8X4 z(Lxu_mGm?QkD=!>I8y&VM|}^~NWF0l&nT%XDfyz#3Qr`1-=$|P8=0%Euk$z|nFaUA zFLQb}F0ZS?Xh~yw;2)J1Ucy1D70kXVD*h8yEq-Pex}#1TpN-?8H8|ab|f{O6|o^%5+QF{I4BX6kR^s!2Hp&hMMTY@6IZjn3`pt^JLUWCWqnvPE%tL z57?t8a+qv*&Qk{z&TL=3is+U|(LB;%z0R3d^>iY1WldBv@VqfAa%tZgA!nHq)^k~@ zs?qUW{>#DrmXAo(dMm3$l~HUo7qW0tCZ|-eNtJn;$q~i(`dHPEiP9~d+-}sq8#6bn zN|?r~yrpU!Mn2|JRE<~)tc%T#Wa&gMf0f6GV;tcG{IY=XaW#?dm?a12WKJo|em#4?vN@1-4%X!;_3Ei{S{_cNJAa^p$wxhqbDTe_=|@b_iFrF zEfRW???ZI0ojWn1Vbo^({A&Yvewg(QZqjFslJHO|I!g7PBBBg1q>Guw>nSBsJEp&v z)sjpf>J6D!QffjGxz)MoFrUAaLyoY#=2UV~O&vas@6oer$7j;oy*`3ZHnKpAy>F^L>M%;Pn8haxi&%Gcx&Xb}c`R3ru^ zHK~{nXL6Cjqr8FGV7VESa*&HE3CB+)KJI6L{5oeEBYM#or(R(ICb zzUjeeL1szHP7EXozUMr6iWx1{ee4io={`P_O{vKb{Wp}XCc)}^t?~`bIyXkP7FGSZ zJ!_KUhe`mHAB{54X z-mp8~X+>qDNl`6|@<&Q&-Apg(k^jRZ600!7ChoE_GtCa#g*=B~Z-Ik9?`b7rc)@NW zLO85s;}XRA{y_<)k=gq#lO4EO9Bq>s_sIphDg`Tv9^dOkX2Kcy9Ivq}RKa7SrScY{ z@5#Cqvx#8FGKSfF_*Q=>^NH{ZNAxW}7ky2nh9F5Wi=2`Y%c#Q#kAF#jv`S$;ii!-C z9P@oc3$uVn+K3O2LesX@&f%3As+kEITJ|?LNXm+rY!AxZp zjlO1YJjO6Z%slkAQ45QcVqRqO0Tkp8%*GVLeowxaq~y<;o0wla&d0e!KbE2sc(zx8 z$N3sXY7F|5S}K=S7jQfVi!^+9nW-|nv_z7b&f{=N1C`bTmVXeVHr~)MRD92wY@*Mf zwM-c5>VH<91XdtAT;ouNoDIl63CKC*7RzquT0deoBfAx|ud|W=7iVZmC@yef#N!N1 zZ%XJn1dCoI*0{M_%xT5MY6yM7_u)ADCi7W6ore7m9yL(n;72k`sROYnw9t%K?-47j zrL-ApIDb|DalA??meYhA9RqXCt}ntVc0Qgn!ueBt*E3dTytax2Ea%~X)PWn-b~K}@ z_OWJ>brppjWv9WxRD2D=BMeQ&g&I4JM_U zXLdC;Cu_HSiv){ItVS37TRF%qvfK%m+wdSqIYUWkU&w(n-Zxv%HG5t6yknL)ge6vDpw{>lC38}VDeDHF@kCWTh87Mz!d#{WVYdxF z=P|tvxWq-W-cJicH?U~~8iDz+{Q{?Ea*|-R@=96?6y45C=ELC2`B3@rZ>*GHIuV%Y zanwgc`$?A8IGJa7bN~~Si^_~#I<2E$aO@)~;a3| z31s_%af3V9oRL2jfO96(NTM*;ia5$zB?J?cK0T_j<>=u@r5z&)K|7Gk&?XmVnPHsl zI0?@=%n(Ur&5FwOl7h~ANp4`NYn)SEi-? zBaJ8f&lOq=pxaJjgY!7dDp<;q7@frfrA<0Y*k}$39H&o72yv^~akH%(vnBIbNtSQ0gKD_n2imX4zRS zI-oSI){S^h!9?jr*&i5u-l;^BT2?vF$5pAA*nKE*b16D(g;%Y<8{8;lqiUD$q0nbe zOn%jXDywN7a+$$QXru?tBBFQ-oX*;L7&CgeYV_(!7+nY#xJeQ`Zf2w9K}3FO;A6Dy zQr%N7H|pqAUx2A&jdblqW_iFq;>eecJtG#0d_vc|2Yzv)>x!$x-EhFp;alNOJ7;!y ze!h?kYf-Zh>kcPbJ218e#g&Q}n?OwlYhCCD98aG3j`_^2Yc-JEBRHEHg2`G&U=5WX z<1z3OO0SXA;O-*WV#DzdJVD%27?p4i&V}}nwP~240>`CP&2qbMGjE{A1&7_TH{^gv zq2q7-L!cULHk8?_@R|#bx=EDUh5QYe3yPbhi#Ydc6j<4~FK20BHN)~x)HP3X=(#aT z6~(-b|9v4`XGgeF64|)2VCZpHjR>~@{K2C@P`a|AbJ>jKxX5|3uP;P6c-$@=b}>;L zem`b|ijwBr;Sh=%BxT`ATi{g^`pR5n`cDVSvCswTMP@tO9{9pZviWP|&)uj$&|=Af z!yna{RoKI76ag|ir0|FdX*v?gPi`6_w5?b;O4+#D9wq5e?=U;?*?ducdgBt zR?w-_V3D&IwNDbp3D9@4Pcten&;+wb);D%M(1@|vEJOLvU@1?G zz+EG1uVr$4L{BD%Hv2v!3KZMrZ{@Q%Euju*jI4Y^RB@UO2b>v3|03^&n+xSzV7wh7 z){_-Ngss++dFC!6H6rh=y}YrUfpJ#S=ex|T^7M5fO69MVxAFr4IXq(fP7YSxE z38-a`%@a{SW^-nhE$RR2eed}d^5Bdj?bizmXE{K$fx5hxp_a?JbVe7PMe;dkIvM;~z2}IzZG|FL zrxJ)IdQ^T8+KY%9$|}9)d*Szj+Pj&Wb%i64Sl8sV%${rA2?a+#&U{F^l%JVfI3t%D z(qNy17}_C3Olm%9H3kB3H}I&vlIlxn(}v%1N2N$YQ=z9o*`SOfMt}bXg-G64Jh@Z$ z{I=!6(ACMenG4l-@oaqPLX_v3LTwzKUZ_m=NV(K%1XSNLY&WB~k7p{N zyO3n^50^;_3IjdXC%3T4^iagIQ1K}ag<-ZEY=|_d{<-O8>F2W5UaU}I;EtC?}FQ$=s!N-(?(iyl+pEe z4plFFPl+OQl)=Z2Z&rHD2HIIEOeHXP4o)J5WwzVAxq@+YE1l(#%;J|d`1xAP+5L;1 zhK|1~Kk#VUdSN|>Q%${m=pWo_B~3rGb}l-o^Loxuj%*RnE#}chUtW8MxQ3`boSY39|tuRiH#h zuaQvcOcDOWhjx+ZvPm=FD3B+@bMRVNIIF~R3@SKrxP%z$8J3+yrNr(G_eo9lV)v-f zUvP_qL!HYU!VB%(8tPiw&?dFk*P}T$n>01FwwgVf+FENv2ib&L@*twuAYnRooX-$YRW)CnL??%Hgt$nbIJB`Lxs+?S)I7uPH!kDic4}v)uMc z>vSZ>ia~&vMh(oUEu?1_2n*b%U6Uw$UdrY&oqOp{4@ohT8p`AsnNOUk<+92^pW_&p zRQljKD!ZCb>q3mihjd)4DAwB04nh7lh031QTWzS7Xw!b4t!|Dx$;>n%G8i?28_^Mm7k z-RA$A2c8g~mxx3=O7nLQ-4A~k3>;w`^o0^uio!atuS2erKb8y3g(%b5#(?iO=28-Y z%jr;u|G%aIE8`Y?%cT>#xhXfS3J;Vqr#qIZ@3T@&m|chjHrB&M6Poa`RMXffb*bS@ zPRaCH8kxB78S4%0*5g?|rYE8m7XeefV7Bm}4c4NKf>*puDf0}}xuCj|%cx1X&V{qN z$9?$E&|II73#(G7nMR8`#_?(rG2%pN=w6UHHkV?4@{mAQGT^cych;eu% zo6?0-%5g;H>+qzmH%kRKNwB42;3X%@RZRD8!8#5{;i00Td*OKp)hS7Xt(ecC;9f8r z9w;++2Zx+h3AAcbB(AAl@;W&|SC_*&v-43@h5dGUCFZu!&cRCsX6b&|R|ZeJ=tI2x zg$dYqjzTn(W4wVJYYCA6a|4~u4Lz}Ao$#BDM{LolXbaA_1W1n%D1=q!ew^D2yz{Jb zzwnk_zMn|2xT4)GHRhLVABDX1)o`qZ~g7RT29mNNJA2AT^%%IV|-0YJY z)r5CS+mFMFimjzpXx@9JTsk1FhI(giv_;STO^KIP)3ne=GRemoL%gMkwor5D*Svyn z0;rP8CzIaxWw6o5>nLB~j&c(A5hVy?3*1UnN-4>T4R({o`_n|Rtc4nh#8K%c`|b(T zoCn@COJ;~R%Xdi4w(7|q<#AWelQM4)YF+XHabJn=Svc&Xzn94?LMid3iu^G;L#6?` zXKIK#do{BJavepK*v2ylVJa2paudSE!8Y?=-jED4`GM^`UZG0GQdBg#*ul9Z3SYU) zaE2P%TIwb7yAoE39Xz`V4eQf(LZWIIDx6|jg>nPF@oOi&sS0@^4I_(KCEZ+1LZh5| zLd$AHq0rB8)XExhUt#C~2@hS#W;5d3Rq&?Qchq~k1G+r!Y$P7lV+ZerN3BW&Jwt4N z2IYE;>4y_`<$5lh>w`5ON1E$Wdgu|S4<{YvY3M(pmxMbxoT_FAPX8~^YC}u^g`Lwg z+44<958a=ik1B+Ig-X!-w%L>E>k=*-m+&l#PzOJ=t3j~aWsCfBXuVmg?H3>A9mC@= zS@t=FFN#UV_p^M3>?2x(MZM76xZYN3(T87#`F39u^8N!gOaW^2OYx(^6V*&=W{er+ zVWkIk{ebN6F;j{Lc}$}poWg}=NY245oK{BXRne;|92?cM#XaT@<>pp;E)~6HU@sIB zF8U!ia|=1Voo$c~USqlTaj_l5U18-1OFl_d};Ack;8m9V|Gz0Snvdq$Z%d@d-4 zi_0(%T$Qk$qaTe%d2km}8soHn8Q9JMW8Jdau?SoUSrLV|UNyOSggMRhX?x%JE#~U1 z3r4xK%3AbI5HJ5Gv1W|r8w9k)Rm5L+N14#cS*HqP!ScTo>)^WrHl1zwlzGx|TgVAt zlp=iBo?KK+x0ZooXM0u4QDp~Cz+M}QHM2f1W22;mp5bC?WjLQnWi<^KG4FA?j9U9CvxHaIYKA()ZS{Naw;Z6q)-S1TVVcKm6*)KnN>!b}cfH#Azip7`NC2`}$MtN3vF$?i7A$VtL& zn1mIV*Fb$4$-(miJqnf%Ul>IT9np5gd)RuiceQVI=o9dk!%QFFt7YS` zzOv&AAtbGkFk{{aK9`B9b0&^dcEh%6W=gxmGQ|0f2n^UuHu~Oo=VCFmO_p=>l{*_v zbu>!|sqm`OpDjn0wKBgd?7Fy93lPC+8tT|l~E ztCJ~R@QbP9tOBd{F#||-4|}!HkQ)>B7T3LKQuZK&?D>Sl+@asqG2@`UeE97mm+$W* z1jEnga-S?ltSaSj#9YWwGuDT0g)X%cHTfcuf)|?ouo}mqDbJ2VZNuEM-@Yheje5+Y9KmrREdNY}}A4j*mfgmB?>`X9YH$hFYi3DZE@BOp$=qKDm!` zn)Ns{!b}H7>m@v*#iON8^V$A{A8w<|IbR4?AxOfyfS0qb+0*|luSh)_v`VP*tKD#m z6%PC9-4$klg^C)^Cvm!642_0=@UWQYBB+ZhJaC{Chj6L@?}$iZa7p>$N;sQCl3tTT zWr^Xisf4Z%z&Jfm~t4<#fMx|B=gBJ`RH>jy;L`UBi-=W?m2 zB@YK|L&ajboi|XZ2}4#UghEC5SA*{u4)n#vl!&m~x_>u)(M~V4i7U-+a zfpW-Y(Mey$zpYHa_lXL)gz_kjb5K}Nal7B#i9CanL})Y)qArRraAHB#H_JQ$7L{~N zZJz}z0&F%eEH0vk%WM$BbA~EeC0OdKQX@#|$v(-5!>izw>I03wP>oVT?=6R3fNi$+ zFEAj7esDHPs2QNEJk$=uF4}7r+$yt%mZN@JP_5PoeHgKl_p%B&R0pTmqm>S{5R1W^ zbxee~=g27KTsKk}jyrTv2H%^5OA1UM1pM#_*W#4=j)<_H*%=bYzisSzNw|>GGZ61m741b%gdZ&# zI@M$Lf(o?wj>iJ$5y#tRX*sdp^;X3dPR}|uqf1hH>xc6B4cF5bD(JbQu*GKSV^`;f ze#23e5Eg<*6oWeLrg_p}oe#dVleO?QPw%%2=#Y(~Wo%f19|SffF~hK-s>(pO|9_n~ z;C?4_NL@}Zvg2jkQto|CP*k%E)?z-yu#uegToaeNlnVN#tz(t^183xt@Pn;?C)cf} z^AEwgF?)XP7=i~XNe{G^2@`FCqgc7vjP(CDFzVDEJ<)BL#qCjoMiniYfU|sjrq4*g zfkr&_x2oWWQ3F}FM;&~PWQ7y<1^Z+)jPUGeXI8;aYEPO)d0((^UB_iJnowD3c1_sQ z$47J{3on-;30~=AF0$SuUp7G*K{vRWB3_a*8l7ov=%Mo+PK3Q)6|xnyt6qL@!uun{ zXB*%>k<(H+rrX)8D%~k~rPM^xsGba+Lm~q=;j9eA^EWZG;QeBpv;RRJJK+^QS0yxVFF>^)uZ0dK zaF-iq7t%*7ptY1bo9R1LSX;oXK#qh`^HNf|V>Qa3vNAuAjoZ5qY-e9|l{-clZN z!xhv$UP|ZE8mtO>(iyc!Lm%)axJ?t-aj3rY4voO)YMbP@b z*-&w`9Bs=f9Q6fBjFA?M-tYto3~zvKb~Y7L*A09I8(NUMlti`(TYFUSI?P7ek?sVX=fnwp*bA}^I`}fl$mYUf^ne=*I6a&YpKPUy zHGk89xi`@}#>K^P3R!Vq&W)xm5zWBYEnGJ$wbp9p2fA<^%9_>Hm@K3Y!MRWJ|Ez5H zcbKheD(lRyjxhz=nuR_)ubKOac5`e}t>_Vvaz80$9uuaG;msD8@@Unel#;adVO9#m zf27!nQ9_qf{-fwM_!;0KkMB9O1ox1* zYmRjy0&nOm5*3aFMONVBXiA{H84^~r6ZM-M-0Ps_o(1>wW)ElUA#m{-LF_Jp?1>H27o;6Ca0n&GCtI)(lT@fA6hbo!rj_t>b;g?#HptP8T#rXI-SHKy` zXh}8y){c)zm-tbsTZt%WNnv!6;^vchk@WU4C@3bnh#@DYT{S|AO?b@S{{)70M1@(X117vmIKv45yWv@2*r z;t_HM5aB}?oj3$8t68$>%~EhQ)9rS$8g8s$8=E@bCDG6&FdpX2A27RwBM+j+!`DStMwWCQk)WYgIoG7mwH!-ky1Y8;*O8yWs z^V99AipfEE$h;G;{pnF9R2Eu~aQisn0j}|5mT2_8$+U9pmQV0F*3o7U-_U5E8{Tj( z>hygGZ{tj+na&gWed}r>$iTg-nl>cAWrA6QRp|E#`2sq6ym|{s3-^tNFU#P%DiWaU z9O5}a*}La!?=RLt1-`IyX(bD*T6WaB<9gPtUZ3?7O_)9zMg)(X7kbAm#Q1TkqEMHx z|0Ou!aVDZtwwE#bKci1^vdvt}rVXBtcrMbWj+?FP2M+G|4~>uEGJSsNEOGr#FSR+9 zG^RXUEjrbxG`=Bl)+u~ckH(noJFY-z@w$rHh9*l5-Bgk|l)-Q*~Ed`xvonR4Nz`Ldfgx-}%MGP<;YPUpD^l9d0L^bLH)?6BTw{cvCe zY^vZ4DFS1I%zU`HmQ{`FUIz_v)~3U+)sAa>K2XO(+zQWmcth3J$(&|{z9hZ0rwJ9w z0YP}!OT(_@O^#K8;>8Ixdx`gU=85 zJH#tJ$Ej~4Q9Iv+74@MrJdwV@h*JrnW*w`{!1q<=TGnVTtY{MbF{nJsCZdjH|7+&< zjB{MBMplW2Y|K9#K|Zb|(=f_>gq)VL89f~z{7ShW=K0OX3dZrGZ_XyFG7qk`!#TyG zgNo&2V4Vksnqf>$etx~yqokz7>RechXy~e(W|QNXn?#E)V-q@E=@&k5BA?H2z|{I$ z?!=XRj~2F-CR^j%A?^m&NbvlZIi<}c&gTS2J^Brm&$61wx#fP zfz!w$}TVgNljbBPxQ3Wi>$r2-$*_2|%N2-FChl{T|==xNGAYHcNw z!!CGuC~jdBeFG1Yz7sZB?Sd=o@ggs>4O@Iup>b5`TzL_*omuM1#QU;ww6dMG=Kb4A z@Sqd&t^Li;tgd%U@DfK7!n{_PH~rX;tS*JZW#jz~QoVnCy}X-Q0I&Lmr)8q8c@+AB z=siz6eg|xjLjCl+AZ)O~W~b#>QWP8whblAq$)0g zw7+-;f_w)Ao6s&sY%pR9G4}k)b|vVPF|gK4pQtBcSZqgJq&u9#jKX1*gKK>Tj;{kAOs7TN8X% z$VtgQdU;Sj-z@E4OjPSp*d{2y!;Fg1Qbr2#C#z^$&@jaK; z4Jx{r2ZYNwriJa*`#Z$n97Sh(r;V#czoGBk?ORU*zWDG)k7RauOyua~ViKdvX3)P2 zm`0MM-^*(rRl)2jL7S}o7s%bvQje<0`mMQc$WO25eS6@%G5mi~{t3%aT~K4ZIuhwG zF(jDHBQo+>SDE=V>?I#)1)*P^Qm$LdwEqiJ?mHK!rG)$Tq4bPIcD0JW@nYB$PD$&Fz0;;7ge8Q!{8{6?md56u?{z>?d#<$LdL# zZAG)7u4R74(KM*AH3W^-MDdnSBFdzdummSR6@$OL{w-{-+wv82jpIt#TnK;ph$)B(^sN37$xM#>1u}%ja~R4JOuMlz4p}bG77r(nS9NuXCnblEO+R0@scM2M6_% zsT70dM5lcFE1}KZ$7=EgyaJL5hz0jXVN)>@WN~%&RHHq^jOzKvh?QDxQ2S4Wi!_h^fATe z(c9n+8=P9syb*d14m3M^)C^kPV-<61ht|P!1u(i5KefBu-6*xTv<3RFgk2%b_!;J= z%sItW7Xr5u_>Tj=7eWsbpJk6PO$+OJ6jW0Cnm6^O6v-Bk~RkaTokt zMHF$R!&k%Tp{sC`HaFH?=?c`5&Q)}N;R;^8n3?HLVbZqwn5W^|nVgc50xys3&$pYL z^i4hf^CA_#X$e-tuXXs#!xbId;d386TFESz4-cv09TlYcU`+1qzl18D>We#sCfDKD z;qyAo`0aIky&tb(wT;BQ<#2GjS#5OfIGVAqnZv3*qG+elalDbxd+Be&)+d@Z#wn@h z61(NqzBhflp16)psKR;DzFT2O2~9S@N~_Q|kpzSrU9Y)OqYN`o+;OlJsZMHXqbr=2 z7~9%t;ZZBfJL%^x-?P?@a`)jcNm}{ItlzNUd*9vk{HY(T%XecmcN`_g)@rz10Hc^~ zYZEs%THc0IFHsKvV*2!^R?9`gl=-fw#9^EDT;WxbtUi(ws>@)y&$;?-eJ3A(RIRZJzSrg1`kjd?iqOYrb%u(S$P&O63Ij}~~RwYnALt*8R8I=3tl zCm^BGO?bl0?X(^Oqn*S!ayC&MNt1A1v^gGNuBfh<;*4mSNDfYQw137nHd2;DvC|V| zu7OWF%%)Q-VQ7$KeKVNfq~`jh6whU%3AjYa--+^8pIoC#NhzYlv>3YDun%KrWHFai zRk~NCKget}LqDD&I(TjJs;5))GFc6XR^9`P+t?!Sz1hHz$~VbYhDWWqLS+wC+~2@dOH|-`$)lW%8pS%yYeZO8%n^ zm4lX6r5^CQF!_&1QJWSOq5FXMI5<{L6j^|o0{(G;hgS>HY4`9GrHpPa-re64`gVz+L z%e&FZ#xn4+-CReuc0px`XJV|R!SB|A2K6)g(@e80=Pgcc9UaRDN zgnEz_+_T`pc2>_M-NbLXhiKy0b@V4_&JgAhoLUOETHAJWMnY-d!@N2$3{AXwZ(zU< z#&lB)^$61rFtziDA}p*#qLS-Ly{{f!%w5jlA(?O3i^B5bv(S_>V@acBEK|+)>Ok4?Ic0p8$;sEddpexcICjPwg=4?D%R?LmDM(H>=QrG|H z5|z0V#M44Prrc?0=6>++YUo)tC+gjXp3BC2QyB(T&S@m8#kTH+XMK5q$qxG5qJa+H zZ0;%_^F-npDQJea6vAiL+BjS#4_^-dYNToL@Bpg*tPq{gX-Ng{tMYz0n#3vP)kQFg z=T#+^%fBIXEo7EB9%t;Xtw3FTE|N98Z&jo2ymwK4in$@o`iD6$ljg|9%$M%4k__wS zGDzs3X!idQ4mp^`{y}P;CoXZ&r^>za{Hz|X-2)8)^R^$%t#o`vy5N-2%u4Y{%>eaY z?(^Dg~udyL@40E1e~aZNxTeu8s{5>!M5t3jzR$E*0Rb__HyjS_^*tlL-YiUX z4EL}JiTR2Cc73vhV+P!Y4P<4rg;!}1jg3|9%+s?hc_skOc_(9jT`IesKF07@+% zRdq?6xj2*)3Z%{${kq6|i@C;n(OH&n;cYLiEMzY3f8U${vDL#A!qL(y9PNyP{w)`w zv&SJHX6Wgy-~87y3(gYRZprZi*Q+E3DqzDnlA&%pJR5?ItjD)1gCLA{#$G3+7g^ndtBzo|KeU%w-#23%rVPz|6)$|6+8jXxSkt2#T6<7htLsXc3VNHD�+d_z`tsC|dol)t%B)ex&g=?VO}%s<$p{KbxLY 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Πux^-tZm-%I9{GXAJGQ0f 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 literal 0 HcmV?d00001 diff --git a/tests/test_dataset_common.py b/tests/test_dataset_common.py index bc49e9a8bfc..be96ba94d23 100644 --- a/tests/test_dataset_common.py +++ b/tests/test_dataset_common.py @@ -74,7 +74,7 @@ def wrapper(self, dataset_name): def get_packaged_dataset_dummy_data_files(dataset_name, path_to_dummy_data): - extensions = {"text": "txt", "json": "json", "pandas": "pkl", "csv": "csv"} + extensions = {"text": "txt", "json": "json", "pandas": "pkl", "csv": "csv", "parquet": "parquet"} return { "train": os.path.join(path_to_dummy_data, "train." + extensions[dataset_name]), "test": os.path.join(path_to_dummy_data, "test." + extensions[dataset_name]), From 0c537ea23b4f6cc2e9f1034de800a932e4d11e6c Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 23 Jun 2021 18:26:05 +0200 Subject: [PATCH 04/11] bump to 3.0.0 --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index df06677b0a2..5e1e314669b 100644 --- a/setup.py +++ b/setup.py @@ -73,9 +73,9 @@ # We use numpy>=1.17 to have np.random.Generator (Dataset shuffling) "numpy>=1.17", # Backend and serialization. - # Minimum 2.0.0 to support nested types in parquet format + # Minimum 3.0.0 to support mix of struct and list types in parquet format # pyarrow 4.0.0 introduced segfault bug, see: https://github.com/huggingface/datasets/pull/2268 - "pyarrow>=2.0.0,!=4.0.0", + "pyarrow>=3.0.0,!=4.0.0", # For smart caching dataset processing "dill", # For performance gains with apache arrow From 17301d8ca8ac1b9b6f09fdeae67380ed46dac7f4 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 23 Jun 2021 18:31:59 +0200 Subject: [PATCH 05/11] don't look for dataset cards for packaged dataset builders --- tests/test_dataset_cards.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/test_dataset_cards.py b/tests/test_dataset_cards.py index 0ed1009022b..be23cce3b57 100644 --- a/tests/test_dataset_cards.py +++ b/tests/test_dataset_cards.py @@ -19,6 +19,7 @@ import pytest +from datasets.packaged_modules import _PACKAGED_DATASETS_MODULES from datasets.utils.logging import get_logger from datasets.utils.metadata import DatasetMetadata from datasets.utils.readme import ReadMe @@ -43,11 +44,12 @@ def get_changed_datasets(repo_path: Path) -> List[Path]: if f.exists() and str(f.resolve()).startswith(str(datasets_dir_path)) ) - return sorted(changed_datasets) + return sorted(dataset_name for dataset_name in changed_datasets if dataset_name not in _PACKAGED_DATASETS_MODULES) def get_all_datasets(repo_path: Path) -> List[Path]: - return [path.parts[-1] for path in (repo_path / "datasets").iterdir()] + dataset_names = [path.parts[-1] for path in (repo_path / "datasets").iterdir()] + return [dataset_name for dataset_name in dataset_names if dataset_name not in _PACKAGED_DATASETS_MODULES] @pytest.mark.parametrize("dataset_name", get_changed_datasets(repo_path)) From ebeb9c1bc6d94b67883bc9dcde745915b1bb1587 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 23 Jun 2021 18:41:21 +0200 Subject: [PATCH 06/11] update CI to use pyarrow 3.0.0 --- .circleci/config.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 07807e67e45..0af391265c8 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -18,7 +18,7 @@ jobs: - run: pip install pyarrow --upgrade - run: HF_SCRIPTS_VERSION=master python -m pytest -sv ./tests/ - run_dataset_script_tests_pyarrow_1: + run_dataset_script_tests_pyarrow_3: working_directory: ~/datasets docker: - image: circleci/python:3.6 @@ -29,7 +29,7 @@ jobs: - run: source venv/bin/activate - run: pip install .[tests] - run: pip install -r additional-tests-requirements.txt --no-deps - - run: pip install pyarrow==1.0.0 + - run: pip install pyarrow==3.0.0 - run: HF_SCRIPTS_VERSION=master python -m pytest -sv ./tests/ run_dataset_script_tests_pyarrow_latest_WIN: @@ -50,7 +50,7 @@ jobs: - run: $env:HF_SCRIPTS_VERSION="master" - run: python -m pytest -sv ./tests/ - run_dataset_script_tests_pyarrow_1_WIN: + run_dataset_script_tests_pyarrow_3_WIN: working_directory: ~/datasets executor: name: win/default @@ -64,7 +64,7 @@ jobs: - run: "& venv/Scripts/activate.ps1" - run: pip install .[tests] - run: pip install -r additional-tests-requirements.txt --no-deps - - run: pip install pyarrow==1.0.0 + - run: pip install pyarrow==3.0.0 - run: $env:HF_SCRIPTS_VERSION="master" - run: python -m pytest -sv ./tests/ @@ -116,8 +116,8 @@ workflows: jobs: - check_code_quality - run_dataset_script_tests_pyarrow_latest - - run_dataset_script_tests_pyarrow_1 + - run_dataset_script_tests_pyarrow_3 - run_dataset_script_tests_pyarrow_latest_WIN - - run_dataset_script_tests_pyarrow_1_WIN + - run_dataset_script_tests_pyarrow_3_WIN - build_doc - deploy_doc: *workflow_filters From a877d8b250693003ef61ba2dec1217b113723628 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Thu, 24 Jun 2021 15:11:03 +0200 Subject: [PATCH 07/11] update benchmarks --- .github/workflows/benchmarks.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmarks.yaml b/.github/workflows/benchmarks.yaml index 6e8971b5c48..bb336a32019 100644 --- a/.github/workflows/benchmarks.yaml +++ b/.github/workflows/benchmarks.yaml @@ -16,8 +16,8 @@ jobs: pip install setuptools wheel pip install -e .[benchmarks] - # pyarrow==1.0.0 - pip install pyarrow==1.0.0 + # pyarrow==3.0.0 + pip install pyarrow==3.0.0 dvc repro --force @@ -26,7 +26,7 @@ jobs: python ./benchmarks/format.py report.json report.md - echo "
\nShow benchmarks\n\nPyArrow==1.0.0\n" > final_report.md + echo "
\nShow benchmarks\n\nPyArrow==3.0.0\n" > final_report.md cat report.md >> final_report.md # pyarrow From 077648bfac78a590a06051248280442e792854bd Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 30 Jun 2021 12:20:20 +0200 Subject: [PATCH 08/11] albert's comments in docstrings --- src/datasets/arrow_dataset.py | 10 +++++----- src/datasets/dataset_dict.py | 17 +++++++++++------ tests/io/test_json.py | 1 - tests/io/test_parquet.py | 2 -- tests/io/test_text.py | 1 - tests/test_arrow_dataset.py | 3 --- tests/test_dataset_dict.py | 3 --- 7 files changed, 16 insertions(+), 21 deletions(-) diff --git a/src/datasets/arrow_dataset.py b/src/datasets/arrow_dataset.py index 231d571ee8b..9dbf9387e6b 100644 --- a/src/datasets/arrow_dataset.py +++ b/src/datasets/arrow_dataset.py @@ -468,7 +468,7 @@ def from_csv( path_or_paths (path-like or list of path-like): Path(s) of the CSV file(s). split (:class:`NamedSplit`, optional): Split name to be assigned to the dataset. features (:class:`Features`, optional): Dataset features. - cache_dir (:obj:`str`, optional, default ``"~/datasets"``): Directory to cache data. + cache_dir (:obj:`str`, optional, default ``"~/.cache/huggingface/datasets"``): Directory to cache data. keep_in_memory (:obj:`bool`, default ``False``): Whether to copy the data in-memory. **kwargs: Keyword arguments to be passed to :meth:`pandas.read_csv`. @@ -498,7 +498,7 @@ def from_json( path_or_paths (path-like or list of path-like): Path(s) of the JSON or JSON Lines file(s). split (:class:`NamedSplit`, optional): Split name to be assigned to the dataset. features (:class:`Features`, optional): Dataset features. - cache_dir (:obj:`str`, optional, default ``"~/datasets"``): Directory to cache data. + cache_dir (:obj:`str`, optional, default ``"~/.cache/huggingface/datasets"``): Directory to cache data. keep_in_memory (:obj:`bool`, default ``False``): Whether to copy the data in-memory. field (:obj:`str`, optional): Field name of the JSON file where the dataset is contained in. **kwargs: Keyword arguments to be passed to :class:`JsonConfig`. @@ -535,7 +535,7 @@ def from_parquet( path_or_paths (path-like or list of path-like): Path(s) of the Parquet file(s). split (:class:`NamedSplit`, optional): Split name to be assigned to the dataset. features (:class:`Features`, optional): Dataset features. - cache_dir (:obj:`str`, optional, default ``"~/datasets"``): Directory to cache data. + cache_dir (:obj:`str`, optional, default ``"~/.cache/huggingface/datasets"``): Directory to cache data. keep_in_memory (:obj:`bool`, default ``False``): Whether to copy the data in-memory. columns (:obj:`List[str]`, optional): If not None, only these columns will be read from the file. A column name may be a prefix of a nested field, e.g. 'a' will select @@ -573,7 +573,7 @@ def from_text( path_or_paths (path-like or list of path-like): Path(s) of the text file(s). split (:class:`NamedSplit`, optional): Split name to be assigned to the dataset. features (:class:`Features`, optional): Dataset features. - cache_dir (:obj:`str`, optional, default ``"~/datasets"``): Directory to cache data. + cache_dir (:obj:`str`, optional, default ``"~/.cache/huggingface/datasets"``): Directory to cache data. keep_in_memory (:obj:`bool`, default ``False``): Whether to copy the data in-memory. **kwargs: Keyword arguments to be passed to :class:`TextConfig`. @@ -2913,7 +2913,7 @@ def to_parquet( path_or_buf (``PathLike`` or ``FileOrBuffer``): Either a path to a file or a BinaryIO. batch_size (Optional ``int``): Size of the batch to load in memory and write at once. Defaults to :obj:`datasets.config.DEFAULT_MAX_BATCH_SIZE`. - parquet_writer_kwargs: Parameters to pass to pandas's :func:`pyarrow.parquet.ParquetWriter` + parquet_writer_kwargs: Parameters to pass to PyArrow's :class:`pyarrow.parquet.ParquetWriter` Returns: int: The number of characters or bytes written diff --git a/src/datasets/dataset_dict.py b/src/datasets/dataset_dict.py index be6decd072e..0249e1713c2 100644 --- a/src/datasets/dataset_dict.py +++ b/src/datasets/dataset_dict.py @@ -748,7 +748,7 @@ def from_csv( Args: path_or_paths (dict of path-like): Path(s) of the CSV file(s). features (:class:`Features`, optional): Dataset features. - cache_dir (str, optional, default="~/datasets"): Directory to cache data. + cache_dir (str, optional, default="~/.cache/huggingface/datasets"): Directory to cache data. keep_in_memory (bool, default=False): Whether to copy the data in-memory. **kwargs: Keyword arguments to be passed to :meth:`pandas.read_csv`. @@ -775,7 +775,7 @@ def from_json( Args: path_or_paths (path-like or list of path-like): Path(s) of the JSON Lines file(s). features (:class:`Features`, optional): Dataset features. - cache_dir (str, optional, default="~/datasets"): Directory to cache data. + cache_dir (str, optional, default="~/.cache/huggingface/datasets"): Directory to cache data. keep_in_memory (bool, default=False): Whether to copy the data in-memory. **kwargs: Keyword arguments to be passed to :class:`JsonConfig`. @@ -803,12 +803,12 @@ def from_parquet( Args: path_or_paths (dict of path-like): Path(s) of the CSV file(s). features (:class:`Features`, optional): Dataset features. - cache_dir (str, optional, default="~/datasets"): Directory to cache data. + cache_dir (str, optional, default="~/.cache/huggingface/datasets"): Directory to cache data. keep_in_memory (bool, default=False): Whether to copy the data in-memory. columns (:obj:`List[str]`, optional): If not None, only these columns will be read from the file. A column name may be a prefix of a nested field, e.g. 'a' will select 'a.b', 'a.c', and 'a.d.e'. - **kwargs: Keyword arguments to be passed to :meth:`pandas.read_csv`. + **kwargs: Keyword arguments to be passed to :class:`ParquetConfig`. Returns: :class:`DatasetDict` @@ -817,7 +817,12 @@ def from_parquet( from .io.parquet import ParquetDatasetReader return ParquetDatasetReader( - path_or_paths, features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs + path_or_paths, + features=features, + cache_dir=cache_dir, + keep_in_memory=keep_in_memory, + columns=columns, + **kwargs, ).read() @staticmethod @@ -833,7 +838,7 @@ def from_text( Args: path_or_paths (dict of path-like): Path(s) of the text file(s). features (:class:`Features`, optional): Dataset features. - cache_dir (str, optional, default="~/datasets"): Directory to cache data. + cache_dir (str, optional, default="~/.cache/huggingface/datasets"): Directory to cache data. keep_in_memory (bool, default=False): Whether to copy the data in-memory. **kwargs: Keyword arguments to be passed to :class:`TextConfig`. diff --git a/tests/io/test_json.py b/tests/io/test_json.py index 5a54c787c95..9c7473b0abd 100644 --- a/tests/io/test_json.py +++ b/tests/io/test_json.py @@ -141,7 +141,6 @@ def test_datasetdict_from_json_keep_in_memory(keep_in_memory, jsonl_path, tmp_pa ) def test_datasetdict_from_json_features(features, jsonl_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( diff --git a/tests/io/test_parquet.py b/tests/io/test_parquet.py index a091e79dff1..30a692c7374 100644 --- a/tests/io/test_parquet.py +++ b/tests/io/test_parquet.py @@ -37,7 +37,6 @@ def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_p ) def test_dataset_from_parquet_features(features, parquet_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( @@ -102,7 +101,6 @@ def test_parquet_datasetdict_reader_keep_in_memory(keep_in_memory, parquet_path, ) def test_parquet_datasetdict_reader_features(features, parquet_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( diff --git a/tests/io/test_text.py b/tests/io/test_text.py index 428399cc2b6..a93e3cff95f 100644 --- a/tests/io/test_text.py +++ b/tests/io/test_text.py @@ -35,7 +35,6 @@ def test_dataset_from_text_keep_in_memory(keep_in_memory, text_path, tmp_path): ) def test_dataset_from_text_features(features, text_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"text": "string"} expected_features = features.copy() if features else default_expected_features features = ( diff --git a/tests/test_arrow_dataset.py b/tests/test_arrow_dataset.py index ed09e0ed982..930e8053f82 100644 --- a/tests/test_arrow_dataset.py +++ b/tests/test_arrow_dataset.py @@ -2638,7 +2638,6 @@ def test_dataset_from_json_keep_in_memory(keep_in_memory, jsonl_path, tmp_path): ) def test_dataset_from_json_features(features, jsonl_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( @@ -2699,7 +2698,6 @@ def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_p ) def test_dataset_from_parquet_features(features, parquet_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( @@ -2759,7 +2757,6 @@ def test_dataset_from_text_keep_in_memory(keep_in_memory, text_path, tmp_path): ) def test_dataset_from_text_features(features, text_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"text": "string"} expected_features = features.copy() if features else default_expected_features features = ( diff --git a/tests/test_dataset_dict.py b/tests/test_dataset_dict.py index aad3f4487b8..23744a450ec 100644 --- a/tests/test_dataset_dict.py +++ b/tests/test_dataset_dict.py @@ -563,7 +563,6 @@ def test_datasetdict_from_json_keep_in_memory(keep_in_memory, jsonl_path, tmp_pa ) def test_datasetdict_from_json_features(features, jsonl_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( @@ -619,7 +618,6 @@ def test_datasetdict_from_parquet_keep_in_memory(keep_in_memory, parquet_path, t ) def test_datasetdict_from_parquet_features(features, parquet_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"col_1": "string", "col_2": "int64", "col_3": "float64"} expected_features = features.copy() if features else default_expected_features features = ( @@ -674,7 +672,6 @@ def test_datasetdict_from_text_keep_in_memory(keep_in_memory, text_path, tmp_pat ) def test_datasetdict_from_text_features(features, text_path, tmp_path): cache_dir = tmp_path / "cache" - # CSV file loses col_1 string dtype information: default now is "int64" instead of "string" default_expected_features = {"text": "string"} expected_features = features.copy() if features else default_expected_features features = ( From 11a2c9f653b13f84a66a49bbcf34df037d6c4a73 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 30 Jun 2021 16:57:24 +0200 Subject: [PATCH 09/11] back to pyarrow 1.0.0 + raise error if using old pyarrow for parquet read/write --- .circleci/config.yml | 8 ++++---- setup.py | 4 ++-- src/datasets/io/parquet.py | 9 +++++++++ src/datasets/packaged_modules/parquet/parquet.py | 5 +++++ tests/io/test_parquet.py | 10 +++++++++- tests/test_arrow_dataset.py | 6 ++++++ tests/test_dataset_common.py | 7 ++++++- tests/test_dataset_dict.py | 4 ++++ tests/utils.py | 14 ++++++++++++++ 9 files changed, 59 insertions(+), 8 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 0af391265c8..a0ea58b1524 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -18,7 +18,7 @@ jobs: - run: pip install pyarrow --upgrade - run: HF_SCRIPTS_VERSION=master python -m pytest -sv ./tests/ - run_dataset_script_tests_pyarrow_3: + run_dataset_script_tests_pyarrow_1: working_directory: ~/datasets docker: - image: circleci/python:3.6 @@ -29,7 +29,7 @@ jobs: - run: source venv/bin/activate - run: pip install .[tests] - run: pip install -r additional-tests-requirements.txt --no-deps - - run: pip install pyarrow==3.0.0 + - run: pip install pyarrow==1.0.0 - run: HF_SCRIPTS_VERSION=master python -m pytest -sv ./tests/ run_dataset_script_tests_pyarrow_latest_WIN: @@ -50,7 +50,7 @@ jobs: - run: $env:HF_SCRIPTS_VERSION="master" - run: python -m pytest -sv ./tests/ - run_dataset_script_tests_pyarrow_3_WIN: + run_dataset_script_tests_pyarrow_1_WIN: working_directory: ~/datasets executor: name: win/default @@ -64,7 +64,7 @@ jobs: - run: "& venv/Scripts/activate.ps1" - run: pip install .[tests] - run: pip install -r additional-tests-requirements.txt --no-deps - - run: pip install pyarrow==3.0.0 + - run: pip install pyarrow==1.0.0 - run: $env:HF_SCRIPTS_VERSION="master" - run: python -m pytest -sv ./tests/ diff --git a/setup.py b/setup.py index 5e1e314669b..e0a013d343c 100644 --- a/setup.py +++ b/setup.py @@ -73,9 +73,9 @@ # We use numpy>=1.17 to have np.random.Generator (Dataset shuffling) "numpy>=1.17", # Backend and serialization. - # Minimum 3.0.0 to support mix of struct and list types in parquet format + # Minimum 3.0.0 to support mix of struct and list types in parquet, and batch iterators of parquet data # pyarrow 4.0.0 introduced segfault bug, see: https://github.com/huggingface/datasets/pull/2268 - "pyarrow>=3.0.0,!=4.0.0", + "pyarrow>=1.0.0,!=4.0.0", # For smart caching dataset processing "dill", # For performance gains with apache arrow diff --git a/src/datasets/io/parquet.py b/src/datasets/io/parquet.py index 30f7f2f5c9f..dabc801dce9 100644 --- a/src/datasets/io/parquet.py +++ b/src/datasets/io/parquet.py @@ -3,6 +3,7 @@ import pyarrow as pa import pyarrow.parquet as pq +from packaging import version from .. import Dataset, Features, NamedSplit, config from ..formatting import query_table @@ -22,6 +23,10 @@ def __init__( keep_in_memory: bool = False, **kwargs, ): + if version.parse(pa.__version__) < version.parse("3.0.0"): + raise ImportError( + "PyArrow >= 3.0.0 is required to used the ParquetDatasetReader: pip install --upgrade pyarrow" + ) super().__init__( path_or_paths, split=split, features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs ) @@ -66,6 +71,10 @@ def __init__( batch_size: Optional[int] = None, **parquet_writer_kwargs, ): + if version.parse(pa.__version__) < version.parse("3.0.0"): + raise ImportError( + "PyArrow >= 3.0.0 is required to used the ParquetDatasetWriter: pip install --upgrade pyarrow" + ) self.dataset = dataset self.path_or_buf = path_or_buf self.batch_size = batch_size diff --git a/src/datasets/packaged_modules/parquet/parquet.py b/src/datasets/packaged_modules/parquet/parquet.py index 982ac8c9652..59311176282 100644 --- a/src/datasets/packaged_modules/parquet/parquet.py +++ b/src/datasets/packaged_modules/parquet/parquet.py @@ -5,6 +5,7 @@ import pyarrow as pa import pyarrow.parquet as pq +from packaging import version import datasets @@ -25,6 +26,10 @@ class Parquet(datasets.ArrowBasedBuilder): BUILDER_CONFIG_CLASS = ParquetConfig def _info(self): + if version.parse(pa.__version__) < version.parse("3.0.0"): + raise ImportError( + "PyArrow >= 3.0.0 is required to used the Parquet dataset builder: pip install --upgrade pyarrow" + ) return datasets.DatasetInfo(features=self.config.features) def _split_generators(self, dl_manager): diff --git a/tests/io/test_parquet.py b/tests/io/test_parquet.py index 30a692c7374..1b284378780 100644 --- a/tests/io/test_parquet.py +++ b/tests/io/test_parquet.py @@ -4,7 +4,7 @@ from datasets import Dataset, DatasetDict, Features, NamedSplit, Value from datasets.io.parquet import ParquetDatasetReader, ParquetDatasetWriter -from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases +from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_pyarrow_at_least_3 def _check_parquet_dataset(dataset, expected_features): @@ -16,6 +16,7 @@ def _check_parquet_dataset(dataset, expected_features): assert dataset.features[feature].dtype == expected_dtype +@require_pyarrow_at_least_3 @pytest.mark.parametrize("keep_in_memory", [False, True]) def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -25,6 +26,7 @@ def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_p _check_parquet_dataset(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize( "features", [ @@ -46,6 +48,7 @@ def test_dataset_from_parquet_features(features, parquet_path, tmp_path): _check_parquet_dataset(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) def test_dataset_from_parquet_split(split, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -55,6 +58,7 @@ def test_dataset_from_parquet_split(split, parquet_path, tmp_path): assert dataset.split == str(split) if split else "train" +@require_pyarrow_at_least_3 @pytest.mark.parametrize("path_type", [str, list]) def test_dataset_from_parquet_path_type(path_type, parquet_path, tmp_path): if issubclass(path_type, str): @@ -78,6 +82,7 @@ def _check_parquet_datasetdict(dataset_dict, expected_features, splits=("train", assert dataset.features[feature].dtype == expected_dtype +@require_pyarrow_at_least_3 @pytest.mark.parametrize("keep_in_memory", [False, True]) def test_parquet_datasetdict_reader_keep_in_memory(keep_in_memory, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -89,6 +94,7 @@ def test_parquet_datasetdict_reader_keep_in_memory(keep_in_memory, parquet_path, _check_parquet_datasetdict(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize( "features", [ @@ -110,6 +116,7 @@ def test_parquet_datasetdict_reader_features(features, parquet_path, tmp_path): _check_parquet_datasetdict(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) def test_parquet_datasetdict_reader_split(split, parquet_path, tmp_path): if split: @@ -124,6 +131,7 @@ def test_parquet_datasetdict_reader_split(split, parquet_path, tmp_path): assert all(dataset[split].split == split for split in path.keys()) +@require_pyarrow_at_least_3 def test_parquer_write(dataset, tmp_path): writer = ParquetDatasetWriter(dataset, tmp_path / "foo.parquet") assert writer.write() > 0 diff --git a/tests/test_arrow_dataset.py b/tests/test_arrow_dataset.py index 930e8053f82..738640f4659 100644 --- a/tests/test_arrow_dataset.py +++ b/tests/test_arrow_dataset.py @@ -27,6 +27,7 @@ from .utils import ( assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, + require_pyarrow_at_least_3, require_s3, require_tf, require_torch, @@ -1692,6 +1693,7 @@ def test_to_pandas(self, in_memory): for col_name in dset.column_names: self.assertEqual(len(dset_to_pandas[col_name]), dset.num_rows) + @require_pyarrow_at_least_3 def test_to_parquet(self, in_memory): with tempfile.TemporaryDirectory() as tmp_dir: # File path argument @@ -2677,6 +2679,7 @@ def _check_parquet_dataset(dataset, expected_features): assert dataset.features[feature].dtype == expected_dtype +@require_pyarrow_at_least_3 @pytest.mark.parametrize("keep_in_memory", [False, True]) def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -2686,6 +2689,7 @@ def test_dataset_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_p _check_parquet_dataset(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize( "features", [ @@ -2707,6 +2711,7 @@ def test_dataset_from_parquet_features(features, parquet_path, tmp_path): _check_parquet_dataset(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) def test_dataset_from_parquet_split(split, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -2716,6 +2721,7 @@ def test_dataset_from_parquet_split(split, parquet_path, tmp_path): assert dataset.split == str(split) if split else "train" +@require_pyarrow_at_least_3 @pytest.mark.parametrize("path_type", [str, list]) def test_dataset_from_parquet_path_type(path_type, parquet_path, tmp_path): if issubclass(path_type, str): diff --git a/tests/test_dataset_common.py b/tests/test_dataset_common.py index be96ba94d23..0a02986c417 100644 --- a/tests/test_dataset_common.py +++ b/tests/test_dataset_common.py @@ -22,7 +22,9 @@ from typing import List, Optional from unittest import TestCase +import pyarrow as pa from absl.testing import parameterized +from packaging import version from datasets import cached_path, import_main_class, load_dataset, prepare_module from datasets.builder import BuilderConfig, DatasetBuilder @@ -270,7 +272,10 @@ def test_load_real_dataset_all_configs(self, dataset_name): def get_packaged_dataset_names(): - return [{"testcase_name": x, "dataset_name": x} for x in _PACKAGED_DATASETS_MODULES.keys()] + packaged_datasets = [{"testcase_name": x, "dataset_name": x} for x in _PACKAGED_DATASETS_MODULES.keys()] + if version.parse(pa.__version) < version.parse("3.0.0"): # parquet is not supported for pyarrow<3.0.0 + packaged_datasets = [pd for pd in packaged_datasets if pd["dataset_name"] != "parquet"] + return packaged_datasets @parameterized.named_parameters(get_packaged_dataset_names()) diff --git a/tests/test_dataset_dict.py b/tests/test_dataset_dict.py index 23744a450ec..50b5463c979 100644 --- a/tests/test_dataset_dict.py +++ b/tests/test_dataset_dict.py @@ -16,6 +16,7 @@ from .utils import ( assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, + require_pyarrow_at_least_3, require_s3, require_tf, require_torch, @@ -597,6 +598,7 @@ def _check_parquet_datasetdict(dataset_dict, expected_features, splits=("train", assert dataset.features[feature].dtype == expected_dtype +@require_pyarrow_at_least_3 @pytest.mark.parametrize("keep_in_memory", [False, True]) def test_datasetdict_from_parquet_keep_in_memory(keep_in_memory, parquet_path, tmp_path): cache_dir = tmp_path / "cache" @@ -606,6 +608,7 @@ def test_datasetdict_from_parquet_keep_in_memory(keep_in_memory, parquet_path, t _check_parquet_datasetdict(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize( "features", [ @@ -627,6 +630,7 @@ def test_datasetdict_from_parquet_features(features, parquet_path, tmp_path): _check_parquet_datasetdict(dataset, expected_features) +@require_pyarrow_at_least_3 @pytest.mark.parametrize("split", [None, NamedSplit("train"), "train", "test"]) def test_datasetdict_from_parquet_split(split, parquet_path, tmp_path): if split: diff --git a/tests/utils.py b/tests/utils.py index 5f6206d31e4..7b0a4fea274 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -8,6 +8,7 @@ from unittest.mock import patch import pyarrow as pa +from packaging import version from datasets import config @@ -34,6 +35,19 @@ def parse_flag_from_env(key, default=False): _run_packaged_tests = parse_flag_from_env("RUN_PACKAGED", default=True) +def require_pyarrow_at_least_3(test_case): + """ + Decorator marking a test that requires PyArrow 3.0.0 + to allow nested types in parquet, as well as batch iterators of parquet files. + + These tests are skipped when the PyArrow version is outdated. + + """ + if version.parse(config.PYARROW_VERSION) < version.parse("3.0.0"): + test_case = unittest.skip("test requires PyTorch")(test_case) + return test_case + + def require_beam(test_case): """ Decorator marking a test that requires Apache Beam. From 33af6d576bf1600a217ef8e08929f9e9550e2df2 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 30 Jun 2021 17:51:06 +0200 Subject: [PATCH 10/11] fix CI + message --- .circleci/config.yml | 4 ++-- tests/utils.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index a0ea58b1524..07807e67e45 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -116,8 +116,8 @@ workflows: jobs: - check_code_quality - run_dataset_script_tests_pyarrow_latest - - run_dataset_script_tests_pyarrow_3 + - run_dataset_script_tests_pyarrow_1 - run_dataset_script_tests_pyarrow_latest_WIN - - run_dataset_script_tests_pyarrow_3_WIN + - run_dataset_script_tests_pyarrow_1_WIN - build_doc - deploy_doc: *workflow_filters diff --git a/tests/utils.py b/tests/utils.py index 7b0a4fea274..872c969374c 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -44,7 +44,7 @@ def require_pyarrow_at_least_3(test_case): """ if version.parse(config.PYARROW_VERSION) < version.parse("3.0.0"): - test_case = unittest.skip("test requires PyTorch")(test_case) + test_case = unittest.skip("test requires PyArrow>=3.0.0")(test_case) return test_case From 00b43fa39d47956250b29f5cea1c23d992f782e9 Mon Sep 17 00:00:00 2001 From: Quentin Lhoest Date: Wed, 30 Jun 2021 18:16:03 +0200 Subject: [PATCH 11/11] typo --- tests/test_dataset_common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_dataset_common.py b/tests/test_dataset_common.py index 0a02986c417..49d30c49a49 100644 --- a/tests/test_dataset_common.py +++ b/tests/test_dataset_common.py @@ -273,7 +273,7 @@ def test_load_real_dataset_all_configs(self, dataset_name): def get_packaged_dataset_names(): packaged_datasets = [{"testcase_name": x, "dataset_name": x} for x in _PACKAGED_DATASETS_MODULES.keys()] - if version.parse(pa.__version) < version.parse("3.0.0"): # parquet is not supported for pyarrow<3.0.0 + if version.parse(pa.__version__) < version.parse("3.0.0"): # parquet is not supported for pyarrow<3.0.0 packaged_datasets = [pd for pd in packaged_datasets if pd["dataset_name"] != "parquet"] return packaged_datasets