

from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset





class       snake_case_  (						__A   ):







			'''simple docstring'''

			def 							snake_case__(	self					:							Tuple				) ->Optional[Any]:
									return [
									    {"col_1": 3, "col_2": "a"},
									    {"col_1": 2, "col_2": "b"},
									    {"col_1": 1, "col_2": "c"},
									    {"col_1": 0, "col_2": "d"},
									]







			def 							snake_case__(	self					:							List[str]				) ->List[str]:
									snake_case_  =      {'''col_1''': [3, 2, 1, 0], '''col_2''': ['''a''', '''b''', '''c''', '''d''']}
									return Dataset.from_dict(_UpperCamelCase				)







			def 							snake_case__(	self					:							Tuple				) ->str:
									snake_case_  =      self._create_example_records()
									snake_case_  =      Dataset.from_list(_UpperCamelCase				)
									self.assertListEqual(dset.column_names				,  ['''col_1''', '''col_2''']				)
									for i, r in enumerate(_UpperCamelCase				):
															self.assertDictEqual(_UpperCamelCase				,  example_records[i]				)







			def 							snake_case__(	self					:							Optional[int]				) ->Any:
									snake_case_  =      self._create_example_records()
									snake_case_  =      Dataset.from_list(_UpperCamelCase				)
									snake_case_  =      Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]}				)
									self.assertEqual(dset.info				,  dset_from_dict.info				)







			def 							snake_case__(	self					:							Dict				) ->Optional[int]:  # checks what happens with missing columns
									snake_case_  =      [{'''col_1''': 1}, {'''col_2''': '''x'''}]
									snake_case_  =      Dataset.from_list(_UpperCamelCase				)
									self.assertDictEqual(dset[0]				,  {'''col_1''': 1}				)
									self.assertDictEqual(dset[1]				,  {'''col_1''': None}				)  # NB: first record is used for columns







			def 							snake_case__(	self					:							Dict				) ->str:  # checks if the type can be inferred from the second record
									snake_case_  =      [{'''col_1''': []}, {'''col_1''': [1, 2]}]
									snake_case_  =      Dataset.from_list(_UpperCamelCase				)
									self.assertEqual(dset.info.features['''col_1''']				,  Sequence(Value('''int64'''				)				)				)







			def 							snake_case__(	self					:							Dict				) ->int:
									snake_case_  =      Dataset.from_list([]				)
									self.assertEqual(len(_UpperCamelCase				)				,  0				)
									self.assertListEqual(dset.column_names				,  []				)
from __future__ import annotations

_lowerCAmelCase       =		[True] * 1_000_001
_lowerCAmelCase       =		2
while i * i <= 1_000_000:
					if seive[i]:
										for j in range(i * i, 1_000_001, i):
															_lowerCAmelCase       =		False
					i += 1
def 					_snake_case	(  __snake_case						):
					return seive[n]
def 					_snake_case	(  __snake_case						):
					return any(digit in '''02468''' for digit in str(__snake_case						)						)
def 					_snake_case	(  __snake_case = 1000000						):
					_UpperCamelCase			     =     [2]  # result already includes the number 2.
					for num in range(3  ,     limit + 1  ,     2						):
										if is_prime(__snake_case						) and not contains_an_even_digit(__snake_case						):
															_UpperCamelCase			     =     str(__snake_case						)
															_UpperCamelCase			     =     [int(str_num[j:] + str_num[:j]						) for j in range(len(__snake_case						)						)]
															if all(is_prime(__snake_case						) for i in list_nums						):
																				result.append(__snake_case						)
					return result
def 					_snake_case	(  ):
					return len(find_circular_primes()						)


if __name__ == "__main__":
					print(f'{len(find_circular_primes()) = }')
