"""simple docstring"""




from math import sqrt






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    number >= 0
							), "'number' must been an int and positive"

							A__		   =							True

							# 0 and 1 are none primes.
							if number <= 1:
														A__		   =							False

							for divisor in range(2				,			int(round(sqrt(UpperCamelCase__ ) ) ) + 1 ):
														# if 'number' divisible by 'divisor' then sets 'status'
														# of false and break up the loop.
														if number % divisor == 0:
																					A__		   =							False
																					break

    # precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'status' must been from type bool"

							return status






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n > 2), "'N' must been an int and > 2"

							# beginList: contains all natural numbers from 2 up to N
							A__		   =							list(range(2				,			n + 1 ) )

							A__		   =							[]  # this list will be returns.

							# actual sieve of erathostenes
							for i in range(len(UpperCamelCase__ ) ):
														for j in range(i + 1				,			len(UpperCamelCase__ ) ):
																					if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
																												A__		   =							0

    # filters actual prime numbers.
							A__		   =							[x for x in begin_list if x != 0]

							# precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'ans' must been from type list"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n > 2), "'N' must been an int and > 2"

							A__		   =							[]

							# iterates over all numbers between 2 up to N+1
							# if a number is prime then appends to list 'ans'
							for number in range(2				,			n + 1 ):
														if is_prime(UpperCamelCase__ ):
																					ans.append(UpperCamelCase__ )

    # precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'ans' must been from type list"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and number >= 0, "'number' must been an int and >= 0"

							A__		   =							[]  # this list will be returns of the function.

							# potential prime number factors.

							A__		   =							2

							A__		   =							number

							if number == 0 or number == 1:
														ans.append(UpperCamelCase__ )

							# if 'number' not prime then builds the prime factorization of 'number'
							elif not is_prime(UpperCamelCase__ ):
														while quotient != 1:
																					if is_prime(UpperCamelCase__ ) and (quotient % factor == 0):
																												ans.append(UpperCamelCase__ )
																												quotient /= factor
																					else:
																												factor += 1

							else:
														ans.append(UpperCamelCase__ )

							# precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'ans' must been from type list"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    number >= 0
							), "'number' bust been an int and >= 0"

							A__		   =							0

							# prime factorization of 'number'
							A__		   =							prime_factorization(UpperCamelCase__ )

							A__		   =							max(UpperCamelCase__ )

							# precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'ans' must been from type int"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    number >= 0
							), "'number' bust been an int and >= 0"

							A__		   =							0

							# prime factorization of 'number'
							A__		   =							prime_factorization(UpperCamelCase__ )

							A__		   =							min(UpperCamelCase__ )

							# precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'ans' must been from type int"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'number' must been an int"
							assert isinstance(number % 2 == 0				,			UpperCamelCase__ ), "compare bust been from type bool"

							return number % 2 == 0






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ), "'number' must been an int"
							assert isinstance(number % 2 != 0				,			UpperCamelCase__ ), "compare bust been from type bool"

							return number % 2 != 0






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (number > 2) and is_even(UpperCamelCase__ )
							), "'number' must been an int, even and > 2"

							A__		   =							[]  # this list will returned

							# creates a list of prime numbers between 2 up to 'number'
							A__		   =							get_prime_numbers(UpperCamelCase__ )
							A__		   =							len(UpperCamelCase__ )

							# run variable for while-loops.
							A__		   =							0
							A__		   =							None

							# exit variable. for break up the loops
							A__		   =							True

							while i < len_pn and loop:
														A__		   =							i + 1

														while j < len_pn and loop:
																					if prime_numbers[i] + prime_numbers[j] == number:
																												A__		   =							False
																												ans.append(prime_numbers[i] )
																												ans.append(prime_numbers[j] )

																					j += 1

														i += 1

							# precondition
							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (len(UpperCamelCase__ ) == 2)
							    and (ans[0] + ans[1] == number)
							    and is_prime(ans[0] )
							    and is_prime(ans[1] )
							), "'ans' must contains two primes. And sum of elements must been eq 'number'"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__				,			UpperCamelCase__ ):






							"""simple docstring"""





							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (numbera >= 0)
							    and (numbera >= 0)
							), "'number1' and 'number2' must been positive integer."

							A__		   =							0

							while numbera != 0:
														A__		   =							numbera % numbera
														A__		   =							numbera
														A__		   =							rest

							# precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    numbera >= 0
							), "'number' must been from type int and positive"

							return numbera






