



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



	'''simple docstring'''







	__lowerCamelCase					: Dict    = KandinskyVaaPriorPipeline
	__lowerCamelCase					: List[str]    = ['prompt']
	__lowerCamelCase					: str    = ['prompt', 'negative_prompt']
	__lowerCamelCase					: Union[str, Any]    = [
	    'num_images_per_prompt',
	    'generator',
	    'num_inference_steps',
	    'latents',
	    'negative_prompt',
	    'guidance_scale',
	    'output_type',
	    'return_dict',
	]
	__lowerCamelCase					: Union[str, Any]    = False



	@property
	def       a__						(self )					->  Tuple:


						"""simple docstring"""



						return 32



	@property
	def       a__						(self )					->  int:


						"""simple docstring"""



						return 32



	@property
	def       a__						(self )					->  int:


						"""simple docstring"""



						return self.time_input_dim



	@property
	def       a__						(self )					->  Any:


						"""simple docstring"""



						return self.time_input_dim * 4



	@property
	def       a__						(self )					->  Optional[Any]:


						"""simple docstring"""



						return 100



	@property
	def       a__						(self )					->  str:


						"""simple docstring"""



						_a											=						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
						return tokenizer



	@property
	def       a__						(self )					->  int:


						"""simple docstring"""



						torch.manual_seed(0 )
						_a											=						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=1_000				,     )
						return CLIPTextModelWithProjection(A )



	@property
	def       a__						(self )					->  List[str]:


						"""simple docstring"""



						torch.manual_seed(0 )

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

						_a											=						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
						_a											=						nn.Parameter(torch.ones(model.clip_std.shape ) )
						return model



	@property
	def       a__						(self )					->  str:


						"""simple docstring"""



						torch.manual_seed(0 )
						_a											=						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											=						CLIPVisionModelWithProjection(A )
						return model



	@property
	def       a__						(self )					->  Union[str, Any]:


						"""simple docstring"""



						_a											=						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       a__						(self )					->  Union[str, Any]:


						"""simple docstring"""



						_a											=						self.dummy_prior
						_a											=						self.dummy_image_encoder
						_a											=						self.dummy_text_encoder
						_a											=						self.dummy_tokenizer
						_a											=						self.dummy_image_processor

						_a											=						UnCLIPScheduler(
						    variance_type='''fixed_small_log'''				,     prediction_type='''sample'''				,     num_train_timesteps=1_000				,     clip_sample=A				,     clip_sample_range=10.0				,     )

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

						return components



	def       a__						(self				,     A				,     A=0 )					->  Optional[int]:


						"""simple docstring"""



						if str(A ).startswith('''mps''' ):
											_a											=						torch.manual_seed(A )
						else:
											_a											=						torch.Generator(device=A ).manual_seed(A )
						_a											=						{
						    '''prompt''': '''horse''',
						    '''generator''': generator,
						    '''guidance_scale''': 4.0,
						    '''num_inference_steps''': 2,
						    '''output_type''': '''np''',
						}
						return inputs



	def       a__						(self )					->  Union[str, Any]:


						"""simple docstring"""



						_a											=						'''cpu'''

						_a											=						self.get_dummy_components()

						_a											=						self.pipeline_class(**A )
						_a											=						pipe.to(A )

						pipe.set_progress_bar_config(disable=A )

						_a											=						pipe(**self.get_dummy_inputs(A ) )
						_a											=						output.image_embeds

						_a											=						pipe(
						    **self.get_dummy_inputs(A )				,     return_dict=A				,     )[0]

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

						assert image.shape == (1, 32)

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


						"""simple docstring"""



						_a											=						torch_device == '''cpu'''
						_a											=						True
						_a											=						False

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



	@skip_mps
	def       a__						(self )					->  List[str]:


						"""simple docstring"""



						_a											=						torch_device == '''cpu'''
						_a											=						False

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








'''simple docstring'''





def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						set()
     # To detect a back edge, keep track of vertices currently in the recursion stack
     _a											=						set()
     return any(
         node not in visited and depth_first_search(__A						,			__A						,			__A						,			__A)
         for node in graph)




def lowerCAmelCase						(__A						,			__A						,			__A						,			__A):



     """simple docstring"""



     visited.add(__A)
     rec_stk.add(__A)

     for node in graph[vertex]:
          if node not in visited:
               if depth_first_search(__A						,			__A						,			__A						,			__A):
                    return True
          elif node in rec_stk:
               return True

    # The node needs to be removed from recursion stack before function ends
     rec_stk.remove(__A)
     return False


if __name__ == "__main__":
  from doctest import testmod

  testmod()



