





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     A     (datasets.BeamBasedBuilder       ):
			'''simple docstring'''




			def   a_			(     self  :       List[Any]  )      ->      str:







					"""simple docstring"""






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






			def   a_			(     self  :       List[Any]				,      __lowerCAmelCase  :       List[str]				,      __lowerCAmelCase  :       Union[str, Any]  )      ->      Optional[int]:







					"""simple docstring"""






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







			def   a_			(     self  :       Tuple				,      __lowerCAmelCase  :       str				,      __lowerCAmelCase  :       List[Any]  )      ->      Union[str, Any]:







					"""simple docstring"""






					import apache_beam as beam

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


class     A     (datasets.BeamBasedBuilder       ):
			'''simple docstring'''




			def   a_			(     self  :       Dict  )      ->      List[str]:







					"""simple docstring"""






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






			def   a_			(     self  :       List[Any]				,      __lowerCAmelCase  :       Union[str, Any]				,      __lowerCAmelCase  :       Optional[int]  )      ->      Any:







					"""simple docstring"""






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







			def   a_			(     self  :       List[Any]				,      __lowerCAmelCase  :       List[Any]				,      __lowerCAmelCase  :       Optional[int]  )      ->      Optional[Any]:







					"""simple docstring"""






					import apache_beam as beam

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







def   __lowerCamelCase   (				)						->							Optional[Any]:






		"""simple docstring"""

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







def   __lowerCamelCase   (				)						->							int:






		"""simple docstring"""

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






class     A     (SCREAMING_SNAKE_CASE       ):
			'''simple docstring'''




			@require_beam
			def   a_			(     self  :       List[str]  )      ->      Tuple:







					"""simple docstring"""






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






			@require_beam
			def   a_			(     self  :       Dict  )      ->      Dict:







					"""simple docstring"""






					import apache_beam as beam

					A__     =  beam.io.parquetio.WriteToParquet

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






			@require_beam
			def   a_			(     self  :       Tuple  )      ->      Tuple:







					"""simple docstring"""






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







			@require_beam
			def   a_			(     self  :       Optional[Any]  )      ->      int:







					"""simple docstring"""






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










def   __lowerCamelCase   (				__a  :str       )						->							bool:






		"""simple docstring"""

		A__     =  0
		for ch in input_str:
				A__     =  ord(__a       )
				A__     =  pow(2       ,	__a       )

				# If we already turned on bit for current character's unicode
				if bitmap >> ch_unicode & 1 == 1:
						return False
				bitmap |= ch_bit_index_on
		return True


if __name__ == "__main__":
					import doctest

					doctest.testmod()



