




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


_lowerCamelCase	:		Optional[int]							       =   {
    """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""": 128,
    """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     ):

    '''simple docstring'''






    @classmethod
    def        SCREAMING_SNAKE_CASE							(			cls      :	Tuple)						->Union[str, Any]:





           '''simple docstring'''

           A__       =    TOKEN
           HfFolder.save_token(UpperCAmelCase__)


    @classmethod
    def        SCREAMING_SNAKE_CASE							(			cls      :	Optional[int])						->Optional[int]:





           '''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        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Union[str, Any]:





           '''simple docstring'''

           A__       =    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)

           A__       =    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)

           A__       =    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        SCREAMING_SNAKE_CASE							(			self      :	str)						->Tuple:





           '''simple docstring'''

           A__       =    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)

           A__       =    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)

           A__       =    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        SCREAMING_SNAKE_CASE							(			self      :	str)						->Dict:





           '''simple docstring'''

           CustomConfig.register_for_auto_class()
           A__       =    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'''})

           A__       =    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 				UpperCamelCase_    ( unittest.TestCase     ):

    '''simple docstring'''






    def        SCREAMING_SNAKE_CASE							(			self      :	Any)						->Tuple:





           '''simple docstring'''

           A__       =    GPTaConfig()

           # attempt to modify each of int/float/bool/str config records and verify they were updated
           A__       =    c.n_embd + 1  # int
           A__       =    c.resid_pdrop + 1.0  # float
           A__       =    not c.scale_attn_weights  # bool
           A__       =    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        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->List[str]:





           '''simple docstring'''

           A__       =    PretrainedConfig()
           A__       =    [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'''])
           A__       =    [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        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Dict:





           '''simple docstring'''

           with self.assertRaises(UpperCAmelCase__):
                  # config is in subfolder, the following should not work without specifying the subfolder
                  A__       =    BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder''')

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

           self.assertIsNotNone(UpperCAmelCase__)


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





           '''simple docstring'''

           A__       =    mock.Mock()
           A__       =    500
           A__       =    {}
           A__       =    HTTPError
           A__       =    {}

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


    def        SCREAMING_SNAKE_CASE							(			self      :	str)						->Tuple:





           '''simple docstring'''

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


    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->str:





           '''simple docstring'''

           A__       =    AutoConfig.from_pretrained('''bert-base-cased''')
           A__       =    ['''config.4.0.0.json''']

           with tempfile.TemporaryDirectory() as tmp_dir:
                  configuration.save_pretrained(UpperCAmelCase__)
                  A__       =    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
                  A__       =    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
                  A__       =    ['''config.42.0.0.json''']
                  A__       =    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'''))
                  A__       =    AutoConfig.from_pretrained(UpperCAmelCase__)
                  self.assertEqual(new_configuration.hidden_size					, 768)





    def        SCREAMING_SNAKE_CASE							(			self      :	str)						->Optional[Any]:





           '''simple docstring'''

           A__       =    '''hf-internal-testing/test-two-configs'''

           import transformers as new_transformers

           A__       =    '''v4.0.0'''
           A__ ,							A__       =    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

           A__       =    '''v3.0.0'''
           A__       =    old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase__)
           self.assertEqual(old_configuration.hidden_size					, 768)








from ...processing_utils import ProcessorMixin


class 				UpperCamelCase_    ( UpperCAmelCase__     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      '''SpeechT5FeatureExtractor'''
    UpperCAmelCase__							  =      '''SpeechT5Tokenizer'''


    def __init__(			self      :	Any					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Tuple)						->Union[str, Any]:





           '''simple docstring'''

           super().__init__(UpperCAmelCase__					, UpperCAmelCase__)


    def __call__(			self      :	Dict					, *UpperCAmelCase__      :	List[str]					, **UpperCAmelCase__      :	Any)						->Optional[Any]:





           '''simple docstring'''

           A__       =    kwargs.pop('''audio'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''audio_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''sampling_rate'''					, UpperCAmelCase__)

           if audio is not None and text is not None:
                  raise ValueError(
                      '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''')
           if audio_target is not None and text_target is not None:
                  raise ValueError(
                      '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''')
           if audio is None and audio_target is None and text is None and text_target is None:
                  raise ValueError(
                      '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''')

           if audio is not None:
                  A__       =    self.feature_extractor(UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
           elif text is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if audio_target is not None:
                  A__       =    self.feature_extractor(audio_target=UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_values''']
           elif text_target is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_ids''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	Tuple					, **UpperCAmelCase__      :	int)						->Optional[int]:





           '''simple docstring'''

           A__       =    kwargs.pop('''input_values'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''input_ids'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''labels'''					, UpperCAmelCase__)

           if input_values is not None and input_ids is not None:
                  raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''')
           if input_values is None and input_ids is None and labels is None:
                  raise ValueError(
                      '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''')

           if input_values is not None:
                  A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
           elif input_ids is not None:
                  A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if labels is not None:
                  if "input_ids" in labels or (isinstance(UpperCAmelCase__					, UpperCAmelCase__) and "input_ids" in labels[0]):
                         A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    targets['''input_ids''']
                  else:
                         A__       =    self.feature_extractor.feature_size
                         A__       =    self.feature_extractor.num_mel_bins
                         A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    feature_size_hack
                         A__       =    targets['''input_values''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Any					, *UpperCAmelCase__      :	Dict					, **UpperCAmelCase__      :	Optional[Any])						->Optional[Any]:





           '''simple docstring'''

           return self.tokenizer.batch_decode(*UpperCAmelCase__					, **UpperCAmelCase__)





    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	List[Any]					, **UpperCAmelCase__      :	Union[str, Any])						->Dict:





           '''simple docstring'''

           return self.tokenizer.decode(*UpperCAmelCase__					, **UpperCAmelCase__)