def      UpperCAmelCase    (		UpperCamelCase__				,			UpperCamelCase__ ):






							"""simple docstring"""





							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (numbera >= 1)
							    and (numbera >= 1)
							), "'number1' and 'number2' must been positive integer."

							A__		   =							1  # actual answer that will be return.

							# for kgV (x,1)
							if numbera > 1 and numbera > 1:
														# builds the prime factorization of 'number1' and 'number2'
														A__		   =							prime_factorization(UpperCamelCase__ )
														A__		   =							prime_factorization(UpperCamelCase__ )

							elif numbera == 1 or numbera == 1:
														A__		   =							[]
														A__		   =							[]
														A__		   =							max(UpperCamelCase__				,			UpperCamelCase__ )

							A__		   =							0
							A__		   =							0

							A__		   =							[]  # captured numbers int both 'primeFac1' and 'primeFac2'

							# iterates through primeFac1
							for n in prime_fac_a:
														if n not in done:
																					if n in prime_fac_a:
																												A__		   =							prime_fac_a.count(UpperCamelCase__ )
																												A__		   =							prime_fac_a.count(UpperCamelCase__ )

																												for _ in range(max(UpperCamelCase__				,			UpperCamelCase__ ) ):
																																			ans *= n

																					else:
																												A__		   =							prime_fac_a.count(UpperCamelCase__ )

																												for _ in range(UpperCamelCase__ ):
																																			ans *= n

																					done.append(UpperCamelCase__ )

    # iterates through primeFac2
							for n in prime_fac_a:
														if n not in done:
																					A__		   =							prime_fac_a.count(UpperCamelCase__ )

																					for _ in range(UpperCamelCase__ ):
																												ans *= n

																					done.append(UpperCamelCase__ )

    # precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    ans >= 0
							), "'ans' must been from type int and positive"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n >= 0), "'number' must been a positive int"

							A__		   =							0
							A__		   =							2  # this variable holds the answer

							while index < n:
														index += 1

														ans += 1  # counts to the next number

														# if ans not prime then
														# runs to the next prime number.
														while not is_prime(UpperCamelCase__ ):
																					ans += 1

    # precondition
							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and is_prime(
							    UpperCamelCase__ ), "'ans' must been a prime number and from type int"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__				,			UpperCamelCase__ ):






							"""simple docstring"""





							assert (
							    is_prime(UpperCamelCase__ ) and is_prime(UpperCamelCase__ ) and (p_number_a < p_number_a)
							), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

							A__		   =							p_number_a + 1  # jump to the next number

							A__		   =							[]  # this list will be returns.

							# if number is not prime then
							# fetch the next prime number.
							while not is_prime(UpperCamelCase__ ):
														number += 1

							while number < p_number_a:
														ans.append(UpperCamelCase__ )

														number += 1

														# fetch the next prime number.
														while not is_prime(UpperCamelCase__ ):
																					number += 1

    # precondition
							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and ans[0] != p_number_a
							    and ans[len(UpperCamelCase__ ) - 1] != p_number_a
							), "'ans' must been a list without the arguments"

							# 'ans' contains not 'pNumber1' and 'pNumber2' !
							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n >= 1), "'n' must been int and >= 1"

							A__		   =							[]  # will be returned.

							for divisor in range(1				,			n + 1 ):
														if n % divisor == 0:
																					ans.append(UpperCamelCase__ )

    # precondition
							assert ans[0] == 1 and ans[len(UpperCamelCase__ ) - 1] == n, "Error in function getDivisiors(...)"

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (
							    number > 1
							), "'number' must been an int and >= 1"

							A__		   =							get_divisors(UpperCamelCase__ )

							# precondition
							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (divisors[0] == 1)
							    and (divisors[len(UpperCamelCase__ ) - 1] == number)
							), "Error in help-function getDivisiors(...)"

							# summed all divisors up to 'number' (exclusive), hence [:-1]
							return sum(divisors[:-1] ) == number






