


"""simple docstring"""



from typing import List, Optional, Union

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


__snake_case   			=    logging.get_logger(__name__)

__snake_case   			=    {
    """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 _lowerCAmelCase				(      snake_case_	):
   __UpperCAmelCase :       List[str]							  =  '''time_series_transformer'''
   __UpperCAmelCase :       Optional[Any]							  =  {
       '''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__ = 100						,	UpperCamelCase__ = 0.02						,	UpperCamelCase__=True						,	**UpperCamelCase__						,	)	->		List[str]:

       '''simple docstring'''




       snake_case    :      int      					=    prediction_length
       snake_case    :      Tuple      					=    context_length or prediction_length
       snake_case    :      Optional[int]      					=    distribution_output
       snake_case    :      List[Any]      					=    loss
       snake_case    :      Optional[int]      					=    input_size
       snake_case    :      Optional[Any]      					=    num_time_features
       snake_case    :      int      					=    lags_sequence
       snake_case    :      Optional[Any]      					=    scaling
       snake_case    :      List[str]      					=    num_dynamic_real_features
       snake_case    :      List[str]      					=    num_static_real_features
       snake_case    :      Dict      					=    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`"						)
           snake_case    :      Optional[int]      					=    cardinality
       else:
           snake_case    :      Dict      					=    [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`"						)
           snake_case    :      Optional[int]      					=    embedding_dimension
       else:
           snake_case    :      Union[str, Any]      					=    [min(50						,	(cat + 1) // 2						) for cat in self.cardinality]
       snake_case    :      List[str]      					=    num_parallel_samples

       # Transformer architecture configuration
       snake_case    :      List[str]      					=    input_size * len(UpperCamelCase__						) + self._number_of_features
       snake_case    :      Union[str, Any]      					=    d_model
       snake_case    :      Any      					=    encoder_attention_heads
       snake_case    :      str      					=    decoder_attention_heads
       snake_case    :      Any      					=    encoder_ffn_dim
       snake_case    :      List[Any]      					=    decoder_ffn_dim
       snake_case    :      Optional[int]      					=    encoder_layers
       snake_case    :      List[str]      					=    decoder_layers

       snake_case    :      List[str]      					=    dropout
       snake_case    :      Union[str, Any]      					=    attention_dropout
       snake_case    :      Optional[Any]      					=    activation_dropout
       snake_case    :      List[Any]      					=    encoder_layerdrop
       snake_case    :      Optional[int]      					=    decoder_layerdrop

       snake_case    :      int      					=    activation_function
       snake_case    :      int      					=    init_std

       snake_case    :      str      					=    use_cache

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







   @property
   def  lowerCamelCase		(	self						)	->		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
       )









"""simple docstring"""



import json
import os
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from requests.exceptions import HTTPError

from transformers.utils import (
    CONFIG_NAME,
    FLAX_WEIGHTS_NAME,
    TF2_WEIGHTS_NAME,
    TRANSFORMERS_CACHE,
    WEIGHTS_NAME,
    cached_file,
    get_file_from_repo,
    has_file,
)


__snake_case   			=    """hf-internal-testing/tiny-random-bert"""
__snake_case   			=    os.path.join(TRANSFORMERS_CACHE, """models--hf-internal-testing--tiny-random-bert""")
__snake_case   			=    """9b8c223d42b2188cb49d29af482996f9d0f3e5a6"""







class _lowerCAmelCase				(      unittest.TestCase	):







   def  lowerCamelCase		(	self						)	->		str:

       '''simple docstring'''




       snake_case    :      int      					=    cached_file(UpperCamelCase__						,	UpperCamelCase__						)
       # Should have downloaded the file in here
       self.assertTrue(os.path.isdir(UpperCamelCase__						)						)
       # Cache should contain at least those three subfolders:
       for subfolder in ["blobs", "refs", "snapshots"]:
           self.assertTrue(os.path.isdir(os.path.join(UpperCamelCase__						,	UpperCamelCase__						)						)						)
       with open(os.path.join(UpperCamelCase__						,	"refs"						,	"main"						)						) as f:
           snake_case    :      Dict      					=    f.read()
       self.assertEqual(UpperCamelCase__						,	os.path.join(UpperCamelCase__						,	"snapshots"						,	UpperCamelCase__						,	UpperCamelCase__						)						)
       self.assertTrue(os.path.isfile(UpperCamelCase__						)						)

       # File is cached at the same place the second time.
       snake_case    :      List[str]      					=    cached_file(UpperCamelCase__						,	UpperCamelCase__						)
       self.assertEqual(UpperCamelCase__						,	UpperCamelCase__						)

       # Using a specific revision to test the full commit hash.
       snake_case    :      Any      					=    cached_file(UpperCamelCase__						,	UpperCamelCase__						,	revision="9b8c223"						)
       self.assertEqual(UpperCamelCase__						,	os.path.join(UpperCamelCase__						,	"snapshots"						,	UpperCamelCase__						,	UpperCamelCase__						)						)







   def  lowerCamelCase		(	self						)	->		Any:

       '''simple docstring'''




       with self.assertRaisesRegex(UpperCamelCase__						,	"is not a valid model identifier"						):
           snake_case    :      Optional[Any]      					=    cached_file("tiny-random-bert"						,	UpperCamelCase__						)

       with self.assertRaisesRegex(UpperCamelCase__						,	"is not a valid git identifier"						):
           snake_case    :      Optional[Any]      					=    cached_file(UpperCamelCase__						,	UpperCamelCase__						,	revision="aaaa"						)

       with self.assertRaisesRegex(UpperCamelCase__						,	"does not appear to have a file named"						):
           snake_case    :      List[Any]      					=    cached_file(UpperCamelCase__						,	"conf"						)







   def  lowerCamelCase		(	self						)	->		Tuple:

       '''simple docstring'''




       with self.assertRaisesRegex(UpperCamelCase__						,	"does not appear to have a file named"						):
           snake_case    :      Tuple      					=    cached_file(UpperCamelCase__						,	"conf"						)

       with open(os.path.join(UpperCamelCase__						,	"refs"						,	"main"						)						) as f:
           snake_case    :      Any      					=    f.read()
       self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__						,	".no_exist"						,	UpperCamelCase__						,	"conf"						)						)						)

       snake_case    :      Optional[Any]      					=    cached_file(UpperCamelCase__						,	"conf"						,	_raise_exceptions_for_missing_entries=UpperCamelCase__						)
       self.assertIsNone(UpperCamelCase__						)

       snake_case    :      Any      					=    cached_file(UpperCamelCase__						,	"conf"						,	local_files_only=UpperCamelCase__						,	_raise_exceptions_for_missing_entries=UpperCamelCase__						)
       self.assertIsNone(UpperCamelCase__						)

       snake_case    :      Any      					=    mock.Mock()
       snake_case    :      List[Any]      					=    500
       snake_case    :      int      					=    {}
       snake_case    :      Optional[int]      					=    HTTPError
       snake_case    :      Tuple      					=    {}

       # Under the mock environment we get a 500 error when trying to reach the tokenizer.
       with mock.patch("requests.Session.request"						,	return_value=UpperCamelCase__						) as mock_head:
           snake_case    :      Tuple      					=    cached_file(UpperCamelCase__						,	"conf"						,	_raise_exceptions_for_connection_errors=UpperCamelCase__						)
           self.assertIsNone(UpperCamelCase__						)
           # This check we did call the fake head request
           mock_head.assert_called()







   def  lowerCamelCase		(	self						)	->		Any:

       '''simple docstring'''




       self.assertTrue(has_file("hf-internal-testing/tiny-bert-pt-only"						,	UpperCamelCase__						)						)
       self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"						,	UpperCamelCase__						)						)
       self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only"						,	UpperCamelCase__						)						)







   def  lowerCamelCase		(	self						)	->		str:

       '''simple docstring'''




       self.assertIsNone(get_file_from_repo("bert-base-cased"						,	"ahah.txt"						)						)

       # The function raises if the repository does not exist.
       with self.assertRaisesRegex(UpperCamelCase__						,	"is not a valid model identifier"						):
           get_file_from_repo("bert-base-case"						,	UpperCamelCase__						)

       # The function raises if the revision does not exist.
       with self.assertRaisesRegex(UpperCamelCase__						,	"is not a valid git identifier"						):
           get_file_from_repo("bert-base-cased"						,	UpperCamelCase__						,	revision="ahaha"						)

       snake_case    :      int      					=    get_file_from_repo("bert-base-cased"						,	UpperCamelCase__						)
       # The name is the cached name which is not very easy to test, so instead we load the content.
       snake_case    :      str      					=    json.loads(open(UpperCamelCase__						,	"r"						).read()						)
       self.assertEqual(config["hidden_size"]						,	768						)







   def  lowerCamelCase		(	self						)	->		Optional[Any]:

       '''simple docstring'''




       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case    :      int      					=    Path(UpperCamelCase__						) / "a.txt"
           filename.touch()
           self.assertEqual(get_file_from_repo(UpperCamelCase__						,	"a.txt"						)						,	str(UpperCamelCase__						)						)

           self.assertIsNone(get_file_from_repo(UpperCamelCase__						,	"b.txt"						)						)





