

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_       : Dict         =			{
    '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__							:    Tuple        =		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__							:    Tuple        =		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__							:    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__			)			)






					def   __A			( self			):
						A__							:    List[str]        =		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__							:    List[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__			)			)

        # 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__							:    int        =		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__							:    Union[str, 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__							:    List[Any]        =		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__							:    Dict        =		c.n_embd + 1  # int
						A__							:    Dict        =		c.resid_pdrop + 1.0  # float
						A__							:    Union[str, Any]        =		not c.scale_attn_weights  # bool
						A__							:    List[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__							:    str        =		PretrainedConfig()
						A__							:    Union[str, Any]        =		[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__							:    Optional[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__							:    Optional[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(A__			)






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

						# 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=A__			) as mock_head:
							A__							:    List[Any]        =		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__							:    str        =		BertConfig.from_pretrained(
						    """https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"""			)






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

						with tempfile.TemporaryDirectory() as tmp_dir:
							configuration.save_pretrained(A__			)
							A__							:    Optional[int]        =		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__							:    Any        =		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__							:    Optional[int]        =		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__							:    Optional[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__							:    Any        =		"""hf-internal-testing/test-two-configs"""

						import transformers as new_transformers

						A__							:    Dict        =		"""v4.0.0"""
						A__   ,   A__							:    Tuple        =		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__							:    Optional[int]        =		"""v3.0.0"""
						A__							:    Union[str, Any]        =		old_transformers.models.auto.AutoConfig.from_pretrained(A__			)
						self.assertEqual(old_configuration.hidden_size    ,       768			)






import os
from collections import namedtuple

import pytest

from datasets import ClassLabel, Features, Sequence, Value
from datasets.commands.test import TestCommand
from datasets.info import DatasetInfo, DatasetInfosDict


A_       : Any         =			namedtuple(
    '_TestCommandArgs',
    [
        'dataset',
        'name',
        'cache_dir',
        'data_dir',
        'all_configs',
        'save_infos',
        'ignore_verifications',
        'force_redownload',
        'clear_cache',
    ],
    defaults=[None, None, None, False, False, False, False, False],
)

def 						UpperCamelCase					(lowercase_: Any    ,      lowercase_: List[str]					)     ->      Optional[int]:
	return (abs(source - target					) / target) < 0.01


@pytest.mark.integration
def 						UpperCamelCase					(lowercase_: str					)     ->      str:
	A__							:    List[str]        =		_TestCommandArgs(dataset=lowercase_    ,      all_configs=lowercase_    ,      save_infos=lowercase_					)
	A__							:    int        =		TestCommand(*lowercase_					)
	test_command.run()
	A__							:    Optional[Any]        =		os.path.join(lowercase_    ,      """README.md"""					)
	assert os.path.exists(lowercase_					)
	A__							:    Dict        =		DatasetInfosDict.from_directory(lowercase_					)
	A__							:    str        =		DatasetInfosDict(
	    {
	        """default""": DatasetInfo(
	            features=Features(
	                {
	                    """tokens""": Sequence(Value("""string"""					)					),
	                    """ner_tags""": Sequence(
	                        ClassLabel(names=["""O""", """B-PER""", """I-PER""", """B-ORG""", """I-ORG""", """B-LOC""", """I-LOC"""]					)					),
	                    """langs""": Sequence(Value("""string"""					)					),
	                    """spans""": Sequence(Value("""string"""					)					),
	                }					)    ,      splits=[
	                {
	                    """name""": """train""",
	                    """num_bytes""": 2351563,
	                    """num_examples""": 10000,
	                },
	                {
	                    """name""": """validation""",
	                    """num_bytes""": 238418,
	                    """num_examples""": 1000,
	                },
	            ]    ,      download_size=3940680    ,      dataset_size=2589981    ,      )
	    }					)
	assert dataset_infos.keys() == expected_dataset_infos.keys()
	for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
		A__   ,   A__							:    Optional[Any]        =		getattr(dataset_infos["""default"""]    ,      lowercase_					), getattr(expected_dataset_infos["""default"""]    ,      lowercase_					)
		if key == "num_bytes":
			assert is_apercent_close(lowercase_    ,      lowercase_					)
		elif key == "splits":
			assert list(lowercase_					) == list(lowercase_					)
			for split in result:
				assert result[split].name == expected[split].name
				assert result[split].num_examples == expected[split].num_examples
				assert is_apercent_close(result[split].num_bytes    ,      expected[split].num_bytes					)
		else:
			result == expected



