





'''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 KandinskyPriorPipeline, 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     UpperCamelCase_     (a__,      unittest.TestCase     ):







						"""simple docstring"""


						_lowerCAmelCase    						=					KandinskyPriorPipeline
						_lowerCAmelCase    						=					['prompt']
						_lowerCAmelCase    						=					['prompt', 'negative_prompt']
						_lowerCAmelCase    						=					[
						    'num_images_per_prompt',
						    'generator',
						    'num_inference_steps',
						    'latents',
						    'negative_prompt',
						    'guidance_scale',
						    'output_type',
						    'return_dict',
						]
						_lowerCAmelCase    						=					False







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											return 32







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											return 32







						@property
						def       _a    (     self      :       List[str]    ):





											"""simple docstring"""







											return self.time_input_dim







						@property
						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											return self.time_input_dim * 4







						@property
						def       _a    (     self      :       int    ):





											"""simple docstring"""







											return 100







						@property
						def       _a    (     self      :       Tuple    ):





											"""simple docstring"""







											A_ :     List[str] =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
											return tokenizer







						@property
						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Optional[int] =							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(_lowerCamelCase    )







						@property
						def       _a    (     self      :       Tuple    ):





											"""simple docstring"""







											torch.manual_seed(0    )

											A_ :     List[str] =							{
											    '''num_attention_heads''': 2,
											    '''attention_head_dim''': 12,
											    '''embedding_dim''': self.text_embedder_hidden_size,
											    '''num_layers''': 1,
											}

											A_ :     Union[str, Any] =							PriorTransformer(**_lowerCamelCase    )
											# 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_ :     Union[str, Any] =							nn.Parameter(torch.ones(model.clip_std.shape    )    )
											return model







						@property
						def       _a    (     self      :       Union[str, Any]    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     int =							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_ :     int =							CLIPVisionModelWithProjection(_lowerCamelCase    )
											return model







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											A_ :     List[str] =							CLIPImageProcessor(
											    crop_size=224							, do_center_crop=_lowerCamelCase							, do_normalize=_lowerCamelCase							, do_resize=_lowerCamelCase							, image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]							, image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]							, resample=3							, size=224							, )

											return image_processor







						def       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Optional[int] =							self.dummy_prior
											A_ :     Union[str, Any] =							self.dummy_image_encoder
											A_ :     List[str] =							self.dummy_text_encoder
											A_ :     Any =							self.dummy_tokenizer
											A_ :     List[str] =							self.dummy_image_processor

											A_ :     Optional[Any] =							UnCLIPScheduler(
											    variance_type='''fixed_small_log'''							, prediction_type='''sample'''							, num_train_timesteps=1000							, clip_sample=_lowerCamelCase							, clip_sample_range=10.0							, )

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

											return components







						def       _a    (     self      :       Optional[Any]							, _lowerCamelCase      :       int							, _lowerCamelCase      :       Any=0    ):





											"""simple docstring"""







											if str(_lowerCamelCase    ).startswith('''mps'''    ):
																A_ :     List[Any] =							torch.manual_seed(_lowerCamelCase    )
											else:
																A_ :     Optional[Any] =							torch.Generator(device=_lowerCamelCase    ).manual_seed(_lowerCamelCase    )
											A_ :     Optional[Any] =							{
											    '''prompt''': '''horse''',
											    '''generator''': generator,
											    '''guidance_scale''': 4.0,
											    '''num_inference_steps''': 2,
											    '''output_type''': '''np''',
											}
											return inputs







						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											A_ :     List[Any] =							'''cpu'''

											A_ :     Dict =							self.get_dummy_components()

											A_ :     Optional[Any] =							self.pipeline_class(**_lowerCamelCase    )
											A_ :     Union[str, Any] =							pipe.to(_lowerCamelCase    )

											pipe.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Optional[Any] =							pipe(**self.get_dummy_inputs(_lowerCamelCase    )    )
											A_ :     Optional[int] =							output.image_embeds

											A_ :     Optional[Any] =							pipe(
											    **self.get_dummy_inputs(_lowerCamelCase    )							, return_dict=_lowerCamelCase							, )[0]

											A_ :     Any =							image[0, -10:]
											A_ :     Union[str, Any] =							image_from_tuple[0, -10:]

											assert image.shape == (1, 32)

											A_ :     Optional[int] =							np.array(
											    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]    )

											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      :       List[str]    ):





											"""simple docstring"""







											A_ :     List[Any] =							torch_device == '''cpu'''
											A_ :     str =							True
											A_ :     List[str] =							False

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







						@skip_mps
						def       _a    (     self      :       Tuple    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							torch_device == '''cpu'''
											A_ :     str =							False

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









'''simple docstring'''




def 						snake_case__    ( lowerCamelCase__				:   int			)   ->   bool:
					if not isinstance(lowerCamelCase__			,		lowerCamelCase__			):
										A_ :     int =							f'Input value of [number={number}] must be an integer'
										raise TypeError(lowerCamelCase__			)
					if number < 0 or number % 2 == 1:
										return False
					A_ :     Dict =							int(number**0.5			)
					return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
							import doctest

							doctest.testmod()



