






from __future__ import annotations

import unittest

import numpy as np

from transformers import OPTConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel






def 					lowerCamelCase__					(_UpperCAmelCase				,							_UpperCAmelCase				,							_UpperCAmelCase=None				,							_UpperCAmelCase=None):
			if attention_mask is None:
						SCREAMING_SNAKE_CASE							=			tf.cast(tf.math.not_equal(_UpperCAmelCase				,							config.pad_token_id)				,							tf.inta)
			return {"input_ids": input_ids, "attention_mask": attention_mask}

@require_tf
class 		_snake_case	:
			_lowercase		:     str        =				OPTConfig
			_lowercase		:     Union[str, Any]        =				{}
			_lowercase		:     str        =				'''gelu'''






			def __init__(							self		,       a		,       a=13		,       a=7		,       a=True		,       a=False		,       a=99		,       a=16		,       a=2		,       a=4		,       a=4		,       a="gelu"		,       a=0.1		,       a=0.1		,       a=20		,       a=2		,       a=1		,       a=0		,       a=16		,       a=16		,       )   ->							List[str]:
						SCREAMING_SNAKE_CASE							=			parent
						SCREAMING_SNAKE_CASE							=			batch_size
						SCREAMING_SNAKE_CASE							=			seq_length
						SCREAMING_SNAKE_CASE							=			is_training
						SCREAMING_SNAKE_CASE							=			use_labels
						SCREAMING_SNAKE_CASE							=			vocab_size
						SCREAMING_SNAKE_CASE							=			hidden_size
						SCREAMING_SNAKE_CASE							=			num_hidden_layers
						SCREAMING_SNAKE_CASE							=			num_attention_heads
						SCREAMING_SNAKE_CASE							=			intermediate_size
						SCREAMING_SNAKE_CASE							=			hidden_act
						SCREAMING_SNAKE_CASE							=			hidden_dropout_prob
						SCREAMING_SNAKE_CASE							=			attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE							=			max_position_embeddings
						SCREAMING_SNAKE_CASE							=			eos_token_id
						SCREAMING_SNAKE_CASE							=			pad_token_id
						SCREAMING_SNAKE_CASE							=			bos_token_id
						SCREAMING_SNAKE_CASE							=			embed_dim
						SCREAMING_SNAKE_CASE							=			word_embed_proj_dim
						SCREAMING_SNAKE_CASE							=			False






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						SCREAMING_SNAKE_CASE							=			ids_tensor([self.batch_size, self.seq_length - 1]		,       self.vocab_size)
						SCREAMING_SNAKE_CASE							=			tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size)		,       1)
						SCREAMING_SNAKE_CASE							=			tf.concat([input_ids, eos_tensor]		,       axis=1)

						SCREAMING_SNAKE_CASE							=			self.config_cls(
						    vocab_size=self.vocab_size		,       hidden_size=self.hidden_size		,       num_hidden_layers=self.num_hidden_layers		,       num_attention_heads=self.num_attention_heads		,       ffn_dim=self.intermediate_size		,       dropout=self.hidden_dropout_prob		,       attention_dropout=self.attention_probs_dropout_prob		,       max_position_embeddings=self.max_position_embeddings		,       eos_token_id=self.eos_token_id		,       bos_token_id=self.bos_token_id		,       pad_token_id=self.pad_token_id		,       embed_dim=self.embed_dim		,       word_embed_proj_dim=self.word_embed_proj_dim		,       is_encoder_decoder=a		,       **self.config_updates		,       )
						SCREAMING_SNAKE_CASE							=			prepare_opt_inputs_dict(a		,       a)
						return config, inputs_dict







			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a)   ->							Union[str, Any]:
						SCREAMING_SNAKE_CASE							=			TFOPTModel(config=a)
						SCREAMING_SNAKE_CASE							=			inputs_dict['input_ids']

						SCREAMING_SNAKE_CASE							=			input_ids[:1, :]
						SCREAMING_SNAKE_CASE							=			inputs_dict['attention_mask'][:1, :]
						SCREAMING_SNAKE_CASE							=			1

						# first forward pass
						SCREAMING_SNAKE_CASE							=			model(a		,       attention_mask=a		,       use_cache=a)

						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			outputs.to_tuple()

						# create hypothetical next token and extent to next_input_ids
						SCREAMING_SNAKE_CASE							=			ids_tensor((self.batch_size, 3)		,       config.vocab_size)
						SCREAMING_SNAKE_CASE							=			tf.cast(ids_tensor((self.batch_size, 3)		,       2)		,       tf.inta)

						# append to next input_ids and
						SCREAMING_SNAKE_CASE							=			tf.concat([input_ids, next_tokens]		,       axis=-1)
						SCREAMING_SNAKE_CASE							=			tf.concat([attention_mask, next_attn_mask]		,       axis=-1)

						SCREAMING_SNAKE_CASE							=			model(a		,       attention_mask=a)[0]
						SCREAMING_SNAKE_CASE							=			model(a		,       attention_mask=a		,       past_key_values=a)[0]

						self.parent.assertEqual(next_tokens.shape[1]		,       output_from_past.shape[1])

						# select random slice
						SCREAMING_SNAKE_CASE							=			int(ids_tensor((1,)		,       output_from_past.shape[-1]))
						SCREAMING_SNAKE_CASE							=			output_from_no_past[:, -3:, random_slice_idx]
						SCREAMING_SNAKE_CASE							=			output_from_past[:, :, random_slice_idx]

						# test that outputs are equal for slice
						tf.debugging.assert_near(a		,       a		,       rtol=1E-3)



