

'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()


class  UpperCAmelCase (							UpperCAmelCase__  , UpperCAmelCase__  , unittest.TestCase    ):

		'''simple docstring'''






		SCREAMING_SNAKE_CASE_           =					StableDiffusionXLImgaImgPipeline
		SCREAMING_SNAKE_CASE_           =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
		SCREAMING_SNAKE_CASE_           =					PipelineTesterMixin.required_optional_params - {'latents'}
		SCREAMING_SNAKE_CASE_           =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
		SCREAMING_SNAKE_CASE_           =					IMAGE_TO_IMAGE_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE_           =					IMAGE_TO_IMAGE_IMAGE_PARAMS
		def 			UpperCamelCase(					self		)  ->     List[Any]:






							'''simple docstring'''



							torch.manual_seed(0		)
							lowerCamelCase_  				=      UNetaDConditionModel(
							    block_out_channels=(32, 64)   ,			layers_per_block=2   ,			sample_size=32   ,			in_channels=4   ,			out_channels=4   ,			down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')   ,			up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')   ,			attention_head_dim=(2, 4)   ,			use_linear_projection=SCREAMING_SNAKE_CASE_   ,			addition_embed_type='text_time'   ,			addition_time_embed_dim=8   ,			transformer_layers_per_block=(1, 2)   ,			projection_class_embeddings_input_dim=80   ,			cross_attention_dim=64   ,			)
							lowerCamelCase_  				=      EulerDiscreteScheduler(
							    beta_start=0.00_085   ,			beta_end=0.012   ,			steps_offset=1   ,			beta_schedule='scaled_linear'   ,			timestep_spacing='leading'   ,			)
							torch.manual_seed(0		)
							lowerCamelCase_  				=      AutoencoderKL(
							    block_out_channels=[32, 64]   ,			in_channels=3   ,			out_channels=3   ,			down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']   ,			up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']   ,			latent_channels=4   ,			sample_size=128   ,			)
							torch.manual_seed(0		)
							lowerCamelCase_  				=      CLIPTextConfig(
							    bos_token_id=0   ,			eos_token_id=2   ,			hidden_size=32   ,			intermediate_size=37   ,			layer_norm_eps=1E-05   ,			num_attention_heads=4   ,			num_hidden_layers=5   ,			pad_token_id=1   ,			vocab_size=1000   ,			hidden_act='gelu'   ,			projection_dim=32   ,			)
							lowerCamelCase_  				=      CLIPTextModel(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   ,			local_files_only=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   ,			local_files_only=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      {
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							    'text_encoder_2': text_encoder_a,
							    'tokenizer_2': tokenizer_a,
							    # "safety_checker": None,
							    # "feature_extractor": None,
							}
							return components
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_=0		)  ->     Optional[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      floats_tensor((1, 3, 32, 32)   ,			rng=random.Random(SCREAMING_SNAKE_CASE_		)		).to(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      image / 2 + 0.5
							if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
												lowerCamelCase_  				=      torch.manual_seed(SCREAMING_SNAKE_CASE_		)
							else:
												lowerCamelCase_  				=      torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      {
							    'prompt': 'A painting of a squirrel eating a burger',
							    'image': image,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'guidance_scale': 5.0,
							    'output_type': 'numpy',
							    'strength': 0.75,
							}
							return inputs
		def 			UpperCamelCase(					self		)  ->     Optional[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      'cpu'  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      StableDiffusionXLImgaImgPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      sd_pipe.to(SCREAMING_SNAKE_CASE_		)
							sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      sd_pipe(**SCREAMING_SNAKE_CASE_		).images
							lowerCamelCase_  				=      image[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)

							lowerCamelCase_  				=      np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165]		)

							assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
		def 			UpperCamelCase(					self		)  ->     Optional[int]:






							'''simple docstring'''



							super().test_attention_slicing_forward_pass(expected_max_diff=3E-3		)
		def 			UpperCamelCase(					self		)  ->     List[Any]:






							'''simple docstring'''



							super().test_inference_batch_single_identical(expected_max_diff=3E-3		)
		def 			UpperCamelCase(					self		)  ->     Union[str, Any]:






							'''simple docstring'''



							pass






		def 			UpperCamelCase(					self		)  ->     int:






							'''simple docstring'''



							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      StableDiffusionXLImgaImgPipeline(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      sd_pipe.to(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      sd_pipe.to(SCREAMING_SNAKE_CASE_		)
							sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							# forward without prompt embeds
							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      3 * ['this is a negative prompt']
							lowerCamelCase_  				=      negative_prompt
							lowerCamelCase_  				=      3 * [inputs['prompt']]

							lowerCamelCase_  				=      sd_pipe(**SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      output.images[0, -3:, -3:, -1]

							# forward with prompt embeds
							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      3 * ['this is a negative prompt']
							lowerCamelCase_  				=      3 * [inputs.pop('prompt'		)]

							(
							    (
							    lowerCamelCase_
							)				,(
							    lowerCamelCase_
							)				,(
							    lowerCamelCase_
							)				,(
							    lowerCamelCase_
							)				,
							)  				=      sd_pipe.encode_prompt(SCREAMING_SNAKE_CASE_   ,			negative_prompt=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      sd_pipe(
							    **SCREAMING_SNAKE_CASE_   ,			prompt_embeds=SCREAMING_SNAKE_CASE_   ,			negative_prompt_embeds=SCREAMING_SNAKE_CASE_   ,			pooled_prompt_embeds=SCREAMING_SNAKE_CASE_   ,			negative_pooled_prompt_embeds=SCREAMING_SNAKE_CASE_   ,			)
							lowerCamelCase_  				=      output.images[0, -3:, -3:, -1]

							# make sure that it's equal
							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1E-4


@slow
@require_torch_gpu
class  UpperCAmelCase (							unittest.TestCase    ):

		'''simple docstring'''






		def 			UpperCamelCase(					self		)  ->     Dict:






							'''simple docstring'''



							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_="cpu"   ,			SCREAMING_SNAKE_CASE_=torch.floataa   ,			SCREAMING_SNAKE_CASE_=0		)  ->     Optional[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      np.random.RandomState(SCREAMING_SNAKE_CASE_		).standard_normal((1, 4, 64, 64)		)
							lowerCamelCase_  				=      torch.from_numpy(SCREAMING_SNAKE_CASE_		).to(device=SCREAMING_SNAKE_CASE_   ,			dtype=SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      {
							    'prompt': 'a photograph of an astronaut riding a horse',
							    'latents': latents,
							    'generator': generator,
							    'num_inference_steps': 3,
							    'guidance_scale': 7.5,
							    'output_type': 'numpy',
							}
							return inputs






		def 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_  				=      DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base'		)
							pipe.to(SCREAMING_SNAKE_CASE_		)
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      pipe(**SCREAMING_SNAKE_CASE_		).images
							lowerCamelCase_  				=      image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase_  				=      np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]		)
							assert np.abs(image_slice - expected_slice		).max() < 7E-3








"""simple docstring"""






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,
)


snake_case   					=				logging.get_logger(__name__)

snake_case   					=				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'''),
    ]
)

snake_case   					=				_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)




def 			snake_case		(		lowerCAmelCase_	)						->				str:
  for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
    if class_name in extractors:
      _snake_case   	=      model_type_to_module_name(lowerCAmelCase_	)

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

  for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
    if getattr(lowerCAmelCase_  ,						'''__name__'''  ,						lowerCAmelCase_	) == 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(lowerCAmelCase_  ,						lowerCAmelCase_	):
    return getattr(lowerCAmelCase_  ,						lowerCAmelCase_	)

  return None




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = False  ,						lowerCAmelCase_ = False  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = False  ,						**lowerCAmelCase_  ,						)						->				int:
  _snake_case   	=      get_file_from_repo(
      lowerCAmelCase_  ,						lowerCAmelCase_  ,						cache_dir=lowerCAmelCase_  ,						force_download=lowerCAmelCase_  ,						resume_download=lowerCAmelCase_  ,						proxies=lowerCAmelCase_  ,						use_auth_token=lowerCAmelCase_  ,						revision=lowerCAmelCase_  ,						local_files_only=lowerCAmelCase_  ,						)
  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(lowerCAmelCase_  ,						encoding='''utf-8'''	) as reader:
    return json.load(lowerCAmelCase_	)







class     UpperCAmelCase    :



   def __init__(       self    :	Any				):



     """simple docstring"""
     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(__lowerCamelCase				)
   def    __UpperCAmelCase    (       cls    :	List[str]							,       __lowerCamelCase    :	List[str]							,       **__lowerCamelCase    :	Dict				):



     """simple docstring"""
     _snake_case   	=      kwargs.pop('''config'''							,       __lowerCamelCase				)
     _snake_case   	=      kwargs.pop('''trust_remote_code'''							,       __lowerCamelCase				)
     _snake_case   	=      True

     _snake_case	,     _snake_case   	=      ImageProcessingMixin.get_image_processor_dict(__lowerCamelCase							,       **__lowerCamelCase				)
     _snake_case   	=      config_dict.get('''image_processor_type'''							,       __lowerCamelCase				)
     _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'''							,       __lowerCamelCase				)
       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(__lowerCamelCase							,       __lowerCamelCase				):
         _snake_case   	=      AutoConfig.from_pretrained(__lowerCamelCase							,       **__lowerCamelCase				)
       # It could be in `config.image_processor_type``
       _snake_case   	=      getattr(__lowerCamelCase							,       '''image_processor_type'''							,       __lowerCamelCase				)
       if hasattr(__lowerCamelCase							,       '''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(__lowerCamelCase				)

     _snake_case   	=      image_processor_auto_map is not None
     _snake_case   	=      image_processor_class is not None or type(__lowerCamelCase				) in IMAGE_PROCESSOR_MAPPING
     _snake_case   	=      resolve_trust_remote_code(
         __lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)

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

     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    __UpperCAmelCase    (       __lowerCamelCase    :	int							,       __lowerCamelCase    :	int				):



     """simple docstring"""
     IMAGE_PROCESSOR_MAPPING.register(__lowerCamelCase							,       __lowerCamelCase				)





