






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





     def 						lowerCamelCase							(	self  )		->				Optional[Any]:
        torch.manual_seed(0  )
        lowerCamelCase									=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  )
        lowerCamelCase									=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  )
        lowerCamelCase									=DDIMScheduler(
            beta_start=0.00085							, beta_end=0.012							, beta_schedule="""scaled_linear"""							, clip_sample=_UpperCAmelCase							, set_alpha_to_one=_UpperCAmelCase							, )
        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							, )
        torch.manual_seed(0  )
        lowerCamelCase									=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							, )
        lowerCamelCase									=CLIPTextModel(_UpperCAmelCase  )
        lowerCamelCase									=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

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





     def 						lowerCamelCase							(	self							, _UpperCAmelCase							, _UpperCAmelCase=0  )		->				int:
        if str(_UpperCAmelCase  ).startswith("""mps"""  ):
           lowerCamelCase									=torch.manual_seed(_UpperCAmelCase  )
        else:
           lowerCamelCase									=torch.Generator(device=_UpperCAmelCase  ).manual_seed(_UpperCAmelCase  )

        lowerCamelCase									=2
        lowerCamelCase									=randn_tensor(
            (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)							, generator=_UpperCAmelCase							, device=torch.device(_UpperCAmelCase  )							, )
        lowerCamelCase									=floats_tensor((1, 3, 32, 32)							, rng=random.Random(_UpperCAmelCase  )  ).to(_UpperCAmelCase  )
        lowerCamelCase									=init_image.cpu().permute(0							, 2							, 3							, 1  )[0]

        lowerCamelCase									=Image.fromarray(np.uinta(_UpperCAmelCase  )  ).convert("""RGB"""  ).resize((64, 64)  )
        lowerCamelCase									=Image.fromarray(np.uinta(init_image + 4  )  ).convert("""RGB"""  ).resize((64, 64)  )

        lowerCamelCase									={
            """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 						lowerCamelCase							(	self  )		->				Dict:
        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 						lowerCamelCase							(	self  )		->				str:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )





     def 						lowerCamelCase							(	self  )		->				Union[str, Any]:
        self._test_inference_batch_single_identical(expected_max_diff=2E-3  )




class 		lowerCAmelCase_				(  UpperCamelCase ):
     __lowerCamelCase       :    List[Any] 	=     StableDiffusionControlNetInpaintPipeline
     __lowerCamelCase       :    Union[str, Any] 	=     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     __lowerCamelCase       :    List[str] 	=     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     __lowerCamelCase       :    List[str] 	=     frozenset([] )





     def 						lowerCamelCase							(	self  )		->				Any:
        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""")							, cross_attention_dim=32							, )
        torch.manual_seed(0  )
        lowerCamelCase									=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  )
        lowerCamelCase									=DDIMScheduler(
            beta_start=0.00085							, beta_end=0.012							, beta_schedule="""scaled_linear"""							, clip_sample=_UpperCAmelCase							, set_alpha_to_one=_UpperCAmelCase							, )
        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							, )
        torch.manual_seed(0  )
        lowerCamelCase									=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							, )
        lowerCamelCase									=CLIPTextModel(_UpperCAmelCase  )
        lowerCamelCase									=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

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




