

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_ :				Tuple						 =    {
    '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 					_a		(unittest.TestCase       ):


					'''simple docstring'''






					@classmethod
					def 						__A    (				cls    ):
						A__							:					List[str]       =	TOKEN
						HfFolder.save_token(A__    )






					@classmethod
					def 						__A    (				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 						__A    (				self    ):
						A__							:					int       =	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__							:					Optional[Any]       =	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    )

						A__							:					str       =	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    ):
						A__							:					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("""valid_org/test-config-org"""					, 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(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    )

						A__							:					str       =	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    ):
						CustomConfig.register_for_auto_class()
						A__							:					Optional[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"""}    )

						A__							:					Optional[int]       =	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 					_a		(unittest.TestCase       ):


					'''simple docstring'''






					def 						__A    (				self    ):
						A__							:					Any       =	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__							:					Union[str, Any]       =	not c.scale_attn_weights  # bool
						A__							:					Optional[Any]       =	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    ):
						A__							:					Optional[Any]       =	PretrainedConfig()
						A__							:					Tuple       =	[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"""]    )
						A__							:					int       =	[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    ):
						with self.assertRaises(A__    ):
							# config is in subfolder, the following should not work without specifying the subfolder
							A__							:					Any       =	BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""    )

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

						self.assertIsNotNone(A__    )






					def 						__A    (				self    ):
						# A mock response for an HTTP head request to emulate server down
						A__							:					Tuple       =	mock.Mock()
						A__							:					Tuple       =	500
						A__							:					Tuple       =	{}
						A__							:					Dict       =	HTTPError
						A__							:					Optional[Any]       =	{}

						# Download this model to make sure it's in the cache.
						A__							:					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=A__    ) as mock_head:
							A__							:					int       =	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    ):
						# This test is for deprecated behavior and can be removed in v5
						A__							:					List[Any]       =	BertConfig.from_pretrained(
						    """https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"""    )






					def 						__A    (				self    ):
						A__							:					Any       =	AutoConfig.from_pretrained("""bert-base-cased"""    )
						A__							:					str       =	["""config.4.0.0.json"""]

						with tempfile.TemporaryDirectory() as tmp_dir:
							configuration.save_pretrained(A__    )
							A__							:					List[str]       =	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
							A__							:					Optional[int]       =	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
							A__							:					Dict       =	["""config.42.0.0.json"""]
							A__							:					Any       =	768
							configuration.save_pretrained(A__    )
							shutil.move(os.path.join(A__					, """config.4.0.0.json"""    )					, os.path.join(A__					, """config.42.0.0.json"""    )    )
							A__							:					List[Any]       =	AutoConfig.from_pretrained(A__    )
							self.assertEqual(new_configuration.hidden_size					, 768    )






					def 						__A    (				self    ):
						# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
						A__							:					List[Any]       =	"""hf-internal-testing/test-two-configs"""

						import transformers as new_transformers

						A__							:					Union[str, Any]       =	"""v4.0.0"""
						A__     ,     A__							:					List[Any]       =	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

						A__							:					Tuple       =	"""v3.0.0"""
						A__							:					str       =	old_transformers.models.auto.AutoConfig.from_pretrained(A__    )
						self.assertEqual(old_configuration.hidden_size					, 768    )






import inspect
import warnings
from typing import Any, Dict, Optional, Union

from packaging import version

def 		UpperCamelCase      (*lowercase_:				Optional[int]					,   lowercase_:				Optional[Union[Dict, Any]] = None					,   lowercase_:				Dict=True					,   lowercase_:				Tuple=2      )  ->   Dict:
	from .. import __version__

	A__							:					Dict       =	take_from
	A__							:					str       =	()
	if not isinstance(args[0]					,   lowercase_      ):
		A__							:					int       =	(args,)

	for attribute, version_name, message in args:
		if version.parse(version.parse(lowercase_      ).base_version      ) >= version.parse(lowercase_      ):
			raise ValueError(
			    f"""The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'"""
			    f""" version {__version__} is >= {version_name}"""      )

		A__							:					Any       =	None
		if isinstance(lowercase_					,   lowercase_      ) and attribute in deprecated_kwargs:
			values += (deprecated_kwargs.pop(lowercase_      ),)
			A__							:					List[str]       =	f"""The `{attribute}` argument is deprecated and will be removed in version {version_name}."""
		elif hasattr(lowercase_					,   lowercase_      ):
			values += (getattr(lowercase_					,   lowercase_      ),)
			A__							:					Optional[Any]       =	f"""The `{attribute}` attribute is deprecated and will be removed in version {version_name}."""
		elif deprecated_kwargs is None:
			A__							:					int       =	f"""`{attribute}` is deprecated and will be removed in version {version_name}."""

		if warning is not None:
			A__							:					int       =	warning + """ """ if standard_warn else """"""
			warnings.warn(warning + message					,   lowercase_					,   stacklevel=lowercase_      )

	if isinstance(lowercase_					,   lowercase_      ) and len(lowercase_      ) > 0:
		A__							:					Union[str, Any]       =	inspect.getouterframes(inspect.currentframe()      )[1]
		A__							:					Optional[Any]       =	call_frame.filename
		A__							:					Optional[int]       =	call_frame.lineno
		A__							:					Any       =	call_frame.function
		A__     ,     A__							:					List[str]       =	next(iter(deprecated_kwargs.items()      )      )
		raise TypeError(f"""{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`"""      )

	if len(lowercase_      ) == 0:
		return
	elif len(lowercase_      ) == 1:
		return values[0]
	return values



