




import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


__UpperCamelCase					:		List[Any]	  =						logging.get_logger(__name__)

__UpperCamelCase					:		str	  =						OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

__UpperCamelCase					:		Union[str, Any]	  =						_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def      a_ (      _A  )			->			Optional[int]:







				"""simple docstring"""
				for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
								if class_name in extractors:
												snake_case__									=     model_type_to_module_name(_A  )

												snake_case__									=     importlib.import_module(f'''.{module_name}'''      ,   'transformers.models'  )
												try:
																return getattr(_A      ,   _A  )
												except AttributeError:
																continue

				for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
								if getattr(_A      ,   '__name__'      ,   _A  ) == class_name:
												return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
				snake_case__									=     importlib.import_module('transformers'  )
				if hasattr(_A      ,   _A  ):
								return getattr(_A      ,   _A  )

				return None
def      a_ (      _A      ,   _A = None      ,   _A = False      ,   _A = False      ,   _A = None      ,   _A = None      ,   _A = None      ,   _A = False      ,   **_A      ,   )			->			Optional[Any]:







				"""simple docstring"""
				snake_case__									=     get_file_from_repo(
				    _A      ,   _A      ,   cache_dir=_A      ,   force_download=_A      ,   resume_download=_A      ,   proxies=_A      ,   use_auth_token=_A      ,   revision=_A      ,   local_files_only=_A      ,   )
				if resolved_config_file is None:
								logger.info(
								    'Could not locate the image processor configuration file, will try to use the model config instead.'  )
								return {}

				with open(_A      ,   encoding='utf-8'  ) as reader:
								return json.load(_A  )


class   __SCREAMING_SNAKE_CASE:
							def __init__(     self:      Optional[int]						)		->		Union[str, Any]:
											raise EnvironmentError(
											    'AutoImageProcessor is designed to be instantiated '
											    'using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'						)
							@classmethod
							@replace_list_option_in_docstrings(UpperCamelCase						)
							def lowerCAmelCase_ (     cls:      int       ,	UpperCamelCase:      int       ,	**UpperCamelCase:      str						)		->		Optional[Any]:
											snake_case__									=     kwargs.pop('config'       ,	UpperCamelCase						)
											snake_case__									=     kwargs.pop('trust_remote_code'       ,	UpperCamelCase						)
											snake_case__									=     True

											snake_case__							,						snake_case__									=     ImageProcessingMixin.get_image_processor_dict(UpperCamelCase       ,	**UpperCamelCase						)
											snake_case__									=     config_dict.get('image_processor_type'       ,	UpperCamelCase						)
											snake_case__									=     None
											if "AutoImageProcessor" in config_dict.get('auto_map'       ,	{}						):
															snake_case__									=     config_dict['auto_map']['AutoImageProcessor']

											# If we still don't have the image processor class, check if we're loading from a previous feature extractor config
											# and if so, infer the image processor class from there.
											if image_processor_class is None and image_processor_auto_map is None:
															snake_case__									=     config_dict.pop('feature_extractor_type'       ,	UpperCamelCase						)
															if feature_extractor_class is not None:
																			logger.warning(
																			    'Could not find image processor class in the image processor config or the model config. Loading'
																			    ' based on pattern matching with the model\'s feature extractor configuration.'						)
																			snake_case__									=     feature_extractor_class.replace('FeatureExtractor'       ,	'ImageProcessor'						)
															if "AutoFeatureExtractor" in config_dict.get('auto_map'       ,	{}						):
																			snake_case__									=     config_dict['auto_map']['AutoFeatureExtractor']
																			snake_case__									=     feature_extractor_auto_map.replace('FeatureExtractor'       ,	'ImageProcessor'						)
																			logger.warning(
																			    'Could not find image processor auto map in the image processor config or the model config.'
																			    ' Loading based on pattern matching with the model\'s feature extractor configuration.'						)

        # If we don't find the image processor class in the image processor config, let's try the model config.
											if image_processor_class is None and image_processor_auto_map is None:
															if not isinstance(UpperCamelCase       ,	UpperCamelCase						):
																			snake_case__									=     AutoConfig.from_pretrained(UpperCamelCase       ,	**UpperCamelCase						)
															# It could be in `config.image_processor_type``
															snake_case__									=     getattr(UpperCamelCase       ,	'image_processor_type'       ,	UpperCamelCase						)
															if hasattr(UpperCamelCase       ,	'auto_map'						) and "AutoImageProcessor" in config.auto_map:
																			snake_case__									=     config.auto_map['AutoImageProcessor']

											if image_processor_class is not None:
															snake_case__									=     image_processor_class_from_name(UpperCamelCase						)

											snake_case__									=     image_processor_auto_map is not None
											snake_case__									=     image_processor_class is not None or type(UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING
											snake_case__									=     resolve_trust_remote_code(
											    UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase						)

											if has_remote_code and trust_remote_code:
															snake_case__									=     get_class_from_dynamic_module(
															    UpperCamelCase       ,	UpperCamelCase       ,	**UpperCamelCase						)
															snake_case__									=     kwargs.pop('code_revision'       ,	UpperCamelCase						)
															if os.path.isdir(UpperCamelCase						):
																			image_processor_class.register_for_auto_class()
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)
											elif image_processor_class is not None:
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)
											# Last try: we use the IMAGE_PROCESSOR_MAPPING.
											elif type(UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING:
															snake_case__									=     IMAGE_PROCESSOR_MAPPING[type(UpperCamelCase						)]
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)

											raise ValueError(
											    F'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
											    F'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
											    F'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()						)}'''						)


							@staticmethod
							def lowerCAmelCase_ (     UpperCamelCase:      Optional[Any]       ,	UpperCamelCase:      int						)		->		Optional[Any]:
											IMAGE_PROCESSOR_MAPPING.register(UpperCamelCase       ,	UpperCamelCase						)












