

import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


lowercase_									=    500000

lowercase_						,     lowercase_									=    os.path.split(__file__)
lowercase_									=    os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))
@get_duration
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      datasets.Dataset )				-> Optional[Any]:





    '''simple docstring'''






    A__        =  dataset.select(range(0       ,     len(SCREAMING_SNAKE_CASE__ )       ,     2 ) )
@get_duration
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      datasets.Dataset )				-> List[Any]:





    '''simple docstring'''






    A__        =  dataset.sort('numbers' )
@get_duration
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      datasets.Dataset )				-> Tuple:





    '''simple docstring'''






    A__        =  dataset.shuffle()
@get_duration
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      datasets.Dataset )				-> Union[str, Any]:





    '''simple docstring'''






    A__        =  dataset.train_test_split(0.1 )
@get_duration
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      datasets.Dataset       ,     SCREAMING_SNAKE_CASE__     :      Dict=10 )				-> Tuple:





    '''simple docstring'''






    for shard_id in range(SCREAMING_SNAKE_CASE__ ):
        A__        =  dataset.shard(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__ )
def 		_snake_case(       )				-> Any:





    '''simple docstring'''






    A__        =  {'num examples': SPEED_TEST_N_EXAMPLES}
    A__        =  (select, sort, shuffle, train_test_split, shard)
    with tempfile.TemporaryDirectory() as tmp_dir:
        print('generating dataset' )
        A__        =  datasets.Features({'text': datasets.Value('string' ), 'numbers': datasets.Value('float32' )} )
        A__        =  generate_example_dataset(
            os.path.join(SCREAMING_SNAKE_CASE__       ,     'dataset.arrow' )       ,     SCREAMING_SNAKE_CASE__       ,     num_examples=SCREAMING_SNAKE_CASE__ )
        print('Functions' )
        for func in functions:
            print(func.__name__ )
            A__        =  func(SCREAMING_SNAKE_CASE__ )

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


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




import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


lowercase_									=    set()
lowercase_									=    get_logger(__name__)
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      Optional[str] = None )				-> Optional[int]:





    '''simple docstring'''






    def decorator(SCREAMING_SNAKE_CASE__     :      Callable ):
        global _emitted_deprecation_warnings

        if inspect.isclass(SCREAMING_SNAKE_CASE__ ):
            A__        =  deprecated_class_or_function.__init__
            A__        =  deprecated_class_or_function.__name__
        else:
            A__        =  deprecated_class_or_function
            A__        =  deprecated_function.__name__
            # Support deprecating __init__ class method: class name instead
            A__        =  name if name != '__init__' else deprecated_function.__qualname__.split('.' )[-2]

        A__        =  (
            f'{name} is deprecated and will be removed in the next major version of datasets.' + f' {help_message}'
            if help_message
            else ''
        )

        @wraps(SCREAMING_SNAKE_CASE__ )
        def wrapper(*SCREAMING_SNAKE_CASE__     :      Tuple       ,     **SCREAMING_SNAKE_CASE__     :      Any ):
            A__        =  hash(SCREAMING_SNAKE_CASE__ )
            if func_hash not in _emitted_deprecation_warnings:
                warnings.warn(SCREAMING_SNAKE_CASE__       ,     category=SCREAMING_SNAKE_CASE__       ,     stacklevel=2 )
                _emitted_deprecation_warnings.add(SCREAMING_SNAKE_CASE__ )
            return deprecated_function(*SCREAMING_SNAKE_CASE__       ,     **SCREAMING_SNAKE_CASE__ )

        A__        =  'deprecated'

        if inspect.isclass(SCREAMING_SNAKE_CASE__ ):
            A__        =  wrapper
            return deprecated_class_or_function
        else:
            return wrapper

    return decorator


class 					A		(				enum.EnumMeta					):







    """simple docstring"""





    def __getattribute__( cls					:			Optional[Any],lowercase_					:			int						)->       Optional[Any]:





        '''simple docstring'''







        A__        =  super().__getattribute__(lowercase_						)
        if isinstance(lowercase_,enum.Enum						) and obj._on_access:
            obj._on_access()
        return obj


    def __getitem__( cls					:			int,lowercase_					:			Any						)->       Tuple:





        '''simple docstring'''







        A__        =  super().__getitem__(lowercase_						)
        if member._on_access:
            member._on_access()
        return member


    def __call__( cls					:			Optional[int],lowercase_					:			Tuple,lowercase_					:			List[Any]=None,*, lowercase_					:			Any=None,lowercase_					:			Optional[Any]=None,lowercase_					:			Any=None,lowercase_					:			Optional[int]=1						)->       List[str]:





        '''simple docstring'''







        A__        =  super().__call__(lowercase_,lowercase_,module=lowercase_,qualname=lowercase_,type=lowercase_,start=lowercase_						)
        if isinstance(lowercase_,enum.Enum						) and obj._on_access:
            obj._on_access()
        return obj




class 					A		(				enum.Enum       ,				metaclass=_UpperCAmelCase					):







    """simple docstring"""





    def __new__( cls					:			Any,lowercase_					:			str						)->       Any:





        '''simple docstring'''







        A__        =  object.__new__(cls						)
        A__        =  value
        A__        =  member.deprecate
        return member


    @property
    def 		snake_case__	( self					:			List[Any]						)->       List[Any]:





        '''simple docstring'''







        return ""


    def 		snake_case__	( self					:			List[str]						)->       Dict:





        '''simple docstring'''







        A__        =  F' {self.help_message}' if self.help_message else ''
        warnings.warn(
            F'\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'
            + help_message,lowercase_,stacklevel=3,)