@require_tf
class 		_snake_case	(	A__ ,     A__ ,     unittest.TestCase       ):
			_lowercase		:     Union[str, Any]        =				(TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
			_lowercase		:     Optional[Any]        =				(TFOPTForCausalLM,) if is_tf_available() else ()
			_lowercase		:     List[Any]        =				(
			    {'''feature-extraction''': TFOPTModel, '''text-generation''': TFOPTForCausalLM} if is_tf_available() else {}
			)
			_lowercase		:     int        =				False
			_lowercase		:     List[str]        =				False
			_lowercase		:     str        =				False
			_lowercase		:     List[str]        =				10






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Tuple:
						SCREAMING_SNAKE_CASE							=			TFOPTModelTester(self)
						SCREAMING_SNAKE_CASE							=			ConfigTester(self		,       config_class=a)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[Any]:
						self.config_tester.run_common_tests()






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[str]:
						SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs_for_common()
						self.model_tester.check_decoder_model_past_large_inputs(*a)







			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[str]:
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs_for_common()

						def _get_word_embedding_weight(a		,       a):
									if hasattr(a		,       'weight'):
												return embedding_layer.weight
									else:
												# Here we build the word embeddings weights if not exists.
												# And then we retry to get the attribute once built.
												model.build()
												if hasattr(a		,       'weight'):
															return embedding_layer.weight
												else:
															return None

						for model_class in self.all_model_classes:
									for size in [config.vocab_size - 10, config.vocab_size + 10]:
												# build the embeddings
												SCREAMING_SNAKE_CASE							=			model_class(config=a)
												SCREAMING_SNAKE_CASE							=			_get_word_embedding_weight(a		,       model.get_input_embeddings())
												SCREAMING_SNAKE_CASE							=			_get_word_embedding_weight(a		,       model.get_output_embeddings())

												# reshape the embeddings
												model.resize_token_embeddings(a)
												SCREAMING_SNAKE_CASE							=			_get_word_embedding_weight(a		,       model.get_input_embeddings())
												SCREAMING_SNAKE_CASE							=			_get_word_embedding_weight(a		,       model.get_output_embeddings())

												# check that the resized embeddings size matches the desired size.
												SCREAMING_SNAKE_CASE							=			size if size is not None else config.vocab_size

												self.assertEqual(new_input_embeddings.shape[0]		,       a)

												# check that weights remain the same after resizing
												SCREAMING_SNAKE_CASE							=			True
												for pa, pa in zip(old_input_embeddings.value()		,       new_input_embeddings.value()):
															if tf.math.reduce_sum(tf.math.abs(pa - pa)) > 0:
																		SCREAMING_SNAKE_CASE							=			False
												self.assertTrue(a)

												if old_output_embeddings is not None and new_output_embeddings is not None:
															self.assertEqual(new_output_embeddings.shape[0]		,       a)

															SCREAMING_SNAKE_CASE							=			True
															for pa, pa in zip(old_output_embeddings.value()		,       new_output_embeddings.value()):
																		if tf.math.reduce_sum(tf.math.abs(pa - pa)) > 0:
																					SCREAMING_SNAKE_CASE							=			False
															self.assertTrue(a)






def 					lowerCamelCase__					(_UpperCAmelCase):
			return tf.constant(_UpperCAmelCase				,							dtype=tf.intaa)

@require_tf
class 		_snake_case	(	unittest.TestCase       ):
			_lowercase		:     List[str]        =				99






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							int:
						SCREAMING_SNAKE_CASE							=			tf.ones((4, 1)		,       dtype=tf.intaa) * 2
						SCREAMING_SNAKE_CASE							=			tf.concat([ids_tensor((4, 6)		,       self.vocab_size - 3) + 3, eos_column_vector]		,       axis=1)
						SCREAMING_SNAKE_CASE							=			input_ids.shape[0]
						SCREAMING_SNAKE_CASE							=			OPTConfig(
						    vocab_size=self.vocab_size		,       hidden_size=24		,       num_hidden_layers=2		,       num_attention_heads=2		,       ffn_dim=32		,       max_position_embeddings=48		,       eos_token_id=2		,       pad_token_id=1		,       bos_token_id=0		,       )
						return config, input_ids, batch_size



@require_sentencepiece
@require_tf
class 		_snake_case	(	unittest.TestCase       ):






			@slow
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						SCREAMING_SNAKE_CASE							=			TFOPTModel.from_pretrained('facebook/opt-350m')
						SCREAMING_SNAKE_CASE							=			_long_tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]])
						SCREAMING_SNAKE_CASE							=			tf.not_equal(a		,       model.config.pad_token_id)
						with tf.GradientTape():
									SCREAMING_SNAKE_CASE							=			model(input_ids=a		,       attention_mask=a).last_hidden_state
						SCREAMING_SNAKE_CASE							=			(1, 11, 512)
						self.assertEqual(output.shape		,       a)
						SCREAMING_SNAKE_CASE							=			tf.constant(
						    [[-0.28_73, -1.92_18, -0.30_33], [-1.27_10, -0.13_38, -0.19_02], [0.40_95, 0.12_14, -1.31_21]])
						self.assertTrue(np.allclose(output[:, :3, :3]		,       a		,       atol=4E-3))

						SCREAMING_SNAKE_CASE							=			tf.function(a		,       jit_compile=a)
						SCREAMING_SNAKE_CASE							=			xla_generate(a		,       a)[0]
						self.assertTrue(np.allclose(output[:, :3, :3]		,       a		,       atol=4E-2))