import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class   __SCREAMING_SNAKE_CASE(	a_    ,  a_    ,  a_    ,  unittest.TestCase	):
							_UpperCAmelCase     =       StableUnCLIPImgaImgPipeline
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_UpperCAmelCase     =       frozenset(
							    []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							_UpperCAmelCase     =       frozenset([]	)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Union[str, Any]:
											snake_case__									=     32
											snake_case__									=     embedder_hidden_size

											# image encoding components

											snake_case__									=     CLIPImageProcessor(crop_size=32       ,	size=32						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPVisionModelWithProjection(
											    CLIPVisionConfig(
											        hidden_size=UpperCamelCase       ,	projection_dim=UpperCamelCase       ,	num_hidden_layers=5       ,	num_attention_heads=4       ,	image_size=32       ,	intermediate_size=37       ,	patch_size=1       ,	)						)

											# regular denoising components

											torch.manual_seed(0						)
											snake_case__									=     StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase						)
											snake_case__									=     DDPMScheduler(beta_schedule='squaredcos_cap_v2'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=UpperCamelCase       ,	projection_dim=32       ,	intermediate_size=37       ,	layer_norm_eps=1e-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	pad_token_id=1       ,	vocab_size=10_00       ,	)						)

											torch.manual_seed(0						)
											snake_case__									=     UNetaDConditionModel(
											    sample_size=32       ,	in_channels=4       ,	out_channels=4       ,	down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')       ,	up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')       ,	block_out_channels=(32, 64)       ,	attention_head_dim=(2, 4)       ,	class_embed_type='projection'       ,	projection_class_embeddings_input_dim=embedder_projection_dim * 2       ,	cross_attention_dim=UpperCamelCase       ,	layers_per_block=1       ,	upcast_attention=UpperCamelCase       ,	use_linear_projection=UpperCamelCase       ,	)

											torch.manual_seed(0						)
											snake_case__									=     DDIMScheduler(
											    beta_schedule='scaled_linear'       ,	beta_start=0.00_085       ,	beta_end=0.012       ,	prediction_type='v_prediction'       ,	set_alpha_to_one=UpperCamelCase       ,	steps_offset=1       ,	)

											torch.manual_seed(0						)
											snake_case__									=     AutoencoderKL()

											snake_case__									=     {
											    # image encoding components
											    'feature_extractor': feature_extractor,
											    'image_encoder': image_encoder.eval(),
											    # image noising components
											    'image_normalizer': image_normalizer.eval(),
											    'image_noising_scheduler': image_noising_scheduler,
											    # regular denoising components
											    'tokenizer': tokenizer,
											    'text_encoder': text_encoder.eval(),
											    'unet': unet.eval(),
											    'scheduler': scheduler,
											    'vae': vae.eval(),
											}

											return components
							def lowerCAmelCase_ (     self:      str       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Tuple=0       ,	UpperCamelCase:      Union[str, Any]=True						)		->		Any:
											if str(UpperCamelCase						).startswith('mps'						):
															snake_case__									=     torch.manual_seed(UpperCamelCase						)
											else:
															snake_case__									=     torch.Generator(device=UpperCamelCase						).manual_seed(UpperCamelCase						)

											snake_case__									=     floats_tensor((1, 3, 32, 32)       ,	rng=random.Random(UpperCamelCase						)						).to(UpperCamelCase						)

											if pil_image:
															snake_case__									=     input_image * 0.5 + 0.5
															snake_case__									=     input_image.clamp(0       ,	1						)
															snake_case__									=     input_image.cpu().permute(0       ,	2       ,	3       ,	1						).float().numpy()
															snake_case__									=     DiffusionPipeline.numpy_to_pil(UpperCamelCase						)[0]

											return {
											    "prompt": "An anime racoon running a marathon",
											    "image": input_image,
											    "generator": generator,
											    "num_inference_steps": 2,
											    "output_type": "np",
											}
							@skip_mps
							def lowerCAmelCase_ (     self:      Dict						)		->		Optional[Any]:
											snake_case__									=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											snake_case__									=     self.get_dummy_components()
											snake_case__									=     StableUnCLIPImgaImgPipeline(**UpperCamelCase						)
											snake_case__									=     sd_pipe.to(UpperCamelCase						)
											sd_pipe.set_progress_bar_config(disable=UpperCamelCase						)

											snake_case__									=     self.get_dummy_inputs(UpperCamelCase						)
											inputs.update({'image_embeds': None}						)
											snake_case__									=     sd_pipe(**UpperCamelCase						).images
											snake_case__									=     image[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											snake_case__									=     np.array([0.3_872, 0.7_224, 0.5_601, 0.4_741, 0.6_872, 0.5_814, 0.4_636, 0.3_867, 0.5_078]						)

											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Union[str, Any]:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		int:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase						)


							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()       ,	reason='XFormers attention is only available with CUDA and `xformers` installed'       ,	)
							def lowerCAmelCase_ (     self:      str						)		->		Optional[int]:
											self._test_xformers_attention_forwardGenerator_pass(test_max_difference=UpperCamelCase						)


@slow
@require_torch_gpu
class   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Optional[int]:
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-l-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		str:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											snake_case__									=     pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     pipe(
											    UpperCamelCase       ,	'anime turtle'       ,	num_inference_steps=2       ,	output_type='np'       ,	)

											snake_case__									=     torch.cuda.max_memory_allocated()
											# make sure that less than 7 GB is allocated
											assert mem_bytes < 7 * 10**9




