




'''simple docstring'''


# This model implementation is heavily based on:

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     SCREAMING_SNAKE_CASE						(	UpperCamelCase__       ,			UpperCamelCase__       ,			UpperCamelCase__       ,			unittest.TestCase							):
      __magic_name__     :					Tuple             =				StableDiffusionControlNetInpaintPipeline
      __magic_name__     :					int             =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      __magic_name__     :					str             =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      __magic_name__     :					List[Any]             =				frozenset({'''control_image'''}							)  # skip `image` and `mask` for now, only test for control_image
      __magic_name__     :					str             =				TEXT_TO_IMAGE_IMAGE_PARAMS






      def        lowercase_	(   self      :     int					):


           '''simple docstring'''

           torch.manual_seed(0					)
           a_    :       Tuple    	=     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					)
           a_    :       Any    	=     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					)
           a_    :       Dict    	=     DDIMScheduler(
               beta_start=0.00085	,	beta_end=0.012	,	beta_schedule="""scaled_linear"""	,	clip_sample=lowerCAmelCase__	,	set_alpha_to_one=lowerCAmelCase__	,	)
           torch.manual_seed(0					)
           a_    :       List[Any]    	=     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					)
           a_    :       Union[str, Any]    	=     CLIPTextConfig(
               bos_token_id=0	,	eos_token_id=2	,	hidden_size=32	,	intermediate_size=37	,	layer_norm_eps=1e-0_5	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1000	,	)
           a_    :       str    	=     CLIPTextModel(lowerCAmelCase__					)
           a_    :       List[Any]    	=     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

           a_    :       List[str]    	=     {
               "unet": unet,
               "controlnet": controlnet,
               "scheduler": scheduler,
               "vae": vae,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "safety_checker": None,
               "feature_extractor": None,
           }
           return components






      def        lowercase_	(   self      :     int	,	lowercase__      :     Tuple	,	lowercase__      :     str=0					):


           '''simple docstring'''

           if str(lowerCAmelCase__					).startswith("""mps"""					):
                a_    :       int    	=     torch.manual_seed(lowerCAmelCase__					)
           else:
                a_    :       List[str]    	=     torch.Generator(device=lowerCAmelCase__					).manual_seed(lowerCAmelCase__					)

           a_    :       Optional[int]    	=     2
           a_    :       str    	=     randn_tensor(
               (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,	generator=lowerCAmelCase__	,	device=torch.device(lowerCAmelCase__					)	,	)
           a_    :       List[Any]    	=     floats_tensor((1, 3, 32, 32)	,	rng=random.Random(lowerCAmelCase__					)					).to(lowerCAmelCase__					)
           a_    :       List[Any]    	=     init_image.cpu().permute(0	,	2	,	3	,	1					)[0]

           a_    :       Tuple    	=     Image.fromarray(np.uinta(lowerCAmelCase__					)					).convert("""RGB"""					).resize((64, 64)					)
           a_    :       Union[str, Any]    	=     Image.fromarray(np.uinta(init_image + 4					)					).convert("""RGB"""					).resize((64, 64)					)

           a_    :       Optional[Any]    	=     {
               "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        lowercase_	(   self      :     Optional[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        lowercase_	(   self      :     List[Any]					):


           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)






      def        lowercase_	(   self      :     List[Any]					):


           '''simple docstring'''

           self._test_inference_batch_single_identical(expected_max_diff=2e-3					)







class     SCREAMING_SNAKE_CASE						(	UpperCamelCase__							):
      __magic_name__     :					Optional[int]             =				StableDiffusionControlNetInpaintPipeline
      __magic_name__     :					Optional[Any]             =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      __magic_name__     :					Optional[Any]             =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      __magic_name__     :					Optional[Any]             =				frozenset([]							)






      def        lowercase_	(   self      :     Tuple					):


           '''simple docstring'''

           torch.manual_seed(0					)
           a_    :       Tuple    	=     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					)
           a_    :       str    	=     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					)
           a_    :       Optional[int]    	=     DDIMScheduler(
               beta_start=0.00085	,	beta_end=0.012	,	beta_schedule="""scaled_linear"""	,	clip_sample=lowerCAmelCase__	,	set_alpha_to_one=lowerCAmelCase__	,	)
           torch.manual_seed(0					)
           a_    :       Dict    	=     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					)
           a_    :       Union[str, Any]    	=     CLIPTextConfig(
               bos_token_id=0	,	eos_token_id=2	,	hidden_size=32	,	intermediate_size=37	,	layer_norm_eps=1e-0_5	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1000	,	)
           a_    :       Optional[int]    	=     CLIPTextModel(lowerCAmelCase__					)
           a_    :       Optional[int]    	=     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

           a_    :       str    	=     {
               "unet": unet,
               "controlnet": controlnet,
               "scheduler": scheduler,
               "vae": vae,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "safety_checker": None,
               "feature_extractor": None,
           }
           return components







