




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 	UpperCAmelCase_						(			self   :Optional[Any]      )     ->			Union[str, Any]:
       return datasets.DatasetInfo(
           features=datasets.Features({"content": datasets.Value("string"      )}      ) ,      supervised_keys=lowerCamelCase ,      )
      def 	UpperCAmelCase_						(			self   :List[str] ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :Tuple      )     ->			Optional[int]:
       return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,      gen_kwargs={"examples": get_test_dummy_examples()}      )]







      def 	UpperCAmelCase_						(			self   :int ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :Any      )     ->			Union[str, Any]:
       import apache_beam as beam

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



class 			_UpperCamelCase      (				datasets.BeamBasedBuilder		):
      def 	UpperCAmelCase_						(			self   :Tuple      )     ->			str:
       return datasets.DatasetInfo(
           features=datasets.Features({"a": datasets.Sequence({"b": datasets.Value("string"      )}      )}      ) ,      supervised_keys=lowerCamelCase ,      )
      def 	UpperCAmelCase_						(			self   :List[str] ,      lowerCamelCase   :Optional[int] ,      lowerCamelCase   :Union[str, Any]      )     ->			Union[str, Any]:
       return [
           datasets.SplitGenerator(name=datasets.Split.TRAIN ,      gen_kwargs={"examples": get_test_nested_examples()}      )
       ]







      def 	UpperCAmelCase_						(			self   :int ,      lowerCamelCase   :str ,      lowerCamelCase   :str      )     ->			Any:
       import apache_beam as beam

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



def 						lowerCAmelCase		(		):




 """simple docstring"""







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



def 						lowerCAmelCase		(		):




 """simple docstring"""







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


class 			_UpperCamelCase      (				lowerCAmelCase		):
      @require_beam
      def 	UpperCAmelCase_						(			self   :Optional[int]      )     ->			List[Any]:
       UpperCAmelCase__							 =						len(get_test_dummy_examples()      )
       with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCAmelCase__							 =						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"      )}      )      )
        UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :Dict      )     ->			Union[str, Any]:
       import apache_beam as beam

       UpperCAmelCase__							 =						beam.io.parquetio.WriteToParquet

       UpperCAmelCase__							 =						len(get_test_dummy_examples()      )
       with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCAmelCase__							 =						DummyBeamDataset(cache_dir=lowerCamelCase ,      beam_runner="DirectRunner"      )
        with patch("apache_beam.io.parquetio.WriteToParquet"      ) as write_parquet_mock:
         UpperCAmelCase__							 =						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"      )}      )      )
        UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :Any      )     ->			str:
       with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCAmelCase__							 =						DummyBeamDataset(cache_dir=lowerCamelCase      )
        self.assertRaises(datasets.builder.MissingBeamOptions ,      builder.download_and_prepare      )







      @require_beam
      def 	UpperCAmelCase_						(			self   :Dict      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						len(get_test_nested_examples()      )
       with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCAmelCase__							 =						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"      )}      )}      )      )
        UpperCAmelCase__							 =						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











import math



def 						lowerCAmelCase		(		_lowerCAmelCase							:   int	):




 """simple docstring"""







 UpperCAmelCase__							 =						math.loga(math.sqrt(4 * positive_integer + 1	) / 2 + 1 / 2	)

 return exponent == int(_lowerCAmelCase	)



def 						lowerCAmelCase		(		_lowerCAmelCase							:   float = 1 / 1_2345	):




 """simple docstring"""







 UpperCAmelCase__							 =						0
 UpperCAmelCase__							 =						0

 UpperCAmelCase__							 =						3
 while True:
  UpperCAmelCase__							 =						(integer**2 - 1) / 4
  # if candidate is an integer, then there is a partition for k
  if partition_candidate == int(_lowerCAmelCase	):
   UpperCAmelCase__							 =						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() = }''')





