


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





							'''simple docstring'''

							def 		lowerCAmelCase       (				self							:      Any       )					->int:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Union[str, Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Any       )					->Tuple:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      List[str]		,       UpperCAmelCase_							:      str		,       UpperCAmelCase_							:      Union[str, Any]       )					->List[Any]:



														"""simple docstring"""



														import apache_beam as beam

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





class      __A     (datasets.BeamBasedBuilder):





							'''simple docstring'''

							def 		lowerCAmelCase       (				self							:      Union[str, Any]       )					->List[str]:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      List[str]		,       UpperCAmelCase_							:      Dict		,       UpperCAmelCase_							:      Optional[int]       )					->List[Any]:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Any		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      Union[str, Any]       )					->Union[str, Any]:



														"""simple docstring"""



														import apache_beam as beam

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







def 						_a				(      )    ->				Dict:
							return [(i, {"content": content}) for i, content in enumerate(["""foo""", """bar""", """foobar"""]				)]







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





class      __A     (snake_case__):





							'''simple docstring'''

							@require_beam
							def 		lowerCAmelCase       (				self							:      Optional[Any]       )					->List[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 		lowerCAmelCase       (				self							:      List[str]       )					->Optional[int]:



														"""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 		lowerCAmelCase       (				self							:      Dict       )					->Optional[int]:



														"""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 		lowerCAmelCase       (				self							:      Tuple       )					->str:



														"""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







"""simple docstring"""
from __future__ import annotations







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				list[int]:
							snake_case_           =		0
							snake_case_           =		len(_SCREAMING_SNAKE_CASE				) - 1

							while i < j:
														if nums[i] + nums[j] == target:
																					return [i, j]
														elif nums[i] + nums[j] < target:
																					snake_case_           =		i + 1
														else:
																					snake_case_           =		j - 1

							return []


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				print(f"""{two_pointer([2, 7, 11, 15], 9) = }""")



