





'''simple docstring'''






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

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402


A__				:   Any      ={
    '''return_dict''': False,
    '''output_hidden_states''': True,
    '''output_attentions''': True,
    '''torchscript''': True,
    '''torch_dtype''': '''float16''',
    '''use_bfloat16''': True,
    '''tf_legacy_loss''': True,
    '''pruned_heads''': {'''a''': 1},
    '''tie_word_embeddings''': False,
    '''is_decoder''': True,
    '''cross_attention_hidden_size''': 1_28,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 50,
    '''min_length''': 3,
    '''do_sample''': True,
    '''early_stopping''': True,
    '''num_beams''': 3,
    '''num_beam_groups''': 3,
    '''diversity_penalty''': 0.5,
    '''temperature''': 2.0,
    '''top_k''': 10,
    '''top_p''': 0.7,
    '''typical_p''': 0.2,
    '''repetition_penalty''': 0.8,
    '''length_penalty''': 0.8,
    '''no_repeat_ngram_size''': 5,
    '''encoder_no_repeat_ngram_size''': 5,
    '''bad_words_ids''': [1, 2, 3],
    '''num_return_sequences''': 3,
    '''chunk_size_feed_forward''': 5,
    '''output_scores''': True,
    '''return_dict_in_generate''': True,
    '''forced_bos_token_id''': 2,
    '''forced_eos_token_id''': 3,
    '''remove_invalid_values''': True,
    '''architectures''': ['''BertModel'''],
    '''finetuning_task''': '''translation''',
    '''id2label''': {0: '''label'''},
    '''label2id''': {'''label''': '''0'''},
    '''tokenizer_class''': '''BertTokenizerFast''',
    '''prefix''': '''prefix''',
    '''bos_token_id''': 6,
    '''pad_token_id''': 7,
    '''eos_token_id''': 8,
    '''sep_token_id''': 9,
    '''decoder_start_token_id''': 10,
    '''exponential_decay_length_penalty''': (5, 1.01),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}




