





"""simple docstring"""




import csv
import os

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.csv import CsvDatasetReader, CsvDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases





def        a_				(							_lowercase       ,						_lowercase   ):
						assert isinstance(_lowercase       ,						_lowercase   )
						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_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					List[Any]     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Optional[int]     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_UpperCamelCase			:					List[str]     =    CsvDatasetReader(_lowercase       ,						cache_dir=_lowercase       ,						keep_in_memory=_lowercase   ).read()
						_check_csv_dataset(_lowercase       ,						_lowercase   )





@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_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					Union[str, Any]     =    tmp_path / '''cache'''
						# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
						_UpperCamelCase			:					List[Any]     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						_UpperCamelCase			:					List[Any]     =    features.copy() if features else default_expected_features
						_UpperCamelCase			:					Optional[Any]     =    (
						    Features({feature: Value(_lowercase   ) for feature, dtype in features.items()}   ) if features is not None else None
						)
						_UpperCamelCase			:					str     =    CsvDatasetReader(_lowercase       ,						features=_lowercase       ,						cache_dir=_lowercase   ).read()
						_check_csv_dataset(_lowercase       ,						_lowercase   )





@pytest.mark.parametrize('''split'''       ,						[None, NamedSplit('''train'''   ), '''train''', '''test''']   )
def        a_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					List[str]     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Dict     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						_UpperCamelCase			:					Dict     =    CsvDatasetReader(_lowercase       ,						cache_dir=_lowercase       ,						split=_lowercase   ).read()
						_check_csv_dataset(_lowercase       ,						_lowercase   )
						assert dataset.split == split if split else "train"





@pytest.mark.parametrize('''path_type'''       ,						[str, list]   )
def        a_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						if issubclass(_lowercase       ,						_lowercase   ):
												_UpperCamelCase			:					Tuple     =    csv_path
						elif issubclass(_lowercase       ,						_lowercase   ):
												_UpperCamelCase			:					List[Any]     =    [csv_path]
						_UpperCamelCase			:					Any     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Optional[Any]     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						_UpperCamelCase			:					int     =    CsvDatasetReader(_lowercase       ,						cache_dir=_lowercase   ).read()
						_check_csv_dataset(_lowercase       ,						_lowercase   )





def        a_				(							_lowercase       ,						_lowercase       ,						_lowercase=("train",)   ):
						assert isinstance(_lowercase       ,						_lowercase   )
						for split in splits:
												_UpperCamelCase			:					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_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					int     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Any     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_UpperCamelCase			:					Optional[Any]     =    CsvDatasetReader({'''train''': csv_path}       ,						cache_dir=_lowercase       ,						keep_in_memory=_lowercase   ).read()
						_check_csv_datasetdict(_lowercase       ,						_lowercase   )





@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_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					str     =    tmp_path / '''cache'''
						# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
						_UpperCamelCase			:					str     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						_UpperCamelCase			:					Tuple     =    features.copy() if features else default_expected_features
						_UpperCamelCase			:					Union[str, Any]     =    (
						    Features({feature: Value(_lowercase   ) for feature, dtype in features.items()}   ) if features is not None else None
						)
						_UpperCamelCase			:					Any     =    CsvDatasetReader({'''train''': csv_path}       ,						features=_lowercase       ,						cache_dir=_lowercase   ).read()
						_check_csv_datasetdict(_lowercase       ,						_lowercase   )





