code: 
  
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      ControlNetModel,
      DDIMScheduler,
      StableDiffusionControlNetInpaintPipeline,
      UNetaDConditionModel,
  )
  from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
  from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import (
      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
      TEXT_TO_IMAGE_IMAGE_PARAMS,
  )
  from ..test_pipelines_common import (
      PipelineKarrasSchedulerTesterMixin,
      PipelineLatentTesterMixin,
      PipelineTesterMixin,
  )
  
  
  enable_full_determinism()
  
  
  
  
  
  class   __lowerCamelCase (snake_case_							,			snake_case_							,			snake_case_							,			unittest.TestCase	):
         _lowercase       							=    StableDiffusionControlNetInpaintPipeline
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
         _lowercase       							=    frozenset({"""control_image"""}	)  # skip `image` and `mask` for now, only test for control_image
         _lowercase       							=    TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.manual_seed(0				)
              __UpperCamelCase   = UNetaDConditionModel(
                  block_out_channels=(32, 64),layers_per_block=2,sample_size=32,in_channels=9,out_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),cross_attention_dim=32,)
              torch.manual_seed(0				)
              __UpperCamelCase   = ControlNetModel(
                  block_out_channels=(32, 64),layers_per_block=2,in_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),cross_attention_dim=32,conditioning_embedding_out_channels=(16, 32),)
              torch.manual_seed(0				)
              __UpperCamelCase   = DDIMScheduler(
                  beta_start=0.0_0_0_8_5,beta_end=0.0_1_2,beta_schedule='scaled_linear',clip_sample=A_,set_alpha_to_one=A_,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              __UpperCamelCase   = CLIPTextModel(A_				)
              __UpperCamelCase   = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)
  
              __UpperCamelCase   = {
                  'unet': unet,
                  'controlnet': controlnet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'text_encoder': text_encoder,
                  'tokenizer': tokenizer,
                  'safety_checker': None,
                  'feature_extractor': None,
              }
              return components
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any,A_:   Union[str, Any],A_:   str=0				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              if str(A_				).startswith('mps'				):
                   __UpperCamelCase   = torch.manual_seed(A_				)
              else:
                   __UpperCamelCase   = torch.Generator(device=A_				).manual_seed(A_				)
  
              __UpperCamelCase   = 2
              __UpperCamelCase   = randn_tensor(
                  (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),generator=A_,device=torch.device(A_				),)
              __UpperCamelCase   = floats_tensor((1, 3, 32, 32),rng=random.Random(A_				)				).to(A_				)
              __UpperCamelCase   = init_image.cpu().permute(0,2,3,1				)[0]
  
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				).resize((64, 64)				)
              __UpperCamelCase   = Image.fromarray(np.uinta(init_image + 4				)				).convert('RGB'				).resize((64, 64)				)
  
              __UpperCamelCase   = {
                  'prompt': 'A painting of a squirrel eating a burger',
                  'generator': generator,
                  'num_inference_steps': 2,
                  'guidance_scale': 6.0,
                  'output_type': 'numpy',
                  'image': image,
                  'mask_image': mask_image,
                  'control_image': control_image,
              }
  
              return inputs
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  
         @unittest.skipIf(
             torch_device != 'cuda' or not is_xformers_available(),reason='XFormers attention is only available with CUDA and `xformers` installed',)
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              self._test_inference_batch_single_identical(expected_max_diff=2E-3				)
  
  
  
  
  
  class   __lowerCamelCase (snake_case_	):
         _lowercase       							=    StableDiffusionControlNetInpaintPipeline
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
         _lowercase       							=    frozenset([]	)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.manual_seed(0				)
              __UpperCamelCase   = 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'),cross_attention_dim=32,)
              torch.manual_seed(0				)
              __UpperCamelCase   = ControlNetModel(
                  block_out_channels=(32, 64),layers_per_block=2,in_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),cross_attention_dim=32,conditioning_embedding_out_channels=(16, 32),)
              torch.manual_seed(0				)
              __UpperCamelCase   = DDIMScheduler(
                  beta_start=0.0_0_0_8_5,beta_end=0.0_1_2,beta_schedule='scaled_linear',clip_sample=A_,set_alpha_to_one=A_,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              __UpperCamelCase   = CLIPTextModel(A_				)
              __UpperCamelCase   = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)
  
              __UpperCamelCase   = {
                  'unet': unet,
                  'controlnet': controlnet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'text_encoder': text_encoder,
                  'tokenizer': tokenizer,
                  'safety_checker': None,
                  'feature_extractor': None,
              }
              return components
  
  
  
  
  
  class   __lowerCamelCase (snake_case_							,			snake_case_							,			unittest.TestCase	):
         _lowercase       							=    StableDiffusionControlNetInpaintPipeline
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
         _lowercase       							=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.manual_seed(0				)
              __UpperCamelCase   = UNetaDConditionModel(
                  block_out_channels=(32, 64),layers_per_block=2,sample_size=32,in_channels=9,out_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),cross_attention_dim=32,)
              torch.manual_seed(0				)
  
              def init_weights(A_:   Tuple				):
                   if isinstance(A_,torch.nn.Convad				):
                        torch.nn.init.normal(m.weight				)
                        m.bias.data.fill_(1.0				)
  
              __UpperCamelCase   = ControlNetModel(
                  block_out_channels=(32, 64),layers_per_block=2,in_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),cross_attention_dim=32,conditioning_embedding_out_channels=(16, 32),)
              controlneta.controlnet_down_blocks.apply(A_				)
  
              torch.manual_seed(0				)
              __UpperCamelCase   = ControlNetModel(
                  block_out_channels=(32, 64),layers_per_block=2,in_channels=4,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),cross_attention_dim=32,conditioning_embedding_out_channels=(16, 32),)
              controlneta.controlnet_down_blocks.apply(A_				)
  
              torch.manual_seed(0				)
              __UpperCamelCase   = DDIMScheduler(
                  beta_start=0.0_0_0_8_5,beta_end=0.0_1_2,beta_schedule='scaled_linear',clip_sample=A_,set_alpha_to_one=A_,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              __UpperCamelCase   = CLIPTextModel(A_				)
              __UpperCamelCase   = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)
  
              __UpperCamelCase   = MultiControlNetModel([controlneta, controlneta]				)
  
              __UpperCamelCase   = {
                  'unet': unet,
                  'controlnet': controlnet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'text_encoder': text_encoder,
                  'tokenizer': tokenizer,
                  'safety_checker': None,
                  'feature_extractor': None,
              }
              return components
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple,A_:   str,A_:   List[Any]=0				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              if str(A_				).startswith('mps'				):
                   __UpperCamelCase   = torch.manual_seed(A_				)
              else:
                   __UpperCamelCase   = torch.Generator(device=A_				).manual_seed(A_				)
  
              __UpperCamelCase   = 2
  
              __UpperCamelCase   = [
                  randn_tensor(
                      (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),generator=A_,device=torch.device(A_				),),
                  randn_tensor(
                      (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),generator=A_,device=torch.device(A_				),),
              ]
              __UpperCamelCase   = floats_tensor((1, 3, 32, 32),rng=random.Random(A_				)				).to(A_				)
              __UpperCamelCase   = init_image.cpu().permute(0,2,3,1				)[0]
  
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				).resize((64, 64)				)
              __UpperCamelCase   = Image.fromarray(np.uinta(init_image + 4				)				).convert('RGB'				).resize((64, 64)				)
  
              __UpperCamelCase   = {
                  'prompt': 'A painting of a squirrel eating a burger',
                  'generator': generator,
                  'num_inference_steps': 2,
                  'guidance_scale': 6.0,
                  'output_type': 'numpy',
                  'image': image,
                  'mask_image': mask_image,
                  'control_image': control_image,
              }
  
              return inputs
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = self.pipeline_class(**A_				)
              pipe.to(A_				)
  
              __UpperCamelCase   = 1_0.0
              __UpperCamelCase   = 4
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = steps
              __UpperCamelCase   = scale
              __UpperCamelCase   = pipe(**A_				)[0]
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = steps
              __UpperCamelCase   = scale
              __UpperCamelCase   = pipe(**A_,control_guidance_start=0.1,control_guidance_end=0.2				)[0]
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = steps
              __UpperCamelCase   = scale
              __UpperCamelCase   = pipe(**A_,control_guidance_start=[0.1, 0.3],control_guidance_end=[0.2, 0.7]				)[0]
  
              __UpperCamelCase   = self.get_dummy_inputs(A_				)
              __UpperCamelCase   = steps
              __UpperCamelCase   = scale
              __UpperCamelCase   = pipe(**A_,control_guidance_start=0.4,control_guidance_end=[0.5, 0.8]				)[0]
  
              # make sure that all outputs are different
              assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
              assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
              assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  
         @unittest.skipIf(
             torch_device != 'cuda' or not is_xformers_available(),reason='XFormers attention is only available with CUDA and `xformers` installed',)
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              self._test_inference_batch_single_identical(expected_max_diff=2E-3				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   int				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_dummy_components()
              __UpperCamelCase   = self.pipeline_class(**A_				)
              pipe.to(A_				)
              pipe.set_progress_bar_config(disable=A_				)
              with tempfile.TemporaryDirectory() as tmpdir:
                   try:
                        # save_pretrained is not implemented for Multi-ControlNet
                        pipe.save_pretrained(A_				)
                   except NotImplementedError:
                        pass
  
  
  
  
  
  @slow
  @require_torch_gpu
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'				)
  
              __UpperCamelCase   = StableDiffusionControlNetInpaintPipeline.from_pretrained(
                  'runwayml/stable-diffusion-inpainting',safety_checker=A_,controlnet=A_				)
              pipe.enable_model_cpu_offload()
              pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = torch.Generator(device='cpu'				).manual_seed(0				)
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'				).resize((512, 512)				)
  
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                  '/stable_diffusion_inpaint/input_bench_mask.png'				).resize((512, 512)				)
  
              __UpperCamelCase   = 'pitch black hole'
  
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'				).resize((512, 512)				)
  
              __UpperCamelCase   = pipe(
                  A_,image=A_,mask_image=A_,control_image=A_,generator=A_,output_type='np',num_inference_steps=3,)
  
              __UpperCamelCase   = output.images[0]
  
              assert image.shape == (512, 512, 3)
  
              __UpperCamelCase   = load_numpy(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy'				)
  
              assert np.abs(expected_image - image				).max() < 9E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint'				)
  
              __UpperCamelCase   = StableDiffusionControlNetInpaintPipeline.from_pretrained(
                  'runwayml/stable-diffusion-v1-5',safety_checker=A_,controlnet=A_				)
              __UpperCamelCase   = DDIMScheduler.from_config(pipe.scheduler.config				)
              pipe.enable_model_cpu_offload()
              pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = torch.Generator(device='cpu'				).manual_seed(33				)
  
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'				)
              __UpperCamelCase   = init_image.resize((512, 512)				)
  
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'				)
              __UpperCamelCase   = mask_image.resize((512, 512)				)
  
              __UpperCamelCase   = 'a handsome man with ray-ban sunglasses'
  
              def make_inpaint_condition(A_:   Optional[Any],A_:   Any				):
                   __UpperCamelCase   = np.array(image.convert('RGB'				)				).astype(np.floataa				) / 2_5_5.0
                   __UpperCamelCase   = np.array(image_mask.convert('L'				)				).astype(np.floataa				) / 2_5_5.0
  
                   assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
                   __UpperCamelCase   = -1.0  # set as masked pixel
                   __UpperCamelCase   = np.expand_dims(A_,0				).transpose(0,3,1,2				)
                   __UpperCamelCase   = torch.from_numpy(A_				)
                   return image
  
              __UpperCamelCase   = make_inpaint_condition(A_,A_				)
  
              __UpperCamelCase   = pipe(
                  A_,image=A_,mask_image=A_,control_image=A_,guidance_scale=9.0,eta=1.0,generator=A_,num_inference_steps=20,output_type='np',)
              __UpperCamelCase   = output.images[0]
  
              assert image.shape == (512, 512, 3)
  
              __UpperCamelCase   = load_numpy(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy'				)
  
              assert np.abs(expected_image - image				).max() < 9E-2
  
  
  
style_context: 
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
      import torch
  
  if is_vision_available():
      from PIL import Image
  
      from transformers import DeiTImageProcessor
  
  
  
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def __init__( self:   List[str],A_:   List[Any],A_:   List[Any]=7,A_:   str=3,A_:   Tuple=18,A_:   Union[str, Any]=30,A_:   Union[str, Any]=400,A_:   List[str]=True,A_:   List[Any]=None,A_:   Tuple=True,A_:   Union[str, Any]=None,A_:   int=True,A_:   Any=[0.5, 0.5, 0.5],A_:   Optional[Any]=[0.5, 0.5, 0.5],):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = size if size is not None else {'height': 20, 'width': 20}
              __UpperCamelCase   = crop_size if crop_size is not None else {'height': 18, 'width': 18}
  
              __UpperCamelCase   = parent
              __UpperCamelCase   = batch_size
              __UpperCamelCase   = num_channels
              __UpperCamelCase   = image_size
              __UpperCamelCase   = min_resolution
              __UpperCamelCase   = max_resolution
              __UpperCamelCase   = do_resize
              __UpperCamelCase   = size
              __UpperCamelCase   = do_center_crop
              __UpperCamelCase   = crop_size
              __UpperCamelCase   = do_normalize
              __UpperCamelCase   = image_mean
              __UpperCamelCase   = image_std
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return {
                  "do_resize": self.do_resize,
                  "size": self.size,
                  "do_center_crop": self.do_center_crop,
                  "crop_size": self.crop_size,
                  "do_normalize": self.do_normalize,
                  "image_mean": self.image_mean,
                  "image_std": self.image_std,
              }
  
  
  
  @require_torch
  @require_vision
  class   __lowerCamelCase (_a							,			unittest.TestCase	):
         _lowercase       							=    DeiTImageProcessor if is_vision_available() else None
         _lowercase       							=    True
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DeiTImageProcessingTester(self				)
  
  
  
  
  
  
  
         @property
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              self.assertTrue(hasattr(A_,'do_resize'				)				)
              self.assertTrue(hasattr(A_,'size'				)				)
              self.assertTrue(hasattr(A_,'do_center_crop'				)				)
              self.assertTrue(hasattr(A_,'center_crop'				)				)
              self.assertTrue(hasattr(A_,'do_normalize'				)				)
              self.assertTrue(hasattr(A_,'image_mean'				)				)
              self.assertTrue(hasattr(A_,'image_std'				)				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class.from_dict(self.image_processor_dict				)
              self.assertEqual(image_processor.size,{'height': 20, 'width': 20}				)
              self.assertEqual(image_processor.crop_size,{'height': 18, 'width': 18}				)
  
              __UpperCamelCase   = self.image_processing_class.from_dict(self.image_processor_dict,size=42,crop_size=84				)
              self.assertEqual(image_processor.size,{'height': 42, 'width': 42}				)
              self.assertEqual(image_processor.crop_size,{'height': 84, 'width': 84}				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              pass
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random PIL images
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,Image.Image				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random numpy tensors
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_,numpify=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,np.ndarray				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random PyTorch tensors
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_,torchify=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,torch.Tensor				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  