code: 
  
  
  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    A					(     A_      ,       unittest.TestCase				):
  							UpperCamelCase_     :							Union[str, Any] =KandinskyVaaPriorEmbaEmbPipeline
  							UpperCamelCase_     :							Optional[Any] =['''prompt''', '''image''']
  							UpperCamelCase_     :							Any =['''prompt''', '''image''']
  							UpperCamelCase_     :							Any =[
  							    '''num_images_per_prompt''',
  							    '''strength''',
  							    '''generator''',
  							    '''num_inference_steps''',
  							    '''latents''',
  							    '''negative_prompt''',
  							    '''guidance_scale''',
  							    '''output_type''',
  							    '''return_dict''',
  							]
  							UpperCamelCase_     :							List[Any] =False
  
  
  							@property
  							def     _A (self      ):
  									return 3_2
  
  
  							@property
  							def     _A (self      ):
  									return 3_2
  
  
  							@property
  							def     _A (self      ):
  									return self.time_input_dim
  
  
  							@property
  							def     _A (self      ):
  									return self.time_input_dim * 4
  
  
  							@property
  							def     _A (self      ):
  									return 1_0_0
  
  
  							@property
  							def     _A (self      ):
  									__lowercase=    CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )
  									return tokenizer
  
  
  							@property
  							def     _A (self      ):
  									torch.manual_seed(0      )
  									__lowercase=    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=3_7   ,       layer_norm_eps=1E-05   ,       num_attention_heads=4   ,       num_hidden_layers=5   ,       pad_token_id=1   ,       vocab_size=1_0_0_0   ,       )
  									return CLIPTextModelWithProjection(lowerCAmelCase      )
  
  
  							@property
  							def     _A (self      ):
  									torch.manual_seed(0      )
  
  									__lowercase=    {
  									    'num_attention_heads': 2,
  									    'attention_head_dim': 1_2,
  									    'embedding_dim': self.text_embedder_hidden_size,
  									    'num_layers': 1,
  									}
  
  									__lowercase=    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=    nn.Parameter(torch.ones(model.clip_std.shape      )      )
  									return model
  
  
  							@property
  							def     _A (self      ):
  									torch.manual_seed(0      )
  									__lowercase=    CLIPVisionConfig(
  									    hidden_size=self.text_embedder_hidden_size   ,       image_size=2_2_4   ,       projection_dim=self.text_embedder_hidden_size   ,       intermediate_size=3_7   ,       num_attention_heads=4   ,       num_channels=3   ,       num_hidden_layers=5   ,       patch_size=1_4   ,       )
  
  									__lowercase=    CLIPVisionModelWithProjection(lowerCAmelCase      )
  									return model
  
  
  							@property
  							def     _A (self      ):
  									__lowercase=    CLIPImageProcessor(
  									    crop_size=2_2_4   ,       do_center_crop=lowerCAmelCase   ,       do_normalize=lowerCAmelCase   ,       do_resize=lowerCAmelCase   ,       image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]   ,       image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]   ,       resample=3   ,       size=2_2_4   ,       )
  
  									return image_processor
  
  
  							def     _A (self      ):
  									__lowercase=    self.dummy_prior
  									__lowercase=    self.dummy_image_encoder
  									__lowercase=    self.dummy_text_encoder
  									__lowercase=    self.dummy_tokenizer
  									__lowercase=    self.dummy_image_processor
  
  									__lowercase=    UnCLIPScheduler(
  									    variance_type='fixed_small_log'   ,       prediction_type='sample'   ,       num_train_timesteps=1_0_0_0   ,       clip_sample=lowerCAmelCase   ,       clip_sample_range=10.0   ,       )
  
  									__lowercase=    {
  									    'prior': prior,
  									    'image_encoder': image_encoder,
  									    'text_encoder': text_encoder,
  									    'tokenizer': tokenizer,
  									    'scheduler': scheduler,
  									    'image_processor': image_processor,
  									}
  
  									return components
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase=0      ):
  									if str(lowerCAmelCase      ).startswith('mps'      ):
  											__lowercase=    torch.manual_seed(lowerCAmelCase      )
  									else:
  											__lowercase=    torch.Generator(device=lowerCAmelCase      ).manual_seed(lowerCAmelCase      )
  
  									__lowercase=    floats_tensor((1, 3, 6_4, 6_4)   ,       rng=random.Random(lowerCAmelCase      )      ).to(lowerCAmelCase      )
  									__lowercase=    image.cpu().permute(0   ,       2   ,       3   ,       1      )[0]
  									__lowercase=    Image.fromarray(np.uinta(lowerCAmelCase      )      ).convert('RGB'      ).resize((2_5_6, 2_5_6)      )
  
  									__lowercase=    {
  									    'prompt': 'horse',
  									    'image': init_image,
  									    'strength': 0.5,
  									    'generator': generator,
  									    'guidance_scale': 4.0,
  									    'num_inference_steps': 2,
  									    'output_type': 'np',
  									}
  									return inputs
  
  
  							def     _A (self      ):
  									__lowercase=    'cpu'
  
  									__lowercase=    self.get_dummy_components()
  
  									__lowercase=    self.pipeline_class(**lowerCAmelCase      )
  									__lowercase=    pipe.to(lowerCAmelCase      )
  
  									pipe.set_progress_bar_config(disable=lowerCAmelCase      )
  
  									__lowercase=    pipe(**self.get_dummy_inputs(lowerCAmelCase      )      )
  									__lowercase=    output.image_embeds
  
  									__lowercase=    pipe(
  									    **self.get_dummy_inputs(lowerCAmelCase      )   ,       return_dict=lowerCAmelCase   ,       )[0]
  
  									__lowercase=    image[0, -1_0:]
  									__lowercase=    image_from_tuple[0, -1_0:]
  
  									assert image.shape == (1, 3_2)
  
  									__lowercase=    np.array(
  									    [
  									        0.1_07_12_84,
  									        1.3_33_02_71,
  									        0.61_26_02_23,
  									        -0.6_69_10_65,
  									        -0.3_84_68_52,
  									        -1.0_30_36_61,
  									        0.22_71_61_11,
  									        0.03_34_89_01,
  									        0.30_04_06_75,
  									        -0.24_80_50_29,
  									    ]      )
  
  									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      ):
  									__lowercase=    torch_device == 'cpu'
  									__lowercase=    True
  									__lowercase=    False
  
  									self._test_inference_batch_single_identical(
  									    test_max_difference=lowerCAmelCase   ,       relax_max_difference=lowerCAmelCase   ,       test_mean_pixel_difference=lowerCAmelCase   ,       )
  
  
  
  
  
  
  
  							@skip_mps
  							def     _A (self      ):
  									__lowercase=    torch_device == 'cpu'
  									__lowercase=    False
  
  									self._test_attention_slicing_forward_pass(
  									    test_max_difference=lowerCAmelCase   ,       test_mean_pixel_difference=lowerCAmelCase   ,       )
  
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from enum import Enum
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  @dataclass
  class    A					(     A_				):
  							UpperCamelCase_     :							Optional[int] ={
  							    '''sld_warmup_steps''': 15,
  							    '''sld_guidance_scale''': 20,
  							    '''sld_threshold''': 0.0,
  							    '''sld_momentum_scale''': 0.0,
  							    '''sld_mom_beta''': 0.0,
  							}
  							UpperCamelCase_     :							Tuple ={
  							    '''sld_warmup_steps''': 10,
  							    '''sld_guidance_scale''': 1_000,
  							    '''sld_threshold''': 0.01,
  							    '''sld_momentum_scale''': 0.3,
  							    '''sld_mom_beta''': 0.4,
  							}
  							UpperCamelCase_     :							Union[str, Any] ={
  							    '''sld_warmup_steps''': 7,
  							    '''sld_guidance_scale''': 2_000,
  							    '''sld_threshold''': 0.025,
  							    '''sld_momentum_scale''': 0.5,
  							    '''sld_mom_beta''': 0.7,
  							}
  							UpperCamelCase_     :							List[Any] ={
  							    '''sld_warmup_steps''': 0,
  							    '''sld_guidance_scale''': 5_000,
  							    '''sld_threshold''': 1.0,
  							    '''sld_momentum_scale''': 0.5,
  							    '''sld_mom_beta''': 0.7,
  							}
  
  
  
  
  
  @dataclass
  class    A					(     A_				):
  							UpperCamelCase_     :							Union[List[PIL.Image.Image], np.ndarray]
  							UpperCamelCase_     :							Optional[List[bool]]
  							UpperCamelCase_     :							Optional[Union[List[PIL.Image.Image], np.ndarray]]
  							UpperCamelCase_     :							Optional[str]
  
  
  if is_transformers_available() and is_torch_available():
  	from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
  	from .safety_checker import SafeStableDiffusionSafetyChecker
  
  
  
  
  
  
  