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__						(					SCREAMING_SNAKE_CASE__    ,		unittest.TestCase					):
					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 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							return 32

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







							"""simple docstring"""






							return 32

					@property
					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							return self.time_input_dim

					@property
					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							return self.time_input_dim * 4

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







							"""simple docstring"""






							return 100

					@property
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )
							return tokenizer

					@property
					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		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(A__    )

					@property
					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							torch.manual_seed(0    )

							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    {
							    "num_attention_heads": 2,
							    "attention_head_dim": 12,
							    "embedding_dim": self.text_embedder_hidden_size,
							    "num_layers": 1,
							}

							SCREAMING_SNAKE_CASE_  :		str				      =    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
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    nn.Parameter(torch.ones(model.clip_std.shape    )    )
							return model

					@property
					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    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_  :		str				      =    CLIPVisionModelWithProjection(A__    )
							return model

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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    CLIPImageProcessor(
							    crop_size=224,do_center_crop=A__,do_normalize=A__,do_resize=A__,image_mean=[0.48145466, 0.4578275, 0.40821073],image_std=[0.26862954, 0.26130258, 0.27577711],resample=3,size=224,)

							return image_processor

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self.dummy_prior
							SCREAMING_SNAKE_CASE_  :		Any				      =    self.dummy_image_encoder
							SCREAMING_SNAKE_CASE_  :		Dict				      =    self.dummy_text_encoder
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.dummy_tokenizer
							SCREAMING_SNAKE_CASE_  :		Any				      =    self.dummy_image_processor

							SCREAMING_SNAKE_CASE_  :		Any				      =    UnCLIPScheduler(
							    variance_type="fixed_small_log",prediction_type="sample",num_train_timesteps=1000,clip_sample=A__,clip_sample_range=10.0,)

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    {
							    "prior": prior,
							    "image_encoder": image_encoder,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "scheduler": scheduler,
							    "image_processor": image_processor,
							}

							return components

					def 				__UpperCamelCase   (    self      :       Dict,_A      :       List[Any],_A      :       Dict=0    ):







							"""simple docstring"""






							if str(A__    ).startswith("mps"    ):
									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    torch.manual_seed(A__    )
							else:
									SCREAMING_SNAKE_CASE_  :		int				      =    torch.Generator(device=A__    ).manual_seed(A__    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    {
							    "prompt": "horse",
							    "generator": generator,
							    "guidance_scale": 4.0,
							    "num_inference_steps": 2,
							    "output_type": "np",
							}
							return inputs

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    "cpu"

							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.get_dummy_components()

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self.pipeline_class(**A__    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    pipe.to(A__    )

							pipe.set_progress_bar_config(disable=A__    )

							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    pipe(**self.get_dummy_inputs(A__    )    )
							SCREAMING_SNAKE_CASE_  :		int				      =    output.image_embeds

							SCREAMING_SNAKE_CASE_  :		Dict				      =    pipe(
							    **self.get_dummy_inputs(A__    ),return_dict=A__,)[0]

							SCREAMING_SNAKE_CASE_  :		str				      =    image[0, -10:]
							SCREAMING_SNAKE_CASE_  :		str				      =    image_from_tuple[0, -10:]

							assert image.shape == (1, 32)

							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    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      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    torch_device == "cpu"
							SCREAMING_SNAKE_CASE_  :		str				      =    True
							SCREAMING_SNAKE_CASE_  :		Dict				      =    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      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    torch_device == "cpu"
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    False

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


import os
import sys

lowercase__		:Tuple   =    os.path.join(os.path.dirname(__file__), "src")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


lowercase__		:List[Any]   =    [
    "torch",
    "numpy",
    "tokenizers",
    "filelock",
    "requests",
    "tqdm",
    "regex",
    "sentencepiece",
    "sacremoses",
    "importlib_metadata",
    "huggingface_hub",
]



@add_start_docstrings(AutoConfig.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoConfig.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoTokenizer.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoTokenizer.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModel.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModel.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForCausalLM.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForCausalLM.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForMaskedLM.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForMaskedLM.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForSequenceClassification.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForSequenceClassification.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForQuestionAnswering.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForQuestionAnswering.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)




