code: 
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
  from diffusers.utils import floats_tensor, nightly, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  
  enable_full_determinism()
  
  
  
  
  
  
  
  class 		__magic_name__    (							unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=1
       a__						=3
       a__						=(32, 32)
  
       a__						=floats_tensor((batch_size, num_channels) + sizes,					rng=random.Random(0 ) ).to(lowercase_ )
       return image
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       torch.manual_seed(0 )
       a__						=UNetaDConditionModel(
           block_out_channels=(32, 64),					layers_per_block=2,					sample_size=32,					in_channels=4,					out_channels=4,					down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D'''),					up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D'''),					cross_attention_dim=32,					)
       return model
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       torch.manual_seed(0 )
       a__						=AutoencoderKL(
           block_out_channels=[32, 64],					in_channels=3,					out_channels=3,					down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],					up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],					latent_channels=4,					)
       return model
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       torch.manual_seed(0 )
       a__						=CLIPTextConfig(
           bos_token_id=0,					eos_token_id=2,					hidden_size=32,					intermediate_size=37,					layer_norm_eps=1E-05,					num_attention_heads=4,					num_hidden_layers=5,					pad_token_id=1,					vocab_size=1000,					)
       return CLIPTextModel(lowercase_ )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       def extract(*lowercase_,					**lowercase_ ):
  
  
  
  
  
  
  
         class 		__magic_name__    :
  
            '''simple docstring'''
  
  
  
  
            def __init__(       self )							->					Union[str, Any]:
  
  
  
  
  
  
              """simple docstring"""
  
  
  
  
  
  
              a__						=torch.ones([0] )
  
  
  
            def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Any:
  
  
  
  
  
  
              """simple docstring"""
  
  
  
  
  
  
              self.pixel_values.to(lowercase_ )
              return self
  
  
  
  
  
         return Out()
  
       return extract
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a__						=self.dummy_cond_unet
       a__						=DDIMScheduler(
           beta_start=0.00085,					beta_end=0.012,					beta_schedule='''scaled_linear''',					clip_sample=lowercase_,					set_alpha_to_one=lowercase_,					)
  
       a__						=self.dummy_vae
       a__						=self.dummy_text_encoder
       a__						=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
  
       # make sure here that pndm scheduler skips prk
       a__						=StableDiffusionPipeline(
           unet=lowercase_,					scheduler=lowercase_,					vae=lowercase_,					text_encoder=lowercase_,					tokenizer=lowercase_,					safety_checker=lowercase_,					feature_extractor=self.dummy_extractor,					)
       a__						=sd_pipe.to(lowercase_ )
       sd_pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''A painting of a squirrel eating a burger'''
  
       a__						=torch.Generator(device=lowercase_ ).manual_seed(0 )
       a__						=sd_pipe([prompt],					generator=lowercase_,					guidance_scale=6.0,					num_inference_steps=2,					output_type='''np''' )
       a__						=output.images
  
       a__						=torch.Generator(device=lowercase_ ).manual_seed(0 )
       a__						=sd_pipe(
           [prompt],					generator=lowercase_,					guidance_scale=6.0,					num_inference_steps=2,					output_type='''np''',					return_dict=lowercase_,					)[0]
  
       a__						=image[0, -3:, -3:, -1]
       a__						=image_from_tuple[0, -3:, -3:, -1]
  
       assert image.shape == (1, 64, 64, 3)
       a__						=np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867] )
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       a__						=self.dummy_cond_unet
       a__						=PNDMScheduler(skip_prk_steps=lowercase_ )
       a__						=self.dummy_vae
       a__						=self.dummy_text_encoder
       a__						=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
  
       # make sure here that pndm scheduler skips prk
       a__						=StableDiffusionPipeline(
           unet=lowercase_,					scheduler=lowercase_,					vae=lowercase_,					text_encoder=lowercase_,					tokenizer=lowercase_,					safety_checker=lowercase_,					feature_extractor=self.dummy_extractor,					)
       a__						=sd_pipe.to(lowercase_ )
       sd_pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''A painting of a squirrel eating a burger'''
       a__						=torch.Generator(device=lowercase_ ).manual_seed(0 )
       a__						=sd_pipe([prompt],					generator=lowercase_,					guidance_scale=6.0,					num_inference_steps=2,					output_type='''np''' )
  
       a__						=output.images
  
       a__						=torch.Generator(device=lowercase_ ).manual_seed(0 )
       a__						=sd_pipe(
           [prompt],					generator=lowercase_,					guidance_scale=6.0,					num_inference_steps=2,					output_type='''np''',					return_dict=lowercase_,					)[0]
  
       a__						=image[0, -3:, -3:, -1]
       a__						=image_from_tuple[0, -3:, -3:, -1]
  
       assert image.shape == (1, 64, 64, 3)
       a__						=np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994] )
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=StableDiffusionPipeline.from_pretrained(
           '''hf-internal-testing/tiny-stable-diffusion-lms-pipe''',					safety_checker=lowercase_ )
       assert isinstance(lowercase_,					lowercase_ )
       assert isinstance(pipe.scheduler,					lowercase_ )
       assert pipe.safety_checker is None
  
       a__						=pipe('''example prompt''',					num_inference_steps=2 ).images[0]
       assert image is not None
  
       # check that there's no error when saving a pipeline with one of the models being None
       with tempfile.TemporaryDirectory() as tmpdirname:
         pipe.save_pretrained(lowercase_ )
         a__						=StableDiffusionPipeline.from_pretrained(lowercase_ )
  
       # sanity check that the pipeline still works
       assert pipe.safety_checker is None
       a__						=pipe('''example prompt''',					num_inference_steps=2 ).images[0]
       assert image is not None
  
  
  
     @unittest.skipIf(torch_device != '''cuda''',					'''This test requires a GPU''' )
     def 				_UpperCAmelCase				(       self )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.dummy_cond_unet
       a__						=PNDMScheduler(skip_prk_steps=lowercase_ )
       a__						=self.dummy_vae
       a__						=self.dummy_text_encoder
       a__						=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
  
       # put models in fp16
       a__						=unet.half()
       a__						=vae.half()
       a__						=bert.half()
  
       # make sure here that pndm scheduler skips prk
       a__						=StableDiffusionPipeline(
           unet=lowercase_,					scheduler=lowercase_,					vae=lowercase_,					text_encoder=lowercase_,					tokenizer=lowercase_,					safety_checker=lowercase_,					feature_extractor=self.dummy_extractor,					)
       a__						=sd_pipe.to(lowercase_ )
       sd_pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''A painting of a squirrel eating a burger'''
       a__						=sd_pipe([prompt],					num_inference_steps=2,					output_type='''np''' ).images
  
       assert image.shape == (1, 64, 64, 3)
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class 		__magic_name__    (							unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
  
  
  
     def 				_UpperCAmelCase				(       self )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cuda'''
       a__						=StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' )
       a__						=pipe.to(lowercase_ )
       pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''a photo of a cat'''
       a__						={
           '''editing_prompt''': ['''sunglasses'''],
           '''reverse_editing_direction''': [False],
           '''edit_warmup_steps''': 10,
           '''edit_guidance_scale''': 6,
           '''edit_threshold''': 0.95,
           '''edit_momentum_scale''': 0.5,
           '''edit_mom_beta''': 0.6,
       }
  
       a__						=3
       a__						=7
  
       # no sega enabled
       a__						=torch.Generator(lowercase_ )
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.34673113,
           0.38492733,
           0.37597352,
           0.34086335,
           0.35650748,
           0.35579205,
           0.3384763,
           0.34340236,
           0.3573271,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
       # with sega enabled
       # generator = torch.manual_seed(seed)
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					**lowercase_,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.41887826,
           0.37728766,
           0.30138272,
           0.41416335,
           0.41664985,
           0.36283392,
           0.36191246,
           0.43364465,
           0.43001732,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cuda'''
       a__						=StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' )
       a__						=pipe.to(lowercase_ )
       pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''an image of a crowded boulevard, realistic, 4k'''
       a__						={
           '''editing_prompt''': '''crowd, crowded, people''',
           '''reverse_editing_direction''': True,
           '''edit_warmup_steps''': 10,
           '''edit_guidance_scale''': 8.3,
           '''edit_threshold''': 0.9,
           '''edit_momentum_scale''': 0.5,
           '''edit_mom_beta''': 0.6,
       }
  
       a__						=9
       a__						=7
  
       # no sega enabled
       a__						=torch.Generator(lowercase_ )
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.43497998,
           0.91814065,
           0.7540739,
           0.55580205,
           0.8467265,
           0.5389691,
           0.62574506,
           0.58897763,
           0.50926757,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
       # with sega enabled
       # generator = torch.manual_seed(seed)
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					**lowercase_,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.3089719,
           0.30500144,
           0.29016042,
           0.30630964,
           0.325687,
           0.29419225,
           0.2908091,
           0.28723598,
           0.27696294,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cuda'''
       a__						=StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' )
       a__						=pipe.to(lowercase_ )
       pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''a castle next to a river'''
       a__						={
           '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
           '''reverse_editing_direction''': False,
           '''edit_warmup_steps''': [15, 18],
           '''edit_guidance_scale''': 6,
           '''edit_threshold''': [0.9, 0.8],
           '''edit_momentum_scale''': 0.5,
           '''edit_mom_beta''': 0.6,
       }
  
       a__						=48
       a__						=7
  
       # no sega enabled
       a__						=torch.Generator(lowercase_ )
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.75163555,
           0.76037145,
           0.61785,
           0.9189673,
           0.8627701,
           0.85189694,
           0.8512813,
           0.87012076,
           0.8312857,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
       # with sega enabled
       # generator = torch.manual_seed(seed)
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					**lowercase_,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.73553365,
           0.7537271,
           0.74341905,
           0.66480356,
           0.6472925,
           0.63039416,
           0.64812905,
           0.6749717,
           0.6517102,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						='''cuda'''
       a__						=StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''',					torch_dtype=torch.floataa )
       a__						=pipe.to(lowercase_ )
       pipe.set_progress_bar_config(disable=lowercase_ )
  
       a__						='''a photo of a cat'''
       a__						={
           '''editing_prompt''': ['''sunglasses'''],
           '''reverse_editing_direction''': [False],
           '''edit_warmup_steps''': 10,
           '''edit_guidance_scale''': 6,
           '''edit_threshold''': 0.95,
           '''edit_momentum_scale''': 0.5,
           '''edit_mom_beta''': 0.6,
       }
  
       a__						=3
       a__						=7
  
       # no sega enabled
       a__						=torch.Generator(lowercase_ )
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.34887695,
           0.3876953,
           0.375,
           0.34423828,
           0.3581543,
           0.35717773,
           0.3383789,
           0.34570312,
           0.359375,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
       # with sega enabled
       # generator = torch.manual_seed(seed)
       generator.manual_seed(lowercase_ )
       a__						=pipe(
           [prompt],					generator=lowercase_,					guidance_scale=lowercase_,					num_inference_steps=50,					output_type='''np''',					width=512,					height=512,					**lowercase_,					)
  
       a__						=output.images
       a__						=image[0, -3:, -3:, -1]
       a__						=[
           0.42285156,
           0.36914062,
           0.29077148,
           0.42041016,
           0.41918945,
           0.35498047,
           0.3618164,
           0.4423828,
           0.43115234,
       ]
  
       assert image.shape == (1, 512, 512, 3)
  
       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
  
style_context: 
  
  import math
  from decimal import Decimal, getcontext
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int = 4_00_00_00							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    try:
      a__						=int(_A							)
    except (TypeError, ValueError):
      raise TypeError('''Parameter n must be int or castable to int.'''							)
    if n <= 0:
      raise ValueError('''Parameter n must be greater than or equal to one.'''							)
    a__						=1_00
    a__						=(Decimal(5							) ** Decimal(0.5							) + 1) / Decimal(2							)
  
    a__						=(math.floor(math.log(n * (phi + 2)			,   _A							) - 1							) // 3) * 3 + 2
    a__						=Decimal(round(phi ** Decimal(index + 1							)							)							) / (phi + 2)
    a__						=num // 2
    return int(_A							)
  
  
  if __name__ == "__main__":
         print(f"""{solution() = }""")
  