class 		lowerCAmelCase_				(  UpperCamelCase				,     UpperCamelCase				,     unittest.TestCase ):
     __lowerCamelCase       :    Tuple 	=     StableDiffusionControlNetInpaintPipeline
     __lowerCamelCase       :    str 	=     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     __lowerCamelCase       :    Dict 	=     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS





     def 						lowerCamelCase							(	self  )		->				Union[str, Any]:
        torch.manual_seed(0  )
        lowerCamelCase									=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(_UpperCAmelCase  ):
           if isinstance(_UpperCAmelCase							, torch.nn.Convad  ):
              torch.nn.init.normal(m.weight  )
              m.bias.data.fill_(1.0  )

        lowerCamelCase									=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(_UpperCAmelCase  )

        torch.manual_seed(0  )
        lowerCamelCase									=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(_UpperCAmelCase  )

        torch.manual_seed(0  )
        lowerCamelCase									=DDIMScheduler(
            beta_start=0.00085							, beta_end=0.012							, beta_schedule="""scaled_linear"""							, clip_sample=_UpperCAmelCase							, set_alpha_to_one=_UpperCAmelCase							, )
        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							, )
        torch.manual_seed(0  )
        lowerCamelCase									=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							, )
        lowerCamelCase									=CLIPTextModel(_UpperCAmelCase  )
        lowerCamelCase									=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

        lowerCamelCase									=MultiControlNetModel([controlneta, controlneta]  )

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





     def 						lowerCamelCase							(	self							, _UpperCAmelCase							, _UpperCAmelCase=0  )		->				List[str]:
        if str(_UpperCAmelCase  ).startswith("""mps"""  ):
           lowerCamelCase									=torch.manual_seed(_UpperCAmelCase  )
        else:
           lowerCamelCase									=torch.Generator(device=_UpperCAmelCase  ).manual_seed(_UpperCAmelCase  )

        lowerCamelCase									=2

        lowerCamelCase									=[
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)							, generator=_UpperCAmelCase							, device=torch.device(_UpperCAmelCase  )							, ),
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)							, generator=_UpperCAmelCase							, device=torch.device(_UpperCAmelCase  )							, ),
        ]
        lowerCamelCase									=floats_tensor((1, 3, 32, 32)							, rng=random.Random(_UpperCAmelCase  )  ).to(_UpperCAmelCase  )
        lowerCamelCase									=init_image.cpu().permute(0							, 2							, 3							, 1  )[0]

        lowerCamelCase									=Image.fromarray(np.uinta(_UpperCAmelCase  )  ).convert("""RGB"""  ).resize((64, 64)  )
        lowerCamelCase									=Image.fromarray(np.uinta(init_image + 4  )  ).convert("""RGB"""  ).resize((64, 64)  )

        lowerCamelCase									={
            """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 						lowerCamelCase							(	self  )		->				Union[str, Any]:
        lowerCamelCase									=self.get_dummy_components()
        lowerCamelCase									=self.pipeline_class(**_UpperCAmelCase  )
        pipe.to(_UpperCAmelCase  )

        lowerCamelCase									=10.0
        lowerCamelCase									=4

        lowerCamelCase									=self.get_dummy_inputs(_UpperCAmelCase  )
        lowerCamelCase									=steps
        lowerCamelCase									=scale
        lowerCamelCase									=pipe(**_UpperCAmelCase  )[0]

        lowerCamelCase									=self.get_dummy_inputs(_UpperCAmelCase  )
        lowerCamelCase									=steps
        lowerCamelCase									=scale
        lowerCamelCase									=pipe(**_UpperCAmelCase							, control_guidance_start=0.1							, control_guidance_end=0.2  )[0]

        lowerCamelCase									=self.get_dummy_inputs(_UpperCAmelCase  )
        lowerCamelCase									=steps
        lowerCamelCase									=scale
        lowerCamelCase									=pipe(**_UpperCAmelCase							, control_guidance_start=[0.1, 0.3]							, control_guidance_end=[0.2, 0.7]  )[0]

        lowerCamelCase									=self.get_dummy_inputs(_UpperCAmelCase  )
        lowerCamelCase									=steps
        lowerCamelCase									=scale
        lowerCamelCase									=pipe(**_UpperCAmelCase							, 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 						lowerCamelCase							(	self  )		->				List[str]:
        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 						lowerCamelCase							(	self  )		->				str:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )





     def 						lowerCamelCase							(	self  )		->				Tuple:
        self._test_inference_batch_single_identical(expected_max_diff=2E-3  )





     def 						lowerCamelCase							(	self  )		->				Any:
        lowerCamelCase									=self.get_dummy_components()
        lowerCamelCase									=self.pipeline_class(**_UpperCAmelCase  )
        pipe.to(_UpperCAmelCase  )
        pipe.set_progress_bar_config(disable=_UpperCAmelCase  )
        with tempfile.TemporaryDirectory() as tmpdir:
           try:
              # save_pretrained is not implemented for Multi-ControlNet
              pipe.save_pretrained(_UpperCAmelCase  )
           except NotImplementedError:
              pass




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





     def 						lowerCamelCase							(	self  )		->				Tuple:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()





     def 						lowerCamelCase							(	self  )		->				Any:
        lowerCamelCase									=ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""  )

        lowerCamelCase									=StableDiffusionControlNetInpaintPipeline.from_pretrained(
            """runwayml/stable-diffusion-inpainting"""							, safety_checker=_UpperCAmelCase							, controlnet=_UpperCAmelCase  )
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=_UpperCAmelCase  )

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

        lowerCamelCase									=load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
            """/stable_diffusion_inpaint/input_bench_mask.png"""  ).resize((512, 512)  )

        lowerCamelCase									="""pitch black hole"""

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

        lowerCamelCase									=pipe(
            _UpperCAmelCase							, image=_UpperCAmelCase							, mask_image=_UpperCAmelCase							, control_image=_UpperCAmelCase							, generator=_UpperCAmelCase							, output_type="""np"""							, num_inference_steps=3							, )

        lowerCamelCase									=output.images[0]

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

        lowerCamelCase									=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 						lowerCamelCase							(	self  )		->				str:
        lowerCamelCase									=ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""  )

        lowerCamelCase									=StableDiffusionControlNetInpaintPipeline.from_pretrained(
            """runwayml/stable-diffusion-v1-5"""							, safety_checker=_UpperCAmelCase							, controlnet=_UpperCAmelCase  )
        lowerCamelCase									=DDIMScheduler.from_config(pipe.scheduler.config  )
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=_UpperCAmelCase  )

        lowerCamelCase									=torch.Generator(device="""cpu"""  ).manual_seed(33  )

        lowerCamelCase									=load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""  )
        lowerCamelCase									=init_image.resize((512, 512)  )

        lowerCamelCase									=load_image(
            """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""  )
        lowerCamelCase									=mask_image.resize((512, 512)  )

        lowerCamelCase									="""a handsome man with ray-ban sunglasses"""

        def make_inpaint_condition(_UpperCAmelCase							, _UpperCAmelCase  ):
           lowerCamelCase									=np.array(image.convert("""RGB"""  )  ).astype(np.floataa  ) / 255.0
           lowerCamelCase									=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"
           lowerCamelCase									=-1.0  # set as masked pixel
           lowerCamelCase									=np.expand_dims(_UpperCAmelCase							, 0  ).transpose(0							, 3							, 1							, 2  )
           lowerCamelCase									=torch.from_numpy(_UpperCAmelCase  )
           return image

        lowerCamelCase									=make_inpaint_condition(_UpperCAmelCase							, _UpperCAmelCase  )

        lowerCamelCase									=pipe(
            _UpperCAmelCase							, image=_UpperCAmelCase							, mask_image=_UpperCAmelCase							, control_image=_UpperCAmelCase							, guidance_scale=9.0							, eta=1.0							, generator=_UpperCAmelCase							, num_inference_steps=20							, output_type="""np"""							, )
        lowerCamelCase									=output.images[0]

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

        lowerCamelCase									=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







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 SwinaSRImageProcessor
   from transformers.image_transforms import get_image_size