@is_staging_test
class  UpperCAmelCase     (			unittest.TestCase   ):




      @classmethod
      def 				lowercase__    (			cls			: Optional[Any]  )				->      Tuple:
            _lowerCAmelCase							     =							TOKEN
            HfFolder.save_token(__snake_case  )




      @classmethod
      def 				lowercase__    (			cls			: Optional[int]  )				->      List[str]:
            try:
                  delete_repo(token=cls._token			,			repo_id="""test-config"""  )
            except HTTPError:
                  pass

            try:
                  delete_repo(token=cls._token			,			repo_id="""valid_org/test-config-org"""  )
            except HTTPError:
                  pass

            try:
                  delete_repo(token=cls._token			,			repo_id="""test-dynamic-config"""  )
            except HTTPError:
                  pass




      def 				lowercase__    (			self			: int  )				->      Union[str, Any]:
            _lowerCAmelCase							     =							BertConfig(
                vocab_size=99			,			hidden_size=32			,			num_hidden_layers=5			,			num_attention_heads=4			,			intermediate_size=37  )
            config.push_to_hub("""test-config"""			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained(f"{USER}/test-config"  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )

        # Reset repo
            delete_repo(token=self._token			,			repo_id="""test-config"""  )

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                  config.save_pretrained(__snake_case			,			repo_id="""test-config"""			,			push_to_hub=__snake_case			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained(f"{USER}/test-config"  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )




      def 				lowercase__    (			self			: Union[str, Any]  )				->      List[Any]:
            _lowerCAmelCase							     =							BertConfig(
                vocab_size=99			,			hidden_size=32			,			num_hidden_layers=5			,			num_attention_heads=4			,			intermediate_size=37  )
            config.push_to_hub("""valid_org/test-config-org"""			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""valid_org/test-config-org"""  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )

        # Reset repo
            delete_repo(token=self._token			,			repo_id="""valid_org/test-config-org"""  )

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                  config.save_pretrained(
                      __snake_case			,			repo_id="""valid_org/test-config-org"""			,			push_to_hub=__snake_case			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""valid_org/test-config-org"""  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )




      def 				lowercase__    (			self			: Dict  )				->      Any:
            CustomConfig.register_for_auto_class()
            _lowerCAmelCase							     =							CustomConfig(attribute=42  )

            config.push_to_hub("""test-dynamic-config"""			,			use_auth_token=self._token  )

            # This has added the proper auto_map field to the config
            self.assertDictEqual(config.auto_map			,			{"""AutoConfig""": """custom_configuration.CustomConfig"""}  )

            _lowerCAmelCase							     =							AutoConfig.from_pretrained(f"{USER}/test-dynamic-config"			,			trust_remote_code=__snake_case  )
            # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
            self.assertEqual(new_config.__class__.__name__			,			"""CustomConfig"""  )
            self.assertEqual(new_config.attribute			,			42  )




class  UpperCAmelCase     (			unittest.TestCase   ):




      def 				lowercase__    (			self			: List[Any]  )				->      Optional[Any]:
            _lowerCAmelCase							     =							GPTaConfig()

            # attempt to modify each of int/float/bool/str config records and verify they were updated
            _lowerCAmelCase							     =							c.n_embd + 1  # int
            _lowerCAmelCase							     =							c.resid_pdrop + 1.0  # float
            _lowerCAmelCase							     =							not c.scale_attn_weights  # bool
            _lowerCAmelCase							     =							c.summary_type + """foo"""  # str
            c.update_from_string(
                f"n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"  )
            self.assertEqual(__snake_case			,			c.n_embd			,			"""mismatch for key: n_embd"""  )
            self.assertEqual(__snake_case			,			c.resid_pdrop			,			"""mismatch for key: resid_pdrop"""  )
            self.assertEqual(__snake_case			,			c.scale_attn_weights			,			"""mismatch for key: scale_attn_weights"""  )
            self.assertEqual(__snake_case			,			c.summary_type			,			"""mismatch for key: summary_type"""  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Any:
            _lowerCAmelCase							     =							PretrainedConfig()
            _lowerCAmelCase							     =							[key for key in base_config.__dict__ if key not in config_common_kwargs]
            # If this part of the test fails, you have arguments to addin config_common_kwargs above.
            self.assertListEqual(
                __snake_case			,			["""is_encoder_decoder""", """_name_or_path""", """_commit_hash""", """transformers_version"""]  )
            _lowerCAmelCase							     =							[key for key, value in config_common_kwargs.items() if value == getattr(__snake_case			,			__snake_case  )]
            if len(__snake_case  ) > 0:
                  raise ValueError(
                      """The following keys are set with the default values in"""
                      """ `test_configuration_common.config_common_kwargs` pick another value for them:"""
                      f" {', '.join(__snake_case  )}."  )




      def 				lowercase__    (			self			: List[str]  )				->      List[Any]:
            with self.assertRaises(__snake_case  ):
                  # config is in subfolder, the following should not work without specifying the subfolder
                  _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""			,			subfolder="""bert"""  )

            self.assertIsNotNone(__snake_case  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      str:
            # A mock response for an HTTP head request to emulate server down
            _lowerCAmelCase							     =							mock.Mock()
            _lowerCAmelCase							     =							5_00
            _lowerCAmelCase							     =							{}
            _lowerCAmelCase							     =							HTTPError
            _lowerCAmelCase							     =							{}

            # Download this model to make sure it's in the cache.
            _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )

            # Under the mock environment we get a 500 error when trying to reach the model.
            with mock.patch("""requests.Session.request"""			,			return_value=__snake_case  ) as mock_head:
                  _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )
                  # This check we did call the fake head request
                  mock_head.assert_called()




      def 				lowercase__    (			self			: str  )				->      Union[str, Any]:
            # This test is for deprecated behavior and can be removed in v5
            _lowerCAmelCase							     =							BertConfig.from_pretrained(
                """https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"""  )




      def 				lowercase__    (			self			: str  )				->      Union[str, Any]:
            _lowerCAmelCase							     =							AutoConfig.from_pretrained("""bert-base-cased"""  )
            _lowerCAmelCase							     =							["""config.4.0.0.json"""]

            with tempfile.TemporaryDirectory() as tmp_dir:
                  configuration.save_pretrained(__snake_case  )
                  _lowerCAmelCase							     =							2
                  json.dump(configuration.to_dict()			,			open(os.path.join(__snake_case			,			"""config.4.0.0.json"""  )			,			"""w"""  )  )

                  # This should pick the new configuration file as the version of Transformers is > 4.0.0
                  _lowerCAmelCase							     =							AutoConfig.from_pretrained(__snake_case  )
                  self.assertEqual(new_configuration.hidden_size			,			2  )

                  # Will need to be adjusted if we reach v42 and this test is still here.
                  # Should pick the old configuration file as the version of Transformers is < 4.42.0
                  _lowerCAmelCase							     =							["""config.42.0.0.json"""]
                  _lowerCAmelCase							     =							7_68
                  configuration.save_pretrained(__snake_case  )
                  shutil.move(os.path.join(__snake_case			,			"""config.4.0.0.json"""  )			,			os.path.join(__snake_case			,			"""config.42.0.0.json"""  )  )
                  _lowerCAmelCase							     =							AutoConfig.from_pretrained(__snake_case  )
                  self.assertEqual(new_configuration.hidden_size			,			7_68  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Optional[Any]:
            # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
            _lowerCAmelCase							     =							"""hf-internal-testing/test-two-configs"""

            import transformers as new_transformers

            _lowerCAmelCase							     =							"""v4.0.0"""
            _lowerCAmelCase     ,							_lowerCAmelCase							     =							new_transformers.models.auto.AutoConfig.from_pretrained(
                __snake_case			,			return_unused_kwargs=__snake_case  )
            self.assertEqual(new_configuration.hidden_size			,			2  )
            # This checks `_configuration_file` ia not kept in the kwargs by mistake.
            self.assertDictEqual(__snake_case			,			{}  )

            # Testing an older version by monkey-patching the version in the module it's used.
            import transformers as old_transformers

            _lowerCAmelCase							     =							"""v3.0.0"""
            _lowerCAmelCase							     =							old_transformers.models.auto.AutoConfig.from_pretrained(__snake_case  )
            self.assertEqual(old_configuration.hidden_size			,			7_68  )








from __future__ import annotations

from typing import Any




class    SCREAMING_SNAKE_CASE__     :





	'''simple docstring'''



	def __init__(  self	:    Tuple			,  lowercase	:    int			,  lowercase	:    int			,  lowercase	:    float = 0	):


				'''simple docstring'''


				_snake_case	,					_snake_case		=			row, column
				_snake_case		=			[[default_value for c in range(lowercase	)] for r in range(lowercase	)]



	def __str__(  self	:    int	):


				'''simple docstring'''


				_snake_case		=			f'''Matrix consist of {self.row} rows and {self.column} columns\n'''

				# Make string identifier
				_snake_case		=			0
				for row_vector in self.array:
							for obj in row_vector:
										_snake_case		=			max(lowercase			,  len(str(lowercase	)	)	)
				_snake_case		=			f'''%{max_element_length}s'''

				# Make string and return
				def single_line(lowercase	:    list[float]	) -> str:
							nonlocal string_format_identifier
							_snake_case		=			'['
							line += ", ".join(string_format_identifier % (obj,) for obj in row_vector	)
							line += "]"
							return line

				s += "\n".join(single_line(lowercase	) for row_vector in self.array	)
				return s



	def __repr__(  self	:    Dict	):


				'''simple docstring'''


				return str(self	)



	def  A							(  self	:    str			,  lowercase	:    tuple[int, int]	):


				'''simple docstring'''


				if not (isinstance(lowercase			,  (list, tuple)	) and len(lowercase	) == 2):
							return False
				elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
							return False
				else:
							return True



	def __getitem__(  self	:    Dict			,  lowercase	:    tuple[int, int]	):


				'''simple docstring'''


				assert self.validate_indicies(lowercase	)
				return self.array[loc[0]][loc[1]]



	def __setitem__(  self	:    str			,  lowercase	:    tuple[int, int]			,  lowercase	:    float	):


				'''simple docstring'''


				assert self.validate_indicies(lowercase	)
				_snake_case		=			value



	def __add__(  self	:    str			,  lowercase	:    Matrix	):


				'''simple docstring'''


				assert isinstance(lowercase			,  lowercase	)
				assert self.row == another.row and self.column == another.column

				# Add
				_snake_case		=			Matrix(self.row			,  self.column	)
				for r in range(self.row	):
							for c in range(self.column	):
										_snake_case		=			self[r, c] + another[r, c]
				return result



	def __neg__(  self	:    Tuple	):


				'''simple docstring'''


				_snake_case		=			Matrix(self.row			,  self.column	)
				for r in range(self.row	):
							for c in range(self.column	):
										_snake_case		=			-self[r, c]
				return result



	def __sub__(  self	:    List[str]			,  lowercase	:    Matrix	):


				'''simple docstring'''


				return self + (-another)



	def __mul__(  self	:    Dict			,  lowercase	:    int | float | Matrix	):


				'''simple docstring'''


				if isinstance(lowercase			,  (int, float)	):  # Scalar multiplication
							_snake_case		=			Matrix(self.row			,  self.column	)
							for r in range(self.row	):
										for c in range(self.column	):
													_snake_case		=			self[r, c] * another
							return result
				elif isinstance(lowercase			,  lowercase	):  # Matrix multiplication
							assert self.column == another.row
							_snake_case		=			Matrix(self.row			,  another.column	)
							for r in range(self.row	):
										for c in range(another.column	):
													for i in range(self.column	):
																result[r, c] += self[r, i] * another[i, c]
							return result
				else:
							_snake_case		=			f'''Unsupported type given for another ({type(lowercase	)})'''
							raise TypeError(lowercase	)



	def  A							(  self	:    Optional[Any]	):


				'''simple docstring'''


				_snake_case		=			Matrix(self.column			,  self.row	)
				for r in range(self.row	):
							for c in range(self.column	):
										_snake_case		=			self[r, c]
				return result





	def  A							(  self	:    List[Any]			,  lowercase	:    Matrix			,  lowercase	:    Matrix	):


				'''simple docstring'''


				assert isinstance(lowercase			,  lowercase	) and isinstance(lowercase			,  lowercase	)
				assert self.row == self.column == u.row == v.row  # u, v should be column vector
				assert u.column == v.column == 1  # u, v should be column vector

				# Calculate
				_snake_case		=			v.transpose()
				_snake_case		=			(v_t * self * u)[0, 0] + 1
				if numerator_factor == 0:
							return None  # It's not invertable
				return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":






			def        a_		(       ) ->  None:
						# a^(-1)
						_snake_case		=			Matrix(3       ,					3       ,					0 )
						for i in range(3 ):
									_snake_case		=			1
						print(f'''a^(-1) is {ainv}''' )
						# u, v
						_snake_case		=			Matrix(3       ,					1       ,					0 )
						_snake_case	,					_snake_case	,					_snake_case		=			1, 2, -3
						_snake_case		=			Matrix(3       ,					1       ,					0 )
						_snake_case	,					_snake_case	,					_snake_case		=			4, -2, 5
						print(f'''u is {u}''' )
						print(f'''v is {v}''' )
						print(f'''uv^T is {u * v.transpose()}''' )
						# Sherman Morrison
						print(f'''(a + uv^T)^(-1) is {ainv.sherman_morrison(__lowercase       ,					__lowercase )}''' )






			def        a_		(       ) ->  None:
						import doctest

						doctest.testmod()

			testa()