




import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases



class  A		(			lowerCamelCase__		):




				'''simple docstring'''





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase=False      )     ->	List[Any]:
							__UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase				:      Tuple									=       (
							    filename_skip_take["filename"],
							    filename_skip_take["skip"] if "skip" in filename_skip_take else None,
							    filename_skip_take["take"] if "take" in filename_skip_take else None,
							)
							open(os.path.join(lowercase_      )			,  "wb"      ).close()
							__UpperCamelCase				:      Union[str, Any]									=       pa.Table.from_pydict({"filename": [Path(lowercase_      ).name] * 1_0_0}      )
							if take == -1:
										__UpperCamelCase				:      Optional[Any]									=       len(lowercase_      ) - skip
							if skip is not None and take is not None:
										__UpperCamelCase				:      List[str]									=       pa_table.slice(lowercase_			,  lowercase_      )
							return pa_table







class  A		(			lowerCamelCase__		):




				'''simple docstring'''





				def 	a_	(self      )     ->	List[str]:
							__UpperCamelCase				:      Any									=       "my_name"
							__UpperCamelCase				:      Union[str, Any]									=       SplitInfo(name="train"			,  num_examples=1_0_0      )
							__UpperCamelCase				:      List[str]									=       SplitInfo(name="test"			,  num_examples=1_0_0      )
							__UpperCamelCase				:      int									=       [train_info, test_info]
							__UpperCamelCase				:      str									=       SplitDict()
							split_dict.add(lowercase_      )
							split_dict.add(lowercase_      )
							__UpperCamelCase				:      Optional[Any]									=       DatasetInfo(splits=lowercase_      )

							with tempfile.TemporaryDirectory() as tmp_dir:
										__UpperCamelCase				:      Optional[Any]									=       ReaderTest(lowercase_			,  lowercase_      )

										__UpperCamelCase				:      Union[str, Any]									=       "test[:33%]"
										__UpperCamelCase				:      Union[str, Any]									=       Dataset(**reader.read(lowercase_			,  lowercase_			,  lowercase_      )      )
										self.assertEqual(dset["filename"][0]			,  f"{name}-test"      )
										self.assertEqual(dset.num_rows			,  3_3      )
										self.assertEqual(dset.num_columns			,  1      )

										__UpperCamelCase				:      str									=       ["train", "test[:33%]"]
										__UpperCamelCase				:      Union[str, Any]									=       [Split.TRAIN, ReadInstruction.from_spec("test[:33%]"      )]
										for instructions in [instructionsa, instructionsa]:
													__UpperCamelCase				:      Union[str, Any]									=       [reader.read(lowercase_			,  lowercase_			,  lowercase_      ) for instr in instructions]
													__UpperCamelCase		, __UpperCamelCase				:      Union[str, Any]									=       (Dataset(**lowercase_      ) for dataset_kwargs in datasets_kwargs)
													self.assertEqual(train_dset["filename"][0]			,  f"{name}-train"      )
													self.assertEqual(train_dset.num_rows			,  1_0_0      )
													self.assertEqual(train_dset.num_columns			,  1      )
													self.assertIsInstance(train_dset.split			,  lowercase_      )
													self.assertEqual(str(train_dset.split      )			,  "train"      )
													self.assertEqual(test_dset["filename"][0]			,  f"{name}-test"      )
													self.assertEqual(test_dset.num_rows			,  3_3      )
													self.assertEqual(test_dset.num_columns			,  1      )
													self.assertIsInstance(test_dset.split			,  lowercase_      )
													self.assertEqual(str(test_dset.split      )			,  "test[:33%]"      )
													del train_dset, test_dset
				def 	a_	(self      )     ->	Any:
							__UpperCamelCase				:      Dict									=       "my_name"
							__UpperCamelCase				:      List[str]									=       SplitInfo(name="train"			,  num_examples=1_0_0_0			,  shard_lengths=[1_0_0] * 1_0      )
							__UpperCamelCase				:      List[str]									=       [train_info]
							__UpperCamelCase				:      Any									=       SplitDict()
							split_dict.add(lowercase_      )
							__UpperCamelCase				:      Any									=       DatasetInfo(splits=lowercase_      )

							with tempfile.TemporaryDirectory() as tmp_dir:
										__UpperCamelCase				:      Tuple									=       ReaderTest(lowercase_			,  lowercase_      )

										__UpperCamelCase				:      Tuple									=       "train[:33%]"
										__UpperCamelCase				:      List[Any]									=       Dataset(**reader.read(lowercase_			,  lowercase_			,  lowercase_      )      )
										self.assertEqual(dset["filename"][0]			,  f"{name}-train-00000-of-00010"      )
										self.assertEqual(dset["filename"][-1]			,  f"{name}-train-00003-of-00010"      )
										self.assertEqual(dset.num_rows			,  3_3_0      )
										self.assertEqual(dset.num_columns			,  1      )





				def 	a_	(self      )     ->	Dict:
							__UpperCamelCase				:      Tuple									=       SplitInfo(name="train"			,  num_examples=1_0_0      )
							__UpperCamelCase				:      Tuple									=       SplitInfo(name="test"			,  num_examples=1_0_0      )
							__UpperCamelCase				:      Union[str, Any]									=       SplitDict()
							split_dict.add(lowercase_      )
							split_dict.add(lowercase_      )
							__UpperCamelCase				:      Union[str, Any]									=       DatasetInfo(splits=lowercase_      )

							with tempfile.TemporaryDirectory() as tmp_dir:
										__UpperCamelCase				:      Optional[int]									=       ReaderTest(lowercase_			,  lowercase_      )

										__UpperCamelCase				:      str									=       [
										    {"filename": os.path.join(lowercase_			,  "train"      )},
										    {"filename": os.path.join(lowercase_			,  "test"      ), "skip": 1_0, "take": 1_0},
										]
										__UpperCamelCase				:      Any									=       Dataset(**reader.read_files(lowercase_			,  original_instructions="train+test[10:20]"      )      )
										self.assertEqual(dset.num_rows			,  1_1_0      )
										self.assertEqual(dset.num_columns			,  1      )
										del dset