@require_tf
@slow
class 		_snake_case	(	unittest.TestCase       ):






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						super().setUp()
						SCREAMING_SNAKE_CASE							=			'facebook/opt-350m'







			def  SCREAMING_SNAKE_CASE__     (							self)   ->							str:
						SCREAMING_SNAKE_CASE							=			TFOPTForCausalLM.from_pretrained(self.path_model)
						SCREAMING_SNAKE_CASE							=			GPTaTokenizer.from_pretrained(self.path_model)

						SCREAMING_SNAKE_CASE							=			[
						    'Today is a beautiful day and I want to',
						    'In the city of',
						    'Paris is the capital of France and',
						    'Computers and mobile phones have taken',
						]
						# verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
						SCREAMING_SNAKE_CASE							=			tokenizer(a		,       return_tensors='tf'		,       padding=a		,       add_special_tokens=a)
						SCREAMING_SNAKE_CASE							=			tf.math.reduce_mean(model(inputs.input_ids		,       attention_mask=inputs.attention_mask)[0]		,       axis=-1)
						SCREAMING_SNAKE_CASE							=			tf.constant(
						    [
						        [1.38_51, -13.89_23, -10.52_29, -10.75_33, -0.23_09, -10.23_84, -0.53_65, -9.09_47, -5.16_70],
						        [-4.70_73, -10.62_76, -3.94_15, -21.52_42, -0.28_22, -0.28_22, -0.28_22, -0.28_22, -0.28_22],
						        [0.62_47, -3.42_29, -8.91_79, -1.42_97, -14.16_50, 1.41_46, -9.02_18, -0.27_03, -0.27_03],
						        [6.47_83, -1.99_13, -10.79_26, -2.33_36, 1.50_92, -0.99_74, -6.82_13, 1.34_77, 1.34_77],
						    ])
						self.assertTrue(np.allclose(a		,       a		,       atol=1E-4))

						SCREAMING_SNAKE_CASE							=			tf.function(a		,       jit_compile=a)
						SCREAMING_SNAKE_CASE							=			tf.math.reduce_mean(xla_generate(inputs.input_ids		,       attention_mask=inputs.attention_mask)[0]		,       axis=-1)
						self.assertTrue(np.allclose(a		,       a		,       atol=1E-4))



