






'''simple docstring'''

import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


UpperCAmelCase__						:Optional[int]          =			50_000
UpperCAmelCase__						:Any          =			5_000

UpperCAmelCase__       ,				UpperCAmelCase__						:Optional[Any]          =			os.path.split(__file__)
UpperCAmelCase__						:Union[str, Any]          =			os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json"""))
@get_duration
def     __lowercase  (_lowercase,						_lowercase     )   ->     List[str]:


     """simple docstring"""
     for i in range(_lowercase     ):
          __lowerCamelCase						:       List[Any]				   =				dataset[i]
@get_duration
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     Dict:


     """simple docstring"""
     for i in range(0,						len(_lowercase     ),						_lowercase     ):
          __lowerCamelCase						:       List[Any]				   =				dataset[i : i + batch_size]
@get_duration
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     List[str]:


     """simple docstring"""
     with dataset.formatted_as(type=_lowercase     ):
          for i in range(_lowercase     ):
               __lowerCamelCase						:       Dict				   =				dataset[i]
@get_duration
def     __lowercase  (_lowercase,						_lowercase,						_lowercase,						_lowercase     )   ->     Optional[int]:


     """simple docstring"""
     with dataset.formatted_as(type=_lowercase     ):
          for i in range(0,						_lowercase,						_lowercase     ):
               __lowerCamelCase						:       Optional[int]				   =				dataset[i : i + batch_size]
def     __lowercase  ()   ->     List[Any]:


     """simple docstring"""
     __lowerCamelCase						:       int				   =				{"""num examples""": SPEED_TEST_N_EXAMPLES}
     __lowerCamelCase						:       List[str]				   =				[
         (read, {"""length""": SMALL_TEST}),
         (read, {"""length""": SPEED_TEST_N_EXAMPLES}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 10}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 100}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_000}),
         (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}),
         (read_formatted, {"""type""": """pandas""", """length""": SMALL_TEST}),
         (read_formatted, {"""type""": """torch""", """length""": SMALL_TEST}),
         (read_formatted, {"""type""": """tensorflow""", """length""": SMALL_TEST}),
         (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 10}),
         (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_000}),
     ]

     __lowerCamelCase						:       Tuple				   =				[
         (read, {"""length""": SMALL_TEST}),
         (read, {"""length""": SPEED_TEST_N_EXAMPLES}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 10}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 100}),
         (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_000}),
         (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}),
         (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 10}),
         (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_000}),
     ]
     with tempfile.TemporaryDirectory() as tmp_dir:
          print("""generating dataset"""     )
          __lowerCamelCase						:       List[Any]				   =				datasets.Features(
              {"""list""": datasets.Sequence(datasets.Value("""float32"""     )     ), """numbers""": datasets.Value("""float32"""     )}     )
          __lowerCamelCase						:       Union[str, Any]				   =				generate_example_dataset(
              os.path.join(_lowercase,						"""dataset.arrow"""     ),						_lowercase,						num_examples=_lowercase,						seq_shapes={"""list""": (100,)},						)
          print("""first set of iterations"""     )
          for func, kwargs in functions:
               print(func.__name__,						str(_lowercase     )     )
               __lowerCamelCase						:       List[Any]				   =				func(_lowercase,						**_lowercase     )

          print("""shuffling dataset"""     )
          __lowerCamelCase						:       str				   =				dataset.shuffle()
          print("""Second set of iterations (after shuffling"""     )
          for func, kwargs in functions_shuffled:
               print("""shuffled """,						func.__name__,						str(_lowercase     )     )
               __lowerCamelCase						:       Optional[int]				   =				func(
                   _lowercase,						**_lowercase     )

     with open(_lowercase,						"""wb"""     ) as f:
          f.write(json.dumps(_lowercase     ).encode("""utf-8"""     )     )


if __name__ == "__main__":  # useful to run the profiler
   benchmark_iterating()











'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive"""     )

     # get the generated string sequence
     __lowerCamelCase						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

     if bit_count == 1:
          return ["0", "1"]

     __lowerCamelCase						:       str				   =				1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     __lowerCamelCase						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2     )     ):
          __lowerCamelCase						:       Optional[Any]				   =				"""1""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



