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



    def   lowerCamelCase_  (	self      :       Optional[Any]     ):
          return datasets.DatasetInfo(
              features=datasets.Features({"content": datasets.Value("string"     )}     ),supervised_keys=UpperCamelCase__,)



    def   lowerCamelCase_  (	self      :       Dict,__A      :       Optional[int],__A      :       Optional[Any]     ):
          return [datasets.SplitGenerator(name=datasets.Split.TRAIN,gen_kwargs={"examples": get_test_dummy_examples()}     )]



    def   lowerCamelCase_  (	self      :       Optional[Any],__A      :       int,__A      :       Dict     ):
          import apache_beam as beam

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


class  UpperCAmelCase__						(       datasets.BeamBasedBuilder ):



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



    def   lowerCamelCase_  (	self      :       str,__A      :       List[Any],__A      :       Dict     ):
          return [
              datasets.SplitGenerator(name=datasets.Split.TRAIN,gen_kwargs={"examples": get_test_nested_examples()}     )
          ]



    def   lowerCamelCase_  (	self      :       Union[str, Any],__A      :       Tuple,__A      :       str     ):
          import apache_beam as beam

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







def 		A_       (	):



      """simple docstring"""




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







def 		A_       (	):



      """simple docstring"""




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



class  UpperCAmelCase__						(       lowercase_ ):



    @require_beam
    def   lowerCamelCase_  (	self      :       Any     ):
          _lowerCamelCase				:   int								=   len(get_test_dummy_examples()     )
          with tempfile.TemporaryDirectory() as tmp_cache_dir:
                _lowerCamelCase				:   Tuple								=   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"     )}     )     )
                _lowerCamelCase				:   List[str]								=   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      :       Dict     ):
          import apache_beam as beam

          _lowerCamelCase				:   Any								=   beam.io.parquetio.WriteToParquet

          _lowerCamelCase				:   str								=   len(get_test_dummy_examples()     )
          with tempfile.TemporaryDirectory() as tmp_cache_dir:
                _lowerCamelCase				:   Dict								=   DummyBeamDataset(cache_dir=UpperCamelCase__,beam_runner="DirectRunner"     )
                with patch("apache_beam.io.parquetio.WriteToParquet"     ) as write_parquet_mock:
                      _lowerCamelCase				:   List[str]								=   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"     )}     )     )
                _lowerCamelCase				:   List[str]								=   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      :       Any     ):







          with tempfile.TemporaryDirectory() as tmp_cache_dir:
                _lowerCamelCase				:   List[Any]								=   DummyBeamDataset(cache_dir=UpperCamelCase__     )
                self.assertRaises(datasets.builder.MissingBeamOptions,builder.download_and_prepare     )



    @require_beam
    def   lowerCamelCase_  (	self      :       int     ):
          _lowerCamelCase				:   Union[str, Any]								=   len(get_test_nested_examples()     )
          with tempfile.TemporaryDirectory() as tmp_cache_dir:
                _lowerCamelCase				:   Optional[Any]								=   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"     )}     )}     )     )
                _lowerCamelCase				:   List[str]								=   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'''






import math







def 		A_       (	_lowerCAmelCase   :    int							):



      """simple docstring"""




      _lowerCamelCase				:   Optional[int]								=   math.loga(math.sqrt(4 * positive_integer + 1							) / 2 + 1 / 2							)

      return exponent == int(_lowerCAmelCase							)







def 		A_       (	_lowerCAmelCase   :    float = 1 / 12345							):



      """simple docstring"""




      _lowerCamelCase				:   Optional[int]								=   0
      _lowerCamelCase				:   int								=   0

      _lowerCamelCase				:   List[str]								=   3
      while True:
            _lowerCamelCase				:   List[Any]								=   (integer**2 - 1) / 4
            # if candidate is an integer, then there is a partition for k
            if partition_candidate == int(_lowerCAmelCase							):
                  _lowerCamelCase				:   Any								=   int(_lowerCAmelCase							)
                  total_partitions += 1
                  if check_partition_perfect(_lowerCAmelCase							):
                        perfect_partitions += 1
            if perfect_partitions > 0:
                  if perfect_partitions / total_partitions < max_proportion:
                        return int(_lowerCAmelCase							)
            integer += 1


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