




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
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		(  __UpperCAmelCase      ,				unittest.TestCase     ):
		__snake_case									=   KandinskyImgaImgPipeline
		__snake_case									=   ['prompt', 'image_embeds', 'negative_image_embeds', 'image']
		__snake_case									=   [
		    'prompt',
		    'negative_prompt',
		    'image_embeds',
		    'negative_image_embeds',
		    'image',
		]
		__snake_case									=   [
		    'generator',
		    'height',
		    'width',
		    'strength',
		    'guidance_scale',
		    'negative_prompt',
		    'num_inference_steps',
		    'return_dict',
		    'guidance_scale',
		    'num_images_per_prompt',
		    'output_type',
		    'return_dict',
		]
		__snake_case									=   False



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 32



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 32



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return self.time_input_dim



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return self.time_input_dim * 4



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 100



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''   )
								return tokenizer



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								torch.manual_seed(0   )
								lowerCAmelCase_      			=  MCLIPConfig(
								    numDims=self.cross_attention_dim,	transformerDimensions=self.text_embedder_hidden_size,	hidden_size=self.text_embedder_hidden_size,	intermediate_size=37,	num_attention_heads=4,	num_hidden_layers=5,	vocab_size=1005,	)

								lowerCAmelCase_      			=  MultilingualCLIP(UpperCamelCase__   )
								lowerCAmelCase_      			=  text_encoder.eval()

								return text_encoder



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								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''': '''text_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''': '''text_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(**UpperCamelCase__   )
								return model



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								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        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								torch.manual_seed(0   )
								lowerCAmelCase_      			=  VQModel(**self.dummy_movq_kwargs   )
								return model



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.dummy_text_encoder
								lowerCAmelCase_      			=  self.dummy_tokenizer
								lowerCAmelCase_      			=  self.dummy_unet
								lowerCAmelCase_      			=  self.dummy_movq

								lowerCAmelCase_      			=  {
								    '''num_train_timesteps''': 1000,
								    '''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(**UpperCamelCase__   )

								lowerCAmelCase_      			=  {
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''movq''': movq,
								}

								return components



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__=0   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  floats_tensor((1, self.cross_attention_dim),	rng=random.Random(UpperCamelCase__   )   ).to(UpperCamelCase__   )
								lowerCAmelCase_      			=  floats_tensor((1, self.cross_attention_dim),	rng=random.Random(seed + 1   )   ).to(UpperCamelCase__   )
								# create init_image
								lowerCAmelCase_      			=  floats_tensor((1, 3, 64, 64),	rng=random.Random(UpperCamelCase__   )   ).to(UpperCamelCase__   )
								lowerCAmelCase_      			=  image.cpu().permute(0,	2,	3,	1   )[0]
								lowerCAmelCase_      			=  Image.fromarray(np.uinta(UpperCamelCase__   )   ).convert('''RGB'''   ).resize((256, 256)   )

								if str(UpperCamelCase__   ).startswith('''mps'''   ):
														lowerCAmelCase_      			=  torch.manual_seed(UpperCamelCase__   )
								else:
														lowerCAmelCase_      			=  torch.Generator(device=UpperCamelCase__   ).manual_seed(UpperCamelCase__   )
								lowerCAmelCase_      			=  {
								    '''prompt''': '''horse''',
								    '''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        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  '''cpu'''

								lowerCAmelCase_      			=  self.get_dummy_components()

								lowerCAmelCase_      			=  self.pipeline_class(**UpperCamelCase__   )
								lowerCAmelCase_      			=  pipe.to(UpperCamelCase__   )

								pipe.set_progress_bar_config(disable=UpperCamelCase__   )

								lowerCAmelCase_      			=  pipe(**self.get_dummy_inputs(UpperCamelCase__   )   )
								lowerCAmelCase_      			=  output.images

								lowerCAmelCase_      			=  pipe(
								    **self.get_dummy_inputs(UpperCamelCase__   ),	return_dict=UpperCamelCase__,	)[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.61_474_943, 0.6_073_539, 0.43_308_544, 0.5_928_269, 0.47_493_595, 0.46_755_973, 0.4_613_838, 0.45_368_797, 0.50_119_233]   )
								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     ):



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



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







		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
								    '''/kandinsky/kandinsky_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_      			=  KandinskyPriorPipeline.from_pretrained(
								    '''kandinsky-community/kandinsky-2-1-prior''',	torch_dtype=torch.floataa   )
								pipe_prior.to(UpperCamelCase__   )

								lowerCAmelCase_      			=  KandinskyImgaImgPipeline.from_pretrained(
								    '''kandinsky-community/kandinsky-2-1''',	torch_dtype=torch.floataa   )
								lowerCAmelCase_      			=  pipeline.to(UpperCamelCase__   )

								pipeline.set_progress_bar_config(disable=UpperCamelCase__   )

								lowerCAmelCase_      			=  torch.Generator(device='''cpu'''   ).manual_seed(0   )
								lowerCAmelCase_			,					lowerCAmelCase_      			=  pipe_prior(
								    UpperCamelCase__,	generator=UpperCamelCase__,	num_inference_steps=5,	negative_prompt='''''',	).to_tuple()

								lowerCAmelCase_      			=  pipeline(
								    UpperCamelCase__,	image=UpperCamelCase__,	image_embeds=UpperCamelCase__,	negative_image_embeds=UpperCamelCase__,	generator=UpperCamelCase__,	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(UpperCamelCase__,	UpperCamelCase__   )










from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_A     =			logging.get_logger(__name__)

_A     =			{
    '''google/vit-base-patch16-224''': '''https://huggingface.co/vit-base-patch16-224/resolve/main/config.json''',
    # See all ViT models at https://huggingface.co/models?filter=vit
}


class  A		(  __UpperCAmelCase     ):
		__snake_case									=   'vit'



		def __init__(     self,	UpperCamelCase__=768,	UpperCamelCase__=12,	UpperCamelCase__=12,	UpperCamelCase__=3072,	UpperCamelCase__="gelu",	UpperCamelCase__=0.0,	UpperCamelCase__=0.0,	UpperCamelCase__=0.02,	UpperCamelCase__=1E-12,	UpperCamelCase__=224,	UpperCamelCase__=16,	UpperCamelCase__=3,	UpperCamelCase__=True,	UpperCamelCase__=16,	**UpperCamelCase__,	):







								"""simple docstring"""



								super().__init__(**UpperCamelCase__   )

								lowerCAmelCase_      			=  hidden_size
								lowerCAmelCase_      			=  num_hidden_layers
								lowerCAmelCase_      			=  num_attention_heads
								lowerCAmelCase_      			=  intermediate_size
								lowerCAmelCase_      			=  hidden_act
								lowerCAmelCase_      			=  hidden_dropout_prob
								lowerCAmelCase_      			=  attention_probs_dropout_prob
								lowerCAmelCase_      			=  initializer_range
								lowerCAmelCase_      			=  layer_norm_eps
								lowerCAmelCase_      			=  image_size
								lowerCAmelCase_      			=  patch_size
								lowerCAmelCase_      			=  num_channels
								lowerCAmelCase_      			=  qkv_bias
								lowerCAmelCase_      			=  encoder_stride







class  A		(  __UpperCAmelCase     ):
		__snake_case									=   version.parse('1.11'     )



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return OrderedDict(
								    [
								        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
								    ]   )







		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 1E-4




