


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


lowerCAmelCase    :     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	):



     """simple docstring"""






     @classmethod
     def a	( cls   ):

            '''simple docstring'''

            _lowerCAmelCase    :							str   			=       TOKEN
            HfFolder.save_token(UpperCamelCase__   )







     @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    :							Union[str, 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   )

            _lowerCAmelCase    :							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   )

            _lowerCAmelCase    :							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__   )   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							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   )

            _lowerCAmelCase    :							List[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   )

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

            '''simple docstring'''

            CustomConfig.register_for_auto_class()
            _lowerCAmelCase    :							List[Any]   			=       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    :							int   			=       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 a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       GPTaConfig()

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

            '''simple docstring'''

            _lowerCAmelCase    :							Union[str, Any]   			=       PretrainedConfig()
            _lowerCAmelCase    :							Optional[int]   			=       [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']   )
            _lowerCAmelCase    :							Optional[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 a	( self   ):

            '''simple docstring'''

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

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

            self.assertIsNotNone(UpperCamelCase__   )







     def a	( self   ):

            '''simple docstring'''

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

            # Download this model to make sure it's in the cache.
            _lowerCAmelCase    :							Dict   			=       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:
                   _lowerCAmelCase    :							str   			=       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    :							Optional[Any]   			=       BertConfig.from_pretrained(
                'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[int]   			=       AutoConfig.from_pretrained('bert-base-cased'   )
            _lowerCAmelCase    :							Tuple   			=       ['''config.4.0.0.json''']

            with tempfile.TemporaryDirectory() as tmp_dir:
                   configuration.save_pretrained(UpperCamelCase__   )
                   _lowerCAmelCase    :							Optional[Any]   			=       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
                   _lowerCAmelCase    :							List[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
                   _lowerCAmelCase    :							Any   			=       ['''config.42.0.0.json''']
                   _lowerCAmelCase    :							Dict   			=       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'   )   )
                   _lowerCAmelCase    :							Union[str, Any]   			=       AutoConfig.from_pretrained(UpperCamelCase__   )
                   self.assertEqual(new_configuration.hidden_size      ,	768   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       '''hf-internal-testing/test-two-configs'''

            import transformers as new_transformers

            _lowerCAmelCase    :							int   			=       '''v4.0.0'''
            _lowerCAmelCase    :							Dict   			=       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

            _lowerCAmelCase    :							Optional[int]   			=       '''v3.0.0'''
            _lowerCAmelCase    :							Dict   			=       old_transformers.models.auto.AutoConfig.from_pretrained(UpperCamelCase__   )
            self.assertEqual(old_configuration.hidden_size      ,	768   )





'''simple docstring'''







import unittest

from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow


if is_flax_available():
       import jax.numpy as jnp

       from transformers import FlaxXLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_flax
class 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       FlaxXLMRobertaModel.from_pretrained('xlm-roberta-base'   )
            _lowerCAmelCase    :							Optional[Any]   			=       AutoTokenizer.from_pretrained('xlm-roberta-base'   )
            _lowerCAmelCase    :							Dict   			=       'The dog is cute and lives in the garden house'
            _lowerCAmelCase    :							List[str]   			=       jnp.array([tokenizer.encode(snake_case__   )]   )

            _lowerCAmelCase    :							Optional[int]   			=       (1, 12, 768)  # batch_size, sequence_length, embedding_vector_dim
            _lowerCAmelCase    :							Tuple   			=       jnp.array(
                [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]]   )

            _lowerCAmelCase    :							Union[str, Any]   			=       model(snake_case__   )['last_hidden_state']
            self.assertEqual(output.shape      ,	snake_case__   )
            # compare the actual values for a slice of last dim
            self.assertTrue(jnp.allclose(output[:, :, -1]      ,	snake_case__      ,	atol=1E-3   )   )

