'''simple docstring'''




from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader





class     __magic_name__						(    _UpperCAmelCase):







			def __init__(	self				:  Any				,			lowercase_				:  NestedDataStructureLike[PathLike]				,			lowercase_				:  Optional[NamedSplit] = None				,			lowercase_				:  Optional[Features] = None				,			lowercase_				:  str = None				,			lowercase_				:  bool = False				,			lowercase_				:  bool = False				,			lowercase_				:  Optional[int] = None				,			**lowercase_				:  Tuple				,			):
										super().__init__(
										    lowercase_				,			split=lowercase_				,			features=lowercase_				,			cache_dir=lowercase_				,			keep_in_memory=lowercase_				,			streaming=lowercase_				,			num_proc=lowercase_				,			**lowercase_				,			)
										lowercase_					:			Optional[int]										=       path_or_paths if isinstance(lowercase_				,			lowercase_    ) else {self.split: path_or_paths}
										lowercase_					:			int										=       Text(
										    cache_dir=lowercase_				,			data_files=lowercase_				,			features=lowercase_				,			**lowercase_				,			)







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										# Build iterable dataset
										if self.streaming:
																	lowercase_					:			str										=       self.builder.as_streaming_dataset(split=self.split    )
										# Build regular (map-style) dataset
										else:
																	lowercase_					:			List[Any]										=       None
																	lowercase_					:			Union[str, Any]										=       None
																	lowercase_					:			List[Any]										=       None
																	lowercase_					:			Optional[Any]										=       None

																	self.builder.download_and_prepare(
																	    download_config=lowercase_				,			download_mode=lowercase_				,			verification_mode=lowercase_				,			base_path=lowercase_				,			num_proc=self.num_proc				,			)
																	lowercase_					:			Tuple										=       self.builder.as_dataset(
																	    split=self.split				,			verification_mode=lowercase_				,			in_memory=self.keep_in_memory    )
										return dataset






'''simple docstring'''




import math
import unittest




def 							lowerCamelCase	(      UpperCAmelCase__       :					int )			->      bool:
							assert isinstance(UpperCAmelCase__      ,      UpperCAmelCase__ ) and (
							    number >= 0
							), "'number' must been an int and positive"

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5      ,      int(math.sqrt(UpperCAmelCase__ ) + 1 )      ,      6 ):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True





class     __magic_name__						(    unittest.TestCase):







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict    ):
										self.assertTrue(is_prime(2    )    )
										self.assertTrue(is_prime(3    )    )
										self.assertTrue(is_prime(5    )    )
										self.assertTrue(is_prime(7    )    )
										self.assertTrue(is_prime(11    )    )
										self.assertTrue(is_prime(13    )    )
										self.assertTrue(is_prime(17    )    )
										self.assertTrue(is_prime(19    )    )
										self.assertTrue(is_prime(23    )    )
										self.assertTrue(is_prime(29    )    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]    ):
										with self.assertRaises(lowercase_    ):
																	is_prime(-19    )
										self.assertFalse(
										    is_prime(0    )				,			"""Zero doesn't have any positive factors, primes must have exactly two."""				,			)
										self.assertFalse(
										    is_prime(1    )				,			"""One only has 1 positive factor, primes must have exactly two."""				,			)
										self.assertFalse(is_prime(2 * 2    )    )
										self.assertFalse(is_prime(2 * 3    )    )
										self.assertFalse(is_prime(3 * 3    )    )
										self.assertFalse(is_prime(3 * 5    )    )
										self.assertFalse(is_prime(3 * 5 * 7    )    )


if __name__ == "__main__":
						unittest.main()





