






'''simple docstring'''







import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import datasets
import datasets.config

from .utils import require_beam





class 	SCREAMING_SNAKE_CASE					(					datasets.BeamBasedBuilder       ):






			def 			SCREAMING_SNAKE_CASE      ( self      :			int					)			->			Dict:
							return datasets.DatasetInfo(
							    features=datasets.Features({'''content''': datasets.Value('''string'''					)}					)  ,						supervised_keys=__SCREAMING_SNAKE_CASE  ,						)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[int]  ,						__SCREAMING_SNAKE_CASE      :			int  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			Any:
							return [datasets.SplitGenerator(name=datasets.Split.TRAIN  ,						gen_kwargs={'''examples''': get_test_dummy_examples()}					)]







			def 			SCREAMING_SNAKE_CASE      ( self      :			Dict  ,						__SCREAMING_SNAKE_CASE      :			Dict  ,						__SCREAMING_SNAKE_CASE      :			Any					)			->			Optional[Any]:
							import apache_beam as beam

							return pipeline | "Load Examples" >> beam.Create(__SCREAMING_SNAKE_CASE					)





class 	SCREAMING_SNAKE_CASE					(					datasets.BeamBasedBuilder       ):






			def 			SCREAMING_SNAKE_CASE      ( self      :			Any					)			->			int:
							return datasets.DatasetInfo(
							    features=datasets.Features({'''a''': datasets.Sequence({'''b''': datasets.Value('''string'''					)}					)}					)  ,						supervised_keys=__SCREAMING_SNAKE_CASE  ,						)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Tuple  ,						__SCREAMING_SNAKE_CASE      :			Dict  ,						__SCREAMING_SNAKE_CASE      :			Tuple					)			->			int:
							return [
							    datasets.SplitGenerator(name=datasets.Split.TRAIN  ,						gen_kwargs={'''examples''': get_test_nested_examples()}					)
							]







			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[int]  ,						__SCREAMING_SNAKE_CASE      :			int  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			Dict:
							import apache_beam as beam

							return pipeline | "Load Examples" >> beam.Create(__SCREAMING_SNAKE_CASE					)





def 		_UpperCAmelCase   (							):
				return [(i, {"content": content}) for i, content in enumerate(['''foo''', '''bar''', '''foobar''']      )]





def 		_UpperCAmelCase   (							):
				return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['''foo''', '''bar''', '''foobar''']      )]





