





"""simple docstring"""





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaImgaImgPipeline,
    KandinskyVaaPriorPipeline,
    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 		lowercase					(					_UpperCAmelCase     ,  unittest.TestCase					):
      _SCREAMING_SNAKE_CASE					=      KandinskyVaaImgaImgPipeline
      _SCREAMING_SNAKE_CASE					=      ['image_embeds', 'negative_image_embeds', 'image']
      _SCREAMING_SNAKE_CASE					=      [
          'image_embeds',
          'negative_image_embeds',
          'image',
      ]
      _SCREAMING_SNAKE_CASE					=      [
          'generator',
          'height',
          'width',
          'strength',
          'guidance_scale',
          'num_inference_steps',
          'return_dict',
          'guidance_scale',
          'num_images_per_prompt',
          'output_type',
          'return_dict',
      ]
      _SCREAMING_SNAKE_CASE					=      False





      @property
      def     _snake_case			(       self )		->     str:
            return 32





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            return 32





      @property
      def     _snake_case			(       self )		->     Optional[Any]:
            return self.time_input_dim





      @property
      def     _snake_case			(       self )		->     List[Any]:
            return self.time_input_dim * 4





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            return 100





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            torch.manual_seed(0 )

            lowerCAmelCase  						=       {
                """in_channels""": 4,
                # Out channels is double in channels because predicts mean and variance
                """out_channels""": 8,
                """addition_embed_type""": """image""",
                """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  						=       UNetaDConditionModel(**lowercase )
            return model





      @property
      def     _snake_case			(       self )		->     Dict:
            return {
                "block_out_channels": [32, 64],
                "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
                "in_channels": 3,
                "latent_channels": 4,
                "layers_per_block": 1,
                "norm_num_groups": 8,
                "norm_type": "spatial",
                "num_vq_embeddings": 12,
                "out_channels": 3,
                "up_block_types": [
                    "AttnUpDecoderBlock2D",
                    "UpDecoderBlock2D",
                ],
                "vq_embed_dim": 4,
            }





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            torch.manual_seed(0 )
            lowerCAmelCase  						=       VQModel(**self.dummy_movq_kwargs )
            return model





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       self.dummy_unet
            lowerCAmelCase  						=       self.dummy_movq

            lowerCAmelCase  						=       {
                """num_train_timesteps""": 1_000,
                """beta_schedule""": """linear""",
                """beta_start""": 0.00_085,
                """beta_end""": 0.012,
                """clip_sample""": False,
                """set_alpha_to_one""": False,
                """steps_offset""": 0,
                """prediction_type""": """epsilon""",
                """thresholding""": False,
            }

            lowerCAmelCase  						=       DDIMScheduler(**lowercase )

            lowerCAmelCase  						=       {
                """unet""": unet,
                """scheduler""": scheduler,
                """movq""": movq,
            }

            return components





      def     _snake_case			(       self      ,						lowercase      ,						lowercase=0 )		->     Any:
            lowerCAmelCase  						=       floats_tensor((1, self.text_embedder_hidden_size)      ,						rng=random.Random(lowercase ) ).to(lowercase )
            lowerCAmelCase  						=       floats_tensor((1, self.text_embedder_hidden_size)      ,						rng=random.Random(seed + 1 ) ).to(
                lowercase )
            # create init_image
            lowerCAmelCase  						=       floats_tensor((1, 3, 64, 64)      ,						rng=random.Random(lowercase ) ).to(lowercase )
            lowerCAmelCase  						=       image.cpu().permute(0      ,						2      ,						3      ,						1 )[0]
            lowerCAmelCase  						=       Image.fromarray(np.uinta(lowercase ) ).convert("""RGB""" ).resize((256, 256) )

            if str(lowercase ).startswith("""mps""" ):
                  lowerCAmelCase  						=       torch.manual_seed(lowercase )
            else:
                  lowerCAmelCase  						=       torch.Generator(device=lowercase ).manual_seed(lowercase )
            lowerCAmelCase  						=       {
                """image""": init_image,
                """image_embeds""": image_embeds,
                """negative_image_embeds""": negative_image_embeds,
                """generator""": generator,
                """height""": 64,
                """width""": 64,
                """num_inference_steps""": 10,
                """guidance_scale""": 7.0,
                """strength""": 0.2,
                """output_type""": """np""",
            }
            return inputs





      def     _snake_case			(       self )		->     int:
            lowerCAmelCase  						=       """cpu"""

            lowerCAmelCase  						=       self.get_dummy_components()

            lowerCAmelCase  						=       self.pipeline_class(**lowercase )
            lowerCAmelCase  						=       pipe.to(lowercase )

            pipe.set_progress_bar_config(disable=lowercase )

            lowerCAmelCase  						=       pipe(**self.get_dummy_inputs(lowercase ) )
            lowerCAmelCase  						=       output.images

            lowerCAmelCase  						=       pipe(
                **self.get_dummy_inputs(lowercase )      ,						return_dict=lowercase      ,						)[0]

            lowerCAmelCase  						=       image[0, -3:, -3:, -1]
            lowerCAmelCase  						=       image_from_tuple[0, -3:, -3:, -1]

            assert image.shape == (1, 64, 64, 3)

            lowerCAmelCase  						=       np.array(
                [0.6_199_778, 0.63_984_406, 0.46_145_785, 0.62_944_984, 0.5_622_215, 0.47_306_132, 0.47_441_456, 0.4_607_606, 0.48_719_263] )
            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 		lowercase					(					unittest.TestCase					):





      def     _snake_case			(       self )		->     Union[str, Any]:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()





      def     _snake_case			(       self )		->     List[str]:
            lowerCAmelCase  						=       load_numpy(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                """/kandinskyv22/kandinskyv22_img2img_frog.npy""" )

            lowerCAmelCase  						=       load_image(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png""" )
            lowerCAmelCase  						=       """A red cartoon frog, 4k"""

            lowerCAmelCase  						=       KandinskyVaaPriorPipeline.from_pretrained(
                """kandinsky-community/kandinsky-2-2-prior"""      ,						torch_dtype=torch.floataa )
            pipe_prior.to(lowercase )

            lowerCAmelCase  						=       KandinskyVaaImgaImgPipeline.from_pretrained(
                """kandinsky-community/kandinsky-2-2-decoder"""      ,						torch_dtype=torch.floataa )
            lowerCAmelCase  						=       pipeline.to(lowercase )

            pipeline.set_progress_bar_config(disable=lowercase )

            lowerCAmelCase  						=       torch.Generator(device="""cpu""" ).manual_seed(0 )
            lowerCAmelCase						,		lowerCAmelCase  						=       pipe_prior(
                lowercase      ,						generator=lowercase      ,						num_inference_steps=5      ,						negative_prompt=""""""      ,						).to_tuple()

            lowerCAmelCase  						=       pipeline(
                image=lowercase      ,						image_embeds=lowercase      ,						negative_image_embeds=lowercase      ,						generator=lowercase      ,						num_inference_steps=100      ,						height=768      ,						width=768      ,						strength=0.2      ,						output_type="""np"""      ,						)

            lowerCAmelCase  						=       output.images[0]

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

            assert_mean_pixel_difference(lowercase      ,						lowercase )













"""simple docstring"""





from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Value
from .base import TaskTemplate

@dataclass(frozen=_UpperCAmelCase					)
class 		lowercase					(					_UpperCAmelCase					):
      _SCREAMING_SNAKE_CASE					=      field(default='language-modeling'     ,  metadata={'include_in_asdict_even_if_is_default': True}					)

      _SCREAMING_SNAKE_CASE					=      Features({'text': Value('string'					)}					)
      _SCREAMING_SNAKE_CASE					=      Features({}					)
      _SCREAMING_SNAKE_CASE					=      "text"





      @property
      def     _snake_case			(       self )		->     Dict[str, str]:
            return {self.text_column: "text"}