@require_tf
@slow
class 		_snake_case	(	unittest.TestCase       ):






			@property
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[Any]:
						return [
						    "Today is a beautiful day and I want",
						    "In the city of",
						    "Paris is the capital of France and",
						    "Computers and mobile phones have taken",
						]






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[int]:
						SCREAMING_SNAKE_CASE							=			'facebook/opt-125m'

						SCREAMING_SNAKE_CASE							=			[
						    'Today is a beautiful day and I want to',
						    'In the city of New York, the city',
						    'Paris is the capital of France and the capital',
						    'Computers and mobile phones have taken over the',
						]

						SCREAMING_SNAKE_CASE							=			[]
						SCREAMING_SNAKE_CASE							=			GPTaTokenizer.from_pretrained(a)
						SCREAMING_SNAKE_CASE							=			TFOPTForCausalLM.from_pretrained(a)

						for prompt in self.prompts:
									SCREAMING_SNAKE_CASE							=			tokenizer(a		,       return_tensors='tf').input_ids

									SCREAMING_SNAKE_CASE							=			model.generate(a		,       max_length=10)

									SCREAMING_SNAKE_CASE							=			tokenizer.batch_decode(a		,       skip_special_tokens=a)
									predicted_outputs += generated_string

						self.assertListEqual(a		,       a)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[int]:
						SCREAMING_SNAKE_CASE							=			'facebook/opt-350m'

						SCREAMING_SNAKE_CASE							=			GPTaTokenizer.from_pretrained(a)
						SCREAMING_SNAKE_CASE							=			TFOPTForCausalLM.from_pretrained(a)

						SCREAMING_SNAKE_CASE							=			'left'

						# use different length sentences to test batching
						SCREAMING_SNAKE_CASE							=			[
						    'Hello, my dog is a little',
						    'Today, I',
						]

						SCREAMING_SNAKE_CASE							=			tokenizer(a		,       return_tensors='tf'		,       padding=a)
						SCREAMING_SNAKE_CASE							=			inputs['input_ids']

						SCREAMING_SNAKE_CASE							=			model.generate(input_ids=a		,       attention_mask=inputs['attention_mask'])

						SCREAMING_SNAKE_CASE							=			tokenizer(sentences[0]		,       return_tensors='tf').input_ids
						SCREAMING_SNAKE_CASE							=			model.generate(input_ids=a)

						SCREAMING_SNAKE_CASE							=			inputs_non_padded.shape[-1] - tf.math.reduce_sum(
						    tf.cast(inputs['attention_mask'][-1]		,       tf.intaa))
						SCREAMING_SNAKE_CASE							=			tokenizer(sentences[1]		,       return_tensors='tf').input_ids
						SCREAMING_SNAKE_CASE							=			model.generate(input_ids=a		,       max_length=model.config.max_length - num_paddings)

						SCREAMING_SNAKE_CASE							=			tokenizer.batch_decode(a		,       skip_special_tokens=a)
						SCREAMING_SNAKE_CASE							=			tokenizer.decode(output_non_padded[0]		,       skip_special_tokens=a)
						SCREAMING_SNAKE_CASE							=			tokenizer.decode(output_padded[0]		,       skip_special_tokens=a)

						SCREAMING_SNAKE_CASE							=			[
						    'Hello, my dog is a little bit of a dork.\nI\'m a little bit',
						    'Today, I was in the middle of a conversation with a friend about the',
						]
						self.assertListEqual(a		,       a)
						self.assertListEqual(a		,       [non_padded_sentence, padded_sentence])







			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[int]:
						SCREAMING_SNAKE_CASE							=			'facebook/opt-350m'

						SCREAMING_SNAKE_CASE							=			[
						    'Today is a beautiful day and I want to',
						    'In the city of San Francisco, the city',
						    'Paris is the capital of France and the capital',
						    'Computers and mobile phones have taken over the',
						]

						SCREAMING_SNAKE_CASE							=			[]
						SCREAMING_SNAKE_CASE							=			GPTaTokenizer.from_pretrained(a)
						SCREAMING_SNAKE_CASE							=			TFOPTForCausalLM.from_pretrained(a)

						for prompt in self.prompts:
									SCREAMING_SNAKE_CASE							=			tokenizer(a		,       return_tensors='tf').input_ids

									SCREAMING_SNAKE_CASE							=			model.generate(a		,       max_length=10)

									SCREAMING_SNAKE_CASE							=			tokenizer.batch_decode(a		,       skip_special_tokens=a)
									predicted_outputs += generated_string

						self.assertListEqual(a		,       a)






