


"""simple docstring"""







import pyarrow.parquet as pq
import pytest

from datasets import Audio, Dataset, DatasetDict, Features, NamedSplit, Sequence, Value, config
from datasets.features.image import Image
from datasets.io.parquet import ParquetDatasetReader, ParquetDatasetWriter, get_writer_batch_size

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases
def  a__      (    SCREAMING_SNAKE_CASE   :   str    ,				SCREAMING_SNAKE_CASE   :   Any    ):


		'''simple docstring'''







		assert isinstance(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
		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  a__      (    SCREAMING_SNAKE_CASE   :   Any    ,				SCREAMING_SNAKE_CASE   :   List[str]    ,				SCREAMING_SNAKE_CASE   :   int    ):


		'''simple docstring'''







		lowerCAmelCase					:					List[Any]								=							tmp_path / "cache"
		lowerCAmelCase					:					Optional[int]								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
				lowerCAmelCase					:					str								=							ParquetDatasetReader(SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ,				keep_in_memory=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_dataset(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
@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  a__      (    SCREAMING_SNAKE_CASE   :   Tuple    ,				SCREAMING_SNAKE_CASE   :   Optional[Any]    ,				SCREAMING_SNAKE_CASE   :   Tuple    ):


		'''simple docstring'''







		lowerCAmelCase					:					Optional[int]								=							tmp_path / "cache"
		lowerCAmelCase					:					Optional[Any]								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		lowerCAmelCase					:					Tuple								=							features.copy() if features else default_expected_features
		lowerCAmelCase					:					List[str]								=							(
		    Features({feature: Value(SCREAMING_SNAKE_CASE    ) for feature, dtype in features.items()}    ) if features is not None else None
		)
		lowerCAmelCase					:					List[str]								=							ParquetDatasetReader(SCREAMING_SNAKE_CASE    ,				features=SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_dataset(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
@pytest.mark.parametrize("split"    ,				[None, NamedSplit("train"    ), "train", "test"]    )
def  a__      (    SCREAMING_SNAKE_CASE   :   Union[str, Any]    ,				SCREAMING_SNAKE_CASE   :   Union[str, Any]    ,				SCREAMING_SNAKE_CASE   :   Optional[int]    ):


		'''simple docstring'''







		lowerCAmelCase					:					List[Any]								=							tmp_path / "cache"
		lowerCAmelCase					:					int								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		lowerCAmelCase					:					Tuple								=							ParquetDatasetReader(SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ,				split=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_dataset(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
		assert dataset.split == split if split else "train"
@pytest.mark.parametrize("path_type"    ,				[str, list]    )
def  a__      (    SCREAMING_SNAKE_CASE   :   List[Any]    ,				SCREAMING_SNAKE_CASE   :   Dict    ,				SCREAMING_SNAKE_CASE   :   List[str]    ):


		'''simple docstring'''







		if issubclass(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ):
				lowerCAmelCase					:					Optional[Any]								=							parquet_path
		elif issubclass(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ):
				lowerCAmelCase					:					Dict								=							[parquet_path]
		lowerCAmelCase					:					Optional[Any]								=							tmp_path / "cache"
		lowerCAmelCase					:					Any								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		lowerCAmelCase					:					Optional[Any]								=							ParquetDatasetReader(SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_dataset(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
def  a__      (    SCREAMING_SNAKE_CASE   :   Dict    ,				SCREAMING_SNAKE_CASE   :   List[str]    ,				SCREAMING_SNAKE_CASE   :   Tuple=("train",)    ):


		'''simple docstring'''







		assert isinstance(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
		for split in splits:
				lowerCAmelCase					:					List[Any]								=							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  a__      (    SCREAMING_SNAKE_CASE   :   Optional[int]    ,				SCREAMING_SNAKE_CASE   :   Tuple    ,				SCREAMING_SNAKE_CASE   :   Tuple    ):


		'''simple docstring'''







		lowerCAmelCase					:					Tuple								=							tmp_path / "cache"
		lowerCAmelCase					:					List[Any]								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
				lowerCAmelCase					:					Optional[Any]								=							ParquetDatasetReader(
				    {"train": parquet_path}    ,				cache_dir=SCREAMING_SNAKE_CASE    ,				keep_in_memory=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_datasetdict(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
@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  a__      (    SCREAMING_SNAKE_CASE   :   Optional[int]    ,				SCREAMING_SNAKE_CASE   :   Dict    ,				SCREAMING_SNAKE_CASE   :   Optional[int]    ):


		'''simple docstring'''







		lowerCAmelCase					:					Any								=							tmp_path / "cache"
		lowerCAmelCase					:					Union[str, Any]								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		lowerCAmelCase					:					List[Any]								=							features.copy() if features else default_expected_features
		lowerCAmelCase					:					List[Any]								=							(
		    Features({feature: Value(SCREAMING_SNAKE_CASE    ) for feature, dtype in features.items()}    ) if features is not None else None
		)
		lowerCAmelCase					:					Optional[int]								=							ParquetDatasetReader({"train": parquet_path}    ,				features=SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_datasetdict(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    )
@pytest.mark.parametrize("split"    ,				[None, NamedSplit("train"    ), "train", "test"]    )
def  a__      (    SCREAMING_SNAKE_CASE   :   str    ,				SCREAMING_SNAKE_CASE   :   Dict    ,				SCREAMING_SNAKE_CASE   :   List[str]    ):


		'''simple docstring'''







		if split:
				lowerCAmelCase					:					List[str]								=							{split: parquet_path}
		else:
				lowerCAmelCase					:					List[str]								=							"train"
				lowerCAmelCase					:					str								=							{"train": parquet_path, "test": parquet_path}
		lowerCAmelCase					:					Optional[int]								=							tmp_path / "cache"
		lowerCAmelCase					:					List[Any]								=							{"col_1": "string", "col_2": "int64", "col_3": "float64"}
		lowerCAmelCase					:					List[str]								=							ParquetDatasetReader(SCREAMING_SNAKE_CASE    ,				cache_dir=SCREAMING_SNAKE_CASE    ).read()
		_check_parquet_datasetdict(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				splits=list(path.keys()    )    )
		assert all(dataset[split].split == split for split in path.keys()    )
def  a__      (    SCREAMING_SNAKE_CASE   :   Optional[Any]    ,				SCREAMING_SNAKE_CASE   :   Any    ):


		'''simple docstring'''







		lowerCAmelCase					:					Optional[int]								=							ParquetDatasetWriter(SCREAMING_SNAKE_CASE    ,				tmp_path / "foo.parquet"    )
		assert writer.write() > 0
		lowerCAmelCase					:					List[str]								=							pq.ParquetFile(tmp_path / "foo.parquet"    )
		lowerCAmelCase					:					Union[str, Any]								=							pf.read()
		assert dataset.data.table == output_table
def  a__      (    SCREAMING_SNAKE_CASE   :   List[Any]    ,				SCREAMING_SNAKE_CASE   :   List[str]    ):


		'''simple docstring'''







		lowerCAmelCase					:					str								=							str(shared_datadir / "test_image_rgb.jpg"    )
		lowerCAmelCase					:					List[str]								=							{"image": [image_path]}
		lowerCAmelCase					:					str								=							Features({"image": Image()}    )
		lowerCAmelCase					:					Optional[Any]								=							Dataset.from_dict(SCREAMING_SNAKE_CASE    ,				features=SCREAMING_SNAKE_CASE    )
		lowerCAmelCase					:					List[Any]								=							ParquetDatasetWriter(SCREAMING_SNAKE_CASE    ,				tmp_path / "foo.parquet"    )
		assert writer.write() > 0

		lowerCAmelCase					:					Any								=							Dataset.from_parquet(str(tmp_path / "foo.parquet"    )    )
		assert dataset.features == reloaded_dataset.features

		lowerCAmelCase					:					Optional[int]								=							ParquetDatasetReader(str(tmp_path / "foo.parquet"    )    ,				streaming=SCREAMING_SNAKE_CASE    ).read()
		assert dataset.features == reloaded_iterable_dataset.features





@pytest.mark.parametrize(
    "feature, expected"    ,				[
        (Features({"foo": Value("int32"    )}    ), None),
        (Features({"image": Image(), "foo": Value("int32"    )}    ), config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS),
        (Features({"nested": Sequence(Audio()    )}    ), config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS),
    ]    ,				)
def  a__      (    SCREAMING_SNAKE_CASE   :   str    ,				SCREAMING_SNAKE_CASE   :   List[str]    ):


		'''simple docstring'''







		assert get_writer_batch_size(SCREAMING_SNAKE_CASE    ) == expected









"""simple docstring"""







import unittest

from datasets import load_dataset

from transformers import BloomTokenizerFast
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    List[str]       =None
       a  :    List[Any]       =BloomTokenizerFast
       a  :    Optional[int]       =BloomTokenizerFast
       a  :    Optional[Any]       =True
       a  :    Dict       =False
       a  :    Optional[Any]       ="tokenizer_file"
       a  :    Optional[int]       ={"bos_token": "<s>", "eos_token": "</s>", "unk_token": "<unk>", "pad_token": "<pad>"}

       def 	lowercase__							(						self						):






         """simple docstring"""





         super().setUp()
         lowerCAmelCase					:					Tuple								=							BloomTokenizerFast.from_pretrained("bigscience/tokenizer"						)
         tokenizer.save_pretrained(self.tmpdirname						)

       def 	lowercase__							(						self		,					**snake_case__						):






         """simple docstring"""





         kwargs.update(self.special_tokens_map						)
         return BloomTokenizerFast.from_pretrained(self.tmpdirname		,					**snake_case__						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							self.get_rust_tokenizer()

         lowerCAmelCase					:					List[Any]								=							["The quick brown fox</s>", "jumps over the lazy dog</s>"]
         lowerCAmelCase					:					str								=							[[2_175, 23_714, 73_173, 144_252, 2], [77, 132_619, 3_478, 368, 109_586, 35_433, 2]]

         lowerCAmelCase					:					Optional[int]								=							tokenizer.batch_encode_plus(snake_case__						)["input_ids"]
         self.assertListEqual(snake_case__		,					snake_case__						)

         lowerCAmelCase					:					Optional[int]								=							tokenizer.batch_decode(snake_case__						)
         self.assertListEqual(snake_case__		,					snake_case__						)

       def 	lowercase__							(						self		,					snake_case__=6						):






         """simple docstring"""





         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
             lowerCAmelCase					:					Tuple								=							self.rust_tokenizer_class.from_pretrained(snake_case__		,					**snake_case__						)
             # tokenizer_r.pad_token = None # Hotfixing padding = None
             # Simple input
             lowerCAmelCase					:					str								=							"This is a simple input"
             lowerCAmelCase					:					Tuple								=							["This is a simple input 1", "This is a simple input 2"]
             lowerCAmelCase					:					Any								=							("This is a simple input", "This is a pair")
             lowerCAmelCase					:					Tuple								=							[
                 ("This is a simple input 1", "This is a simple input 2"),
                 ("This is a simple pair 1", "This is a simple pair 2"),
             ]

             # Simple input tests
             try:
               tokenizer_r.encode(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.encode_plus(snake_case__		,					max_length=snake_case__						)

               tokenizer_r.batch_encode_plus(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.encode(snake_case__		,					max_length=snake_case__						)
               tokenizer_r.batch_encode_plus(snake_case__		,					max_length=snake_case__						)
             except ValueError:
               self.fail("Bloom Tokenizer should be able to deal with padding"						)

             lowerCAmelCase					:					Tuple								=							None  # Hotfixing padding = None
             self.assertRaises(snake_case__		,					tokenizer_r.encode		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Simple input
             self.assertRaises(snake_case__		,					tokenizer_r.encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Simple input
             self.assertRaises(
                 snake_case__		,					tokenizer_r.batch_encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"		,					)

             # Pair input
             self.assertRaises(snake_case__		,					tokenizer_r.encode		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Pair input
             self.assertRaises(snake_case__		,					tokenizer_r.encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"						)

             # Pair input
             self.assertRaises(
                 snake_case__		,					tokenizer_r.batch_encode_plus		,					snake_case__		,					max_length=snake_case__		,					padding="max_length"		,					)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							self.get_rust_tokenizer()
         lowerCAmelCase					:					int								=							load_dataset("xnli"		,					"all_languages"		,					split="test"		,					streaming=snake_case__						)

         lowerCAmelCase					:					Tuple								=							next(iter(snake_case__						)						)["premise"]  # pick up one data
         lowerCAmelCase					:					Optional[Any]								=							list(sample_data.values()						)

         lowerCAmelCase					:					int								=							list(map(tokenizer.encode		,					snake_case__						)						)
         lowerCAmelCase					:					List[Any]								=							[tokenizer.decode(snake_case__		,					clean_up_tokenization_spaces=snake_case__						) for x in output_tokens]
         self.assertListEqual(snake_case__		,					snake_case__						)







       def 	lowercase__							(						self						):






         """simple docstring"""





         self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map						)		,					1						)
         self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values()						)[0]						)		,					1						)





