






"""simple docstring"""
from string import ascii_uppercase

lowerCamelCase_							      = {str(ord(c) - 55): c for c in ascii_uppercase}

def 							snake_case (  A__      ,A__		):
			if isinstance(A__      ,A__		):
						raise TypeError("int() can't convert non-string with explicit base"		)
			if num < 0:
						raise ValueError("parameter must be positive int"		)
			if isinstance(A__      ,A__		):
						raise TypeError("'str' object cannot be interpreted as an integer"		)
			if isinstance(A__      ,A__		):
						raise TypeError("'float' object cannot be interpreted as an integer"		)
			if base in (0, 1):
						raise ValueError("base must be >= 2"		)
			if base > 36:
						raise ValueError("base must be <= 36"		)
			UpperCAmelCase_	:					Union[str, Any]     	=   ""
			UpperCAmelCase_	:					List[str]     	=   0
			UpperCAmelCase_	:					List[str]     	=   0
			while div != 1:
						UpperCAmelCase_	,      UpperCAmelCase_	:					List[str]     	=   divmod(A__      ,A__		)
						if base >= 11 and 9 < mod < 36:
									UpperCAmelCase_	:					str     	=   ALPHABET_VALUES[str(A__		)]
						else:
									UpperCAmelCase_	:					Optional[int]     	=   str(A__		)
						new_value += actual_value
						UpperCAmelCase_	:					str     	=   num // base
						UpperCAmelCase_	:					Optional[int]     	=   div
						if div == 0:
									return str(new_value[::-1]		)
						elif div == 1:
									new_value += str(A__		)
									return str(new_value[::-1]		)

			return new_value[::-1]


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			for base in range(2, 37):
						for num in range(1000):
									assert int(decimal_to_any(num, base), base) == num, (
									    num,
									    base,
									    decimal_to_any(num, base),
									    int(decimal_to_any(num, base), base),
									)











"""simple docstring"""
import timeit

import numpy as np

import datasets
from datasets.arrow_writer import ArrowWriter
from datasets.features.features import _ArrayXD

def 							snake_case (  A__		):
			def wrapper(*A__      ,**A__		):
						UpperCAmelCase_	:					Union[str, Any]     	=   timeit.default_timer()
						UpperCAmelCase_	:					Union[str, Any]     	=   func(*A__      ,**A__		)
						UpperCAmelCase_	:					Dict     	=   timeit.default_timer() - starttime
						return delta

			UpperCAmelCase_	:					Optional[Any]     	=   func.__name__

			return wrapper

def 							snake_case (  A__      ,A__=1_00      ,A__=None		):
			UpperCAmelCase_	:					str     	=   []
			UpperCAmelCase_	:					List[str]     	=   seq_shapes or {}
			for i in range(A__		):
						UpperCAmelCase_	:					int     	=   {}
						for col_id, (k, v) in enumerate(features.items()		):
									if isinstance(A__      ,_ArrayXD		):
												UpperCAmelCase_	:					Optional[int]     	=   np.random.rand(*v.shape		).astype(v.dtype		)
									elif isinstance(A__      ,datasets.Value		):
												if v.dtype == "string":
															UpperCAmelCase_	:					List[str]     	=   "The small grey turtle was surprisingly fast when challenged."
												else:
															UpperCAmelCase_	:					List[str]     	=   np.random.randint(10      ,size=1		).astype(v.dtype		).item()
									elif isinstance(A__      ,datasets.Sequence		):
												while isinstance(A__      ,datasets.Sequence		):
															UpperCAmelCase_	:					List[str]     	=   v.feature
												UpperCAmelCase_	:					List[Any]     	=   seq_shapes[k]
												UpperCAmelCase_	:					Dict     	=   np.random.rand(*A__		).astype(v.dtype		)
									UpperCAmelCase_	:					Dict     	=   data

						dummy_data.append((i, example)		)

			return dummy_data




def 							snake_case (  A__      ,A__      ,A__=1_00      ,A__=None		):
			UpperCAmelCase_	:					Optional[Any]     	=   generate_examples(A__      ,num_examples=A__      ,seq_shapes=A__		)

			with ArrowWriter(features=A__      ,path=A__		) as writer:
						for key, record in dummy_data:
									UpperCAmelCase_	:					Any     	=   features.encode_example(A__		)
									writer.write(A__		)

						UpperCAmelCase_	,      UpperCAmelCase_	:					Optional[int]     	=   writer.finalize()

			if not num_final_examples == num_examples:
						raise ValueError(
						    F"""Error writing the dataset, wrote {num_final_examples} examples but should have written {num_examples}."""		)

			UpperCAmelCase_	:					List[Any]     	=   datasets.Dataset.from_file(filename=A__      ,info=datasets.DatasetInfo(features=A__		)		)

			return dataset