def      UpperCAmelCase    (		UpperCamelCase__				,			UpperCamelCase__ ):






							"""simple docstring"""





							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (denominator != 0)
							), "The arguments must been from type int and 'denominator' != 0"

							# build the greatest common divisor of numerator and denominator.
							A__		   =							gcd(abs(UpperCamelCase__ )				,			abs(UpperCamelCase__ ) )

							# precondition
							assert (
							    isinstance(UpperCamelCase__				,			UpperCamelCase__ )
							    and (numerator % gcd_of_fraction == 0)
							    and (denominator % gcd_of_fraction == 0)
							), "Error in function gcd(...,...)"

							return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n >= 0), "'n' must been a int and >= 0"

							A__		   =							1  # this will be return.

							for factor in range(1				,			n + 1 ):
														ans *= factor

							return ans






def      UpperCAmelCase    (		UpperCamelCase__ ):






							"""simple docstring"""





							assert isinstance(UpperCamelCase__				,			UpperCamelCase__ ) and (n >= 0), "'n' must been an int and >= 0"

							A__		   =							0
							A__		   =							1
							A__		   =							1  # this will be return

							for _ in range(n - 1 ):
														A__		   =							ans
														ans += fiba
														A__		   =							tmp

							return ans






"""simple docstring"""




from typing import List, Optional, Union

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


__lowerCamelCase							 =     logging.get_logger(__name__)

__lowerCamelCase							 =     {
    "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 			UpperCamelCase__(	__A       ):
						lowerCAmelCase__     :  List[Any]  							=						'time_series_transformer'
						lowerCAmelCase__     :  Dict  							=						{
						    'hidden_size': 'd_model',
						    'num_attention_heads': 'encoder_attention_heads',
						    'num_hidden_layers': 'encoder_layers',
						}





						def __init__(				self						,__UpperCAmelCase = None						,__UpperCAmelCase = None						,__UpperCAmelCase = "student_t"						,__UpperCAmelCase = "nll"						,__UpperCAmelCase = 1						,__UpperCAmelCase = [1, 2, 3, 4, 5, 6, 7]						,__UpperCAmelCase = "mean"						,__UpperCAmelCase = 0						,__UpperCAmelCase = 0						,__UpperCAmelCase = 0						,__UpperCAmelCase = 0						,__UpperCAmelCase = None						,__UpperCAmelCase = None						,__UpperCAmelCase = 32						,__UpperCAmelCase = 32						,__UpperCAmelCase = 2						,__UpperCAmelCase = 2						,__UpperCAmelCase = 2						,__UpperCAmelCase = 2						,__UpperCAmelCase = True						,__UpperCAmelCase = "gelu"						,__UpperCAmelCase = 64						,__UpperCAmelCase = 0.1						,__UpperCAmelCase = 0.1						,__UpperCAmelCase = 0.1						,__UpperCAmelCase = 0.1						,__UpperCAmelCase = 0.1						,__UpperCAmelCase = 1_00						,__UpperCAmelCase = 0.0_2						,__UpperCAmelCase=True						,**__UpperCAmelCase						,)    -> List[str]:
													# time series specific configuration
													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(__UpperCAmelCase   ) != 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(__UpperCAmelCase   ) != 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(__UpperCAmelCase   ) + 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=__UpperCAmelCase						,**__UpperCAmelCase   )





						@property
						def  snake_case__		(				self   )    -> int:
													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
													)





