from .imports import is_tqdm_available


if is_tqdm_available():
	from tqdm.auto import tqdm as _tqdm

from ..state import PartialState




def     UpperCamelCase						(	__lowercase						:			bool = True						,*__lowercase						:			Optional[Any]						,**__lowercase						:			List[str]     ):
		'''simple docstring'''




		if not is_tqdm_available():
				raise ImportError('Accelerate\'s `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`.'     )
		A_		:    Union[str, Any]         =				False
		if main_process_only:
				A_		:    Tuple         =				PartialState().local_process_index == 0
		return _tqdm(*__lowercase						,**__lowercase						,disable=__lowercase     )







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""": 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   lowerCAmelCase_       (						cls ):



						"""simple docstring"""





						A_		:    Optional[int]         =				TOKEN
						HfFolder.save_token(lowercase )
				@classmethod
				def   lowerCAmelCase_       (						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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Union[str, Any]         =				BertConfig(
						    vocab_size=9_9		,     hidden_size=3_2		,     num_hidden_layers=5		,     num_attention_heads=4		,     intermediate_size=3_7 )
						config.push_to_hub('test-config'		,     use_auth_token=self._token )

						A_		:    Dict         =				BertConfig.from_pretrained(F'''{USER}/test-config''' )
						for k, v in config.to_dict().items():
								if k != "transformers_version":
										self.assertEqual(lowercase		,     getattr(lowercase		,     lowercase ) )

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

						A_		:    Dict         =				BertConfig.from_pretrained(F'''{USER}/test-config''' )
						for k, v in config.to_dict().items():
								if k != "transformers_version":
										self.assertEqual(lowercase		,     getattr(lowercase		,     lowercase ) )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    List[str]         =				BertConfig(
						    vocab_size=9_9		,     hidden_size=3_2		,     num_hidden_layers=5		,     num_attention_heads=4		,     intermediate_size=3_7 )
						config.push_to_hub('valid_org/test-config-org'		,     use_auth_token=self._token )

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

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

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







				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						CustomConfig.register_for_auto_class()
						A_		:    Optional[int]         =				CustomConfig(attribute=4_2 )

						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_		:    Optional[int]         =				AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''		,     trust_remote_code=lowercase )
						# 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		,     4_2 )





class UpperCAmelCase						( unittest.TestCase  ):


				'''simple docstring'''






				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    int         =				GPTaConfig()

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



						"""simple docstring"""





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



						"""simple docstring"""





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

						A_		:    Optional[int]         =				BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'		,     subfolder='bert' )

						self.assertIsNotNone(lowercase )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    int         =				mock.Mock()
						A_		:    int         =				5_0_0
						A_		:    Union[str, Any]         =				{}
						A_		:    List[str]         =				HTTPError
						A_		:    List[Any]         =				{}

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



						"""simple docstring"""





						A_		:    Any         =				BertConfig.from_pretrained(
						    'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json' )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





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

						with tempfile.TemporaryDirectory() as tmp_dir:
								configuration.save_pretrained(lowercase )
								A_		:    Dict         =				2
								json.dump(configuration.to_dict()		,     open(os.path.join(lowercase		,     'config.4.0.0.json' )		,     'w' ) )

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







				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    List[Any]         =				'hf-internal-testing/test-two-configs'

						import transformers as new_transformers

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

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

						A_		:    Optional[int]         =				'v3.0.0'
						A_		:    List[Any]         =				old_transformers.models.auto.AutoConfig.from_pretrained(lowercase )
						self.assertEqual(old_configuration.hidden_size		,     7_6_8 )






