

import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin

class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Dict             =       DownBlockaD  # noqa F405
							UpperCAmelCase__			:		List[Any]             =       "down"


							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       List[Any]   =						[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		str             =       ResnetDownsampleBlockaD  # noqa F405
							UpperCAmelCase__			:		Union[str, Any]             =       "down"


							def 							__lowercase							(     self			)       ->       Optional[Any]:
												_a      :       str   =						[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Tuple             =       AttnDownBlockaD  # noqa F405
							UpperCAmelCase__			:		List[Any]             =       "down"


							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       str   =						[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Tuple             =       CrossAttnDownBlockaD  # noqa F405
							UpperCAmelCase__			:		Any             =       "down"


							def 							__lowercase							(     self			)       ->       Optional[int]:
												_a ,   _a      :       List[Any]   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       List[Any]   =						3_2
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a      :       Dict   =						[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[Any]             =       SimpleCrossAttnDownBlockaD  # noqa F405
							UpperCAmelCase__			:		Optional[Any]             =       "down"


							@property
							def 							__lowercase							(     self			)       ->       List[str]:
												return super().get_dummy_input(include_encoder_hidden_states=_a			)


							def 							__lowercase							(     self			)       ->       int:
												_a ,   _a      :       List[Any]   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       int   =						3_2
												return init_dict, inputs_dict




							@unittest.skipIf(torch_device == '''mps'''			,				'''MPS result is not consistent'''			)
							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a      :       str   =						[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Any             =       SkipDownBlockaD  # noqa F405
							UpperCAmelCase__			:		Optional[Any]             =       "down"


							@property
							def 							__lowercase							(     self			)       ->       Any:
												return super().get_dummy_input(include_skip_sample=_a			)




							def 							__lowercase							(     self			)       ->       Dict:
												_a      :       List[Any]   =						[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		str             =       AttnSkipDownBlockaD  # noqa F405
							UpperCAmelCase__			:		Any             =       "down"


							@property
							def 							__lowercase							(     self			)       ->       Tuple:
												return super().get_dummy_input(include_skip_sample=_a			)




							def 							__lowercase							(     self			)       ->       Optional[int]:
												_a      :       int   =						[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Tuple             =       DownEncoderBlockaD  # noqa F405
							UpperCAmelCase__			:		List[str]             =       "down"


							@property
							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												return super().get_dummy_input(include_temb=_a			)


							def 							__lowercase							(     self			)       ->       int:
												_a      :       List[Any]   =						{
												    '''in_channels''': 3_2,
												    '''out_channels''': 3_2,
												}
												_a      :       List[str]   =						self.dummy_input
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       int   =						[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Tuple             =       AttnDownEncoderBlockaD  # noqa F405
							UpperCAmelCase__			:		int             =       "down"


							@property
							def 							__lowercase							(     self			)       ->       int:
												return super().get_dummy_input(include_temb=_a			)


							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       Union[str, Any]   =						{
												    '''in_channels''': 3_2,
												    '''out_channels''': 3_2,
												}
												_a      :       Union[str, Any]   =						self.dummy_input
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Optional[Any]:
												_a      :       Optional[int]   =						[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[Any]             =       UNetMidBlockaD  # noqa F405
							UpperCAmelCase__			:		Tuple             =       "mid"


							def 							__lowercase							(     self			)       ->       str:
												_a      :       Any   =						{
												    '''in_channels''': 3_2,
												    '''temb_channels''': 1_2_8,
												}
												_a      :       Optional[int]   =						self.dummy_input
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Any:
												_a      :       str   =						[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Union[str, Any]             =       UNetMidBlockaDCrossAttn  # noqa F405
							UpperCAmelCase__			:		int             =       "mid"


							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a ,   _a      :       List[str]   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       Dict   =						3_2
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       Dict   =						[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		List[Any]             =       UNetMidBlockaDSimpleCrossAttn  # noqa F405
							UpperCAmelCase__			:		Tuple             =       "mid"


							@property
							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												return super().get_dummy_input(include_encoder_hidden_states=_a			)


							def 							__lowercase							(     self			)       ->       int:
												_a ,   _a      :       Dict   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       Optional[int]   =						3_2
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       Optional[int]   =						[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Dict             =       UpBlockaD  # noqa F405
							UpperCAmelCase__			:		Any             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Tuple:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)




							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       Any   =						[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[int]             =       ResnetUpsampleBlockaD  # noqa F405
							UpperCAmelCase__			:		Tuple             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Any:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)




							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a      :       List[Any]   =						[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[int]             =       CrossAttnUpBlockaD  # noqa F405
							UpperCAmelCase__			:		List[str]             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       List[Any]:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)


							def 							__lowercase							(     self			)       ->       Dict:
												_a ,   _a      :       Union[str, Any]   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       List[str]   =						3_2
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a      :       int   =						[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Union[str, Any]             =       SimpleCrossAttnUpBlockaD  # noqa F405
							UpperCAmelCase__			:		List[Any]             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       List[str]:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			,				include_encoder_hidden_states=_a			)


							def 							__lowercase							(     self			)       ->       int:
												_a ,   _a      :       int   =						super().prepare_init_args_and_inputs_for_common()
												_a      :       Dict   =						3_2
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       Tuple   =						[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		List[str]             =       AttnUpBlockaD  # noqa F405
							UpperCAmelCase__			:		Dict             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       str:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)




							@unittest.skipIf(torch_device == '''mps'''			,				'''MPS result is not consistent'''			)
							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       Union[str, Any]   =						[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		int             =       SkipUpBlockaD  # noqa F405
							UpperCAmelCase__			:		int             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Any:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)




							def 							__lowercase							(     self			)       ->       str:
												_a      :       Optional[Any]   =						[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[int]             =       AttnSkipUpBlockaD  # noqa F405
							UpperCAmelCase__			:		Optional[int]             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Dict:
												return super().get_dummy_input(include_res_hidden_states_tuple=_a			)




							def 							__lowercase							(     self			)       ->       Optional[int]:
												_a      :       Any   =						[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		List[str]             =       UpDecoderBlockaD  # noqa F405
							UpperCAmelCase__			:		str             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Optional[int]:
												return super().get_dummy_input(include_temb=_a			)


							def 							__lowercase							(     self			)       ->       int:
												_a      :       Any   =						{'''in_channels''': 3_2, '''out_channels''': 3_2}

												_a      :       List[Any]   =						self.dummy_input
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       List[str]:
												_a      :       int   =						[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
												super().test_output(_a			)



class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Tuple             =       AttnUpDecoderBlockaD  # noqa F405
							UpperCAmelCase__			:		Optional[Any]             =       "up"


							@property
							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												return super().get_dummy_input(include_temb=_a			)


							def 							__lowercase							(     self			)       ->       Optional[int]:
												_a      :       Union[str, Any]   =						{'''in_channels''': 3_2, '''out_channels''': 3_2}

												_a      :       List[str]   =						self.dummy_input
												return init_dict, inputs_dict




							def 							__lowercase							(     self			)       ->       str:
												_a      :       Union[str, Any]   =						[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
												super().test_output(_a			)






import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402

class 							UpperCAmelCase_						(     unittest.TestCase  ):
							"""simple docstring"""







							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       int   =						0


							def 							__lowercase							(     self			)       ->       List[str]:
												_a      :       Dict   =						AutoImageProcessor.from_pretrained('''openai/clip-vit-base-patch32'''			)
												self.assertIsInstance(_a			,				_a			)


							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												with tempfile.TemporaryDirectory() as tmpdirname:
																	_a      :       Tuple   =						Path(_a			) / '''preprocessor_config.json'''
																	_a      :       Optional[Any]   =						Path(_a			) / '''config.json'''
																	json.dump(
																	    {'''image_processor_type''': '''CLIPImageProcessor''', '''processor_class''': '''CLIPProcessor'''}			,				open(_a			,				'''w'''			)			,				)
																	json.dump({'''model_type''': '''clip'''}			,				open(_a			,				'''w'''			)			)

																	_a      :       List[str]   =						AutoImageProcessor.from_pretrained(_a			)
																	self.assertIsInstance(_a			,				_a			)


							def 							__lowercase							(     self			)       ->       Optional[Any]:
												# Ensure we can load the image processor from the feature extractor config
												with tempfile.TemporaryDirectory() as tmpdirname:
																	_a      :       Optional[int]   =						Path(_a			) / '''preprocessor_config.json'''
																	_a      :       Any   =						Path(_a			) / '''config.json'''
																	json.dump(
																	    {'''feature_extractor_type''': '''CLIPFeatureExtractor''', '''processor_class''': '''CLIPProcessor'''}			,				open(_a			,				'''w'''			)			,				)
																	json.dump({'''model_type''': '''clip'''}			,				open(_a			,				'''w'''			)			)

																	_a      :       Optional[Any]   =						AutoImageProcessor.from_pretrained(_a			)
																	self.assertIsInstance(_a			,				_a			)


							def 							__lowercase							(     self			)       ->       Optional[Any]:
												with tempfile.TemporaryDirectory() as tmpdirname:
																	_a      :       Dict   =						CLIPConfig()

																	# Create a dummy config file with image_proceesor_type
																	_a      :       Tuple   =						Path(_a			) / '''preprocessor_config.json'''
																	_a      :       List[str]   =						Path(_a			) / '''config.json'''
																	json.dump(
																	    {'''image_processor_type''': '''CLIPImageProcessor''', '''processor_class''': '''CLIPProcessor'''}			,				open(_a			,				'''w'''			)			,				)
																	json.dump({'''model_type''': '''clip'''}			,				open(_a			,				'''w'''			)			)

																	# remove image_processor_type to make sure config.json alone is enough to load image processor locally
																	_a      :       Tuple   =						AutoImageProcessor.from_pretrained(_a			).to_dict()

																	config_dict.pop('''image_processor_type'''			)
																	_a      :       Tuple   =						CLIPImageProcessor(**_a			)

																	# save in new folder
																	model_config.save_pretrained(_a			)
																	config.save_pretrained(_a			)

																	_a      :       List[str]   =						AutoImageProcessor.from_pretrained(_a			)

																	# make sure private variable is not incorrectly saved
																	_a      :       Optional[int]   =						json.loads(config.to_json_string()			)
																	self.assertTrue('''_processor_class''' not in dict_as_saved			)

												self.assertIsInstance(_a			,				_a			)


							def 							__lowercase							(     self			)       ->       Dict:
												with tempfile.TemporaryDirectory() as tmpdirname:
																	_a      :       Optional[int]   =						Path(_a			) / '''preprocessor_config.json'''
																	json.dump(
																	    {'''image_processor_type''': '''CLIPImageProcessor''', '''processor_class''': '''CLIPProcessor'''}			,				open(_a			,				'''w'''			)			,				)

																	_a      :       List[str]   =						AutoImageProcessor.from_pretrained(_a			)
																	self.assertIsInstance(_a			,				_a			)


							def 							__lowercase							(     self			)       ->       Any:
												with self.assertRaisesRegex(
												    _a			,				'''clip-base is not a local folder and is not a valid model identifier'''			):
																	_a      :       Dict   =						AutoImageProcessor.from_pretrained('''clip-base'''			)


							def 							__lowercase							(     self			)       ->       List[Any]:
												with self.assertRaisesRegex(
												    _a			,				R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''			):
																	_a      :       List[str]   =						AutoImageProcessor.from_pretrained(_a			,				revision='''aaaaaa'''			)


							def 							__lowercase							(     self			)       ->       Dict:
												with self.assertRaisesRegex(
												    _a			,				'''hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'''			,				):
																	_a      :       Optional[int]   =						AutoImageProcessor.from_pretrained('''hf-internal-testing/config-no-model'''			)


							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												# If remote code is not set, we will time out when asking whether to load the model.
												with self.assertRaises(_a			):
																	_a      :       str   =						AutoImageProcessor.from_pretrained('''hf-internal-testing/test_dynamic_image_processor'''			)
												# If remote code is disabled, we can't load this config.
												with self.assertRaises(_a			):
																	_a      :       Optional[Any]   =						AutoImageProcessor.from_pretrained(
																	    '''hf-internal-testing/test_dynamic_image_processor'''			,				trust_remote_code=_a			)

												_a      :       Union[str, Any]   =						AutoImageProcessor.from_pretrained(
												    '''hf-internal-testing/test_dynamic_image_processor'''			,				trust_remote_code=_a			)
												self.assertEqual(image_processor.__class__.__name__			,				'''NewImageProcessor'''			)

												# Test image processor can be reloaded.
												with tempfile.TemporaryDirectory() as tmp_dir:
																	image_processor.save_pretrained(_a			)
																	_a      :       Optional[Any]   =						AutoImageProcessor.from_pretrained(_a			,				trust_remote_code=_a			)
												self.assertEqual(reloaded_image_processor.__class__.__name__			,				'''NewImageProcessor'''			)


							def 							__lowercase							(     self			)       ->       Dict:
												try:
																	AutoConfig.register('''custom'''			,				_a			)
																	AutoImageProcessor.register(_a			,				_a			)
																	# Trying to register something existing in the Transformers library will raise an error
																	with self.assertRaises(_a			):
																						AutoImageProcessor.register(_a			,				_a			)

																	with tempfile.TemporaryDirectory() as tmpdirname:
																						_a      :       int   =						Path(_a			) / '''preprocessor_config.json'''
																						_a      :       int   =						Path(_a			) / '''config.json'''
																						json.dump(
																						    {'''feature_extractor_type''': '''CLIPFeatureExtractor''', '''processor_class''': '''CLIPProcessor'''}			,				open(_a			,				'''w'''			)			,				)
																						json.dump({'''model_type''': '''clip'''}			,				open(_a			,				'''w'''			)			)

																						_a      :       int   =						CustomImageProcessor.from_pretrained(_a			)

																	# Now that the config is registered, it can be used as any other config with the auto-API
																	with tempfile.TemporaryDirectory() as tmp_dir:
																						image_processor.save_pretrained(_a			)
																						_a      :       Optional[Any]   =						AutoImageProcessor.from_pretrained(_a			)
																						self.assertIsInstance(_a			,				_a			)

												finally:
																	if "custom" in CONFIG_MAPPING._extra_content:
																						del CONFIG_MAPPING._extra_content["custom"]
																	if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
																						del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]




							def 							__lowercase							(     self			)       ->       Union[str, Any]:

												class 							UpperCAmelCase_						(     __lowercase  ):
																			"""simple docstring"""







																			UpperCAmelCase__			:		Tuple             =       True

												try:
																	AutoConfig.register('''custom'''			,				_a			)
																	AutoImageProcessor.register(_a			,				_a			)
																	# If remote code is not set, the default is to use local
																	_a      :       str   =						AutoImageProcessor.from_pretrained('''hf-internal-testing/test_dynamic_image_processor'''			)
																	self.assertEqual(image_processor.__class__.__name__			,				'''NewImageProcessor'''			)
																	self.assertTrue(image_processor.is_local			)

																	# If remote code is disabled, we load the local one.
																	_a      :       int   =						AutoImageProcessor.from_pretrained(
																	    '''hf-internal-testing/test_dynamic_image_processor'''			,				trust_remote_code=_a			)
																	self.assertEqual(image_processor.__class__.__name__			,				'''NewImageProcessor'''			)
																	self.assertTrue(image_processor.is_local			)

																	# If remote is enabled, we load from the Hub
																	_a      :       Dict   =						AutoImageProcessor.from_pretrained(
																	    '''hf-internal-testing/test_dynamic_image_processor'''			,				trust_remote_code=_a			)
																	self.assertEqual(image_processor.__class__.__name__			,				'''NewImageProcessor'''			)
																	self.assertTrue(not hasattr(_a			,				'''is_local'''			)			)

												finally:
																	if "custom" in CONFIG_MAPPING._extra_content:
																						del CONFIG_MAPPING._extra_content["custom"]
																	if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
																						del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]