class 	SCREAMING_SNAKE_CASE					(					SCREAMING_SNAKE_CASE_       ):






			@require_beam
			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Dict:
							a_		:  Union[str, Any]											=      len(get_test_dummy_examples()					)
							with tempfile.TemporaryDirectory() as tmp_cache_dir:
											a_		:  Any											=      DummyBeamDataset(cache_dir=__SCREAMING_SNAKE_CASE  ,						beam_runner='''DirectRunner'''					)
											builder.download_and_prepare()
											self.assertTrue(
											    os.path.exists(
											        os.path.join(__SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						f'{builder.name}-train.arrow'					)					)					)
											self.assertDictEqual(builder.info.features  ,						datasets.Features({'''content''': datasets.Value('''string'''					)}					)					)
											a_		:  List[Any]											=      builder.as_dataset()
											self.assertEqual(dset['''train'''].num_rows  ,						__SCREAMING_SNAKE_CASE					)
											self.assertEqual(dset['''train'''].info.splits['''train'''].num_examples  ,						__SCREAMING_SNAKE_CASE					)
											self.assertDictEqual(dset['''train'''][0]  ,						get_test_dummy_examples()[0][1]					)
											self.assertDictEqual(
											    dset['''train'''][expected_num_examples - 1]  ,						get_test_dummy_examples()[expected_num_examples - 1][1]					)
											self.assertTrue(
											    os.path.exists(os.path.join(__SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						'''dataset_info.json'''					)					)					)
											del dset






			@require_beam
			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]					)			->			Any:
							import apache_beam as beam

							a_		:  str											=      beam.io.parquetio.WriteToParquet

							a_		:  Dict											=      len(get_test_dummy_examples()					)
							with tempfile.TemporaryDirectory() as tmp_cache_dir:
											a_		:  Union[str, Any]											=      DummyBeamDataset(cache_dir=__SCREAMING_SNAKE_CASE  ,						beam_runner='''DirectRunner'''					)
											with patch('''apache_beam.io.parquetio.WriteToParquet'''					) as write_parquet_mock:
															a_		:  Optional[Any]											=      partial(__SCREAMING_SNAKE_CASE  ,						num_shards=2					)
															builder.download_and_prepare()
											self.assertTrue(
											    os.path.exists(
											        os.path.join(
											            __SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						f'{builder.name}-train-00000-of-00002.arrow'					)					)					)
											self.assertTrue(
											    os.path.exists(
											        os.path.join(
											            __SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						f'{builder.name}-train-00000-of-00002.arrow'					)					)					)
											self.assertDictEqual(builder.info.features  ,						datasets.Features({'''content''': datasets.Value('''string'''					)}					)					)
											a_		:  Union[str, Any]											=      builder.as_dataset()
											self.assertEqual(dset['''train'''].num_rows  ,						__SCREAMING_SNAKE_CASE					)
											self.assertEqual(dset['''train'''].info.splits['''train'''].num_examples  ,						__SCREAMING_SNAKE_CASE					)
											# Order is not preserved when sharding, so we just check that all the elements are there
											self.assertListEqual(sorted(dset['''train''']['''content''']					)  ,						sorted(['''foo''', '''bar''', '''foobar''']					)					)
											self.assertTrue(
											    os.path.exists(os.path.join(__SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						'''dataset_info.json'''					)					)					)
											del dset






			@require_beam
			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]					)			->			Dict:
							with tempfile.TemporaryDirectory() as tmp_cache_dir:
											a_		:  int											=      DummyBeamDataset(cache_dir=__SCREAMING_SNAKE_CASE					)
											self.assertRaises(datasets.builder.MissingBeamOptions  ,						builder.download_and_prepare					)







			@require_beam
			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]					)			->			Optional[int]:
							a_		:  Union[str, Any]											=      len(get_test_nested_examples()					)
							with tempfile.TemporaryDirectory() as tmp_cache_dir:
											a_		:  int											=      NestedBeamDataset(cache_dir=__SCREAMING_SNAKE_CASE  ,						beam_runner='''DirectRunner'''					)
											builder.download_and_prepare()
											self.assertTrue(
											    os.path.exists(
											        os.path.join(__SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						f'{builder.name}-train.arrow'					)					)					)
											self.assertDictEqual(
											    builder.info.features  ,						datasets.Features({'''a''': datasets.Sequence({'''b''': datasets.Value('''string'''					)}					)}					)					)
											a_		:  List[str]											=      builder.as_dataset()
											self.assertEqual(dset['''train'''].num_rows  ,						__SCREAMING_SNAKE_CASE					)
											self.assertEqual(dset['''train'''].info.splits['''train'''].num_examples  ,						__SCREAMING_SNAKE_CASE					)
											self.assertDictEqual(dset['''train'''][0]  ,						get_test_nested_examples()[0][1]					)
											self.assertDictEqual(
											    dset['''train'''][expected_num_examples - 1]  ,						get_test_nested_examples()[expected_num_examples - 1][1]					)
											self.assertTrue(
											    os.path.exists(os.path.join(__SCREAMING_SNAKE_CASE  ,						builder.name  ,						'''default'''  ,						'''0.0.0'''  ,						'''dataset_info.json'''					)					)					)
											del dset












'''simple docstring'''







import sys

__lowerCAmelCase       		=      (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)





def 		_UpperCAmelCase   (							__A							:   str      ):
				a_		:  Tuple											=      1
				for digit in s:
								product *= int(__A      )
				return product





def 		_UpperCAmelCase   (							__A							:   str = N      ):
				a_		:  Dict											=      -sys.maxsize - 1
				a_		:  Optional[int]											=      n[:13]
				a_		:  str											=      13
				while cur_index < len(__A      ) - 13:
								if int(n[cur_index]      ) >= int(substr[0]      ):
												a_		:  Tuple											=      substr[1:] + n[cur_index]
												cur_index += 1
								else:
												a_		:  Dict											=      max(__A						,		str_eval(__A      )      )
												a_		:  List[str]											=      n[cur_index : cur_index + 13]
												cur_index += 13
				return largest_product


if __name__ == "__main__":
		print(F"""{solution() = }""")




