

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class A__    ( A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					List[str]      =						KandinskyVaaControlnetImgaImgPipeline
 _lowercase     :					Tuple      =						['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
 _lowercase     :					str      =						['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
 _lowercase     :					Optional[Any]      =						[
     '''generator''',
     '''height''',
     '''width''',
     '''strength''',
     '''guidance_scale''',
     '''num_inference_steps''',
     '''return_dict''',
     '''guidance_scale''',
     '''num_images_per_prompt''',
     '''output_type''',
     '''return_dict''',
 ]
 _lowercase     :					Tuple      =						False

 @property
 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      return 3_2

 @property
 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      return 3_2

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






      '''simple docstring'''




      return self.time_input_dim

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






      '''simple docstring'''




      return self.time_input_dim * 4

 @property
 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      return 1_0_0

 @property
 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      torch.manual_seed(0       )

      _lowerCAmelCase   :					Tuple        =    {
          "in_channels": 8,
          # Out channels is double in channels because predicts mean and variance
          "out_channels": 8,
          "addition_embed_type": "image_hint",
          "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
          "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
          "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
          "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
          "layers_per_block": 1,
          "encoder_hid_dim": self.text_embedder_hidden_size,
          "encoder_hid_dim_type": "image_proj",
          "cross_attention_dim": self.cross_attention_dim,
          "attention_head_dim": 4,
          "resnet_time_scale_shift": "scale_shift",
          "class_embed_type": None,
      }

      _lowerCAmelCase   :					Optional[int]        =    UNetaDConditionModel(**A_       )
      return model

 @property
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      return {
          "block_out_channels": [3_2, 3_2, 6_4, 6_4],
          "down_block_types": [
              "DownEncoderBlock2D",
              "DownEncoderBlock2D",
              "DownEncoderBlock2D",
              "AttnDownEncoderBlock2D",
          ],
          "in_channels": 3,
          "latent_channels": 4,
          "layers_per_block": 1,
          "norm_num_groups": 8,
          "norm_type": "spatial",
          "num_vq_embeddings": 1_2,
          "out_channels": 3,
          "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
          "vq_embed_dim": 4,
      }

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






      '''simple docstring'''




      torch.manual_seed(0       )
      _lowerCAmelCase   :					List[str]        =    VQModel(**self.dummy_movq_kwargs       )
      return model

 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    self.dummy_unet
      _lowerCAmelCase   :					List[Any]        =    self.dummy_movq

      _lowerCAmelCase   :					Tuple        =    {
          "num_train_timesteps": 1_0_0_0,
          "beta_schedule": "linear",
          "beta_start": 0.00085,
          "beta_end": 0.012,
          "clip_sample": False,
          "set_alpha_to_one": False,
          "steps_offset": 0,
          "prediction_type": "epsilon",
          "thresholding": False,
      }

      _lowerCAmelCase   :					int        =    DDIMScheduler(**A_       )

      _lowerCAmelCase   :					Tuple        =    {
          "unet": unet,
          "scheduler": scheduler,
          "movq": movq,
      }

      return components

 def    __magic_name__       (		self :	Union[str, Any]     ,						A_ :	Union[str, Any]     ,						A_ :	Optional[int]=0       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    floats_tensor((1, self.text_embedder_hidden_size)     ,						rng=random.Random(A_       )       ).to(A_       )
      _lowerCAmelCase   :					str        =    floats_tensor((1, self.text_embedder_hidden_size)     ,						rng=random.Random(seed + 1       )       ).to(
          A_       )
      # create init_image
      _lowerCAmelCase   :					Dict        =    floats_tensor((1, 3, 6_4, 6_4)     ,						rng=random.Random(A_       )       ).to(A_       )
      _lowerCAmelCase   :					Dict        =    image.cpu().permute(0     ,						2     ,						3     ,						1       )[0]
      _lowerCAmelCase   :					Tuple        =    Image.fromarray(np.uinta(A_       )       ).convert("RGB"       ).resize((2_5_6, 2_5_6)       )
      # create hint
      _lowerCAmelCase   :					Union[str, Any]        =    floats_tensor((1, 3, 6_4, 6_4)     ,						rng=random.Random(A_       )       ).to(A_       )

      if str(A_       ).startswith("mps"       ):
           _lowerCAmelCase   :					Tuple        =    torch.manual_seed(A_       )
      else:
           _lowerCAmelCase   :					Any        =    torch.Generator(device=A_       ).manual_seed(A_       )
      _lowerCAmelCase   :					Union[str, Any]        =    {
          "image": init_image,
          "image_embeds": image_embeds,
          "negative_image_embeds": negative_image_embeds,
          "hint": hint,
          "generator": generator,
          "height": 6_4,
          "width": 6_4,
          "num_inference_steps": 1_0,
          "guidance_scale": 7.0,
          "strength": 0.2,
          "output_type": "np",
      }
      return inputs


 def    __magic_name__       (		self :	Optional[int]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Union[str, Any]        =    "cpu"

      _lowerCAmelCase   :					Tuple        =    self.get_dummy_components()

      _lowerCAmelCase   :					Optional[int]        =    self.pipeline_class(**A_       )
      _lowerCAmelCase   :					Optional[Any]        =    pipe.to(A_       )

      pipe.set_progress_bar_config(disable=A_       )

      _lowerCAmelCase   :					List[str]        =    pipe(**self.get_dummy_inputs(A_       )       )
      _lowerCAmelCase   :					List[Any]        =    output.images

      _lowerCAmelCase   :					str        =    pipe(
          **self.get_dummy_inputs(A_       )     ,						return_dict=A_     ,						)[0]

      _lowerCAmelCase   :					int        =    image[0, -3:, -3:, -1]
      _lowerCAmelCase   :					List[str]        =    image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 6_4, 6_4, 3)

      _lowerCAmelCase   :					List[Any]        =    np.array(
          [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]       )
      assert (
          np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
      ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
      assert (
          np.abs(image_from_tuple_slice.flatten() - expected_slice       ).max() < 1E-2
      ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''





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



 """simple docstring"""







 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




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


 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[str]        =    load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
          "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"       )

      _lowerCAmelCase   :					str        =    load_image(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"       )
      _lowerCAmelCase   :					Union[str, Any]        =    init_image.resize((5_1_2, 5_1_2)       )

      _lowerCAmelCase   :					Dict        =    load_image(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
          "/kandinskyv22/hint_image_cat.png"       )
      _lowerCAmelCase   :					Tuple        =    torch.from_numpy(np.array(A_       )       ).float() / 255.0
      _lowerCAmelCase   :					Optional[int]        =    hint.permute(2     ,						0     ,						1       ).unsqueeze(0       )

      _lowerCAmelCase   :					List[str]        =    "A robot, 4k photo"

      _lowerCAmelCase   :					Dict        =    KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
          "kandinsky-community/kandinsky-2-2-prior"     ,						torch_dtype=torch.floataa       )
      pipe_prior.to(A_       )

      _lowerCAmelCase   :					str        =    KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
          "kandinsky-community/kandinsky-2-2-controlnet-depth"     ,						torch_dtype=torch.floataa       )
      _lowerCAmelCase   :					Optional[int]        =    pipeline.to(A_       )

      pipeline.set_progress_bar_config(disable=A_       )

      _lowerCAmelCase   :					Dict        =    torch.Generator(device="cpu"       ).manual_seed(0       )

      _lowerCAmelCase      ,			_lowerCAmelCase   :					Tuple        =    pipe_prior(
          A_     ,						image=A_     ,						strength=0.85     ,						generator=A_     ,						negative_prompt=""     ,						).to_tuple()

      _lowerCAmelCase   :					List[Any]        =    pipeline(
          image=A_     ,						image_embeds=A_     ,						negative_image_embeds=A_     ,						hint=A_     ,						generator=A_     ,						num_inference_steps=1_0_0     ,						height=5_1_2     ,						width=5_1_2     ,						strength=0.5     ,						output_type="np"     ,						)

      _lowerCAmelCase   :					str        =    output.images[0]

      assert image.shape == (5_1_2, 5_1_2, 3)

      assert_mean_pixel_difference(A_     ,						A_       )









from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
  import torch


__UpperCAmelCase    				=     logging.get_logger(__name__)





class A__    ( A ):



 """simple docstring"""







 _lowercase     :					int      =						['''pixel_values''']

 def __init__(		self :	Union[str, Any]     ,						A_ :	bool = True     ,						A_ :	Optional[Dict[str, int]] = None     ,						A_ :	PILImageResampling = PILImageResampling.BILINEAR     ,						A_ :	bool = True     ,						A_ :	Dict[str, int] = None     ,						A_ :	bool = True     ,						A_ :	Union[int, float] = 1 / 2_5_5     ,						A_ :	bool = True     ,						A_ :	Optional[Union[float, List[float]]] = None     ,						A_ :	Optional[Union[float, List[float]]] = None     ,						**A_ :	Optional[Any]     ,						):






      '''simple docstring'''




      super().__init__(**A_       )
      _lowerCAmelCase   :					Optional[Any]        =    size if size is not None else {"shortest_edge": 2_5_6}
      _lowerCAmelCase   :					Optional[int]        =    get_size_dict(A_     ,						default_to_square=A_       )
      _lowerCAmelCase   :					Dict        =    crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
      _lowerCAmelCase   :					Tuple        =    get_size_dict(A_     ,						param_name="crop_size"       )
      _lowerCAmelCase   :					Dict        =    do_resize
      _lowerCAmelCase   :					Optional[Any]        =    size
      _lowerCAmelCase   :					Union[str, Any]        =    resample
      _lowerCAmelCase   :					List[Any]        =    do_center_crop
      _lowerCAmelCase   :					str        =    crop_size
      _lowerCAmelCase   :					int        =    do_rescale
      _lowerCAmelCase   :					Tuple        =    rescale_factor
      _lowerCAmelCase   :					str        =    do_normalize
      _lowerCAmelCase   :					List[Any]        =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      _lowerCAmelCase   :					str        =    image_std if image_std is not None else IMAGENET_STANDARD_STD

 def    __magic_name__       (		self :	Dict     ,						A_ :	np.ndarray     ,						A_ :	Dict[str, int]     ,						A_ :	PILImageResampling = PILImageResampling.BICUBIC     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	Tuple     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    get_size_dict(A_     ,						default_to_square=A_       )
      if "shortest_edge" not in size:
           raise ValueError(F'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''       )
      _lowerCAmelCase   :					Optional[Any]        =    get_resize_output_image_size(A_     ,						size=size["shortest_edge"]     ,						default_to_square=A_       )
      return resize(A_     ,						size=A_     ,						resample=A_     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	List[Any]     ,						A_ :	np.ndarray     ,						A_ :	Dict[str, int]     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	Dict     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    get_size_dict(A_       )
      if "height" not in size or "width" not in size:
           raise ValueError(F'''The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}'''       )
      return center_crop(A_     ,						size=(size["height"], size["width"])     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	int     ,						A_ :	np.ndarray     ,						A_ :	float     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	List[Any]       ):






      '''simple docstring'''




      return rescale(A_     ,						scale=A_     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	Tuple     ,						A_ :	np.ndarray     ,						A_ :	Union[float, List[float]]     ,						A_ :	Union[float, List[float]]     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	List[Any]     ,						):






      '''simple docstring'''




      return normalize(A_     ,						mean=A_     ,						std=A_     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	List[str]     ,						A_ :	ImageInput     ,						A_ :	Optional[bool] = None     ,						A_ :	Dict[str, int] = None     ,						A_ :	PILImageResampling = None     ,						A_ :	bool = None     ,						A_ :	Dict[str, int] = None     ,						A_ :	Optional[bool] = None     ,						A_ :	Optional[float] = None     ,						A_ :	Optional[bool] = None     ,						A_ :	Optional[Union[float, List[float]]] = None     ,						A_ :	Optional[Union[float, List[float]]] = None     ,						A_ :	Optional[Union[str, TensorType]] = None     ,						A_ :	Union[str, ChannelDimension] = ChannelDimension.FIRST     ,						**A_ :	int     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    do_resize if do_resize is not None else self.do_resize
      _lowerCAmelCase   :					Optional[Any]        =    size if size is not None else self.size
      _lowerCAmelCase   :					Optional[Any]        =    get_size_dict(A_     ,						default_to_square=A_       )
      _lowerCAmelCase   :					Tuple        =    resample if resample is not None else self.resample
      _lowerCAmelCase   :					str        =    do_center_crop if do_center_crop is not None else self.do_center_crop
      _lowerCAmelCase   :					List[Any]        =    crop_size if crop_size is not None else self.crop_size
      _lowerCAmelCase   :					str        =    get_size_dict(A_     ,						param_name="crop_size"       )
      _lowerCAmelCase   :					Union[str, Any]        =    do_rescale if do_rescale is not None else self.do_rescale
      _lowerCAmelCase   :					List[str]        =    rescale_factor if rescale_factor is not None else self.rescale_factor
      _lowerCAmelCase   :					int        =    do_normalize if do_normalize is not None else self.do_normalize
      _lowerCAmelCase   :					Optional[Any]        =    image_mean if image_mean is not None else self.image_mean
      _lowerCAmelCase   :					Any        =    image_std if image_std is not None else self.image_std

      _lowerCAmelCase   :					str        =    make_list_of_images(A_       )

      if not valid_images(A_       ):
           raise ValueError(
               "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
               "torch.Tensor, tf.Tensor or jax.ndarray."       )

      if do_resize and size is None:
           raise ValueError("Size must be specified if do_resize is True."       )

      if do_center_crop and crop_size is None:
           raise ValueError("Crop size must be specified if do_center_crop is True."       )

      if do_rescale and rescale_factor is None:
           raise ValueError("Rescale factor must be specified if do_rescale is True."       )

      if do_normalize and (image_mean is None or image_std is None):
           raise ValueError("Image mean and std must be specified if do_normalize is True."       )

      # All transformations expect numpy arrays.
      _lowerCAmelCase   :					Any        =    [to_numpy_array(A_       ) for image in images]

      if do_resize:
           _lowerCAmelCase   :					str        =    [self.resize(image=A_     ,						size=A_     ,						resample=A_       ) for image in images]

      if do_center_crop:
           _lowerCAmelCase   :					List[Any]        =    [self.center_crop(image=A_     ,						size=A_       ) for image in images]

      if do_rescale:
           _lowerCAmelCase   :					Dict        =    [self.rescale(image=A_     ,						scale=A_       ) for image in images]

      if do_normalize:
           _lowerCAmelCase   :					Tuple        =    [self.normalize(image=A_     ,						mean=A_     ,						std=A_       ) for image in images]

      _lowerCAmelCase   :					List[Any]        =    [to_channel_dimension_format(A_     ,						A_       ) for image in images]

      _lowerCAmelCase   :					Tuple        =    {"pixel_values": images}
      return BatchFeature(data=A_     ,						tensor_type=A_       )


 def    __magic_name__       (		self :	Optional[int]     ,						A_ :	Tuple     ,						A_ :	List[Tuple] = None       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    outputs.logits

      # Resize logits and compute semantic segmentation maps
      if target_sizes is not None:
           if len(A_       ) != len(A_       ):
                raise ValueError(
                    "Make sure that you pass in as many target sizes as the batch dimension of the logits"       )

           if is_torch_tensor(A_       ):
                _lowerCAmelCase   :					List[str]        =    target_sizes.numpy()

           _lowerCAmelCase   :					Tuple        =    []

           for idx in range(len(A_       )       ):
                _lowerCAmelCase   :					Tuple        =    torch.nn.functional.interpolate(
                    logits[idx].unsqueeze(dim=0       )     ,						size=target_sizes[idx]     ,						mode="bilinear"     ,						align_corners=A_       )
                _lowerCAmelCase   :					str        =    resized_logits[0].argmax(dim=0       )
                semantic_segmentation.append(A_       )
      else:
           _lowerCAmelCase   :					List[Any]        =    logits.argmax(dim=1       )
           _lowerCAmelCase   :					str        =    [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]       )]

      return semantic_segmentation