class     SCREAMING_SNAKE_CASE						(	UpperCamelCase__       ,			UpperCamelCase__       ,			unittest.TestCase							):
      __magic_name__     :					Tuple             =				StableDiffusionControlNetInpaintPipeline
      __magic_name__     :					Dict             =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      __magic_name__     :					int             =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS






      def        lowercase_	(   self      :     List[str]					):


           '''simple docstring'''

           torch.manual_seed(0					)
           a_    :       str    	=     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(lowercase__      :     Dict					):
                if isinstance(lowerCAmelCase__	,	torch.nn.Convad					):
                     torch.nn.init.normal(m.weight					)
                     m.bias.data.fill_(1.0					)

           a_    :       List[str]    	=     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(lowerCAmelCase__					)

           torch.manual_seed(0					)
           a_    :       Union[str, Any]    	=     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(lowerCAmelCase__					)

           torch.manual_seed(0					)
           a_    :       Union[str, Any]    	=     DDIMScheduler(
               beta_start=0.00085	,	beta_end=0.012	,	beta_schedule="""scaled_linear"""	,	clip_sample=lowerCAmelCase__	,	set_alpha_to_one=lowerCAmelCase__	,	)
           torch.manual_seed(0					)
           a_    :       Optional[Any]    	=     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					)
           a_    :       Optional[Any]    	=     CLIPTextConfig(
               bos_token_id=0	,	eos_token_id=2	,	hidden_size=32	,	intermediate_size=37	,	layer_norm_eps=1e-0_5	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1000	,	)
           a_    :       List[str]    	=     CLIPTextModel(lowerCAmelCase__					)
           a_    :       List[Any]    	=     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

           a_    :       Union[str, Any]    	=     MultiControlNetModel([controlneta, controlneta]					)

           a_    :       int    	=     {
               "unet": unet,
               "controlnet": controlnet,
               "scheduler": scheduler,
               "vae": vae,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "safety_checker": None,
               "feature_extractor": None,
           }
           return components






      def        lowercase_	(   self      :     Optional[int]	,	lowercase__      :     Tuple	,	lowercase__      :     List[Any]=0					):


           '''simple docstring'''

           if str(lowerCAmelCase__					).startswith("""mps"""					):
                a_    :       List[str]    	=     torch.manual_seed(lowerCAmelCase__					)
           else:
                a_    :       Optional[Any]    	=     torch.Generator(device=lowerCAmelCase__					).manual_seed(lowerCAmelCase__					)

           a_    :       List[str]    	=     2

           a_    :       Optional[int]    	=     [
               randn_tensor(
                   (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,	generator=lowerCAmelCase__	,	device=torch.device(lowerCAmelCase__					)	,	),
               randn_tensor(
                   (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,	generator=lowerCAmelCase__	,	device=torch.device(lowerCAmelCase__					)	,	),
           ]
           a_    :       List[str]    	=     floats_tensor((1, 3, 32, 32)	,	rng=random.Random(lowerCAmelCase__					)					).to(lowerCAmelCase__					)
           a_    :       Dict    	=     init_image.cpu().permute(0	,	2	,	3	,	1					)[0]

           a_    :       int    	=     Image.fromarray(np.uinta(lowerCAmelCase__					)					).convert("""RGB"""					).resize((64, 64)					)
           a_    :       str    	=     Image.fromarray(np.uinta(init_image + 4					)					).convert("""RGB"""					).resize((64, 64)					)

           a_    :       Optional[Any]    	=     {
               "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        lowercase_	(   self      :     Tuple					):


           '''simple docstring'''

           a_    :       Tuple    	=     self.get_dummy_components()
           a_    :       Union[str, Any]    	=     self.pipeline_class(**lowerCAmelCase__					)
           pipe.to(lowerCAmelCase__					)

           a_    :       int    	=     10.0
           a_    :       int    	=     4

           a_    :       Dict    	=     self.get_dummy_inputs(lowerCAmelCase__					)
           a_    :       int    	=     steps
           a_    :       List[Any]    	=     scale
           a_    :       Tuple    	=     pipe(**lowerCAmelCase__					)[0]

           a_    :       Dict    	=     self.get_dummy_inputs(lowerCAmelCase__					)
           a_    :       Dict    	=     steps
           a_    :       int    	=     scale
           a_    :       int    	=     pipe(**lowerCAmelCase__	,	control_guidance_start=0.1	,	control_guidance_end=0.2					)[0]

           a_    :       Tuple    	=     self.get_dummy_inputs(lowerCAmelCase__					)
           a_    :       Optional[Any]    	=     steps
           a_    :       List[Any]    	=     scale
           a_    :       int    	=     pipe(**lowerCAmelCase__	,	control_guidance_start=[0.1, 0.3]	,	control_guidance_end=[0.2, 0.7]					)[0]

           a_    :       Any    	=     self.get_dummy_inputs(lowerCAmelCase__					)
           a_    :       int    	=     steps
           a_    :       Dict    	=     scale
           a_    :       Union[str, Any]    	=     pipe(**lowerCAmelCase__	,	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        lowercase_	(   self      :     Dict					):


           '''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        lowercase_	(   self      :     Optional[int]					):


           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)






      def        lowercase_	(   self      :     Dict					):


           '''simple docstring'''

           self._test_inference_batch_single_identical(expected_max_diff=2e-3					)






      def        lowercase_	(   self      :     str					):


           '''simple docstring'''

           a_    :       Union[str, Any]    	=     self.get_dummy_components()
           a_    :       Optional[Any]    	=     self.pipeline_class(**lowerCAmelCase__					)
           pipe.to(lowerCAmelCase__					)
           pipe.set_progress_bar_config(disable=lowerCAmelCase__					)
           with tempfile.TemporaryDirectory() as tmpdir:
                try:
                     # save_pretrained is not implemented for Multi-ControlNet
                     pipe.save_pretrained(lowerCAmelCase__					)
                except NotImplementedError:
                     pass







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






      def        lowercase_	(   self      :     List[str]					):


           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()






      def        lowercase_	(   self      :     List[Any]					):


           '''simple docstring'''

           a_    :       Optional[int]    	=     ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""					)

           a_    :       Dict    	=     StableDiffusionControlNetInpaintPipeline.from_pretrained(
               """runwayml/stable-diffusion-inpainting"""	,	safety_checker=lowerCAmelCase__	,	controlnet=lowerCAmelCase__					)
           pipe.enable_model_cpu_offload()
           pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

           a_    :       int    	=     torch.Generator(device="""cpu"""					).manual_seed(0					)
           a_    :       List[Any]    	=     load_image(
               """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""					).resize((512, 512)					)

           a_    :       Union[str, Any]    	=     load_image(
               """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
               """/stable_diffusion_inpaint/input_bench_mask.png"""					).resize((512, 512)					)

           a_    :       Optional[Any]    	=     "pitch black hole"

           a_    :       Tuple    	=     load_image(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""					).resize((512, 512)					)

           a_    :       List[str]    	=     pipe(
               lowerCAmelCase__	,	image=lowerCAmelCase__	,	mask_image=lowerCAmelCase__	,	control_image=lowerCAmelCase__	,	generator=lowerCAmelCase__	,	output_type="""np"""	,	num_inference_steps=3	,	)

           a_    :       Tuple    	=     output.images[0]

           assert image.shape == (512, 512, 3)

           a_    :       List[Any]    	=     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        lowercase_	(   self      :     List[Any]					):


           '''simple docstring'''

           a_    :       Any    	=     ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""					)

           a_    :       Tuple    	=     StableDiffusionControlNetInpaintPipeline.from_pretrained(
               """runwayml/stable-diffusion-v1-5"""	,	safety_checker=lowerCAmelCase__	,	controlnet=lowerCAmelCase__					)
           a_    :       Optional[int]    	=     DDIMScheduler.from_config(pipe.scheduler.config					)
           pipe.enable_model_cpu_offload()
           pipe.set_progress_bar_config(disable=lowerCAmelCase__					)

           a_    :       int    	=     torch.Generator(device="""cpu"""					).manual_seed(33					)

           a_    :       Any    	=     load_image(
               """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""					)
           a_    :       Union[str, Any]    	=     init_image.resize((512, 512)					)

           a_    :       List[str]    	=     load_image(
               """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""					)
           a_    :       Optional[Any]    	=     mask_image.resize((512, 512)					)

           a_    :       str    	=     "a handsome man with ray-ban sunglasses"

           def make_inpaint_condition(lowercase__      :     List[str]	,	lowercase__      :     Union[str, Any]					):
                a_    :       List[Any]    	=     np.array(image.convert("""RGB"""					)					).astype(np.floataa					) / 255.0
                a_    :       str    	=     np.array(image_mask.convert("""L"""					)					).astype(np.floataa					) / 255.0

                assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
                a_    :       Any    	=     -1.0  # set as masked pixel
                a_    :       int    	=     np.expand_dims(lowerCAmelCase__	,	0					).transpose(0	,	3	,	1	,	2					)
                a_    :       Tuple    	=     torch.from_numpy(lowerCAmelCase__					)
                return image

           a_    :       List[str]    	=     make_inpaint_condition(lowerCAmelCase__	,	lowerCAmelCase__					)

           a_    :       int    	=     pipe(
               lowerCAmelCase__	,	image=lowerCAmelCase__	,	mask_image=lowerCAmelCase__	,	control_image=lowerCAmelCase__	,	guidance_scale=9.0	,	eta=1.0	,	generator=lowerCAmelCase__	,	num_inference_steps=20	,	output_type="""np"""	,	)
           a_    :       Dict    	=     output.images[0]

           assert image.shape == (512, 512, 3)

           a_    :       Tuple    	=     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






'''simple docstring'''


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


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import CLIPImageProcessor







class     SCREAMING_SNAKE_CASE						(	unittest.TestCase							):






      def __init__(   self      :     Tuple	,	lowercase__      :     Union[str, Any]	,	lowercase__      :     Optional[Any]=7	,	lowercase__      :     str=3	,	lowercase__      :     Tuple=18	,	lowercase__      :     Dict=30	,	lowercase__      :     List[Any]=400	,	lowercase__      :     Optional[Any]=True	,	lowercase__      :     Union[str, Any]=None	,	lowercase__      :     Union[str, Any]=True	,	lowercase__      :     Tuple=None	,	lowercase__      :     str=True	,	lowercase__      :     List[Any]=[0.48145466, 0.4578275, 0.40821073]	,	lowercase__      :     Optional[Any]=[0.26862954, 0.26130258, 0.27577711]	,	lowercase__      :     str=True	,	):


           '''simple docstring'''

           a_    :       Dict    	=     size if size is not None else {"""shortest_edge""": 20}
           a_    :       Any    	=     crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
           a_    :       List[str]    	=     parent
           a_    :       Dict    	=     batch_size
           a_    :       Any    	=     num_channels
           a_    :       Optional[int]    	=     image_size
           a_    :       Union[str, Any]    	=     min_resolution
           a_    :       Tuple    	=     max_resolution
           a_    :       int    	=     do_resize
           a_    :       List[str]    	=     size
           a_    :       Optional[int]    	=     do_center_crop
           a_    :       str    	=     crop_size
           a_    :       str    	=     do_normalize
           a_    :       Any    	=     image_mean
           a_    :       List[str]    	=     image_std
           a_    :       Any    	=     do_convert_rgb






      def        lowercase_	(   self      :     Optional[int]					):


           '''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,
               "do_convert_rgb": self.do_convert_rgb,
           }






      def        lowercase_	(   self      :     str	,	lowercase__      :     Union[str, Any]=False	,	lowercase__      :     Union[str, Any]=False	,	lowercase__      :     Union[str, Any]=False					):


           '''simple docstring'''

           assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

           if equal_resolution:
                a_    :       Union[str, Any]    	=     []
                for i in range(self.batch_size					):
                     image_inputs.append(
                         np.random.randint(
                             255	,	size=(self.num_channels, self.max_resolution, self.max_resolution)	,	dtype=np.uinta					)					)
           else:
                a_    :       int    	=     []
                for i in range(self.batch_size					):
                     a_	,    a_    :       Any    	=     np.random.choice(np.arange(self.min_resolution	,	self.max_resolution					)	,	2					)
                     image_inputs.append(np.random.randint(255	,	size=(self.num_channels, width, height)	,	dtype=np.uinta					)					)

           if not numpify and not torchify:
                # PIL expects the channel dimension as last dimension
                a_    :       Union[str, Any]    	=     [Image.fromarray(np.moveaxis(lowercase__	,	0	,	-1					)					) for x in image_inputs]

           if torchify:
                a_    :       List[Any]    	=     [torch.from_numpy(lowercase__					) for x in image_inputs]

           return image_inputs







@require_torch
@require_vision
class     SCREAMING_SNAKE_CASE						(	snake_case_       ,			unittest.TestCase							):
      __magic_name__     :					int             =				CLIPImageProcessor if is_vision_available() else None






      def        lowercase_	(   self      :     List[str]					):


           '''simple docstring'''

           a_    :       Dict    	=     CLIPImageProcessingTester(self					)






      @property
      def        lowercase_	(   self      :     Optional[int]					):


           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()






      def        lowercase_	(   self      :     Optional[Any]					):


           '''simple docstring'''

           a_    :       List[Any]    	=     self.image_processing_class(**self.image_processor_dict					)
           self.assertTrue(hasattr(lowercase__	,	"""do_resize"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""size"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_center_crop"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""center_crop"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_normalize"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""image_mean"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""image_std"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_convert_rgb"""					)					)






      def        lowercase_	(   self      :     Dict					):


           '''simple docstring'''

           a_    :       Optional[Any]    	=     self.image_processing_class.from_dict(self.image_processor_dict					)
           self.assertEqual(image_processor.size	,	{"""shortest_edge""": 20}					)
           self.assertEqual(image_processor.crop_size	,	{"""height""": 18, """width""": 18}					)

           a_    :       Optional[int]    	=     self.image_processing_class.from_dict(self.image_processor_dict	,	size=42	,	crop_size=84					)
           self.assertEqual(image_processor.size	,	{"""shortest_edge""": 42}					)
           self.assertEqual(image_processor.crop_size	,	{"""height""": 84, """width""": 84}					)






      def        lowercase_	(   self      :     List[str]					):


           '''simple docstring'''

           pass






      def        lowercase_	(   self      :     Tuple					):


           '''simple docstring'''

           a_    :       str    	=     self.image_processing_class(**self.image_processor_dict					)
           # create random PIL images
           a_    :       str    	=     self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__					)
           for image in image_inputs:
                self.assertIsInstance(lowercase__	,	Image.Image					)

           # Test not batched input
           a_    :       Optional[Any]    	=     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
           a_    :       str    	=     image_processing(lowercase__	,	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        lowercase_	(   self      :     Tuple					):


           '''simple docstring'''

           a_    :       Optional[Any]    	=     self.image_processing_class(**self.image_processor_dict					)
           # create random numpy tensors
           a_    :       Optional[int]    	=     self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__	,	numpify=lowercase__					)
           for image in image_inputs:
                self.assertIsInstance(lowercase__	,	np.ndarray					)

           # Test not batched input
           a_    :       Tuple    	=     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
           a_    :       str    	=     image_processing(lowercase__	,	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        lowercase_	(   self      :     str					):


           '''simple docstring'''

           a_    :       Dict    	=     self.image_processing_class(**self.image_processor_dict					)
           # create random PyTorch tensors
           a_    :       Optional[int]    	=     self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__	,	torchify=lowercase__					)
           for image in image_inputs:
                self.assertIsInstance(lowercase__	,	torch.Tensor					)

           # Test not batched input
           a_    :       Optional[int]    	=     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
           a_    :       int    	=     image_processing(lowercase__	,	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"""],
               )	,	)







@require_torch
@require_vision
class     SCREAMING_SNAKE_CASE						(	snake_case_       ,			unittest.TestCase							):
      __magic_name__     :					List[str]             =				CLIPImageProcessor if is_vision_available() else None






      def        lowercase_	(   self      :     str					):


           '''simple docstring'''

           a_    :       str    	=     CLIPImageProcessingTester(self	,	num_channels=4					)
           a_    :       Dict    	=     3






      @property
      def        lowercase_	(   self      :     Any					):


           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()






      def        lowercase_	(   self      :     List[Any]					):


           '''simple docstring'''

           a_    :       int    	=     self.image_processing_class(**self.image_processor_dict					)
           self.assertTrue(hasattr(lowercase__	,	"""do_resize"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""size"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_center_crop"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""center_crop"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_normalize"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""image_mean"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""image_std"""					)					)
           self.assertTrue(hasattr(lowercase__	,	"""do_convert_rgb"""					)					)






      def        lowercase_	(   self      :     int					):


           '''simple docstring'''

           pass






      def        lowercase_	(   self      :     Tuple					):


           '''simple docstring'''

           a_    :       List[Any]    	=     self.image_processing_class(**self.image_processor_dict					)
           # create random PIL images
           a_    :       Union[str, Any]    	=     self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__					)
           for image in image_inputs:
                self.assertIsInstance(lowercase__	,	Image.Image					)

           # Test not batched input
           a_    :       Optional[Any]    	=     image_processing(image_inputs[0]	,	return_tensors="""pt"""					).pixel_values
           self.assertEqual(
               encoded_images.shape	,	(
                   1,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )	,	)

           # Test batched
           a_    :       List[str]    	=     image_processing(lowercase__	,	return_tensors="""pt"""					).pixel_values
           self.assertEqual(
               encoded_images.shape	,	(
                   self.image_processor_tester.batch_size,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )	,	)
