
import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device






def 						lowerCamelCase__							(      a   )   ->     Tuple:
   _A:						Optional[int]	    = {}
   for name in unet.attn_processors.keys():
      _A:						Union[str, Any]	    = None if name.endswith('''attn1.processor'''   ) else unet.config.cross_attention_dim
      if name.startswith('''mid_block'''   ):
         _A:						Tuple	    = unet.config.block_out_channels[-1]
      elif name.startswith('''up_blocks'''   ):
         _A:						List[str]	    = int(name[len('''up_blocks.'''   )]   )
         _A:						List[Any]	    = list(reversed(unet.config.block_out_channels   )   )[block_id]
      elif name.startswith('''down_blocks'''   ):
         _A:						Dict	    = int(name[len('''down_blocks.'''   )]   )
         _A:						List[str]	    = unet.config.block_out_channels[block_id]
      _A:						Optional[int]	    = (
          LoRAAttnProcessor2_0 if hasattr(lowercase_	,	'''scaled_dot_product_attention'''   ) else LoRAAttnProcessor
      )
      _A:						List[Any]	    = lora_attn_processor_class(
          hidden_size=lowercase_	,	cross_attention_dim=lowercase_   )
   _A:						Optional[int]	    = AttnProcsLayers(lowercase_   )
   return lora_attn_procs, unet_lora_layers






def 						lowerCamelCase__							(      a   )   ->     Union[str, Any]:
   _A:						Optional[int]	    = {}
   _A:						int	    = (
       LoRAAttnProcessor2_0 if hasattr(lowercase_	,	'''scaled_dot_product_attention'''   ) else LoRAAttnProcessor
   )
   for name, module in text_encoder.named_modules():
      if name.endswith(lowercase_   ):
         _A:						Dict	    = lora_attn_processor_class(
             hidden_size=module.out_proj.out_features	,	cross_attention_dim=lowercase_   )
   return text_lora_attn_procs






def 						lowerCamelCase__							(      a   )   ->     str:
   _A:						str	    = create_text_encoder_lora_attn_procs(lowercase_   )
   _A:						List[str]	    = AttnProcsLayers(lowercase_   )
   return text_encoder_lora_layers






def 						lowerCamelCase__							(      a	,	a=False   )   ->     int:
   for _, attn_proc in text_lora_attn_procs.items():
      # set up.weights
      for layer_name, layer_module in attn_proc.named_modules():
         if layer_name.endswith('''_lora'''   ):
            _A:						int	    = (
                torch.randn_like(layer_module.up.weight   )
                if randn_weight
                else torch.zeros_like(layer_module.up.weight   )
            )
            _A:						str	    = torch.nn.Parameter(lowercase_   )