@pytest.mark.parametrize("in_memory" ,				[False, True]						)
def       __lowerCAmelCase (   snake_case__ ,				snake_case__ ,				snake_case__						):
			__UpperCamelCase				:      Tuple									=       arrow_file
			with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
						__UpperCamelCase				:      int									=       ArrowReader.read_table(_A ,				in_memory=_A						)
			assert table.shape == dataset.data.shape
			assert set(table.column_names						) == set(dataset.data.column_names						)
			assert dict(table.to_pydict()						) == dict(dataset.data.to_pydict()						)  # to_pydict returns OrderedDict

@pytest.mark.parametrize("in_memory" ,				[False, True]						)
def       __lowerCAmelCase (   snake_case__ ,				snake_case__ ,				snake_case__						):
			__UpperCamelCase				:      Optional[Any]									=       arrow_file
			__UpperCamelCase				:      List[str]									=       ArrowReader("" ,				_A						)
			with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
						__UpperCamelCase				:      List[str]									=       reader.read_files([{"filename": filename}] ,				in_memory=_A						)
			assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
			__UpperCamelCase				:      Tuple									=       dataset_kwargs["arrow_table"]
			assert table.shape == dataset.data.shape
			assert set(table.column_names						) == set(dataset.data.column_names						)
			assert dict(table.to_pydict()						) == dict(dataset.data.to_pydict()						)  # to_pydict returns OrderedDict

