





import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs







@pytest.mark.parametrize(
    """kwargs, expected"""   ,					[
        ({"""num_shards""": 0, """max_num_jobs""": 1}, []),
        ({"""num_shards""": 1_0, """max_num_jobs""": 1}, [range(1_0   )]),
        ({"""num_shards""": 1_0, """max_num_jobs""": 1_0}, [range(__a   ,					i + 1   ) for i in range(1_0   )]),
        ({"""num_shards""": 1, """max_num_jobs""": 1_0}, [range(1   )]),
        ({"""num_shards""": 1_0, """max_num_jobs""": 3}, [range(0   ,					4   ), range(4   ,					7   ), range(7   ,					1_0   )]),
        ({"""num_shards""": 3, """max_num_jobs""": 1_0}, [range(0   ,					1   ), range(1   ,					2   ), range(2   ,					3   )]),
    ]   ,					)
def        __lowerCamelCase (							__a       :int   ,					__a       :Dict   )		->    Union[str, Any]:






		"""simple docstring"""

		A__  				=       _distribute_shards(**__a   )
		assert out == expected







@pytest.mark.parametrize(
    """gen_kwargs, max_num_jobs, expected"""   ,					[
        ({"""foo""": 0}, 1_0, [{"""foo""": 0}]),
        ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]),
        ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]),
        ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]),
        ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]),
    ]   ,					)
def        __lowerCamelCase (							__a       :Optional[int]   ,					__a       :int   ,					__a       :str   )		->    Tuple:






		"""simple docstring"""

		A__  				=       _split_gen_kwargs(__a   ,					__a   )
		assert out == expected







@pytest.mark.parametrize(
    """gen_kwargs, expected"""   ,					[
        ({"""foo""": 0}, 1),
        ({"""shards""": [0]}, 1),
        ({"""shards""": [0, 1, 2, 3]}, 4),
        ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4),
        ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4),
        ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError),
    ]   ,					)
def        __lowerCamelCase (							__a       :Optional[int]   ,					__a       :List[str]   )		->    Union[str, Any]:






		"""simple docstring"""

		if expected is RuntimeError:
				with pytest.raises(__a   ):
						_number_of_shards_in_gen_kwargs(__a   )
		else:
				A__  				=       _number_of_shards_in_gen_kwargs(__a   )
				assert out == expected










from typing import List, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A   : Optional[Any]			=				logging.get_logger(__name__)

A   : List[str]			=				{
    '''huggingface/time-series-transformer-tourism-monthly''': (
        '''https://huggingface.co/huggingface/time-series-transformer-tourism-monthly/resolve/main/config.json'''
    ),
    # See all TimeSeriesTransformer models at https://huggingface.co/models?filter=time_series_transformer
}


class   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	Any          =   '''time_series_transformer'''
			__lowerCamelCase     :	Dict          =   {
			    '''hidden_size''': '''d_model''',
			    '''num_attention_heads''': '''encoder_attention_heads''',
			    '''num_hidden_layers''': '''encoder_layers''',
			}






			def __init__(      self       :   Union[str, Any]							,     __lowerCAmelCase       :   Optional[int] = None							,     __lowerCAmelCase       :   Optional[int] = None							,     __lowerCAmelCase       :   str = "student_t"							,     __lowerCAmelCase       :   str = "nll"							,     __lowerCAmelCase       :   int = 1							,     __lowerCAmelCase       :   List[int] = [1, 2, 3, 4, 5, 6, 7]							,     __lowerCAmelCase       :   Optional[Union[str, bool]] = "mean"							,     __lowerCAmelCase       :   int = 0							,     __lowerCAmelCase       :   int = 0							,     __lowerCAmelCase       :   int = 0							,     __lowerCAmelCase       :   int = 0							,     __lowerCAmelCase       :   Optional[List[int]] = None							,     __lowerCAmelCase       :   Optional[List[int]] = None							,     __lowerCAmelCase       :   int = 32							,     __lowerCAmelCase       :   int = 32							,     __lowerCAmelCase       :   int = 2							,     __lowerCAmelCase       :   int = 2							,     __lowerCAmelCase       :   int = 2							,     __lowerCAmelCase       :   int = 2							,     __lowerCAmelCase       :   bool = True							,     __lowerCAmelCase       :   str = "gelu"							,     __lowerCAmelCase       :   int = 64							,     __lowerCAmelCase       :   float = 0.1							,     __lowerCAmelCase       :   float = 0.1							,     __lowerCAmelCase       :   float = 0.1							,     __lowerCAmelCase       :   float = 0.1							,     __lowerCAmelCase       :   float = 0.1							,     __lowerCAmelCase       :   int = 1_00							,     __lowerCAmelCase       :   float = 0.0_2							,     __lowerCAmelCase       :   Optional[Any]=True							,     **__lowerCAmelCase       :   Union[str, Any]							,     )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       prediction_length
					A__  				=       context_length or prediction_length
					A__  				=       distribution_output
					A__  				=       loss
					A__  				=       input_size
					A__  				=       num_time_features
					A__  				=       lags_sequence
					A__  				=       scaling
					A__  				=       num_dynamic_real_features
					A__  				=       num_static_real_features
					A__  				=       num_static_categorical_features
					if cardinality and num_static_categorical_features > 0:
							if len(__lowerCAmelCase       ) != num_static_categorical_features:
									raise ValueError(
									    """The cardinality should be a list of the same length as `num_static_categorical_features`"""       )
							A__  				=       cardinality
					else:
							A__  				=       [0]
					if embedding_dimension and num_static_categorical_features > 0:
							if len(__lowerCAmelCase       ) != num_static_categorical_features:
									raise ValueError(
									    """The embedding dimension should be a list of the same length as `num_static_categorical_features`"""       )
							A__  				=       embedding_dimension
					else:
							A__  				=       [min(50							,     (cat + 1) // 2       ) for cat in self.cardinality]
					A__  				=       num_parallel_samples

					# Transformer architecture configuration
					A__  				=       input_size * len(__lowerCAmelCase       ) + self._number_of_features
					A__  				=       d_model
					A__  				=       encoder_attention_heads
					A__  				=       decoder_attention_heads
					A__  				=       encoder_ffn_dim
					A__  				=       decoder_ffn_dim
					A__  				=       encoder_layers
					A__  				=       decoder_layers

					A__  				=       dropout
					A__  				=       attention_dropout
					A__  				=       activation_dropout
					A__  				=       encoder_layerdrop
					A__  				=       decoder_layerdrop

					A__  				=       activation_function
					A__  				=       init_std

					A__  				=       use_cache

					super().__init__(is_encoder_decoder=__lowerCAmelCase							,     **__lowerCAmelCase       )







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







					"""simple docstring"""






					return (
					    sum(self.embedding_dimension       )
					    + self.num_dynamic_real_features
					    + self.num_time_features
					    + self.num_static_real_features
					    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
					)



