


"""simple docstring"""


import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class snake_case      (  _UpperCamelCase     ,				unittest.TestCase):
		__UpperCamelCase           =			KandinskyVaaPriorPipeline
		__UpperCamelCase           =			['prompt']
		__UpperCamelCase           =			['prompt', 'negative_prompt']
		__UpperCamelCase           =			[
		    'num_images_per_prompt',
		    'generator',
		    'num_inference_steps',
		    'latents',
		    'negative_prompt',
		    'guidance_scale',
		    'output_type',
		    'return_dict',
		]
		__UpperCamelCase           =			False







		@property
		def  a_ (					self      :       List[str]		)       ->						List[Any]:





						'''simple docstring'''







						return 32







		@property
		def  a_ (					self      :       List[str]		)       ->						Dict:





						'''simple docstring'''







						return 32







		@property
		def  a_ (					self      :       Optional[int]		)       ->						List[Any]:





						'''simple docstring'''







						return self.time_input_dim







		@property
		def  a_ (					self      :       Dict		)       ->						int:





						'''simple docstring'''







						return self.time_input_dim * 4







		@property
		def  a_ (					self      :       str		)       ->						List[str]:





						'''simple docstring'''







						return 1_00







		@property
		def  a_ (					self      :       List[str]		)       ->						Any:





						'''simple docstring'''







						_A					  =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)
						return tokenizer







		@property
		def  a_ (					self      :       Dict		)       ->						List[str]:





						'''simple docstring'''







						torch.manual_seed(0		)
						_A					  =			CLIPTextConfig(
						    bos_token_id=0    ,   eos_token_id=2    ,   hidden_size=self.text_embedder_hidden_size    ,   projection_dim=self.text_embedder_hidden_size    ,   intermediate_size=37    ,   layer_norm_eps=1E-0_5    ,   num_attention_heads=4    ,   num_hidden_layers=5    ,   pad_token_id=1    ,   vocab_size=10_00    ,   )
						return CLIPTextModelWithProjection(a__		)







		@property
		def  a_ (					self      :       Any		)       ->						Optional[Any]:





						'''simple docstring'''







						torch.manual_seed(0		)

						_A					  =			{
						    "num_attention_heads": 2,
						    "attention_head_dim": 12,
						    "embedding_dim": self.text_embedder_hidden_size,
						    "num_layers": 1,
						}

						_A					  =			PriorTransformer(**a__		)
						# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
						_A					  =			nn.Parameter(torch.ones(model.clip_std.shape		)		)
						return model







		@property
		def  a_ (					self      :       Optional[Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						torch.manual_seed(0		)
						_A					  =			CLIPVisionConfig(
						    hidden_size=self.text_embedder_hidden_size    ,   image_size=2_24    ,   projection_dim=self.text_embedder_hidden_size    ,   intermediate_size=37    ,   num_attention_heads=4    ,   num_channels=3    ,   num_hidden_layers=5    ,   patch_size=14    ,   )

						_A					  =			CLIPVisionModelWithProjection(a__		)
						return model







		@property
		def  a_ (					self      :       Dict		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			CLIPImageProcessor(
						    crop_size=2_24    ,   do_center_crop=a__    ,   do_normalize=a__    ,   do_resize=a__    ,   image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]    ,   image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]    ,   resample=3    ,   size=2_24    ,   )

						return image_processor







		def  a_ (					self      :       Dict		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			self.dummy_prior
						_A					  =			self.dummy_image_encoder
						_A					  =			self.dummy_text_encoder
						_A					  =			self.dummy_tokenizer
						_A					  =			self.dummy_image_processor

						_A					  =			UnCLIPScheduler(
						    variance_type="fixed_small_log"    ,   prediction_type="sample"    ,   num_train_timesteps=10_00    ,   clip_sample=a__    ,   clip_sample_range=1_0.0    ,   )

						_A					  =			{
						    "prior": prior,
						    "image_encoder": image_encoder,
						    "text_encoder": text_encoder,
						    "tokenizer": tokenizer,
						    "scheduler": scheduler,
						    "image_processor": image_processor,
						}

						return components







		def  a_ (					self      :       Union[str, Any]    ,   a__      :       Optional[Any]    ,   a__      :       List[str]=0		)       ->						Optional[int]:





						'''simple docstring'''







						if str(a__		).startswith("mps"		):
										_A					  =			torch.manual_seed(a__		)
						else:
										_A					  =			torch.Generator(device=a__		).manual_seed(a__		)
						_A					  =			{
						    "prompt": "horse",
						    "generator": generator,
						    "guidance_scale": 4.0,
						    "num_inference_steps": 2,
						    "output_type": "np",
						}
						return inputs







		def  a_ (					self      :       List[Any]		)       ->						str:





						'''simple docstring'''







						_A					  =			"cpu"

						_A					  =			self.get_dummy_components()

						_A					  =			self.pipeline_class(**a__		)
						_A					  =			pipe.to(a__		)

						pipe.set_progress_bar_config(disable=a__		)

						_A					  =			pipe(**self.get_dummy_inputs(a__		)		)
						_A					  =			output.image_embeds

						_A					  =			pipe(
						    **self.get_dummy_inputs(a__		)    ,   return_dict=a__    ,   )[0]

						_A					  =			image[0, -10:]
						_A					  =			image_from_tuple[0, -10:]

						assert image.shape == (1, 32)

						_A					  =			np.array(
						    [-0.0_5_3_2, 1.7_1_2_0, 0.3_6_5_6, -1.0_8_5_2, -0.8_9_4_6, -1.1_7_5_6, 0.4_3_4_8, 0.2_4_8_2, 0.5_1_4_6, -0.1_1_5_6]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice		).max() < 1E-2







		@skip_mps
		def  a_ (					self      :       Tuple		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			torch_device == "cpu"
						_A					  =			True
						_A					  =			False

						self._test_inference_batch_single_identical(
						    test_max_difference=a__    ,   relax_max_difference=a__    ,   test_mean_pixel_difference=a__    ,   )







		@skip_mps
		def  a_ (					self      :       List[Any]		)       ->						Tuple:





						'''simple docstring'''







						_A					  =			torch_device == "cpu"
						_A					  =			False

						self._test_attention_slicing_forward_pass(
						    test_max_difference=a__    ,   test_mean_pixel_difference=a__    ,   )



"""simple docstring"""


import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


a_       							=    False
class snake_case      (  unittest.TestCase):
		pass





@nightly
@require_torch_gpu
class snake_case      (  unittest.TestCase):







		def  a_ (					self      :       Optional[int]		)       ->						str:





						'''simple docstring'''







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







		def  a_ (					self      :       Tuple		)       ->						Any:





						'''simple docstring'''







						_A					  =			VersatileDiffusionPipeline.from_pretrained("shi-labs/versatile-diffusion"    ,   torch_dtype=torch.floataa		)
						pipe.to(a__		)
						pipe.set_progress_bar_config(disable=a__		)

						_A					  =			load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"		)

						_A					  =			torch.manual_seed(0		)
						_A					  =			pipe.dual_guided(
						    prompt="first prompt"    ,   image=a__    ,   text_to_image_strength=0.7_5    ,   generator=a__    ,   guidance_scale=7.5    ,   num_inference_steps=2    ,   output_type="numpy"    ,   ).images

						with tempfile.TemporaryDirectory() as tmpdirname:
										pipe.save_pretrained(a__		)
										_A					  =			VersatileDiffusionPipeline.from_pretrained(a__    ,   torch_dtype=torch.floataa		)
						pipe.to(a__		)
						pipe.set_progress_bar_config(disable=a__		)

						_A					  =			generator.manual_seed(0		)
						_A					  =			pipe.dual_guided(
						    prompt="first prompt"    ,   image=a__    ,   text_to_image_strength=0.7_5    ,   generator=a__    ,   guidance_scale=7.5    ,   num_inference_steps=2    ,   output_type="numpy"    ,   ).images

						assert np.abs(image - new_image		).sum() < 1E-5, "Models don't have the same forward pass"







		def  a_ (					self      :       Optional[int]		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			VersatileDiffusionPipeline.from_pretrained("shi-labs/versatile-diffusion"    ,   torch_dtype=torch.floataa		)
						pipe.to(a__		)
						pipe.set_progress_bar_config(disable=a__		)

						_A					  =			"cyberpunk 2077"
						_A					  =			load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"		)
						_A					  =			torch.manual_seed(0		)
						_A					  =			pipe.dual_guided(
						    prompt=a__    ,   image=a__    ,   text_to_image_strength=0.7_5    ,   generator=a__    ,   guidance_scale=7.5    ,   num_inference_steps=50    ,   output_type="numpy"    ,   ).images

						_A					  =			image[0, 2_53:2_56, 2_53:2_56, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						_A					  =			np.array([0.1_4_4_8, 0.1_6_1_9, 0.1_7_4_1, 0.1_0_8_6, 0.1_1_4_7, 0.1_1_2_8, 0.1_1_9_9, 0.1_1_6_5, 0.1_0_0_1]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1

						_A					  =			"A painting of a squirrel eating a burger "
						_A					  =			torch.manual_seed(0		)
						_A					  =			pipe.text_to_image(
						    prompt=a__    ,   generator=a__    ,   guidance_scale=7.5    ,   num_inference_steps=50    ,   output_type="numpy"		).images

						_A					  =			image[0, 2_53:2_56, 2_53:2_56, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						_A					  =			np.array([0.3_3_6_7, 0.3_1_6_9, 0.2_6_5_6, 0.3_8_7_0, 0.4_7_9_0, 0.3_7_9_6, 0.4_0_0_9, 0.4_8_7_8, 0.4_7_7_8]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1

						_A					  =			pipe.image_variation(a__    ,   generator=a__    ,   output_type="numpy"		).images

						_A					  =			image[0, 2_53:2_56, 2_53:2_56, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						_A					  =			np.array([0.3_0_7_6, 0.3_1_2_3, 0.3_2_8_4, 0.3_7_8_2, 0.3_7_7_0, 0.3_8_9_4, 0.4_2_9_7, 0.4_3_3_1, 0.4_4_5_6]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1