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 (       SCREAMING_SNAKE_CASE__		,			unittest.TestCase):
   _lowerCamelCase :					Tuple    					=					KandinskyVaaPriorEmbaEmbPipeline
   _lowerCamelCase :					int    					=					['prompt', 'image']
   _lowerCamelCase :					int    					=					['prompt', 'image']
   _lowerCamelCase :					Any    					=					[
       'num_images_per_prompt',
       'strength',
       'generator',
       'num_inference_steps',
       'latents',
       'negative_prompt',
       'guidance_scale',
       'output_type',
       'return_dict',
   ]
   _lowerCamelCase :					Tuple    					=					False
  
   @property
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return 32
  
   @property
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return 32
  
   @property
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return self.time_input_dim
  
   @property
   def 		lowercase_						( self :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return self.time_input_dim * 4
  
   @property
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return 100
  
   @property
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)
      return tokenizer
  
   @property
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      torch.manual_seed(0					)
      UpperCamelCase__ 						=						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-0_5,					num_attention_heads=4,					num_hidden_layers=5,					pad_token_id=1,					vocab_size=1000,					)
      return CLIPTextModelWithProjection(a_					)
  
   @property
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      torch.manual_seed(0					)
  
      UpperCamelCase__ 						=						{
          "num_attention_heads": 2,
          "attention_head_dim": 12,
          "embedding_dim": self.text_embedder_hidden_size,
          "num_layers": 1,
      }
  
      UpperCamelCase__ 						=						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
      UpperCamelCase__ 						=						nn.Parameter(torch.ones(model.clip_std.shape					)					)
      return model
  
   @property
   def 		lowercase_						( self :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      torch.manual_seed(0					)
      UpperCamelCase__ 						=						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__ 						=						CLIPVisionModelWithProjection(a_					)
      return model
  
   @property
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						CLIPImageProcessor(
          crop_size=224,					do_center_crop=a_,					do_normalize=a_,					do_resize=a_,					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]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						self.dummy_prior
      UpperCamelCase__ 						=						self.dummy_image_encoder
      UpperCamelCase__ 						=						self.dummy_text_encoder
      UpperCamelCase__ 						=						self.dummy_tokenizer
      UpperCamelCase__ 						=						self.dummy_image_processor
  
      UpperCamelCase__ 						=						UnCLIPScheduler(
          variance_type="fixed_small_log",					prediction_type="sample",					num_train_timesteps=1000,					clip_sample=a_,					clip_sample_range=10.0,					)
  
      UpperCamelCase__ 						=						{
          "prior": prior,
          "image_encoder": image_encoder,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "scheduler": scheduler,
          "image_processor": image_processor,
      }
  
      return components
  
   def 		lowercase_						( self :	int,					a_ :	List[Any],					a_ :	Union[str, Any]=0					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      if str(a_					).startswith("mps"					):
         UpperCamelCase__ 						=						torch.manual_seed(a_					)
      else:
         UpperCamelCase__ 						=						torch.Generator(device=a_					).manual_seed(a_					)
  
      UpperCamelCase__ 						=						floats_tensor((1, 3, 64, 64),					rng=random.Random(a_					)					).to(a_					)
      UpperCamelCase__ 						=						image.cpu().permute(0,					2,					3,					1					)[0]
      UpperCamelCase__ 						=						Image.fromarray(np.uinta(a_					)					).convert("RGB"					).resize((256, 256)					)
  
      UpperCamelCase__ 						=						{
          "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 :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						"cpu"
  
      UpperCamelCase__ 						=						self.get_dummy_components()
  
      UpperCamelCase__ 						=						self.pipeline_class(**a_					)
      UpperCamelCase__ 						=						pipe.to(a_					)
  
      pipe.set_progress_bar_config(disable=a_					)
  
      UpperCamelCase__ 						=						pipe(**self.get_dummy_inputs(a_					)					)
      UpperCamelCase__ 						=						output.image_embeds
  
      UpperCamelCase__ 						=						pipe(
          **self.get_dummy_inputs(a_					),					return_dict=a_,					)[0]
  
      UpperCamelCase__ 						=						image[0, -10:]
      UpperCamelCase__ 						=						image_from_tuple[0, -10:]
  
      assert image.shape == (1, 32)
  
      UpperCamelCase__ 						=						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 :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						torch_device == "cpu"
      UpperCamelCase__ 						=						True
      UpperCamelCase__ 						=						False
  
      self._test_inference_batch_single_identical(
          test_max_difference=a_,					relax_max_difference=a_,					test_mean_pixel_difference=a_,					)
  
   @skip_mps
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						torch_device == "cpu"
      UpperCamelCase__ 						=						False
  
      self._test_attention_slicing_forward_pass(
          test_max_difference=a_,					test_mean_pixel_difference=a_,					)
style_context: 
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __lowercase:		int							=     {
      "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
  }
  
  try:
         if not is_sentencepiece_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		str							=     ["LlamaTokenizer"]
  
  try:
         if not is_tokenizers_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		List[Any]							=     ["LlamaTokenizerFast"]
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		Union[str, Any]							=     [
             "OpenLlamaForCausalLM",
             "OpenLlamaModel",
             "OpenLlamaPreTrainedModel",
             "OpenLlamaForSequenceClassification",
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig
  
         try:
                if not is_sentencepiece_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from transformers import LlamaTokenizer
  
         try:
                if not is_tokenizers_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from transformers import LlamaTokenizerFast
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_open_llama import (
                    OpenLlamaForCausalLM,
                    OpenLlamaForSequenceClassification,
                    OpenLlamaModel,
                    OpenLlamaPreTrainedModel,
                )
  
  
  else:
         import sys
  
         __lowercase:		Tuple							=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)