






"""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_       (    _lowerCamelCase    ,							unittest.TestCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							str   			=					KandinskyVaaPriorPipeline
	SCREAMING_SNAKE_CASE_:							Dict   			=					["""prompt"""]
	SCREAMING_SNAKE_CASE_:							Union[str, Any]   			=					["""prompt""", """negative_prompt"""]
	SCREAMING_SNAKE_CASE_:							Optional[Any]   			=					[
	    """num_images_per_prompt""",
	    """generator""",
	    """num_inference_steps""",
	    """latents""",
	    """negative_prompt""",
	    """guidance_scale""",
	    """output_type""",
	    """return_dict""",
	]
	SCREAMING_SNAKE_CASE_:							List[Any]   			=					False


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return 32


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return 32


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return self.time_input_dim


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return self.time_input_dim * 4


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return 100


	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

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


	@property
	def       _UpperCAmelCase						(      self						):


					"""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-05  ,					num_attention_heads=4  ,					num_hidden_layers=5  ,					pad_token_id=1  ,					vocab_size=1000  ,					)
					return CLIPTextModelWithProjection(__a						)


	@property
	def       _UpperCAmelCase						(      self						):


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


					"""simple docstring"""

					torch.manual_seed(0						)
					A__							 =       CLIPVisionConfig(
					    hidden_size=self.text_embedder_hidden_size  ,					image_size=224  ,					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       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       CLIPImageProcessor(
					    crop_size=224  ,					do_center_crop=__a  ,					do_normalize=__a  ,					do_resize=__a  ,					image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]  ,					image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]  ,					resample=3  ,					size=224  ,					)

					return image_processor


	def       _UpperCAmelCase						(      self						):


					"""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=1000  ,					clip_sample=__a  ,					clip_sample_range=10.0  ,					)

					A__							 =       {
					    'prior': prior,
					    'image_encoder': image_encoder,
					    'text_encoder': text_encoder,
					    'tokenizer': tokenizer,
					    'scheduler': scheduler,
					    'image_processor': image_processor,
					}

					return components


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a=0						):


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


					"""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.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]						)

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


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


					"""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"""






print((lambda quine: quine % quine)('''print((lambda quine: quine %% quine)(%r))'''))


