






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




							@classmethod
							def 		lowerCamelCase_    (							cls:    Tuple					):
														lowerCamelCase__ :     int	  =	TOKEN
														HfFolder.save_token(UpperCamelCase__					)




							@classmethod
							def 		lowerCamelCase_    (							cls:    Optional[int]					):
														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:    Tuple					):
														lowerCamelCase__ :     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("""test-config"""      ,							use_auth_token=self._token					)

														lowerCamelCase__ :     Any	  =	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__ :     int	  =	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 		lowerCamelCase_    (							self:    int					):
														lowerCamelCase__ :     Dict	  =	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__ :     Optional[int]	  =	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__ :     Any	  =	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 		lowerCamelCase_    (							self:    Optional[Any]					):
														CustomConfig.register_for_auto_class()
														lowerCamelCase__ :     Dict	  =	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__ :     Optional[Any]	  =	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 _lowercase     (    unittest.TestCase		):




							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														lowerCamelCase__ :     int	  =	GPTaConfig()

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

														lowerCamelCase__ :     Optional[Any]	  =	BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""      ,							subfolder="""bert"""					)

														self.assertIsNotNone(UpperCamelCase__					)




							def 		lowerCamelCase_    (							self:    Any					):
														# A mock response for an HTTP head request to emulate server down
														lowerCamelCase__ :     Union[str, Any]	  =	mock.Mock()
														lowerCamelCase__ :     List[Any]	  =	500
														lowerCamelCase__ :     Any	  =	{}
														lowerCamelCase__ :     str	  =	HTTPError
														lowerCamelCase__ :     Dict	  =	{}

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




							def 		lowerCamelCase_    (							self:    List[str]					):
														lowerCamelCase__ :     str	  =	AutoConfig.from_pretrained("""bert-base-cased"""					)
														lowerCamelCase__ :     Optional[Any]	  =	["""config.4.0.0.json"""]

														with tempfile.TemporaryDirectory() as tmp_dir:
																					configuration.save_pretrained(UpperCamelCase__					)
																					lowerCamelCase__ :     Union[str, Any]	  =	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__ :     Tuple	  =	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__ :     List[Any]	  =	["""config.42.0.0.json"""]
																					lowerCamelCase__ :     Any	  =	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__ :     Any	  =	AutoConfig.from_pretrained(UpperCamelCase__					)
																					self.assertEqual(new_configuration.hidden_size      ,							768					)




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

														import transformers as new_transformers

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









'''simple docstring'''







import argparse

from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection

from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline


if __name__ == "__main__":
			_A     :      List[Any]   					=argparse.ArgumentParser()

			parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')

			parser.add_argument(
			    '''--txt2img_unclip''',
			    default='''kakaobrain/karlo-v1-alpha''',
			    type=str,
			    required=False,
			    help='''The pretrained txt2img unclip.''',
			)

			_A     :      Dict   					=parser.parse_args()

			_A     :      List[str]   					=UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)

			_A     :      Any   					=CLIPImageProcessor()
			_A     :      Union[str, Any]   					=CLIPVisionModelWithProjection.from_pretrained('''openai/clip-vit-large-patch14''')

			_A     :      Union[str, Any]   					=UnCLIPImageVariationPipeline(
			    decoder=txtaimg.decoder,
			    text_encoder=txtaimg.text_encoder,
			    tokenizer=txtaimg.tokenizer,
			    text_proj=txtaimg.text_proj,
			    feature_extractor=feature_extractor,
			    image_encoder=image_encoder,
			    super_res_first=txtaimg.super_res_first,
			    super_res_last=txtaimg.super_res_last,
			    decoder_scheduler=txtaimg.decoder_scheduler,
			    super_res_scheduler=txtaimg.super_res_scheduler,
			)

			imgaimg.save_pretrained(args.dump_path)

