





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,
)


_SCREAMING_SNAKE_CASE      	=		"""hf-internal-testing/tiny-random-bert"""
_SCREAMING_SNAKE_CASE      	=		os.path.join(TRANSFORMERS_CACHE, """models--hf-internal-testing--tiny-random-bert""")
_SCREAMING_SNAKE_CASE      	=		"""9b8c223d42b2188cb49d29af482996f9d0f3e5a6"""
class SCREAMING_SNAKE_CASE_						(					unittest.TestCase					):






						def UpperCAmelCase_				(      self      :      List[str]	)							->    int:







							"""simple docstring"""


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

							# File is cached at the same place the second time.
							snake_case_		:			int											=	cached_file(_A		,   _A	)
							self.assertEqual(_A		,   _A	)

							# Using a specific revision to test the full commit hash.
							snake_case_		:			Dict											=	cached_file(_A		,   _A		,   revision='9b8c223'	)
							self.assertEqual(_A		,   os.path.join(_A		,   'snapshots'		,   _A		,   _A	)	)






						def UpperCAmelCase_				(      self      :      Optional[Any]	)							->    Optional[int]:







							"""simple docstring"""


							with self.assertRaisesRegex(_A		,   'is not a valid model identifier'	):
								snake_case_		:			List[Any]											=	cached_file('tiny-random-bert'		,   _A	)

							with self.assertRaisesRegex(_A		,   'is not a valid git identifier'	):
								snake_case_		:			Dict											=	cached_file(_A		,   _A		,   revision='aaaa'	)

							with self.assertRaisesRegex(_A		,   'does not appear to have a file named'	):
								snake_case_		:			str											=	cached_file(_A		,   'conf'	)






						def UpperCAmelCase_				(      self      :      Optional[int]	)							->    List[str]:







							"""simple docstring"""


							with self.assertRaisesRegex(_A		,   'does not appear to have a file named'	):
								snake_case_		:			Union[str, Any]											=	cached_file(_A		,   'conf'	)

							with open(os.path.join(_A		,   'refs'		,   'main'	)	) as f:
								snake_case_		:			Any											=	f.read()
							self.assertTrue(os.path.isfile(os.path.join(_A		,   '.no_exist'		,   _A		,   'conf'	)	)	)

							snake_case_		:			int											=	cached_file(_A		,   'conf'		,   _raise_exceptions_for_missing_entries=_A	)
							self.assertIsNone(_A	)

							snake_case_		:			List[str]											=	cached_file(_A		,   'conf'		,   local_files_only=_A		,   _raise_exceptions_for_missing_entries=_A	)
							self.assertIsNone(_A	)

							snake_case_		:			Union[str, Any]											=	mock.Mock()
							snake_case_		:			Optional[int]											=	500
							snake_case_		:			Optional[Any]											=	{}
							snake_case_		:			str											=	HTTPError
							snake_case_		:			Union[str, Any]											=	{}

							# Under the mock environment we get a 500 error when trying to reach the tokenizer.
							with mock.patch('requests.Session.request'		,   return_value=_A	) as mock_head:
								snake_case_		:			Optional[Any]											=	cached_file(_A		,   'conf'		,   _raise_exceptions_for_connection_errors=_A	)
								self.assertIsNone(_A	)
								# This check we did call the fake head request
								mock_head.assert_called()






						def UpperCAmelCase_				(      self      :      Optional[int]	)							->    Union[str, Any]:







							"""simple docstring"""


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






						def UpperCAmelCase_				(      self      :      Any	)							->    int:







							"""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(_A		,   'is not a valid model identifier'	):
								get_file_from_repo('bert-base-case'		,   _A	)

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

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






						def UpperCAmelCase_				(      self      :      List[Any]	)							->    Any:







							"""simple docstring"""


							with tempfile.TemporaryDirectory() as tmp_dir:
								snake_case_		:			List[str]											=	Path(_A	) / 'a.txt'
								filename.touch()
								self.assertEqual(get_file_from_repo(_A		,   'a.txt'	)		,   str(_A	)	)

								self.assertIsNone(get_file_from_repo(_A		,   'b.txt'	)	)










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


_SCREAMING_SNAKE_CASE      	=		logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE      	=		{
    """SCUT-DLVCLab/lilt-roberta-en-base""": (
        """https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json"""
    ),
}
class SCREAMING_SNAKE_CASE_						(					snake_case_					):
						__magic_name__:			str       =       "lilt"






						def __init__(      self      :      Any		,   _A      :      Dict=30522		,   _A      :      List[Any]=768		,   _A      :      str=12		,   _A      :      int=12		,   _A      :      Optional[int]=3072		,   _A      :      Optional[Any]="gelu"		,   _A      :      Dict=0.1		,   _A      :      Tuple=0.1		,   _A      :      str=512		,   _A      :      Union[str, Any]=2		,   _A      :      Union[str, Any]=0.0_2		,   _A      :      Optional[Any]=1E-12		,   _A      :      Optional[int]=0		,   _A      :      Dict="absolute"		,   _A      :      Any=None		,   _A      :      Optional[Any]=4		,   _A      :      Any=1024		,   **_A      :      Union[str, Any]		,   )							->    List[str]:







							"""simple docstring"""


							super().__init__(pad_token_id=_A		,   **_A	)

							snake_case_		:			List[str]											=	vocab_size
							snake_case_		:			Dict											=	hidden_size
							snake_case_		:			Union[str, Any]											=	num_hidden_layers
							snake_case_		:			List[str]											=	num_attention_heads
							snake_case_		:			Tuple											=	hidden_act
							snake_case_		:			Tuple											=	intermediate_size
							snake_case_		:			int											=	hidden_dropout_prob
							snake_case_		:			Tuple											=	attention_probs_dropout_prob
							snake_case_		:			Dict											=	max_position_embeddings
							snake_case_		:			Any											=	type_vocab_size
							snake_case_		:			Union[str, Any]											=	initializer_range
							snake_case_		:			Optional[int]											=	layer_norm_eps
							snake_case_		:			List[str]											=	position_embedding_type
							snake_case_		:			Optional[int]											=	classifier_dropout
							snake_case_		:			Dict											=	channel_shrink_ratio
							snake_case_		:			Tuple											=	max_ad_position_embeddings