def       __lowerCAmelCase (   ):
			assert ReadInstruction("train" ,				to=10 ,				unit="abs"						).to_spec() == "train[:10]"
			assert ReadInstruction("train" ,				from_=-80 ,				to=10 ,				unit="%"						).to_spec() == "train[-80%:10%]"

			__UpperCamelCase				:      Dict									=       "train+test"
			assert ReadInstruction.from_spec(_A						).to_spec() == spec_train_test

			__UpperCamelCase				:      List[Any]									=       "train[2:10]"
			assert ReadInstruction.from_spec(_A						).to_spec() == spec_train_abs

			__UpperCamelCase				:      List[Any]									=       "train[15%:-20%]"
			assert ReadInstruction.from_spec(_A						).to_spec() == spec_train_pct

			__UpperCamelCase				:      str									=       "train[:10%](closest)"
			assert ReadInstruction.from_spec(_A						).to_spec() == "train[:10%]"

			__UpperCamelCase				:      str									=       "train[:10%](pct1_dropremainder)"
			assert ReadInstruction.from_spec(_A						).to_spec() == spec_train_pct_rounding

			__UpperCamelCase				:      Optional[Any]									=       "train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)"
			assert ReadInstruction.from_spec(_A						).to_spec() == spec_train_test_pct_rounding

def       __lowerCAmelCase (   ):
			__UpperCamelCase				:      List[Any]									=       "dummy"
			__UpperCamelCase				:      Dict									=       [SplitInfo(name="train" ,				num_examples=100						)]
			__UpperCamelCase				:      int									=       "train[:33%]"
			__UpperCamelCase				:      List[str]									=       "arrow"
			__UpperCamelCase				:      int									=       "prefix"

			__UpperCamelCase				:      Tuple									=       make_file_instructions(_A ,				_A ,				_A ,				_A ,				_A						)
			assert isinstance(_A ,				_A						)
			assert file_instructions.num_examples == 33
			assert file_instructions.file_instructions == [
			    {"filename": os.path.join(_A ,				F"{name}-train.arrow"						), "skip": 0, "take": 33}
			]

			__UpperCamelCase				:      int									=       [SplitInfo(name="train" ,				num_examples=100 ,				shard_lengths=[10] * 10						)]
			__UpperCamelCase				:      Dict									=       make_file_instructions(_A ,				_A ,				_A ,				_A ,				_A						)
			assert isinstance(_A ,				_A						)
			assert file_instructions.num_examples == 33
			assert file_instructions.file_instructions == [
			    {"filename": os.path.join(_A ,				F"{name}-train-00000-of-00010.arrow"						), "skip": 0, "take": -1},
			    {"filename": os.path.join(_A ,				F"{name}-train-00001-of-00010.arrow"						), "skip": 0, "take": -1},
			    {"filename": os.path.join(_A ,				F"{name}-train-00002-of-00010.arrow"						), "skip": 0, "take": -1},
			    {"filename": os.path.join(_A ,				F"{name}-train-00003-of-00010.arrow"						), "skip": 0, "take": 3},
			]




@pytest.mark.parametrize("name, expected_exception" ,				[(None, TypeError), ("", ValueError)]						)
def       __lowerCAmelCase (   snake_case__ ,				snake_case__						):
			__UpperCamelCase				:      Optional[int]									=       [SplitInfo(name="train" ,				num_examples=100						)]
			__UpperCamelCase				:      Optional[Any]									=       "train"
			__UpperCamelCase				:      int									=       "arrow"
			__UpperCamelCase				:      Any									=       "prefix_path"
			with pytest.raises(_A						):
						__UpperCamelCase				:      int									=       make_file_instructions(_A ,				_A ,				_A ,				_A ,				_A						)









'''simple docstring'''






from doctest import testmod
from math import sqrt

def       __lowerCAmelCase (   snake_case__						):
			__UpperCamelCase				:      list[int]									=       []
			if num < 1:
						return facs
			facs.append(1						)
			if num == 1:
						return facs
			facs.append(snake_case__						)
			for i in range(2 ,				int(sqrt(snake_case__						)						) + 1						):
						if num % i == 0:  # If i is a factor of num
									facs.append(snake_case__						)
									__UpperCamelCase				:      List[str]									=       num // i  # num//i is the other factor of num
									if d != i:  # If d and i are distinct
												facs.append(snake_case__						)  # we have found another factor
			facs.sort()
			return facs


if __name__ == "__main__":
				testmod(name='''factors_of_a_number''', verbose=True)



