

from __future__ import annotations

from collections.abc import Callable
from typing import Any, Generic, TypeVar

A_ :				Dict						 =    TypeVar('T')



class 					_a		(Generic[T]       ):


					'''simple docstring'''






					def __init__(				self					, A__					, A__    ):
						A__							:					Any | T       =	None

						A__							:					int       =	len(A__    )
						A__							:					list[T]       =	[any_type for _ in range(self.N    )] + arr
						A__							:					Any       =	fnc
						self.build()






					def 						__A    (				self    ):
						for p in range(self.N - 1					, 0					, -1    ):
							A__							:					str       =	self.fn(self.st[p * 2]					, self.st[p * 2 + 1]    )






					def 						__A    (				self					, A__					, A__    ):
						p += self.N
						A__							:					Dict       =	v
						while p > 1:
							A__							:					List[str]       =	p // 2
							A__							:					Dict       =	self.fn(self.st[p * 2]					, self.st[p * 2 + 1]    )






					def 						__A    (				self					, A__					, A__    ):  # noqa: E741
						A__     ,     A__							:					List[Any]       =	l + self.N, r + self.N

						A__							:					T | None       =	None
						while l <= r:
							if l % 2 == 1:
								A__							:					List[str]       =	self.st[l] if res is None else self.fn(A__					, self.st[l]    )
							if r % 2 == 0:
								A__							:					List[str]       =	self.st[r] if res is None else self.fn(A__					, self.st[r]    )
							A__     ,     A__							:					Union[str, Any]       =	(l + 1) // 2, (r - 1) // 2
						return res


if __name__ == "__main__":
	from functools import reduce

	A_ :				Optional[int]						 =    [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12]

	A_ :				List[Any]						 =    {
	    0: 7,
	    1: 2,
	    2: 6,
	    3: -14,
	    4: 5,
	    5: 4,
	    6: 7,
	    7: -10,
	    8: 9,
	    9: 10,
	    10: 12,
	    11: 1,
	}

	A_ :				Dict						 =    SegmentTree(test_array, min)
	A_ :				str						 =    SegmentTree(test_array, max)
	A_ :				str						 =    SegmentTree(test_array, lambda a, b: a + b)

	def 		UpperCamelCase      ()  ->   None:
		for i in range(len(lowercase_      )      ):
			for j in range(lowercase_					,   len(lowercase_      )      ):
				A__							:					List[str]       =	reduce(lowercase_					,   test_array[i : j + 1]      )
				A__							:					Any       =	reduce(lowercase_					,   test_array[i : j + 1]      )
				A__							:					Tuple       =	reduce(lambda lowercase_					,   lowercase_      : a + b					,   test_array[i : j + 1]      )
				assert min_range == min_segment_tree.query(lowercase_					,   lowercase_      )
				assert max_range == max_segment_tree.query(lowercase_					,   lowercase_      )
				assert sum_range == sum_segment_tree.query(lowercase_					,   lowercase_      )

	test_all_segments()

	for index, value in test_updates.items():
		A_ :				Optional[int]						 =    value
		min_segment_tree.update(index, value)
		max_segment_tree.update(index, value)
		sum_segment_tree.update(index, value)
		test_all_segments()






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    ):
						return datasets.DatasetInfo(
						    features=datasets.Features({"""content""": datasets.Value("""string"""    )}    )					, supervised_keys=A__					, )






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






					def 						__A    (				self					, A__					, A__    ):
						import apache_beam as beam

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



class 					_a		(datasets.BeamBasedBuilder       ):


					'''simple docstring'''






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






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






					def 						__A    (				self					, A__					, A__    ):
						import apache_beam as beam

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



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

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



class 					_a		(__magic_name__       ):


					'''simple docstring'''






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






					@require_beam
					def 						__A    (				self    ):
						import apache_beam as beam

						A__							:					int       =	beam.io.parquetio.WriteToParquet

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






					@require_beam
					def 						__A    (				self    ):
						with tempfile.TemporaryDirectory() as tmp_cache_dir:
							A__							:					int       =	DummyBeamDataset(cache_dir=A__    )
							self.assertRaises(datasets.builder.MissingBeamOptions					, builder.download_and_prepare    )






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



