





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     _UpperCamelCase     (a__   :Tuple   ,			a__   :Optional[Any]       ):






				"""simple docstring"""





				assert isinstance(__snake_case   ,			__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     _UpperCamelCase     (a__   :List[Any]   ,			a__   :List[Any]   ,			a__   :Union[str, Any]       ):






				"""simple docstring"""





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






				"""simple docstring"""





				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				UpperCamelCase__				     =			features.copy() if features else default_expected_features
				UpperCamelCase__				     =			(
				    Features({feature: Value(__snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
				)
				UpperCamelCase__				     =			ParquetDatasetReader(__snake_case   ,			features=__snake_case   ,			cache_dir=__snake_case       ).read()
				_check_parquet_dataset(__snake_case   ,			__snake_case       )





@pytest.mark.parametrize("""split"""   ,			[None, NamedSplit("""train"""       ), """train""", """test"""]       )
def     _UpperCamelCase     (a__   :str   ,			a__   :Any   ,			a__   :Dict       ):






				"""simple docstring"""





				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				UpperCamelCase__				     =			ParquetDatasetReader(__snake_case   ,			cache_dir=__snake_case   ,			split=__snake_case       ).read()
				_check_parquet_dataset(__snake_case   ,			__snake_case       )
				assert dataset.split == split if split else "train"





@pytest.mark.parametrize("""path_type"""   ,			[str, list]       )
def     _UpperCamelCase     (a__   :Dict   ,			a__   :List[str]   ,			a__   :Tuple       ):






				"""simple docstring"""





				if issubclass(__snake_case   ,			__snake_case       ):
								UpperCamelCase__				     =			parquet_path
				elif issubclass(__snake_case   ,			__snake_case       ):
								UpperCamelCase__				     =			[parquet_path]
				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				UpperCamelCase__				     =			ParquetDatasetReader(__snake_case   ,			cache_dir=__snake_case       ).read()
				_check_parquet_dataset(__snake_case   ,			__snake_case       )





def     _UpperCamelCase     (a__   :Any   ,			a__   :Any   ,			a__   :Tuple=("train",)       ):






				"""simple docstring"""





				assert isinstance(__snake_case   ,			__snake_case       )
				for split in splits:
								UpperCamelCase__				     =			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     _UpperCamelCase     (a__   :Tuple   ,			a__   :List[Any]   ,			a__   :Any       ):






				"""simple docstring"""





				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
								UpperCamelCase__				     =			ParquetDatasetReader(
								    {"""train""": parquet_path}   ,			cache_dir=__snake_case   ,			keep_in_memory=__snake_case       ).read()
				_check_parquet_datasetdict(__snake_case   ,			__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     _UpperCamelCase     (a__   :List[Any]   ,			a__   :Union[str, Any]   ,			a__   :str       ):






				"""simple docstring"""





				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				UpperCamelCase__				     =			features.copy() if features else default_expected_features
				UpperCamelCase__				     =			(
				    Features({feature: Value(__snake_case       ) for feature, dtype in features.items()}       ) if features is not None else None
				)
				UpperCamelCase__				     =			ParquetDatasetReader({"""train""": parquet_path}   ,			features=__snake_case   ,			cache_dir=__snake_case       ).read()
				_check_parquet_datasetdict(__snake_case   ,			__snake_case       )





@pytest.mark.parametrize("""split"""   ,			[None, NamedSplit("""train"""       ), """train""", """test"""]       )
def     _UpperCamelCase     (a__   :Optional[Any]   ,			a__   :Optional[Any]   ,			a__   :List[Any]       ):






				"""simple docstring"""





				if split:
								UpperCamelCase__				     =			{split: parquet_path}
				else:
								UpperCamelCase__				     =			"""train"""
								UpperCamelCase__				     =			{"""train""": parquet_path, """test""": parquet_path}
				UpperCamelCase__				     =			tmp_path / """cache"""
				UpperCamelCase__				     =			{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
				UpperCamelCase__				     =			ParquetDatasetReader(__snake_case   ,			cache_dir=__snake_case       ).read()
				_check_parquet_datasetdict(__snake_case   ,			__snake_case   ,			splits=list(path.keys()       )       )
				assert all(dataset[split].split == split for split in path.keys()       )





def     _UpperCamelCase     (a__   :List[Any]   ,			a__   :Union[str, Any]       ):






				"""simple docstring"""





				UpperCamelCase__				     =			ParquetDatasetWriter(__snake_case   ,			tmp_path / """foo.parquet"""       )
				assert writer.write() > 0
				UpperCamelCase__				     =			pq.ParquetFile(tmp_path / """foo.parquet"""       )
				UpperCamelCase__				     =			pf.read()
				assert dataset.data.table == output_table





def     _UpperCamelCase     (a__   :str   ,			a__   :List[str]       ):






				"""simple docstring"""





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

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

				UpperCamelCase__				     =			ParquetDatasetReader(str(tmp_path / """foo.parquet"""       )   ,			streaming=__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     _UpperCamelCase     (a__   :str   ,			a__   :Optional[Any]       ):






				"""simple docstring"""





				assert get_writer_batch_size(__snake_case       ) == expected











def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							if divisor % 5 == 0 or divisor % 2 == 0:
														return 0
							UpperCamelCase__				     =			1
							UpperCamelCase__				     =			1
							while repunit:
														UpperCamelCase__				     =			(10 * repunit + 1) % divisor
														repunit_index += 1
							return repunit_index





def     _UpperCamelCase     (a__   :int = 100_0000       ):






							"""simple docstring"""





							UpperCamelCase__				     =			limit - 1
							if divisor % 2 == 0:
														divisor += 1
							while least_divisible_repunit(a__       ) <= limit:
														divisor += 2
							return divisor


if __name__ == "__main__":
					print(f"""{solution() = }""")