class 		lowerCAmelCase_				(  unittest.TestCase ):





     def __init__(	self							, _UpperCAmelCase							, _UpperCAmelCase=7							, _UpperCAmelCase=3							, _UpperCAmelCase=18							, _UpperCAmelCase=30							, _UpperCAmelCase=400							, _UpperCAmelCase=True							, _UpperCAmelCase=1 / 255							, _UpperCAmelCase=True							, _UpperCAmelCase=8							, )		->				Tuple:
        lowerCamelCase									=parent
        lowerCamelCase									=batch_size
        lowerCamelCase									=num_channels
        lowerCamelCase									=image_size
        lowerCamelCase									=min_resolution
        lowerCamelCase									=max_resolution
        lowerCamelCase									=do_rescale
        lowerCamelCase									=rescale_factor
        lowerCamelCase									=do_pad
        lowerCamelCase									=pad_size





     def 						lowerCamelCase							(	self  )		->				Optional[Any]:
        return {
            "do_rescale": self.do_rescale,
            "rescale_factor": self.rescale_factor,
            "do_pad": self.do_pad,
            "pad_size": self.pad_size,
        }





     def 						lowerCamelCase							(	self							, _UpperCAmelCase=False							, _UpperCAmelCase=False							, _UpperCAmelCase=False  )		->				int:
        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

        if equal_resolution:
           lowerCamelCase									=[]
           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:
           lowerCamelCase									=[]
           for i in range(self.batch_size  ):
              lowerCamelCase				,       lowerCamelCase									=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
           lowerCamelCase									=[Image.fromarray(np.moveaxis(_UpperCAmelCase							, 0							, -1  )  ) for x in image_inputs]

        if torchify:
           lowerCamelCase									=[torch.from_numpy(_UpperCAmelCase  ) for x in image_inputs]

        return image_inputs