@pytest.mark.parametrize('''split'''       ,						[None, NamedSplit('''train'''   ), '''train''', '''test''']   )
def        a_				(							_lowercase       ,						_lowercase       ,						_lowercase   ):
						if split:
												_UpperCamelCase			:					List[Any]     =    {split: csv_path}
						else:
												_UpperCamelCase			:					List[str]     =    {'''train''': csv_path, '''test''': csv_path}
						_UpperCamelCase			:					int     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Any     =    {'''col_1''': '''int64''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
						_UpperCamelCase			:					int     =    CsvDatasetReader(_lowercase       ,						cache_dir=_lowercase   ).read()
						_check_csv_datasetdict(_lowercase       ,						_lowercase       ,						splits=list(path.keys()   )   )
						assert all(dataset[split].split == split for split in path.keys()   )





def        a_				(							_lowercase   ):
						with open(_lowercase       ,						encoding='''utf-8'''   ) as csvfile:
												yield from csv.reader(_lowercase   )





def        a_				(							_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					int     =    tmp_path / '''cache'''
						_UpperCamelCase			:					str     =    os.path.join(_lowercase       ,						'''tmp.csv'''   )
						_UpperCamelCase			:					Tuple     =    CsvDatasetReader({'''train''': csv_path}       ,						cache_dir=_lowercase   ).read()
						CsvDatasetWriter(dataset['''train''']       ,						_lowercase       ,						num_proc=1   ).write()

						_UpperCamelCase			:					Optional[Any]     =    iter_csv_file(_lowercase   )
						_UpperCamelCase			:					List[str]     =    iter_csv_file(_lowercase   )

						for rowa, rowa in zip(_lowercase       ,						_lowercase   ):
												assert rowa == rowa





def        a_				(							_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					Union[str, Any]     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Any     =    os.path.join(_lowercase       ,						'''tmp.csv'''   )
						_UpperCamelCase			:					Dict     =    CsvDatasetReader({'''train''': csv_path}       ,						cache_dir=_lowercase   ).read()
						CsvDatasetWriter(dataset['''train''']       ,						_lowercase       ,						num_proc=2   ).write()

						_UpperCamelCase			:					Tuple     =    iter_csv_file(_lowercase   )
						_UpperCamelCase			:					Dict     =    iter_csv_file(_lowercase   )

						for rowa, rowa in zip(_lowercase       ,						_lowercase   ):
												assert rowa == rowa






def        a_				(							_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					List[Any]     =    tmp_path / '''cache'''
						_UpperCamelCase			:					Optional[int]     =    os.path.join(_lowercase       ,						'''tmp.csv'''   )
						_UpperCamelCase			:					Any     =    CsvDatasetReader({'''train''': csv_path}       ,						cache_dir=_lowercase   ).read()
						with pytest.raises(_lowercase   ):
												CsvDatasetWriter(dataset['''train''']       ,						_lowercase       ,						num_proc=0   )





'''simple docstring'''
from __future__ import annotations

import sys




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )   ->				tuple[int, int]:


		'''simple docstring'''


		if abs(SCREAMING_SNAKE_CASE__       ) == 1:
				return a, 0
		elif abs(SCREAMING_SNAKE_CASE__       ) == 1:
				return 0, b

		snake_case       ,snake_case   :    Tuple			       =		a, b
		snake_case       ,snake_case   :    List[str]			       =		1, 0
		snake_case       ,snake_case   :    Optional[Any]			       =		0, 1

		while remainder != 0:
				snake_case   :    int			       =		old_remainder // remainder
				snake_case       ,snake_case   :    Tuple			       =		remainder, old_remainder - quotient * remainder
				snake_case       ,snake_case   :    Optional[Any]			       =		coeff_a, old_coeff_a - quotient * coeff_a
				snake_case       ,snake_case   :    Dict			       =		coeff_b, old_coeff_b - quotient * coeff_b

		# sign correction for negative numbers
		if a < 0:
				snake_case   :    Optional[Any]			       =		-old_coeff_a
		if b < 0:
				snake_case   :    int			       =		-old_coeff_b

		return old_coeff_a, old_coeff_b




def 					_UpperCamelCase		(    )   ->				str:


		'''simple docstring'''


		if len(sys.argv       ) < 3:
				print('''2 integer arguments required'''       )
				return 1
		snake_case   :    str			       =		int(sys.argv[1]       )
		snake_case   :    List[str]			       =		int(sys.argv[2]       )
		print(extended_euclidean_algorithm(SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )       )
		return 0


if __name__ == "__main__":
						raise SystemExit(main())


