code: 
  '''simple docstring'''
  
  import random
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from torch import nn
  from transformers import (
      CLIPImageProcessor,
      CLIPTextConfig,
      CLIPTextModelWithProjection,
      CLIPTokenizer,
      CLIPVisionConfig,
      CLIPVisionModelWithProjection,
  )
  
  from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
  from diffusers.utils import floats_tensor, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, skip_mps
  
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  
  class 			UpperCAmelCase				(					a_  ,		unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   str          =    KandinskyVaaPriorEmbaEmbPipeline
  		A__  :   Dict          =    ['prompt', 'image']
  		A__  :   List[Any]          =    ['prompt', 'image']
  		A__  :   List[Any]          =    [
  		    'num_images_per_prompt',
  		    'strength',
  		    'generator',
  		    'num_inference_steps',
  		    'latents',
  		    'negative_prompt',
  		    'guidance_scale',
  		    'output_type',
  		    'return_dict',
  		]
  		A__  :   List[str]          =    False
  		@property
  		def _lowercase  (    self     )				->    List[Any]:
  				return 32
  		@property
  		def _lowercase  (    self     )				->    List[str]:
  				return 32
  		@property
  		def _lowercase  (    self     )				->    Any:
  				return self.time_input_dim
  		@property
  		def _lowercase  (    self     )				->    str:
  				return self.time_input_dim * 4
  		@property
  		def _lowercase  (    self     )				->    List[Any]:
  				return 100
  		@property
  		def _lowercase  (    self     )				->    Optional[int]:
  				_UpperCamelCase       : Any    =      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     )
  				return tokenizer
  		@property
  		def _lowercase  (    self     )				->    List[Any]:
  				torch.manual_seed(0     )
  				_UpperCamelCase       : Optional[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(_snake_case     )
  		@property
  		def _lowercase  (    self     )				->    Optional[int]:
  				torch.manual_seed(0     )
  
  				_UpperCamelCase       : Any    =      {
  				    '''num_attention_heads''': 2,
  				    '''attention_head_dim''': 12,
  				    '''embedding_dim''': self.text_embedder_hidden_size,
  				    '''num_layers''': 1,
  				}
  
  				_UpperCamelCase       : Union[str, Any]    =      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
  				_UpperCamelCase       : Tuple    =      nn.Parameter(torch.ones(model.clip_std.shape     )     )
  				return model
  		@property
  		def _lowercase  (    self     )				->    str:
  				torch.manual_seed(0     )
  				_UpperCamelCase       : str    =      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  ,					)
  
  				_UpperCamelCase       : str    =      CLIPVisionModelWithProjection(_snake_case     )
  				return model
  		@property
  		def _lowercase  (    self     )				->    Union[str, Any]:
  				_UpperCamelCase       : List[str]    =      CLIPImageProcessor(
  				    crop_size=224  ,					do_center_crop=_snake_case  ,					do_normalize=_snake_case  ,					do_resize=_snake_case  ,					image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073]  ,					image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711]  ,					resample=3  ,					size=224  ,					)
  
  				return image_processor
  		def _lowercase  (    self     )				->    Union[str, Any]:
  				_UpperCamelCase       : List[str]    =      self.dummy_prior
  				_UpperCamelCase       : List[str]    =      self.dummy_image_encoder
  				_UpperCamelCase       : List[Any]    =      self.dummy_text_encoder
  				_UpperCamelCase       : Tuple    =      self.dummy_tokenizer
  				_UpperCamelCase       : List[Any]    =      self.dummy_image_processor
  
  				_UpperCamelCase       : Optional[Any]    =      UnCLIPScheduler(
  				    variance_type='''fixed_small_log'''  ,					prediction_type='''sample'''  ,					num_train_timesteps=1000  ,					clip_sample=_snake_case  ,					clip_sample_range=10.0  ,					)
  
  				_UpperCamelCase       : Union[str, Any]    =      {
  				    '''prior''': prior,
  				    '''image_encoder''': image_encoder,
  				    '''text_encoder''': text_encoder,
  				    '''tokenizer''': tokenizer,
  				    '''scheduler''': scheduler,
  				    '''image_processor''': image_processor,
  				}
  
  				return components
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case=0     )				->    Any:
  				if str(_snake_case     ).startswith('''mps'''     ):
  						_UpperCamelCase       : str    =      torch.manual_seed(_snake_case     )
  				else:
  						_UpperCamelCase       : str    =      torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )
  
  				_UpperCamelCase       : List[str]    =      floats_tensor((1, 3, 64, 64)  ,					rng=random.Random(_snake_case     )     ).to(_snake_case     )
  				_UpperCamelCase       : int    =      image.cpu().permute(0  ,					2  ,					3  ,					1     )[0]
  				_UpperCamelCase       : List[str]    =      Image.fromarray(np.uinta(_snake_case     )     ).convert('''RGB'''     ).resize((256, 256)     )
  
  				_UpperCamelCase       : List[str]    =      {
  				    '''prompt''': '''horse''',
  				    '''image''': init_image,
  				    '''strength''': 0.5,
  				    '''generator''': generator,
  				    '''guidance_scale''': 4.0,
  				    '''num_inference_steps''': 2,
  				    '''output_type''': '''np''',
  				}
  				return inputs
  		def _lowercase  (    self     )				->    List[str]:
  				_UpperCamelCase       : Any    =      '''cpu'''
  
  				_UpperCamelCase       : Union[str, Any]    =      self.get_dummy_components()
  
  				_UpperCamelCase       : Optional[Any]    =      self.pipeline_class(**_snake_case     )
  				_UpperCamelCase       : str    =      pipe.to(_snake_case     )
  
  				pipe.set_progress_bar_config(disable=_snake_case     )
  
  				_UpperCamelCase       : List[Any]    =      pipe(**self.get_dummy_inputs(_snake_case     )     )
  				_UpperCamelCase       : Tuple    =      output.image_embeds
  
  				_UpperCamelCase       : int    =      pipe(
  				    **self.get_dummy_inputs(_snake_case     )  ,					return_dict=_snake_case  ,					)[0]
  
  				_UpperCamelCase       : Union[str, Any]    =      image[0, -10:]
  				_UpperCamelCase       : List[str]    =      image_from_tuple[0, -10:]
  
  				assert image.shape == (1, 32)
  
  				_UpperCamelCase       : int    =      np.array(
  				    [
  				        0.1_071_284,
  				        1.3_330_271,
  				        0.61_260_223,
  				        -0.6_691_065,
  				        -0.3_846_852,
  				        -1.0_303_661,
  				        0.22_716_111,
  				        0.03_348_901,
  				        0.30_040_675,
  				        -0.24_805_029,
  				    ]     )
  
  				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 _lowercase  (    self     )				->    Any:
  				_UpperCamelCase       : Union[str, Any]    =      torch_device == '''cpu'''
  				_UpperCamelCase       : Any    =      True
  				_UpperCamelCase       : Optional[Any]    =      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 _lowercase  (    self     )				->    Any:
  				_UpperCamelCase       : Any    =      torch_device == '''cpu'''
  				_UpperCamelCase       : Union[str, Any]    =      False
  
  				self._test_attention_slicing_forward_pass(
  				    test_max_difference=_snake_case  ,					test_mean_pixel_difference=_snake_case  ,					)
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  _UpperCAmelCase   :      Optional[int] 						=  """
  # Transformers installation
  ! pip install transformers datasets evaluate
  # 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
  """
  
  _UpperCAmelCase   :      Union[str, Any] 						=  [{"""type""": """code""", """content""": INSTALL_CONTENT}]
  _UpperCAmelCase   :      Union[str, Any] 						=  {
      """{processor_class}""": """FakeProcessorClass""",
      """{model_class}""": """FakeModelClass""",
      """{object_class}""": """FakeObjectClass""",
  }
  
  
  
  
  
  