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






					'''simple docstring'''


					a   	=		KandinskyVaaPriorPipeline
					a   	=		["prompt"]
					a   	=		["prompt", "negative_prompt"]
					a   	=		[
					    "num_images_per_prompt",
					    "generator",
					    "num_inference_steps",
					    "latents",
					    "negative_prompt",
					    "guidance_scale",
					    "output_type",
					    "return_dict",
					]
					a   	=		False



					@property
					def 			lowerCAmelCase_					(						self			:				int		)							->       Union[str, Any]:
									return 32



					@property
					def 			lowerCAmelCase_					(						self			:				Tuple		)							->       Any:
									return 32



					@property
					def 			lowerCAmelCase_					(						self			:				Optional[Any]		)							->       List[str]:
									return self.time_input_dim



					@property
					def 			lowerCAmelCase_					(						self			:				List[Any]		)							->       Tuple:
									return self.time_input_dim * 4



					@property
					def 			lowerCAmelCase_					(						self			:				str		)							->       Any:
									return 100



					@property
					def 			lowerCAmelCase_					(						self			:				Any		)							->       str:
									SCREAMING_SNAKE_CASE__		  =				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)
									return tokenizer



					@property
					def 			lowerCAmelCase_					(						self			:				Union[str, Any]		)							->       List[Any]:
									torch.manual_seed(0		)
									SCREAMING_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(_snake_case		)



					@property
					def 			lowerCAmelCase_					(						self			:				Dict		)							->       str:
									torch.manual_seed(0		)

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

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



					@property
					def 			lowerCAmelCase_					(						self			:				List[str]		)							->       Optional[int]:
									torch.manual_seed(0		)
									SCREAMING_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   , )

									SCREAMING_SNAKE_CASE__		  =				CLIPVisionModelWithProjection(_snake_case		)
									return model



					@property
					def 			lowerCAmelCase_					(						self			:				List[str]		)							->       Tuple:
									SCREAMING_SNAKE_CASE__		  =				CLIPImageProcessor(
									    crop_size=224   , do_center_crop=_snake_case   , do_normalize=_snake_case   , do_resize=_snake_case   , 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 			lowerCAmelCase_					(						self			:				Any		)							->       Tuple:
									SCREAMING_SNAKE_CASE__		  =				self.dummy_prior
									SCREAMING_SNAKE_CASE__		  =				self.dummy_image_encoder
									SCREAMING_SNAKE_CASE__		  =				self.dummy_text_encoder
									SCREAMING_SNAKE_CASE__		  =				self.dummy_tokenizer
									SCREAMING_SNAKE_CASE__		  =				self.dummy_image_processor

									SCREAMING_SNAKE_CASE__		  =				UnCLIPScheduler(
									    variance_type="fixed_small_log"   , prediction_type="sample"   , num_train_timesteps=1000   , clip_sample=_snake_case   , clip_sample_range=10.0   , )

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

									return components



					def 			lowerCAmelCase_					(						self			:				str   , _snake_case			:				str   , _snake_case			:				List[Any]=0		)							->       Tuple:
									if str(_snake_case		).startswith("mps"		):
													SCREAMING_SNAKE_CASE__		  =				torch.manual_seed(_snake_case		)
									else:
													SCREAMING_SNAKE_CASE__		  =				torch.Generator(device=_snake_case		).manual_seed(_snake_case		)
									SCREAMING_SNAKE_CASE__		  =				{
									    "prompt": "horse",
									    "generator": generator,
									    "guidance_scale": 4.0,
									    "num_inference_steps": 2,
									    "output_type": "np",
									}
									return inputs



					def 			lowerCAmelCase_					(						self			:				Optional[Any]		)							->       Optional[int]:
									SCREAMING_SNAKE_CASE__		  =				"cpu"

									SCREAMING_SNAKE_CASE__		  =				self.get_dummy_components()

									SCREAMING_SNAKE_CASE__		  =				self.pipeline_class(**_snake_case		)
									SCREAMING_SNAKE_CASE__		  =				pipe.to(_snake_case		)

									pipe.set_progress_bar_config(disable=_snake_case		)

									SCREAMING_SNAKE_CASE__		  =				pipe(**self.get_dummy_inputs(_snake_case		)		)
									SCREAMING_SNAKE_CASE__		  =				output.image_embeds

									SCREAMING_SNAKE_CASE__		  =				pipe(
									    **self.get_dummy_inputs(_snake_case		)   , return_dict=_snake_case   , )[0]

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

									assert image.shape == (1, 32)

									SCREAMING_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 			lowerCAmelCase_					(						self			:				Optional[int]		)							->       Any:
									SCREAMING_SNAKE_CASE__		  =				torch_device == "cpu"
									SCREAMING_SNAKE_CASE__		  =				True
									SCREAMING_SNAKE_CASE__		  =				False

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



					@skip_mps
					def 			lowerCAmelCase_					(						self			:				int		)							->       List[Any]:
									SCREAMING_SNAKE_CASE__		  =				torch_device == "cpu"
									SCREAMING_SNAKE_CASE__		  =				False

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





"""simple docstring"""






from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_A   					=    {'configuration_van': ['VAN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VanConfig']}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_A   					=    [
						    'VAN_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'VanForImageClassification',
						    'VanModel',
						    'VanPreTrainedModel',
						]

if TYPE_CHECKING:
						from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_van import (
												    VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
												    VanForImageClassification,
												    VanModel,
												    VanPreTrainedModel,
												)

else:
						import sys

						_A   					=    _LazyModule(__name__, globals()['__file__'], _import_structure)




