



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_    :  Union[str, 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_2_8,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 5_0,
    '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': 1_0,
    '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': 1_0,
    '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  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     @classmethod
     def     _a   (cls     ):






           '''simple docstring'''



           lowerCamelCase             =		TOKEN
           HfFolder.save_token(__a     )







     @classmethod
     def     _a   (cls     ):






           '''simple docstring'''



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






           '''simple docstring'''



           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(__a					,      getattr(__a					,      __a     )     )

        # 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(__a					,      repo_id="test-config"					,      push_to_hub=__a					,      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(__a					,      getattr(__a					,      __a     )     )







     def     _a   (self     ):






           '''simple docstring'''



           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(__a					,      getattr(__a					,      __a     )     )

        # 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(
                     __a					,      repo_id="valid_org/test-config-org"					,      push_to_hub=__a					,      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(__a					,      getattr(__a					,      __a     )     )







     def     _a   (self     ):






           '''simple docstring'''



           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=__a     )
           # 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  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     def     _a   (self     ):






           '''simple docstring'''



           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(__a					,      c.n_embd					,      "mismatch for key: n_embd"     )
           self.assertEqual(__a					,      c.resid_pdrop					,      "mismatch for key: resid_pdrop"     )
           self.assertEqual(__a					,      c.scale_attn_weights					,      "mismatch for key: scale_attn_weights"     )
           self.assertEqual(__a					,      c.summary_type					,      "mismatch for key: summary_type"     )







     def     _a   (self     ):






           '''simple docstring'''



           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(
               __a					,      ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]     )
           lowerCamelCase             =		[key for key, value in config_common_kwargs.items() if value == getattr(__a					,      __a     )]
           if len(__a     ) > 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(__a     )}."""     )







     def     _a   (self     ):






           '''simple docstring'''



           with self.assertRaises(__a     ):
                 # 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(__a     )







     def     _a   (self     ):






           '''simple docstring'''



           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=__a     ) 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     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		BertConfig.from_pretrained(
               "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		AutoConfig.from_pretrained("bert-base-cased"     )
           lowerCamelCase             =		["config.4.0.0.json"]

           with tempfile.TemporaryDirectory() as tmp_dir:
                 configuration.save_pretrained(__a     )
                 lowerCamelCase             =		2
                 json.dump(configuration.to_dict()					,      open(os.path.join(__a					,      "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(__a     )
                 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(__a     )
                 shutil.move(os.path.join(__a					,      "config.4.0.0.json"     )					,      os.path.join(__a					,      "config.42.0.0.json"     )     )
                 lowerCamelCase             =		AutoConfig.from_pretrained(__a     )
                 self.assertEqual(new_configuration.hidden_size					,      7_68     )







     def     _a   (self     ):






           '''simple docstring'''



           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(
               __a					,      return_unused_kwargs=__a     )
           self.assertEqual(new_configuration.hidden_size					,      2     )
           # This checks `_configuration_file` ia not kept in the kwargs by mistake.
           self.assertDictEqual(__a					,      {}     )

           # 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(__a     )
           self.assertEqual(old_configuration.hidden_size					,      7_68     )




import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
         OpenAIGPTConfig,
         OpenAIGPTDoubleHeadsModel,
         OpenAIGPTForSequenceClassification,
         OpenAIGPTLMHeadModel,
         OpenAIGPTModel,
     )





class  lowerCamelCase__	:
     """simple docstring"""



     def __init__(self					,      __a					,      __a=13					,      __a=7					,      __a=True					,      __a=True					,      __a=True					,      __a=99					,      __a=32					,      __a=5					,      __a=4					,      __a=37					,      __a="gelu"					,      __a=0.1					,      __a=0.1					,      __a=5_12					,      __a=16					,      __a=2					,      __a=0.02					,      __a=3					,      __a=4					,      __a=None					,      ):






           '''simple docstring'''



           lowerCamelCase             =		parent
           lowerCamelCase             =		batch_size
           lowerCamelCase             =		seq_length
           lowerCamelCase             =		is_training
           lowerCamelCase             =		use_token_type_ids
           lowerCamelCase             =		use_labels
           lowerCamelCase             =		vocab_size
           lowerCamelCase             =		hidden_size
           lowerCamelCase             =		num_hidden_layers
           lowerCamelCase             =		num_attention_heads
           lowerCamelCase             =		intermediate_size
           lowerCamelCase             =		hidden_act
           lowerCamelCase             =		hidden_dropout_prob
           lowerCamelCase             =		attention_probs_dropout_prob
           lowerCamelCase             =		max_position_embeddings
           lowerCamelCase             =		type_vocab_size
           lowerCamelCase             =		type_sequence_label_size
           lowerCamelCase             =		initializer_range
           lowerCamelCase             =		num_labels
           lowerCamelCase             =		num_choices
           lowerCamelCase             =		scope
           lowerCamelCase             =		self.vocab_size - 1







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size     )

           lowerCamelCase             =		None
           if self.use_token_type_ids:
                 lowerCamelCase             =		ids_tensor([self.batch_size, self.seq_length]					,      self.type_vocab_size     )

           lowerCamelCase             =		None
           lowerCamelCase             =		None
           lowerCamelCase             =		None
           if self.use_labels:
                 lowerCamelCase             =		ids_tensor([self.batch_size]					,      self.type_sequence_label_size     )
                 lowerCamelCase             =		ids_tensor([self.batch_size, self.seq_length]					,      self.num_labels     )
                 lowerCamelCase             =		ids_tensor([self.batch_size]					,      self.num_choices     )

           lowerCamelCase             =		OpenAIGPTConfig(
               vocab_size=self.vocab_size					,      n_embd=self.hidden_size					,      n_layer=self.num_hidden_layers					,      n_head=self.num_attention_heads					,      n_positions=self.max_position_embeddings					,      pad_token_id=self.pad_token_id					,      )

           lowerCamelCase             =		ids_tensor([self.num_hidden_layers, self.num_attention_heads]					,      2     )

           return (
               config,
               input_ids,
               head_mask,
               token_type_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )







     def     _a   (self					,      __a					,      __a					,      __a					,      __a					,      *__a     ):






           '''simple docstring'''



           lowerCamelCase             =		OpenAIGPTModel(config=__a     )
           model.to(__a     )
           model.eval()

           lowerCamelCase             =		model(__a					,      token_type_ids=__a					,      head_mask=__a     )
           lowerCamelCase             =		model(__a					,      token_type_ids=__a     )
           lowerCamelCase             =		model(__a     )

           self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size)     )







     def     _a   (self					,      __a					,      __a					,      __a					,      __a					,      *__a     ):






           '''simple docstring'''



           lowerCamelCase             =		OpenAIGPTLMHeadModel(__a     )
           model.to(__a     )
           model.eval()

           lowerCamelCase             =		model(__a					,      token_type_ids=__a					,      labels=__a     )
           self.parent.assertEqual(result.loss.shape					,      ()     )
           self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.vocab_size)     )







     def     _a   (self					,      __a					,      __a					,      __a					,      __a					,      *__a     ):






           '''simple docstring'''



           lowerCamelCase             =		OpenAIGPTDoubleHeadsModel(__a     )
           model.to(__a     )
           model.eval()

           lowerCamelCase             =		model(__a					,      token_type_ids=__a					,      labels=__a     )
           self.parent.assertEqual(result.loss.shape					,      ()     )
           self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.vocab_size)     )







     def     _a   (self					,      __a					,      __a					,      __a					,      __a					,      *__a     ):






           '''simple docstring'''



           lowerCamelCase             =		self.num_labels
           lowerCamelCase             =		OpenAIGPTForSequenceClassification(__a     )
           model.to(__a     )
           model.eval()

           lowerCamelCase             =		ids_tensor([self.batch_size]					,      self.type_sequence_label_size     )
           lowerCamelCase             =		model(__a					,      token_type_ids=__a					,      labels=__a     )
           self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_labels)     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.prepare_config_and_inputs()
           (
               (
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				(
               lowerCamelCase
           )      ,				
           )             =		config_and_inputs
           lowerCamelCase             =		{
               "input_ids": input_ids,
               "token_type_ids": token_type_ids,
               "head_mask": head_mask,
           }

           return config, inputs_dict





@require_torch
class  lowerCamelCase__	(    UpperCAmelCase_							,     UpperCAmelCase_							,     UpperCAmelCase_							,     unittest.TestCase):
     """simple docstring"""



     _A      =      (
         (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
         if is_torch_available()
         else ()
     )
     _A      =      (
         (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
     _A      =      (
         {
             'feature-extraction': OpenAIGPTModel,
             'text-classification': OpenAIGPTForSequenceClassification,
             'text-generation': OpenAIGPTLMHeadModel,
             'zero-shot': OpenAIGPTForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )







     def     _a   (self					,      __a					,      __a					,      __a					,      __a					,      __a     ):






           '''simple docstring'''



           if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                 # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                 # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
                 # tiny config could not be created.
                 return True

           return False







     def     _a   (self					,      __a					,      __a					,      __a=False     ):






           '''simple docstring'''



           lowerCamelCase             =		super()._prepare_for_class(__a					,      __a					,      return_labels=__a     )

           if return_labels:
                 if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
                       lowerCamelCase             =		torch.zeros(
                           (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)					,      dtype=torch.long					,      device=__a					,      )
                       lowerCamelCase             =		inputs_dict["labels"]
                       lowerCamelCase             =		inputs_dict["labels"]
                       lowerCamelCase             =		torch.zeros(
                           (self.model_tester.batch_size, self.model_tester.num_choices)					,      dtype=torch.long					,      device=__a					,      )
                       lowerCamelCase             =		torch.zeros(
                           self.model_tester.batch_size					,      dtype=torch.long					,      device=__a     )
           return inputs_dict







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		OpenAIGPTModelTester(self     )
           lowerCamelCase             =		ConfigTester(self					,      config_class=__a					,      n_embd=37     )







     def     _a   (self     ):






           '''simple docstring'''



           self.config_tester.run_common_tests()







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_model(*__a     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_lm_head_model(*__a     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_double_lm_head_model(*__a     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*__a     )







     @slow
     def     _a   (self     ):






           '''simple docstring'''



           for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCamelCase             =		OpenAIGPTModel.from_pretrained(__a     )
                 self.assertIsNotNone(__a     )





@require_torch
class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     @slow
     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		OpenAIGPTLMHeadModel.from_pretrained("openai-gpt"     )
           model.to(__a     )
           lowerCamelCase             =		torch.tensor([[4_81, 47_35, 5_44]]					,      dtype=torch.long					,      device=__a     )  # the president is
           lowerCamelCase             =		[
               4_81,
               47_35,
               5_44,
               2_46,
               9_63,
               8_70,
               7_62,
               2_39,
               2_44,
               4_04_77,
               2_44,
               2_49,
               7_19,
               8_81,
               4_87,
               5_44,
               2_40,
               2_44,
               6_03,
               4_81,
           ]  # the president is a very good man. " \n " i\'m sure he is, " said the

           lowerCamelCase             =		model.generate(__a					,      do_sample=__a     )
           self.assertListEqual(output_ids[0].tolist()					,      __a     )