"""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


UpperCamelCase__          =	{
    '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 				a			(					unittest.TestCase      ):



      @classmethod
      def  __snake_case							(   cls      ):
          UpperCAmelCase__	:      List[str]     							=					TOKEN
          HfFolder.save_token(UpperCamelCase_      )



      @classmethod
      def  __snake_case							(   cls      ):
          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  __snake_case							(   self      ):
          UpperCAmelCase__	:      Optional[Any]     							=					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      )

          UpperCAmelCase__	:      Optional[int]     							=					BertConfig.from_pretrained(F'''{USER}/test-config'''      )
          for k, v in config.to_dict().items():
              if k != "transformers_version":
                  self.assertEqual(UpperCamelCase_     ,	getattr(UpperCamelCase_     ,	UpperCamelCase_      )      )

        # 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(UpperCamelCase_     ,	repo_id='test-config'     ,	push_to_hub=UpperCamelCase_     ,	use_auth_token=self._token      )

          UpperCAmelCase__	:      Union[str, Any]     							=					BertConfig.from_pretrained(F'''{USER}/test-config'''      )
          for k, v in config.to_dict().items():
              if k != "transformers_version":
                  self.assertEqual(UpperCamelCase_     ,	getattr(UpperCamelCase_     ,	UpperCamelCase_      )      )



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      List[Any]     							=					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      )

          UpperCAmelCase__	:      Union[str, Any]     							=					BertConfig.from_pretrained('valid_org/test-config-org'      )
          for k, v in config.to_dict().items():
              if k != "transformers_version":
                  self.assertEqual(UpperCamelCase_     ,	getattr(UpperCamelCase_     ,	UpperCamelCase_      )      )

        # 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(
                  UpperCamelCase_     ,	repo_id='valid_org/test-config-org'     ,	push_to_hub=UpperCamelCase_     ,	use_auth_token=self._token      )

          UpperCAmelCase__	:      Optional[Any]     							=					BertConfig.from_pretrained('valid_org/test-config-org'      )
          for k, v in config.to_dict().items():
              if k != "transformers_version":
                  self.assertEqual(UpperCamelCase_     ,	getattr(UpperCamelCase_     ,	UpperCamelCase_      )      )



      def  __snake_case							(   self      ):
          CustomConfig.register_for_auto_class()
          UpperCAmelCase__	:      Dict     							=					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'}      )

          UpperCAmelCase__	:      Any     							=					AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''     ,	trust_remote_code=UpperCamelCase_      )
          # 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 				a			(					unittest.TestCase      ):



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      List[str]     							=					GPTaConfig()

          # attempt to modify each of int/float/bool/str config records and verify they were updated
          UpperCAmelCase__	:      List[str]     							=					c.n_embd + 1  # int
          UpperCAmelCase__	:      Optional[int]     							=					c.resid_pdrop + 1.0  # float
          UpperCAmelCase__	:      Optional[int]     							=					not c.scale_attn_weights  # bool
          UpperCAmelCase__	:      str     							=					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(UpperCamelCase_     ,	c.n_embd     ,	'mismatch for key: n_embd'      )
          self.assertEqual(UpperCamelCase_     ,	c.resid_pdrop     ,	'mismatch for key: resid_pdrop'      )
          self.assertEqual(UpperCamelCase_     ,	c.scale_attn_weights     ,	'mismatch for key: scale_attn_weights'      )
          self.assertEqual(UpperCamelCase_     ,	c.summary_type     ,	'mismatch for key: summary_type'      )



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Dict     							=					PretrainedConfig()
          UpperCAmelCase__	:      str     							=					[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(
              UpperCamelCase_     ,	['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']      )
          UpperCAmelCase__	:      int     							=					[key for key, value in config_common_kwargs.items() if value == getattr(UpperCamelCase_     ,	UpperCamelCase_      )]
          if len(UpperCamelCase_      ) > 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(UpperCamelCase_      )}.'''      )



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

          UpperCAmelCase__	:      str     							=					BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'     ,	subfolder='bert'      )

          self.assertIsNotNone(UpperCamelCase_      )



      def  __snake_case							(   self      ):
          # A mock response for an HTTP head request to emulate server down
          UpperCAmelCase__	:      str     							=					mock.Mock()
          UpperCAmelCase__	:      List[Any]     							=					500
          UpperCAmelCase__	:      Optional[int]     							=					{}
          UpperCAmelCase__	:      Dict     							=					HTTPError
          UpperCAmelCase__	:      Optional[int]     							=					{}

          # Download this model to make sure it's in the cache.
          UpperCAmelCase__	:      List[str]     							=					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=UpperCamelCase_      ) as mock_head:
              UpperCAmelCase__	:      Optional[Any]     							=					BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert'      )
              # This check we did call the fake head request
              mock_head.assert_called()



      def  __snake_case							(   self      ):
          # This test is for deprecated behavior and can be removed in v5
          UpperCAmelCase__	:      List[str]     							=					BertConfig.from_pretrained(
              'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'      )



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      int     							=					AutoConfig.from_pretrained('bert-base-cased'      )
          UpperCAmelCase__	:      str     							=					['config.4.0.0.json']

          with tempfile.TemporaryDirectory() as tmp_dir:
              configuration.save_pretrained(UpperCamelCase_      )
              UpperCAmelCase__	:      List[str]     							=					2
              json.dump(configuration.to_dict()     ,	open(os.path.join(UpperCamelCase_     ,	'config.4.0.0.json'      )     ,	'w'      )      )

              # This should pick the new configuration file as the version of Transformers is > 4.0.0
              UpperCAmelCase__	:      Any     							=					AutoConfig.from_pretrained(UpperCamelCase_      )
              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
              UpperCAmelCase__	:      Tuple     							=					['config.42.0.0.json']
              UpperCAmelCase__	:      Tuple     							=					768
              configuration.save_pretrained(UpperCamelCase_      )
              shutil.move(os.path.join(UpperCamelCase_     ,	'config.4.0.0.json'      )     ,	os.path.join(UpperCamelCase_     ,	'config.42.0.0.json'      )      )
              UpperCAmelCase__	:      Any     							=					AutoConfig.from_pretrained(UpperCamelCase_      )
              self.assertEqual(new_configuration.hidden_size     ,	768      )



      def  __snake_case							(   self      ):
          # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
          UpperCAmelCase__	:      Tuple     							=					'hf-internal-testing/test-two-configs'

          import transformers as new_transformers

          UpperCAmelCase__	:      Optional[int]     							=					'v4.0.0'
          UpperCAmelCase__							,							UpperCAmelCase__	:      Any     							=					new_transformers.models.auto.AutoConfig.from_pretrained(
              UpperCamelCase_     ,	return_unused_kwargs=UpperCamelCase_      )
          self.assertEqual(new_configuration.hidden_size     ,	2      )
          # This checks `_configuration_file` ia not kept in the kwargs by mistake.
          self.assertDictEqual(UpperCamelCase_     ,	{}      )

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

          UpperCAmelCase__	:      List[Any]     							=					'v3.0.0'
          UpperCAmelCase__	:      Union[str, Any]     							=					old_transformers.models.auto.AutoConfig.from_pretrained(UpperCamelCase_      )
          self.assertEqual(old_configuration.hidden_size     ,	768      )

