






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    _lowerCAmelCase			(		datasets.BeamBasedBuilder      ):



				"""simple docstring"""



				def 					__magic_name__							(      self    :    Optional[Any]):






											'''simple docstring'''







											return datasets.DatasetInfo(
											    features=datasets.Features({"""content""": datasets.Value("""string""")})			,		supervised_keys=UpperCamelCase__			,		)



				def 					__magic_name__							(      self    :    Dict			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Optional[Any]):






											'''simple docstring'''







											return [datasets.SplitGenerator(name=datasets.Split.TRAIN			,		gen_kwargs={"""examples""": get_test_dummy_examples()})]



				def 					__magic_name__							(      self    :    Optional[Any]			,		UpperCamelCase__    :    int			,		UpperCamelCase__    :    Dict):






											'''simple docstring'''







											import apache_beam as beam

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


class    _lowerCAmelCase			(		datasets.BeamBasedBuilder      ):



				"""simple docstring"""



				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







											return datasets.DatasetInfo(
											    features=datasets.Features({"""a""": datasets.Sequence({"""b""": datasets.Value("""string""")})})			,		supervised_keys=UpperCamelCase__			,		)



				def 					__magic_name__							(      self    :    str			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Dict):






											'''simple docstring'''







											return [
											    datasets.SplitGenerator(name=datasets.Split.TRAIN			,		gen_kwargs={"""examples""": get_test_nested_examples()})
											]



				def 					__magic_name__							(      self    :    Union[str, Any]			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    str):






											'''simple docstring'''







											import apache_beam as beam

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


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    _lowerCAmelCase			(		lowercase_      ):



				"""simple docstring"""



				@require_beam
				def 					__magic_name__							(      self    :    Any):






											'''simple docstring'''







											snake_case__	  =       len(get_test_dummy_examples())
											with tempfile.TemporaryDirectory() as tmp_cache_dir:
																		snake_case__	  =       DummyBeamDataset(cache_dir=UpperCamelCase__			,		beam_runner="""DirectRunner""")
																		builder.download_and_prepare()
																		self.assertTrue(
																		    os.path.exists(
																		        os.path.join(UpperCamelCase__			,		builder.name			,		"""default"""			,		"""0.0.0"""			,		F'''{builder.name}-train.arrow''')))
																		self.assertDictEqual(builder.info.features			,		datasets.Features({"""content""": datasets.Value("""string""")}))
																		snake_case__	  =       builder.as_dataset()
																		self.assertEqual(dset["""train"""].num_rows			,		UpperCamelCase__)
																		self.assertEqual(dset["""train"""].info.splits["""train"""].num_examples			,		UpperCamelCase__)
																		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(UpperCamelCase__			,		builder.name			,		"""default"""			,		"""0.0.0"""			,		"""dataset_info.json""")))
																		del dset



				@require_beam
				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







											import apache_beam as beam

											snake_case__	  =       beam.io.parquetio.WriteToParquet

											snake_case__	  =       len(get_test_dummy_examples())
											with tempfile.TemporaryDirectory() as tmp_cache_dir:
																		snake_case__	  =       DummyBeamDataset(cache_dir=UpperCamelCase__			,		beam_runner="""DirectRunner""")
																		with patch("""apache_beam.io.parquetio.WriteToParquet""") as write_parquet_mock:
																									snake_case__	  =       partial(UpperCamelCase__			,		num_shards=2)
																									builder.download_and_prepare()
																		self.assertTrue(
																		    os.path.exists(
																		        os.path.join(
																		            UpperCamelCase__			,		builder.name			,		"""default"""			,		"""0.0.0"""			,		F'''{builder.name}-train-00000-of-00002.arrow''')))
																		self.assertTrue(
																		    os.path.exists(
																		        os.path.join(
																		            UpperCamelCase__			,		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""")}))
																		snake_case__	  =       builder.as_dataset()
																		self.assertEqual(dset["""train"""].num_rows			,		UpperCamelCase__)
																		self.assertEqual(dset["""train"""].info.splits["""train"""].num_examples			,		UpperCamelCase__)
																		# 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(UpperCamelCase__			,		builder.name			,		"""default"""			,		"""0.0.0"""			,		"""dataset_info.json""")))
																		del dset



				@require_beam
				def 					__magic_name__							(      self    :    Any):






											'''simple docstring'''







											with tempfile.TemporaryDirectory() as tmp_cache_dir:
																		snake_case__	  =       DummyBeamDataset(cache_dir=UpperCamelCase__)
																		self.assertRaises(datasets.builder.MissingBeamOptions			,		builder.download_and_prepare)



				@require_beam
				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







											snake_case__	  =       len(get_test_nested_examples())
											with tempfile.TemporaryDirectory() as tmp_cache_dir:
																		snake_case__	  =       NestedBeamDataset(cache_dir=UpperCamelCase__			,		beam_runner="""DirectRunner""")
																		builder.download_and_prepare()
																		self.assertTrue(
																		    os.path.exists(
																		        os.path.join(UpperCamelCase__			,		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""")})}))
																		snake_case__	  =       builder.as_dataset()
																		self.assertEqual(dset["""train"""].num_rows			,		UpperCamelCase__)
																		self.assertEqual(dset["""train"""].info.splits["""train"""].num_examples			,		UpperCamelCase__)
																		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(UpperCamelCase__			,		builder.name			,		"""default"""			,		"""0.0.0"""			,		"""dataset_info.json""")))
																		del dset








def _UpperCAmelCase   (	a						:	int = 400_0000 ):
							snake_case__	  =       [0, 1]
							snake_case__	  =       0
							while fib[i] <= n:
														fib.append(fib[i] + fib[i + 1] )
														if fib[i + 2] > n:
																					break
														i += 1
							snake_case__	  =       0
							for j in range(len(a ) - 1 ):
														if fib[j] % 2 == 0:
																					total += fib[j]

							return total


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