





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 					=      {
    '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     ):


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   TOKEN
									HfFolder.save_token(__A		)


							@classmethod
							def   _snake_case	(				cls     :Union[str, Any]		) -> 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   _snake_case	(				self     :Optional[Any]		) -> List[str]:



									"""simple docstring"""



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

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

									SCREAMING_SNAKE_CASE__								=   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   _snake_case	(				self     :List[str]		) -> Tuple:



									"""simple docstring"""



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

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

									SCREAMING_SNAKE_CASE__								=   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   _snake_case	(				self     :Optional[int]		) -> Optional[Any]:



									"""simple docstring"""



									CustomConfig.register_for_auto_class()
									SCREAMING_SNAKE_CASE__								=   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"""}		)

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


							def   _snake_case	(				self     :Optional[int]		) -> Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   GPTaConfig()

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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   PretrainedConfig()
									SCREAMING_SNAKE_CASE__								=   [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"""]		)
									SCREAMING_SNAKE_CASE__								=   [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   _snake_case	(				self     :Optional[int]		) -> Optional[int]:



									"""simple docstring"""



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

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

									self.assertIsNotNone(__A		)


							def   _snake_case	(				self     :str		) -> Dict:



									"""simple docstring"""



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

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


							def   _snake_case	(				self     :Optional[Any]		) -> Optional[Any]:



									"""simple docstring"""



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


							def   _snake_case	(				self     :Tuple		) -> Tuple:



									"""simple docstring"""



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

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


							def   _snake_case	(				self     :List[Any]		) -> Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   """hf-internal-testing/test-two-configs"""

									import transformers as new_transformers

									SCREAMING_SNAKE_CASE__								=   """v4.0.0"""
									SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   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

									SCREAMING_SNAKE_CASE__								=   """v3.0.0"""
									SCREAMING_SNAKE_CASE__								=   old_transformers.models.auto.AutoConfig.from_pretrained(__A		)
									self.assertEqual(old_configuration.hidden_size				,					768		)






import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Value
from .base import TaskTemplate




@dataclass(frozen=UpperCamelCase__     )
class 	UpperCamelCase_							(  UpperCamelCase__     ):
							# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
							lowerCamelCase_							     =       field(default="text-classification"					,	metadata={"include_in_asdict_even_if_is_default": True}     )
							lowerCamelCase_							     =       Features({"text": Value("string"     )}     )
							lowerCamelCase_							     =       Features({"labels": ClassLabel}     )
							lowerCamelCase_							     =       "text"
							lowerCamelCase_							     =       "labels"


							def   _snake_case	(				self     :Any				,					__A     :Dict		) -> Optional[Any]:



									"""simple docstring"""



									if self.label_column not in features:
											raise ValueError(f'''Column {self.label_column} is not present in features.'''		)
									if not isinstance(features[self.label_column]				,					__A		):
											raise ValueError(f'''Column {self.label_column} is not a ClassLabel.'''		)
									SCREAMING_SNAKE_CASE__								=   copy.deepcopy(self		)
									SCREAMING_SNAKE_CASE__								=   self.label_schema.copy()
									SCREAMING_SNAKE_CASE__								=   features[self.label_column]
									SCREAMING_SNAKE_CASE__								=   label_schema
									return task_template


							@property
							def   _snake_case	(				self     :str		) -> Dict[str, str]:



									"""simple docstring"""



									return {
									    self.text_column: "text",
									    self.label_column: "labels",
									}