@require_torch
@require_vision
class 		lowerCAmelCase_				(  UpperCamelCase				,     unittest.TestCase ):
     __lowerCamelCase       :    Optional[Any] 	=     SwinaSRImageProcessor if is_vision_available() else None





     def 						lowerCamelCase							(	self  )		->				Dict:
        lowerCamelCase									=SwinaSRImageProcessingTester(self  )





     @property
     def 						lowerCamelCase							(	self  )		->				Any:
        return self.image_processor_tester.prepare_image_processor_dict()





     def 						lowerCamelCase							(	self  )		->				Any:
        lowerCamelCase									=self.image_processing_class(**self.image_processor_dict  )
        self.assertTrue(hasattr(_UpperCAmelCase							, """do_rescale"""  )  )
        self.assertTrue(hasattr(_UpperCAmelCase							, """rescale_factor"""  )  )
        self.assertTrue(hasattr(_UpperCAmelCase							, """do_pad"""  )  )
        self.assertTrue(hasattr(_UpperCAmelCase							, """pad_size"""  )  )





     def 						lowerCamelCase							(	self  )		->				Any:
        pass





     def 						lowerCamelCase							(	self							, _UpperCAmelCase  )		->				int:
        lowerCamelCase				,       lowerCamelCase									=get_image_size(_UpperCAmelCase  )
        lowerCamelCase									=self.image_processor_tester.pad_size

        lowerCamelCase									=(old_height // size + 1) * size - old_height
        lowerCamelCase									=(old_width // size + 1) * size - old_width
        return old_height + pad_height, old_width + pad_width





     def 						lowerCamelCase							(	self  )		->				Optional[Any]:
        # Initialize image_processor
        lowerCamelCase									=self.image_processing_class(**self.image_processor_dict  )
        # create random PIL images
        lowerCamelCase									=self.image_processor_tester.prepare_inputs(equal_resolution=_UpperCAmelCase  )
        for image in image_inputs:
           self.assertIsInstance(_UpperCAmelCase							, Image.Image  )

        # Test not batched input
        lowerCamelCase									=image_processor(image_inputs[0]							, return_tensors="""pt"""  ).pixel_values
        lowerCamelCase				,       lowerCamelCase									=self.calculate_expected_size(np.array(image_inputs[0]  )  )
        self.assertEqual(
            encoded_images.shape							, (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )							, )





     def 						lowerCamelCase							(	self  )		->				Any:
        # Initialize image_processor
        lowerCamelCase									=self.image_processing_class(**self.image_processor_dict  )
        # create random numpy tensors
        lowerCamelCase									=self.image_processor_tester.prepare_inputs(equal_resolution=_UpperCAmelCase							, numpify=_UpperCAmelCase  )
        for image in image_inputs:
           self.assertIsInstance(_UpperCAmelCase							, np.ndarray  )

        # Test not batched input
        lowerCamelCase									=image_processor(image_inputs[0]							, return_tensors="""pt"""  ).pixel_values
        lowerCamelCase				,       lowerCamelCase									=self.calculate_expected_size(image_inputs[0]  )
        self.assertEqual(
            encoded_images.shape							, (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )							, )





     def 						lowerCamelCase							(	self  )		->				Dict:
        # Initialize image_processor
        lowerCamelCase									=self.image_processing_class(**self.image_processor_dict  )
        # create random PyTorch tensors
        lowerCamelCase									=self.image_processor_tester.prepare_inputs(equal_resolution=_UpperCAmelCase							, torchify=_UpperCAmelCase  )
        for image in image_inputs:
           self.assertIsInstance(_UpperCAmelCase							, torch.Tensor  )

        # Test not batched input
        lowerCamelCase									=image_processor(image_inputs[0]							, return_tensors="""pt"""  ).pixel_values
        lowerCamelCase				,       lowerCamelCase									=self.calculate_expected_size(image_inputs[0]  )
        self.assertEqual(
            encoded_images.shape							, (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )							, )