






def   __lowercase       (			snake_case			):







				"""simple docstring"""






				if not head:
								return True
				# split the list to two parts
				__magic_name__  ,					__magic_name__		:List[str]   =   head.next, head
				while fast and fast.next:
								__magic_name__		:str   =   fast.next.next
								__magic_name__		:int   =   slow.next
				__magic_name__		:Optional[int]   =   slow.next
				__magic_name__		:Optional[Any]   =   None  # Don't forget here! But forget still works!
				# reverse the second part
				__magic_name__		:Optional[int]   =   None
				while second:
								__magic_name__		:List[str]   =   second.next
								__magic_name__		:Dict   =   node
								__magic_name__		:Dict   =   second
								__magic_name__		:Union[str, Any]   =   nxt
				# compare two parts
				# second part has the same or one less node
				while node:
								if node.val != head.val:
												return False
								__magic_name__		:int   =   node.next
								__magic_name__		:Dict   =   head.next
				return True

def   __lowercase       (			snake_case			):







				"""simple docstring"""






				if not head or not head.next:
								return True

				# 1. Get the midpoint (slow)
				__magic_name__		:Dict   =   head
				while fast and fast.next:
								__magic_name__  ,					__magic_name__		:Union[str, Any]   =   fast.next.next, slow.next

				# 2. Push the second half into the stack
				__magic_name__		:Union[str, Any]   =   [slow.val]
				while slow.next:
								__magic_name__		:List[Any]   =   slow.next
								stack.append(slow.val			)

				# 3. Comparison
				while stack:
								if stack.pop() != cur.val:
												return False
								__magic_name__		:Optional[int]   =   cur.next

				return True

def   __lowercase       (			snake_case			):







				"""simple docstring"""






				if not head or not head.next:
								return True
				__magic_name__		:List[str]   =   {}
				__magic_name__		:Optional[Any]   =   0
				while head:
								if head.val in d:
												d[head.val].append(snake_case			)
								else:
												__magic_name__		:Optional[Any]   =   [pos]
								__magic_name__		:Optional[Any]   =   head.next
								pos += 1
				__magic_name__		:Optional[int]   =   pos - 1
				__magic_name__		:Union[str, Any]   =   0
				for v in d.values():
								if len(snake_case			) % 2 != 0:
												middle += 1
								else:
												__magic_name__		:int   =   0
												for i in range(0,	len(snake_case			)			):
																if v[i] + v[len(snake_case			) - 1 - step] != checksum:
																				return False
																step += 1
								if middle > 1:
												return False
				return True














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   __lowercase       (			snake_case,	snake_case			):







				"""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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:Tuple   =   tmp_path / '''cache'''
				__magic_name__		: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():
								__magic_name__		:Optional[Any]   =   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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:List[str]   =   tmp_path / '''cache'''
				__magic_name__		:int   =   {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
				__magic_name__		:Tuple   =   features.copy() if features else default_expected_features
				__magic_name__		:Union[str, Any]   =   (
				    Features({feature: Value(snake_case			) for feature, dtype in features.items()}			) if features is not None else None
				)
				__magic_name__		:int   =   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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:str   =   tmp_path / '''cache'''
				__magic_name__		:List[Any]   =   {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
				__magic_name__		:int   =   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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				if issubclass(snake_case,	snake_case			):
								__magic_name__		:Union[str, Any]   =   parquet_path
				elif issubclass(snake_case,	snake_case			):
								__magic_name__		:Union[str, Any]   =   [parquet_path]
				__magic_name__		:Optional[int]   =   tmp_path / '''cache'''
				__magic_name__		:Optional[int]   =   {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
				__magic_name__		:str   =   ParquetDatasetReader(snake_case,	cache_dir=snake_case			).read()
				_check_parquet_dataset(snake_case,	snake_case			)

def   __lowercase       (			snake_case,	snake_case,	snake_case=("train",)			):







				"""simple docstring"""






				assert isinstance(snake_case,	snake_case			)
				for split in splits:
								__magic_name__		:Optional[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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:Any   =   tmp_path / '''cache'''
				__magic_name__		: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():
								__magic_name__		:Tuple   =   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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:Optional[Any]   =   tmp_path / '''cache'''
				__magic_name__		:Dict   =   {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
				__magic_name__		:int   =   features.copy() if features else default_expected_features
				__magic_name__		:List[Any]   =   (
				    Features({feature: Value(snake_case			) for feature, dtype in features.items()}			) if features is not None else None
				)
				__magic_name__		:Optional[int]   =   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   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				if split:
								__magic_name__		:Dict   =   {split: parquet_path}
				else:
								__magic_name__		:Optional[int]   =   '''train'''
								__magic_name__		:Dict   =   {'''train''': parquet_path, '''test''': parquet_path}
				__magic_name__		:List[Any]   =   tmp_path / '''cache'''
				__magic_name__		:Optional[Any]   =   {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
				__magic_name__		:Optional[Any]   =   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   __lowercase       (			snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:str   =   ParquetDatasetWriter(snake_case,	tmp_path / '''foo.parquet'''			)
				assert writer.write() > 0
				__magic_name__		:List[Any]   =   pq.ParquetFile(tmp_path / '''foo.parquet'''			)
				__magic_name__		:List[Any]   =   pf.read()
				assert dataset.data.table == output_table

def   __lowercase       (			snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:List[str]   =   str(shared_datadir / '''test_image_rgb.jpg'''			)
				__magic_name__		:Tuple   =   {'''image''': [image_path]}
				__magic_name__		:List[Any]   =   Features({'''image''': Image()}			)
				__magic_name__		:Tuple   =   Dataset.from_dict(snake_case,	features=snake_case			)
				__magic_name__		:Union[str, Any]   =   ParquetDatasetWriter(snake_case,	tmp_path / '''foo.parquet'''			)
				assert writer.write() > 0

				__magic_name__		:List[str]   =   Dataset.from_parquet(str(tmp_path / '''foo.parquet'''			)			)
				assert dataset.features == reloaded_dataset.features

				__magic_name__		:List[str]   =   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   __lowercase       (			snake_case,	snake_case			):







				"""simple docstring"""






				assert get_writer_batch_size(snake_case			) == expected






