






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			:		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  lowerCAmelCase_       (				unittest.TestCase					):




       @classmethod
       def 						__snake_case					(   cls     :   Any	):
           lowerCAmelCase__      			=						TOKEN
           HfFolder.save_token(UpperCAmelCase_	)




       @classmethod
       def 						__snake_case					(   cls     :   List[str]	):
           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     :   str	):
           lowerCAmelCase__      			=						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__      			=						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__      			=						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 						__snake_case					(   self     :   Dict	):
           lowerCAmelCase__      			=						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__      			=						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__      			=						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 						__snake_case					(   self     :   Any	):
           CustomConfig.register_for_auto_class()
           lowerCAmelCase__      			=						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__      			=						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  lowerCAmelCase_       (				unittest.TestCase					):




       def 						__snake_case					(   self     :   Optional[Any]	):
           lowerCAmelCase__      			=						GPTaConfig()

           # attempt to modify each of int/float/bool/str config records and verify they were updated
           lowerCAmelCase__      			=						c.n_embd + 1  # int
           lowerCAmelCase__      			=						c.resid_pdrop + 1.0  # float
           lowerCAmelCase__      			=						not c.scale_attn_weights  # bool
           lowerCAmelCase__      			=						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 						__snake_case					(   self     :   Tuple	):
           lowerCAmelCase__      			=						PretrainedConfig()
           lowerCAmelCase__      			=						[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__      			=						[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 						__snake_case					(   self     :   Optional[Any]	):
           with self.assertRaises(UpperCAmelCase_	):
               # config is in subfolder, the following should not work without specifying the subfolder
               lowerCAmelCase__      			=						BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''	)

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

           self.assertIsNotNone(UpperCAmelCase_	)




       def 						__snake_case					(   self     :   Tuple	):
           # A mock response for an HTTP head request to emulate server down
           lowerCAmelCase__      			=						mock.Mock()
           lowerCAmelCase__      			=						500
           lowerCAmelCase__      			=						{}
           lowerCAmelCase__      			=						HTTPError
           lowerCAmelCase__      			=						{}

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




       def 						__snake_case					(   self     :   str	):
           lowerCAmelCase__      			=						AutoConfig.from_pretrained('''bert-base-cased'''	)
           lowerCAmelCase__      			=						['config.4.0.0.json']

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




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

           import transformers as new_transformers

           lowerCAmelCase__      			=						'v4.0.0'
           lowerCAmelCase__      			=						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__      			=						'v3.0.0'
           lowerCAmelCase__      			=						old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase_	)
           self.assertEqual(old_configuration.hidden_size ,							768	)













from pathlib import Path

import fire





def 	lowerCAmelCase_		(lowercase__						:       str     ,					lowercase__						:       str     ,					lowercase__						:       int       )		->    Dict:


				'''simple docstring'''




				lowerCAmelCase__      			=						Path(lowercase__       )
				lowerCAmelCase__      			=						Path(lowercase__       )
				dest_dir.mkdir(exist_ok=lowercase__       )
				for path in src_dir.iterdir():
								lowerCAmelCase__      			=						[x.rstrip() for x in list(path.open().readlines()       )][:n]
								lowerCAmelCase__      			=						dest_dir.joinpath(path.name       )
								print(lowercase__       )
								dest_path.open('''w'''       ).write('''\n'''.join(lowercase__       )       )


if __name__ == "__main__":
			fire.Fire(minify)





