from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
					from ... import FeatureExtractionMixin, TensorType

__UpperCamelCase						:			Dict     		=	logging.get_logger(__name__)

__UpperCamelCase						:			Union[str, Any]     		=	{
    '''openai/imagegpt-small''': '''''',
    '''openai/imagegpt-medium''': '''''',
    '''openai/imagegpt-large''': '''''',
}





class    lowercase__		(  a__):
						UpperCamelCase_	=						"""imagegpt"""
						UpperCamelCase_	=						["""past_key_values"""]
						UpperCamelCase_	=						{
						    """hidden_size""": """n_embd""",
						    """max_position_embeddings""": """n_positions""",
						    """num_attention_heads""": """n_head""",
						    """num_hidden_layers""": """n_layer""",
						}


						def __init__(			self      :							Any       ,						UpperCamelCase__      :							Tuple=512 + 1       ,						UpperCamelCase__      :							Tuple=32 * 32       ,						UpperCamelCase__      :							Any=512       ,						UpperCamelCase__      :							Union[str, Any]=24       ,						UpperCamelCase__      :							List[Any]=8       ,						UpperCamelCase__      :							Dict=None       ,						UpperCamelCase__      :							List[Any]="quick_gelu"       ,						UpperCamelCase__      :							Tuple=0.1       ,						UpperCamelCase__      :							int=0.1       ,						UpperCamelCase__      :							Union[str, Any]=0.1       ,						UpperCamelCase__      :							Any=1E-5       ,						UpperCamelCase__      :							Union[str, Any]=0.02       ,						UpperCamelCase__      :							List[str]=True       ,						UpperCamelCase__      :							Dict=True       ,						UpperCamelCase__      :							str=False       ,						UpperCamelCase__      :							Optional[Any]=False       ,						UpperCamelCase__      :							List[Any]=False       ,						**UpperCamelCase__      :							Optional[Any]       ,						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				:       str     							=				vocab_size
												SCREAMING_SNAKE_CASE				:       List[Any]     							=				n_positions
												SCREAMING_SNAKE_CASE				:       List[Any]     							=				n_embd
												SCREAMING_SNAKE_CASE				:       Dict     							=				n_layer
												SCREAMING_SNAKE_CASE				:       str     							=				n_head
												SCREAMING_SNAKE_CASE				:       List[str]     							=				n_inner
												SCREAMING_SNAKE_CASE				:       Optional[Any]     							=				activation_function
												SCREAMING_SNAKE_CASE				:       Optional[Any]     							=				resid_pdrop
												SCREAMING_SNAKE_CASE				:       str     							=				embd_pdrop
												SCREAMING_SNAKE_CASE				:       Tuple     							=				attn_pdrop
												SCREAMING_SNAKE_CASE				:       str     							=				layer_norm_epsilon
												SCREAMING_SNAKE_CASE				:       Union[str, Any]     							=				initializer_range
												SCREAMING_SNAKE_CASE				:       Union[str, Any]     							=				scale_attn_weights
												SCREAMING_SNAKE_CASE				:       List[str]     							=				use_cache
												SCREAMING_SNAKE_CASE				:       int     							=				scale_attn_by_inverse_layer_idx
												SCREAMING_SNAKE_CASE				:       Optional[Any]     							=				reorder_and_upcast_attn
												SCREAMING_SNAKE_CASE				:       Optional[int]     							=				tie_word_embeddings

												super().__init__(tie_word_embeddings=_UpperCAmelCase       ,						**_UpperCAmelCase		)






class    lowercase__		(  a__):


						@property
						def 			__A			(			self      :							Dict		):





												'''simple docstring'''





												return OrderedDict(
												    [
												        ('''input_ids''', {0: '''batch''', 1: '''sequence'''}),
												    ]		)



						def 			__A			(			self      :							Union[str, Any]       ,						UpperCamelCase__      :							Tuple       ,						UpperCamelCase__      :							Dict = 1       ,						UpperCamelCase__      :							Optional[Any] = -1       ,						UpperCamelCase__      :							Optional[Any] = False       ,						UpperCamelCase__      :							List[str] = None       ,						UpperCamelCase__      :							Dict = 3       ,						UpperCamelCase__      :							List[Any] = 32       ,						UpperCamelCase__      :							List[Any] = 32       ,						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE				:       List[str]     							=				self._generate_dummy_images(_UpperCAmelCase       ,						_UpperCAmelCase       ,						_UpperCAmelCase       ,						_UpperCAmelCase		)
												SCREAMING_SNAKE_CASE				:       Any     							=				dict(preprocessor(images=_UpperCAmelCase       ,						return_tensors=_UpperCAmelCase		)		)

												return inputs












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


lowercase__       : Any         =       '''hf-internal-testing/tiny-random-bert'''
lowercase__       : Optional[Any]         =       os.path.join(TRANSFORMERS_CACHE, '''models--hf-internal-testing--tiny-random-bert''')
lowercase__       : List[Any]         =       '''9b8c223d42b2188cb49d29af482996f9d0f3e5a6'''


class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			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:
               __A		:					Any						=			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.
          __A		:					Tuple						=			cached_file(_UpperCAmelCase		,      _UpperCAmelCase)
          self.assertEqual(_UpperCAmelCase		,      _UpperCAmelCase)

          # Using a specific revision to test the full commit hash.
          __A		:					List[Any]						=			cached_file(_UpperCAmelCase		,      _UpperCAmelCase		,      revision='9b8c223')
          self.assertEqual(_UpperCAmelCase		,      os.path.join(_UpperCAmelCase		,      'snapshots'		,      _UpperCAmelCase		,      _UpperCAmelCase))


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          with self.assertRaisesRegex(_UpperCAmelCase		,      'is not a valid model identifier'):
               __A		:					Dict						=			cached_file('tiny-random-bert'		,      _UpperCAmelCase)

          with self.assertRaisesRegex(_UpperCAmelCase		,      'is not a valid git identifier'):
               __A		:					Optional[int]						=			cached_file(_UpperCAmelCase		,      _UpperCAmelCase		,      revision='aaaa')

          with self.assertRaisesRegex(_UpperCAmelCase		,      'does not appear to have a file named'):
               __A		:					int						=			cached_file(_UpperCAmelCase		,      'conf')


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          with self.assertRaisesRegex(_UpperCAmelCase		,      'does not appear to have a file named'):
               __A		:					Any						=			cached_file(_UpperCAmelCase		,      'conf')

          with open(os.path.join(_UpperCAmelCase		,      'refs'		,      'main')) as f:
               __A		:					Dict						=			f.read()
          self.assertTrue(os.path.isfile(os.path.join(_UpperCAmelCase		,      '.no_exist'		,      _UpperCAmelCase		,      'conf')))

          __A		:					List[Any]						=			cached_file(_UpperCAmelCase		,      'conf'		,      _raise_exceptions_for_missing_entries=_UpperCAmelCase)
          self.assertIsNone(_UpperCAmelCase)

          __A		:					str						=			cached_file(_UpperCAmelCase		,      'conf'		,      local_files_only=_UpperCAmelCase		,      _raise_exceptions_for_missing_entries=_UpperCAmelCase)
          self.assertIsNone(_UpperCAmelCase)

          __A		:					List[str]						=			mock.Mock()
          __A		:					Dict						=			500
          __A		:					List[str]						=			{}
          __A		:					List[Any]						=			HTTPError
          __A		:					Optional[Any]						=			{}

          # 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:
               __A		:					Dict						=			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 				SCREAMING_SNAKE_CASE    (		self):

          '''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 				SCREAMING_SNAKE_CASE    (		self):

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

          __A		:					List[str]						=			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.
          __A		:					List[str]						=			json.loads(open(_UpperCAmelCase		,      'r').read())
          self.assertEqual(config['hidden_size']		,      768)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          with tempfile.TemporaryDirectory() as tmp_dir:
               __A		:					Tuple						=			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'))