




'''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 		a							(  _lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						KandinskyVaaPriorPipeline
				snake_case_           =						["prompt"]
				snake_case_           =						["prompt", "negative_prompt"]
				snake_case_           =						[
				    "num_images_per_prompt",
				    "generator",
				    "num_inference_steps",
				    "latents",
				    "negative_prompt",
				    "guidance_scale",
				    "output_type",
				    "return_dict",
				]
				snake_case_           =						False


				@property
				def     A_					(						self       :   Optional[Any]   ):
									return 32


				@property
				def     A_					(						self       :   Tuple   ):
									return 32


				@property
				def     A_					(						self       :   Optional[Any]   ):
									return self.time_input_dim


				@property
				def     A_					(						self       :   str   ):
									return self.time_input_dim * 4


				@property
				def     A_					(						self       :   Tuple   ):
									return 100


				@property
				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )
									return tokenizer


				@property
				def     A_					(						self       :   Any   ):
									torch.manual_seed(0   )
									snake_case_		     =							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(lowercase_   )


				@property
				def     A_					(						self       :   Optional[int]   ):
									torch.manual_seed(0   )

									snake_case_		     =							{
									    '''num_attention_heads''': 2,
									    '''attention_head_dim''': 12,
									    '''embedding_dim''': self.text_embedder_hidden_size,
									    '''num_layers''': 1,
									}

									snake_case_		     =							PriorTransformer(**lowercase_   )
									# 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
									snake_case_		     =							nn.Parameter(torch.ones(model.clip_std.shape   )   )
									return model


				@property
				def     A_					(						self       :   Any   ):
									torch.manual_seed(0   )
									snake_case_		     =							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			,							)

									snake_case_		     =							CLIPVisionModelWithProjection(lowercase_   )
									return model


				@property
				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							CLIPImageProcessor(
									    crop_size=224			,							do_center_crop=lowercase_			,							do_normalize=lowercase_			,							do_resize=lowercase_			,							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     A_					(						self       :   Any   ):
									snake_case_		     =							self.dummy_prior
									snake_case_		     =							self.dummy_image_encoder
									snake_case_		     =							self.dummy_text_encoder
									snake_case_		     =							self.dummy_tokenizer
									snake_case_		     =							self.dummy_image_processor

									snake_case_		     =							UnCLIPScheduler(
									    variance_type='''fixed_small_log'''			,							prediction_type='''sample'''			,							num_train_timesteps=1000			,							clip_sample=lowercase_			,							clip_sample_range=10.0			,							)

									snake_case_		     =							{
									    '''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]			,							lowercase_       :   Optional[int]			,							lowercase_       :   List[str]=0   ):
									if str(lowercase_   ).startswith('''mps'''   ):
														snake_case_		     =							torch.manual_seed(lowercase_   )
									else:
														snake_case_		     =							torch.Generator(device=lowercase_   ).manual_seed(lowercase_   )
									snake_case_		     =							{
									    '''prompt''': '''horse''',
									    '''generator''': generator,
									    '''guidance_scale''': 4.0,
									    '''num_inference_steps''': 2,
									    '''output_type''': '''np''',
									}
									return inputs


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							'''cpu'''

									snake_case_		     =							self.get_dummy_components()

									snake_case_		     =							self.pipeline_class(**lowercase_   )
									snake_case_		     =							pipe.to(lowercase_   )

									pipe.set_progress_bar_config(disable=lowercase_   )

									snake_case_		     =							pipe(**self.get_dummy_inputs(lowercase_   )   )
									snake_case_		     =							output.image_embeds

									snake_case_		     =							pipe(
									    **self.get_dummy_inputs(lowercase_   )			,							return_dict=lowercase_			,							)[0]

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

									assert image.shape == (1, 32)

									snake_case_		     =							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     A_					(						self       :   Any   ):
									snake_case_		     =							torch_device == '''cpu'''
									snake_case_		     =							True
									snake_case_		     =							False

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


				@skip_mps
				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							torch_device == '''cpu'''
									snake_case_		     =							False

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







'''simple docstring'''

from ....utils import logging


a    :							Optional[int]										=    logging.get_logger(__name__)






class 		a							(  _lowerCamelCase	):


				def __init__(						self       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   Any=None			,							lowercase_       :   List[Any]=2048   ):
									snake_case_		     =							config.__dict__
									snake_case_		     =							modal_hidden_size
									if num_labels:
														snake_case_		     =							num_labels

