"""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        UpperCamelCase		(			_snake_case						,      unittest.TestCase  ):
   lowercase							=  KandinskyVaaPriorPipeline
   lowercase							=  ['prompt']
   lowercase							=  ['prompt', 'negative_prompt']
   lowercase							=  [
       'num_images_per_prompt',
       'generator',
       'num_inference_steps',
       'latents',
       'negative_prompt',
       'guidance_scale',
       'output_type',
       'return_dict',
   ]
   lowercase							=  False
   @property
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        return 32
   @property
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


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


        '''simple docstring'''


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


        '''simple docstring'''


        return self.time_input_dim * 4
   @property
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        return 100
   @property
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


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


        '''simple docstring'''


        torch.manual_seed(0			)
        lowercase_	:				Any													=	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 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        torch.manual_seed(0			)

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

        lowercase_	:				str													=	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
        lowercase_	:				str													=	nn.Parameter(torch.ones(model.clip_std.shape			)			)
        return model
   @property
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        torch.manual_seed(0			)
        lowercase_	:				Tuple													=	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     ,)

        lowercase_	:				Tuple													=	CLIPVisionModelWithProjection(_lowerCamelCase			)
        return model
   @property
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


        lowercase_	:				Any													=	CLIPImageProcessor(
            crop_size=224     ,do_center_crop=_lowerCamelCase     ,do_normalize=_lowerCamelCase     ,do_resize=_lowerCamelCase     ,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			)	->      List[Any]:


        '''simple docstring'''


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

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

        lowercase_	:				Optional[Any]													=	{
            '''prior''': prior,
            '''image_encoder''': image_encoder,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''scheduler''': scheduler,
            '''image_processor''': image_processor,
        }

        return components
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase=0			)	->      str:


        '''simple docstring'''


        if str(_lowerCamelCase			).startswith('mps'			):
             lowercase_	:				str													=	torch.manual_seed(_lowerCamelCase			)
        else:
             lowercase_	:				Any													=	torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
        lowercase_	:				List[str]													=	{
            '''prompt''': '''horse''',
            '''generator''': generator,
            '''guidance_scale''': 4.0,
            '''num_inference_steps''': 2,
            '''output_type''': '''np''',
        }
        return inputs
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				int													=	'''cpu'''

        lowercase_	:				Tuple													=	self.get_dummy_components()

        lowercase_	:				Optional[int]													=	self.pipeline_class(**_lowerCamelCase			)
        lowercase_	:				Dict													=	pipe.to(_lowerCamelCase			)

        pipe.set_progress_bar_config(disable=_lowerCamelCase			)

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

        lowercase_	:				Union[str, Any]													=	pipe(
            **self.get_dummy_inputs(_lowerCamelCase			)     ,return_dict=_lowerCamelCase     ,)[0]

        lowercase_	:				Tuple													=	image[0, -10:]
        lowercase_	:				int													=	image_from_tuple[0, -10:]

        assert image.shape == (1, 32)

        lowercase_	:				Optional[int]													=	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			)	->      Any:


        '''simple docstring'''


        lowercase_	:				List[str]													=	torch_device == '''cpu'''
        lowercase_	:				Union[str, Any]													=	True
        lowercase_	:				int													=	False

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







   @skip_mps
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				List[str]													=	torch_device == '''cpu'''
        lowercase_	:				Union[str, Any]													=	False

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





snake_case				:    str       				=     '''
# Transformers installation
! pip install transformers datasets
# To install from source instead of the last release, comment the command above and uncomment the following one.
# ! pip install git+https://github.com/huggingface/transformers.git
'''

snake_case				:    List[Any]       				=     [{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
snake_case				:    int       				=     {
    '''{processor_class}''': '''FakeProcessorClass''',
    '''{model_class}''': '''FakeModelClass''',
    '''{object_class}''': '''FakeObjectClass''',
}