class UpperCAmelCase     (		unittest.TestCase     ):





   '''simple docstring'''


   def 				__magic_name__       (      self  :							List[Any]  ):

      """simple docstring"""
      torch.manual_seed(0  )
      _A:						Optional[Any]	    = UNetaDConditionModel(
          block_out_channels=(3_2, 6_4)    ,    layers_per_block=2    ,    sample_size=3_2    ,    in_channels=4    ,    out_channels=4    ,    down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')    ,    up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')    ,    cross_attention_dim=3_2    ,    )
      _A:						List[Any]	    = DDIMScheduler(
          beta_start=0.00085    ,    beta_end=0.012    ,    beta_schedule='''scaled_linear'''    ,    clip_sample=lowercase_    ,    set_alpha_to_one=lowercase_    ,    steps_offset=1    ,    )
      torch.manual_seed(0  )
      _A:						Tuple	    = AutoencoderKL(
          block_out_channels=[3_2, 6_4]    ,    in_channels=3    ,    out_channels=3    ,    down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']    ,    up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']    ,    latent_channels=4    ,    )
      _A:						Optional[Any]	    = CLIPTextConfig(
          bos_token_id=0    ,    eos_token_id=2    ,    hidden_size=3_2    ,    intermediate_size=3_7    ,    layer_norm_eps=1e-05    ,    num_attention_heads=4    ,    num_hidden_layers=5    ,    pad_token_id=1    ,    vocab_size=1_0_0_0    ,    )
      _A:						Optional[int]	    = CLIPTextModel(lowercase_  )
      _A:						Optional[Any]	    = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

      _A:						Dict	    = create_unet_lora_layers(lowercase_  )
      _A:						str	    = create_text_encoder_lora_layers(lowercase_  )

      _A:						List[Any]	    = {
          '''unet''': unet,
          '''scheduler''': scheduler,
          '''vae''': vae,
          '''text_encoder''': text_encoder,
          '''tokenizer''': tokenizer,
          '''safety_checker''': None,
          '''feature_extractor''': None,
      }
      _A:						int	    = {
          '''unet_lora_layers''': unet_lora_layers,
          '''text_encoder_lora_layers''': text_encoder_lora_layers,
          '''unet_lora_attn_procs''': unet_lora_attn_procs,
      }
      return pipeline_components, lora_components


   def 				__magic_name__       (      self  :							Union[str, Any]  ):

      """simple docstring"""
      _A:						Optional[Any]	    = 1
      _A:						int	    = 1_0
      _A:						List[Any]	    = 4
      _A:						List[str]	    = (3_2, 3_2)

      _A:						Dict	    = torch.manual_seed(0  )
      _A:						Union[str, Any]	    = floats_tensor((batch_size, num_channels) + sizes  )
      _A:						Any	    = torch.randint(1    ,    lowercase_    ,    size=(batch_size, sequence_length)    ,    generator=lowercase_  )

      _A:						List[Any]	    = {
          '''prompt''': '''A painting of a squirrel eating a burger''',
          '''generator''': generator,
          '''num_inference_steps''': 2,
          '''guidance_scale''': 6.0,
          '''output_type''': '''numpy''',
      }

      return noise, input_ids, pipeline_inputs

      # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb


   def 				__magic_name__       (      self  :							int  ):

      """simple docstring"""
      _A:						Dict	    = 7_7

      _A:						Tuple	    = torch.randint(2    ,    5_6    ,    size=(1, max_seq_length)    ,    generator=torch.manual_seed(0  )  )

      _A:						Optional[int]	    = {}
      _A:						Optional[int]	    = inputs
      return prepared_inputs


   def 				__magic_name__       (      self  :							List[str]    ,    lowerCAmelCase_  :							Any  ):

      """simple docstring"""
      _A:						List[str]	    = self.get_dummy_components()
      LoraLoaderMixin.save_lora_weights(
          save_directory=lowercase_    ,    unet_lora_layers=lora_components['''unet_lora_layers''']    ,    text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']    ,    )
      self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.bin'''  )  )  )


   def 				__magic_name__       (      self  :							Any  ):

      """simple docstring"""
      _A:						Optional[int]	    = self.get_dummy_components()
      _A:						Optional[Any]	    = StableDiffusionPipeline(**lowercase_  )
      _A:						Optional[Any]	    = sd_pipe.to(lowercase_  )
      sd_pipe.set_progress_bar_config(disable=lowercase_  )

      _A:						Union[str, Any]	    = self.get_dummy_inputs()

      _A:						Optional[int]	    = sd_pipe(**lowercase_  ).images
      _A:						str	    = original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
         LoraLoaderMixin.save_lora_weights(
             save_directory=lowercase_    ,    unet_lora_layers=lora_components['''unet_lora_layers''']    ,    text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']    ,    )
         self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.bin'''  )  )  )
         sd_pipe.load_lora_weights(lowercase_  )

      _A:						int	    = sd_pipe(**lowercase_  ).images
      _A:						Optional[int]	    = lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(lowercase_  )    ,    torch.from_numpy(lowercase_  )  )  )


   def 				__magic_name__       (      self  :							List[str]  ):

      """simple docstring"""
      _A:						Union[str, Any]	    = self.get_dummy_components()
      _A:						Optional[int]	    = StableDiffusionPipeline(**lowercase_  )
      _A:						str	    = sd_pipe.to(lowercase_  )
      sd_pipe.set_progress_bar_config(disable=lowercase_  )

      _A:						Any	    = self.get_dummy_inputs()

      _A:						Optional[Any]	    = sd_pipe(**lowercase_  ).images
      _A:						Union[str, Any]	    = original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
         LoraLoaderMixin.save_lora_weights(
             save_directory=lowercase_    ,    unet_lora_layers=lora_components['''unet_lora_layers''']    ,    text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']    ,    safe_serialization=lowercase_    ,    )
         self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.safetensors'''  )  )  )
         sd_pipe.load_lora_weights(lowercase_  )

      _A:						int	    = sd_pipe(**lowercase_  ).images
      _A:						Optional[int]	    = lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(lowercase_  )    ,    torch.from_numpy(lowercase_  )  )  )


   def 				__magic_name__       (      self  :							str  ):

      """simple docstring"""
      _A:						Any	    = self.get_dummy_components()
      _A:						Union[str, Any]	    = lora_components['''unet_lora_attn_procs''']
      _A:						List[Any]	    = StableDiffusionPipeline(**lowercase_  )
      _A:						str	    = sd_pipe.to(lowercase_  )
      sd_pipe.set_progress_bar_config(disable=lowercase_  )

      _A:						Tuple	    = self.get_dummy_inputs()

      _A:						Optional[int]	    = sd_pipe(**lowercase_  ).images
      _A:						List[str]	    = original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
         _A:						str	    = sd_pipe.unet
         unet.set_attn_processor(lowercase_  )
         unet.save_attn_procs(lowercase_  )
         self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.bin'''  )  )  )
         sd_pipe.load_lora_weights(lowercase_  )

      _A:						str	    = sd_pipe(**lowercase_  ).images
      _A:						Tuple	    = lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(lowercase_  )    ,    torch.from_numpy(lowercase_  )  )  )


   def 				__magic_name__       (      self  :							Optional[int]  ):

      """simple docstring"""
      _A:						Tuple	    = self.get_dummy_components()
      _A:						List[Any]	    = StableDiffusionPipeline(**lowercase_  )

      _A:						int	    = self.get_dummy_tokens()

      # inference without lora
      _A:						Optional[int]	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # create lora_attn_procs with zeroed out up.weights
      _A:						List[str]	    = create_text_encoder_lora_attn_procs(pipe.text_encoder  )
      set_lora_up_weights(lowercase_    ,    randn_weight=lowercase_  )

      # monkey patch
      pipe._modify_text_encoder(lowercase_  )

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      _A:						List[str]	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert torch.allclose(
          lowercase_    ,    lowercase_  ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

      # create lora_attn_procs with randn up.weights
      _A:						Dict	    = create_text_encoder_lora_attn_procs(pipe.text_encoder  )
      set_lora_up_weights(lowercase_    ,    randn_weight=lowercase_  )

      # monkey patch
      pipe._modify_text_encoder(lowercase_  )

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      _A:						Dict	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert not torch.allclose(
          lowercase_    ,    lowercase_  ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"


   def 				__magic_name__       (      self  :							str  ):

      """simple docstring"""
      _A:						Tuple	    = self.get_dummy_components()
      _A:						Optional[Any]	    = StableDiffusionPipeline(**lowercase_  )

      _A:						int	    = self.get_dummy_tokens()

      # inference without lora
      _A:						Optional[Any]	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # create lora_attn_procs with randn up.weights
      _A:						List[Any]	    = create_text_encoder_lora_attn_procs(pipe.text_encoder  )
      set_lora_up_weights(lowercase_    ,    randn_weight=lowercase_  )

      # monkey patch
      pipe._modify_text_encoder(lowercase_  )

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      _A:						List[Any]	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert not torch.allclose(
          lowercase_    ,    lowercase_  ), "lora outputs should be different to without lora outputs"

      # remove monkey patch
      pipe._remove_text_encoder_monkey_patch()

      # inference with removed lora
      _A:						str	    = pipe.text_encoder(**lowercase_  )[0]
      assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)

      assert torch.allclose(
          lowercase_    ,    lowercase_  ), "remove lora monkey patch should restore the original outputs"


   def 				__magic_name__       (      self  :							List[str]  ):

      """simple docstring"""
      _A:						Optional[Any]	    = self.get_dummy_components()
      _A:						int	    = StableDiffusionPipeline(**lowercase_  )
      _A:						List[Any]	    = sd_pipe.to(lowercase_  )
      sd_pipe.set_progress_bar_config(disable=lowercase_  )

      _A:						Union[str, Any]	    = self.get_dummy_inputs()

      with tempfile.TemporaryDirectory() as tmpdirname:
         LoraLoaderMixin.save_lora_weights(
             save_directory=lowercase_    ,    unet_lora_layers=lora_components['''unet_lora_layers''']    ,    text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']    ,    )
         self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.bin'''  )  )  )
         sd_pipe.load_lora_weights(lowercase_  )

      _A:						str	    = sd_pipe(**lowercase_  ).images
      _A:						Union[str, Any]	    = lora_images[0, -3:, -3:, -1]

      _A:						Union[str, Any]	    = sd_pipe(**lowercase_    ,    cross_attention_kwargs={'''scale''': 0.5}  ).images
      _A:						Optional[int]	    = lora_images_with_scale[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(
          torch.allclose(torch.from_numpy(lowercase_  )    ,    torch.from_numpy(lowercase_  )  )  )


   def 				__magic_name__       (      self  :							Union[str, Any]  ):

      """simple docstring"""

      with tempfile.TemporaryDirectory() as tmpdirname:
         self.create_lora_weight_file(lowercase_  )

         _A:						str	    = self.get_dummy_components()
         _A:						Optional[Any]	    = StableDiffusionPipeline(**lowercase_  )
         _A:						Any	    = sd_pipe.to(lowercase_  )
         sd_pipe.set_progress_bar_config(disable=lowercase_  )

         # check if vanilla attention processors are used
         for _, module in sd_pipe.unet.named_modules():
            if isinstance(lowercase_    ,    lowercase_  ):
               self.assertIsInstance(module.processor    ,    (AttnProcessor, AttnProcessor2_0)  )

            # load LoRA weight file
         sd_pipe.load_lora_weights(lowercase_  )

         # check if lora attention processors are used
         for _, module in sd_pipe.unet.named_modules():
            if isinstance(lowercase_    ,    lowercase_  ):
               _A:						str	    = (
                   LoRAAttnProcessor2_0 if hasattr(lowercase_    ,    '''scaled_dot_product_attention'''  ) else LoRAAttnProcessor
               )
               self.assertIsInstance(module.processor    ,    lowercase_  )


   @unittest.skipIf(torch_device != '''cuda'''    ,    '''This test is supposed to run on GPU'''  )
   def 				__magic_name__       (      self  :							List[str]  ):

      """simple docstring"""

      with tempfile.TemporaryDirectory() as tmpdirname:
         self.create_lora_weight_file(lowercase_  )

         _A:						Any	    = self.get_dummy_components()
         _A:						int	    = StableDiffusionPipeline(**lowercase_  )
         _A:						List[Any]	    = sd_pipe.to(lowercase_  )
         sd_pipe.set_progress_bar_config(disable=lowercase_  )

         # enable XFormers
         sd_pipe.enable_xformers_memory_efficient_attention()

         # check if xFormers attention processors are used
         for _, module in sd_pipe.unet.named_modules():
            if isinstance(lowercase_    ,    lowercase_  ):
               self.assertIsInstance(module.processor    ,    lowercase_  )

            # load LoRA weight file
         sd_pipe.load_lora_weights(lowercase_  )

         # check if lora attention processors are used
         for _, module in sd_pipe.unet.named_modules():
            if isinstance(lowercase_    ,    lowercase_  ):
               self.assertIsInstance(module.processor    ,    lowercase_  )


   @unittest.skipIf(torch_device != '''cuda'''    ,    '''This test is supposed to run on GPU'''  )
   def 				__magic_name__       (      self  :							List[Any]  ):

      """simple docstring"""
      _A:						Tuple	    = self.get_dummy_components()
      _A:						List[Any]	    = StableDiffusionPipeline(**lowercase_  )
      _A:						Dict	    = sd_pipe.to(lowercase_  )
      sd_pipe.set_progress_bar_config(disable=lowercase_  )

      _A:						Dict	    = self.get_dummy_inputs()

      # enable XFormers
      sd_pipe.enable_xformers_memory_efficient_attention()

      _A:						List[Any]	    = sd_pipe(**lowercase_  ).images
      _A:						Tuple	    = original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
         LoraLoaderMixin.save_lora_weights(
             save_directory=lowercase_    ,    unet_lora_layers=lora_components['''unet_lora_layers''']    ,    text_encoder_lora_layers=lora_components['''text_encoder_lora_layers''']    ,    )
         self.assertTrue(os.path.isfile(os.path.join(lowercase_    ,    '''pytorch_lora_weights.bin'''  )  )  )
         sd_pipe.load_lora_weights(lowercase_  )

      _A:						Tuple	    = sd_pipe(**lowercase_  ).images
      _A:						Dict	    = lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(lowercase_  )    ,    torch.from_numpy(lowercase_  )  )  )





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 UpperCAmelCase     (		unittest.TestCase     ):





   '''simple docstring'''


   def __init__(      self  :							Union[str, Any]    ,    lowerCAmelCase_  :							Optional[int]    ,    lowerCAmelCase_  :							Optional[int]=7    ,    lowerCAmelCase_  :							Dict=3    ,    lowerCAmelCase_  :							Optional[Any]=1_8    ,    lowerCAmelCase_  :							Union[str, Any]=3_0    ,    lowerCAmelCase_  :							int=4_0_0    ,    lowerCAmelCase_  :							int=True    ,    lowerCAmelCase_  :							Dict=1 / 2_5_5    ,    lowerCAmelCase_  :							Union[str, Any]=True    ,    lowerCAmelCase_  :							str=8    ,    ):

      """simple docstring"""
      _A:						Optional[Any]	    = parent
      _A:						int	    = batch_size
      _A:						List[str]	    = num_channels
      _A:						Union[str, Any]	    = image_size
      _A:						Optional[int]	    = min_resolution
      _A:						int	    = max_resolution
      _A:						int	    = do_rescale
      _A:						Optional[Any]	    = rescale_factor
      _A:						List[Any]	    = do_pad
      _A:						Optional[int]	    = pad_size


   def 				__magic_name__       (      self  :							List[Any]  ):

      """simple docstring"""
      return {
          "do_rescale": self.do_rescale,
          "rescale_factor": self.rescale_factor,
          "do_pad": self.do_pad,
          "pad_size": self.pad_size,
      }


   def 				__magic_name__       (      self  :							Union[str, Any]    ,    lowerCAmelCase_  :							Optional[Any]=False    ,    lowerCAmelCase_  :							Tuple=False    ,    lowerCAmelCase_  :							Dict=False  ):

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

      if equal_resolution:
         _A:						Dict	    = []
         for i in range(self.batch_size  ):
            image_inputs.append(
                np.random.randint(
                    2_5_5    ,    size=(self.num_channels, self.max_resolution, self.max_resolution)    ,    dtype=np.uinta  )  )
      else:
         _A:						List[str]	    = []
         for i in range(self.batch_size  ):
            _A    ,						_A:						Optional[Any]	    = np.random.choice(np.arange(self.min_resolution    ,    self.max_resolution  )    ,    2  )
            image_inputs.append(np.random.randint(2_5_5    ,    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(lowerCAmelCase_    ,    0    ,    -1  )  ) for x in image_inputs]

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

      return image_inputs






@require_torch
@require_vision
class UpperCAmelCase     (		SCREAMING_SNAKE_CASE__							,							unittest.TestCase     ):





   '''simple docstring'''
   __UpperCamelCase	:					int				       =					SwinaSRImageProcessor if is_vision_available() else None


   def 				__magic_name__       (      self  :							Tuple  ):

      """simple docstring"""
      _A:						int	    = SwinaSRImageProcessingTester(self  )


   @property
   def 				__magic_name__       (      self  :							Optional[Any]  ):

      """simple docstring"""
      return self.image_processor_tester.prepare_image_processor_dict()


   def 				__magic_name__       (      self  :							Union[str, Any]  ):

      """simple docstring"""
      _A:						Any	    = self.image_processing_class(**self.image_processor_dict  )
      self.assertTrue(hasattr(lowerCAmelCase_    ,    '''do_rescale'''  )  )
      self.assertTrue(hasattr(lowerCAmelCase_    ,    '''rescale_factor'''  )  )
      self.assertTrue(hasattr(lowerCAmelCase_    ,    '''do_pad'''  )  )
      self.assertTrue(hasattr(lowerCAmelCase_    ,    '''pad_size'''  )  )


   def 				__magic_name__       (      self  :							List[Any]  ):

      """simple docstring"""
      pass


   def 				__magic_name__       (      self  :							Optional[int]    ,    lowerCAmelCase_  :							Dict  ):

      """simple docstring"""
      _A    ,						_A:						Any	    = get_image_size(lowerCAmelCase_  )
      _A:						Union[str, Any]	    = self.image_processor_tester.pad_size

      _A:						Optional[Any]	    = (old_height // size + 1) * size - old_height
      _A:						int	    = (old_width // size + 1) * size - old_width
      return old_height + pad_height, old_width + pad_width


   def 				__magic_name__       (      self  :							Dict  ):

      """simple docstring"""
      # Initialize image_processor
      _A:						Optional[int]	    = self.image_processing_class(**self.image_processor_dict  )
      # create random PIL images
      _A:						str	    = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase_  )
      for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_    ,    Image.Image  )

      # Test not batched input
      _A:						int	    = image_processor(image_inputs[0]    ,    return_tensors='''pt'''  ).pixel_values
      _A    ,						_A:						str	    = 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 				__magic_name__       (      self  :							Tuple  ):

      """simple docstring"""
      # Initialize image_processor
      _A:						Union[str, Any]	    = self.image_processing_class(**self.image_processor_dict  )
      # create random numpy tensors
      _A:						List[str]	    = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase_    ,    numpify=lowerCAmelCase_  )
      for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_    ,    np.ndarray  )

      # Test not batched input
      _A:						int	    = image_processor(image_inputs[0]    ,    return_tensors='''pt'''  ).pixel_values
      _A    ,						_A:						Union[str, Any]	    = self.calculate_expected_size(image_inputs[0]  )
      self.assertEqual(
          encoded_images.shape    ,    (
              1,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )    ,    )


   def 				__magic_name__       (      self  :							int  ):

      """simple docstring"""
      # Initialize image_processor
      _A:						Optional[Any]	    = self.image_processing_class(**self.image_processor_dict  )
      # create random PyTorch tensors
      _A:						Tuple	    = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase_    ,    torchify=lowerCAmelCase_  )
      for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_    ,    torch.Tensor  )

      # Test not batched input
      _A:						List[str]	    = image_processor(image_inputs[0]    ,    return_tensors='''pt'''  ).pixel_values
      _A    ,						_A:						Dict	    = self.calculate_expected_size(image_inputs[0]  )
      self.assertEqual(
          encoded_images.shape    ,    (
              1,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )    ,    )



