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




    '''simple docstring'''







    snake_case__							:   Optional[int]							=						KandinskyVaaImgaImgPipeline
    snake_case__							:   str							=						["image_embeds", "negative_image_embeds", "image"]
    snake_case__							:   int							=						[
        "image_embeds",
        "negative_image_embeds",
        "image",
    ]
    snake_case__							:   List[str]							=						[
        "generator",
        "height",
        "width",
        "strength",
        "guidance_scale",
        "num_inference_steps",
        "return_dict",
        "guidance_scale",
        "num_images_per_prompt",
        "output_type",
        "return_dict",
    ]
    snake_case__							:   Tuple							=						False






    @property
    def       _UpperCamelCase    (       self )							-> Tuple:
         return 32






    @property
    def       _UpperCamelCase    (       self )							-> List[Any]:
         return 32






    @property
    def       _UpperCamelCase    (       self )							-> str:
         return self.time_input_dim






    @property
    def       _UpperCamelCase    (       self )							-> int:
         return self.time_input_dim * 4






    @property
    def       _UpperCamelCase    (       self )							-> List[str]:
         return 100






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

         SCREAMING_SNAKE_CASE					:			int    	=       {
             '''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,
         }

         SCREAMING_SNAKE_CASE					:			Dict    	=       UNetaDConditionModel(**__lowerCamelCase )
         return model






    @property
    def       _UpperCamelCase    (       self )							-> int:
         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       _UpperCamelCase    (       self )							-> Union[str, Any]:
         torch.manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       VQModel(**self.dummy_movq_kwargs )
         return model






    def       _UpperCamelCase    (       self )							-> Any:
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       self.dummy_unet
         SCREAMING_SNAKE_CASE					:			Any    	=       self.dummy_movq

         SCREAMING_SNAKE_CASE					:			Any    	=       {
             '''num_train_timesteps''': 1_000,
             '''beta_schedule''': '''linear''',
             '''beta_start''': 0.0_0_0_8_5,
             '''beta_end''': 0.0_1_2,
             '''clip_sample''': False,
             '''set_alpha_to_one''': False,
             '''steps_offset''': 0,
             '''prediction_type''': '''epsilon''',
             '''thresholding''': False,
         }

         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       DDIMScheduler(**__lowerCamelCase )

         SCREAMING_SNAKE_CASE					:			Tuple    	=       {
             '''unet''': unet,
             '''scheduler''': scheduler,
             '''movq''': movq,
         }

         return components






    def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__=0 )							-> Optional[Any]:
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase )
         SCREAMING_SNAKE_CASE					:			Dict    	=       floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(seed + 1 ) ).to(
             __lowerCamelCase )
         # create init_image
         SCREAMING_SNAKE_CASE					:			Any    	=       floats_tensor((1, 3, 64, 64)    ,							rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase )
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       image.cpu().permute(0    ,							2    ,							3    ,							1 )[0]
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       Image.fromarray(np.uinta(__lowerCamelCase ) ).convert('RGB' ).resize((256, 256) )

         if str(__lowerCamelCase ).startswith('mps' ):
              SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       torch.manual_seed(__lowerCamelCase )
         else:
              SCREAMING_SNAKE_CASE					:			List[str]    	=       torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       {
             '''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       _UpperCamelCase    (       self )							-> List[str]:
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       '''cpu'''

         SCREAMING_SNAKE_CASE					:			int    	=       self.get_dummy_components()

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       self.pipeline_class(**__lowerCamelCase )
         SCREAMING_SNAKE_CASE					:			int    	=       pipe.to(__lowerCamelCase )

         pipe.set_progress_bar_config(disable=__lowerCamelCase )

         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       pipe(**self.get_dummy_inputs(__lowerCamelCase ) )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       output.images

         SCREAMING_SNAKE_CASE					:			Tuple    	=       pipe(
             **self.get_dummy_inputs(__lowerCamelCase )    ,							return_dict=__lowerCamelCase    ,							)[0]

         SCREAMING_SNAKE_CASE					:			str    	=       image[0, -3:, -3:, -1]
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       image_from_tuple[0, -3:, -3:, -1]

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

         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       np.array(
             [0.6_1_9_9_7_7_8, 0.6_3_9_8_4_4_0_6, 0.4_6_1_4_5_7_8_5, 0.6_2_9_4_4_9_8_4, 0.5_6_2_2_2_1_5, 0.4_7_3_0_6_1_3_2, 0.4_7_4_4_1_4_5_6, 0.4_6_0_7_6_0_6, 0.4_8_7_1_9_2_6_3] )
         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 				UpperCAmelCase (       unittest.TestCase ):




    '''simple docstring'''







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






    def       _UpperCamelCase    (       self )							-> Optional[int]:
         SCREAMING_SNAKE_CASE					:			Any    	=       load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/kandinskyv22/kandinskyv22_img2img_frog.npy' )

         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png' )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       '''A red cartoon frog, 4k'''

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       KandinskyVaaPriorPipeline.from_pretrained(
             'kandinsky-community/kandinsky-2-2-prior'    ,							torch_dtype=torch.floataa )
         pipe_prior.to(__lowerCamelCase )

         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       KandinskyVaaImgaImgPipeline.from_pretrained(
             'kandinsky-community/kandinsky-2-2-decoder'    ,							torch_dtype=torch.floataa )
         SCREAMING_SNAKE_CASE					:			Any    	=       pipeline.to(__lowerCamelCase )

         pipeline.set_progress_bar_config(disable=__lowerCamelCase )

         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       torch.Generator(device='cpu' ).manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			List[str]    	=       pipe_prior(
             __lowerCamelCase    ,							generator=__lowerCamelCase    ,							num_inference_steps=5    ,							negative_prompt=''    ,							).to_tuple()

         SCREAMING_SNAKE_CASE					:			str    	=       pipeline(
             image=__lowerCamelCase    ,							image_embeds=__lowerCamelCase    ,							negative_image_embeds=__lowerCamelCase    ,							generator=__lowerCamelCase    ,							num_inference_steps=100    ,							height=768    ,							width=768    ,							strength=0.2    ,							output_type='np'    ,							)

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       output.images[0]

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

         assert_mean_pixel_difference(__lowerCamelCase    ,							__lowerCamelCase )




'''simple docstring'''





import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
 import torch

 from transformers.activations import gelu_new, gelu_python, get_activation






@require_torch
class 				UpperCAmelCase (       unittest.TestCase ):




    '''simple docstring'''







    def       _UpperCamelCase    (       self )							-> int:
         SCREAMING_SNAKE_CASE					:			str    	=       torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100] )
         SCREAMING_SNAKE_CASE					:			str    	=       get_activation('gelu' )
         self.assertTrue(torch.allclose(gelu_python(lowercase__ )    ,							torch_builtin(lowercase__ ) ) )
         self.assertFalse(torch.allclose(gelu_python(lowercase__ )    ,							gelu_new(lowercase__ ) ) )






    def       _UpperCamelCase    (       self )							-> Optional[Any]:
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100] )
         SCREAMING_SNAKE_CASE					:			str    	=       get_activation('gelu' )
         SCREAMING_SNAKE_CASE					:			Dict    	=       get_activation('gelu_10' )

         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       torch_builtin(lowercase__ )
         SCREAMING_SNAKE_CASE					:			str    	=       geluaa(lowercase__ )

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       torch.where(y_gelu_aa < 1_0.0    ,							1    ,							0 )

         self.assertTrue(torch.max(lowercase__ ).item() == 1_0.0 )
         self.assertTrue(torch.allclose(y_gelu * clipped_mask    ,							y_gelu_aa * clipped_mask ) )






    def       _UpperCamelCase    (       self )							-> Optional[Any]:
         get_activation('gelu' )
         get_activation('gelu_10' )
         get_activation('gelu_fast' )
         get_activation('gelu_new' )
         get_activation('gelu_python' )
         get_activation('gelu_pytorch_tanh' )
         get_activation('linear' )
         get_activation('mish' )
         get_activation('quick_gelu' )
         get_activation('relu' )
         get_activation('sigmoid' )
         get_activation('silu' )
         get_activation('swish' )
         get_activation('tanh' )
         with self.assertRaises(lowercase__ ):
              get_activation('bogus' )
         with self.assertRaises(lowercase__ ):
              get_activation(lowercase__ )






    def       _UpperCamelCase    (       self )							-> int:
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       get_activation('gelu' )
         SCREAMING_SNAKE_CASE					:			str    	=       1
         SCREAMING_SNAKE_CASE					:			List[str]    	=       get_activation('gelu' )
         self.assertEqual(acta.a    ,							1 )
         with self.assertRaises(lowercase__ ):
              SCREAMING_SNAKE_CASE					:			Dict    	=       acta.a



