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 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      def _a       (							self			:    int			)			->       Optional[Any]:
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
  
  
  
      @property
      def _a       (							self			:    Union[str, Any]			)			->       Any:
             __UpperCAmelCase    							=1
             __UpperCAmelCase    							=3
             __UpperCAmelCase    							=(32, 32)
  
             __UpperCAmelCase    							=floats_tensor((batch_size, num_channels) + sizes   ,    rng=random.Random(0			)			).to(lowercase_			)
             return image
  
  
  
      @property
      def _a       (							self			:    List[Any]			)			->       Optional[int]:
             torch.manual_seed(0			)
             __UpperCAmelCase    							=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 _a       (							self			:    Tuple			)			->       Optional[Any]:
             torch.manual_seed(0			)
             __UpperCAmelCase    							=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 _a       (							self			:    str			)			->       Optional[int]:
             torch.manual_seed(0			)
             __UpperCAmelCase    							=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 _a       (							self			:    Tuple			)			->       Optional[Any]:
  
  
  
  
  
  
             def extract(*__SCREAMING_SNAKE_CASE			:    Any   ,    **__SCREAMING_SNAKE_CASE			:    Tuple			):
  
  
  
                    class 							_A :
                        """simple docstring"""
  
                        def __init__(							self			:    List[Any]			)			->       Union[str, Any]:
                               __UpperCAmelCase    							=torch.ones([0]			)
  
  
  
                        def _a       (							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Tuple			)			->       Any:
                               self.pixel_values.to(lowercase_			)
                               return self
  
  
  
  
                    return Out()
  
             return extract
  
  
  
      def _a       (							self			:    Tuple			)			->       int:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.dummy_cond_unet
             __UpperCAmelCase    							=DDIMScheduler(
                 beta_start=0.00_085   ,    beta_end=0.012   ,    beta_schedule="""scaled_linear"""   ,    clip_sample=lowercase_   ,    set_alpha_to_one=lowercase_   ,    )
  
             __UpperCAmelCase    							=self.dummy_vae
             __UpperCAmelCase    							=self.dummy_text_encoder
             __UpperCAmelCase    							=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
             # make sure here that pndm scheduler skips prk
             __UpperCAmelCase    							=StableDiffusionPipeline(
                 unet=lowercase_   ,    scheduler=lowercase_   ,    vae=lowercase_   ,    text_encoder=lowercase_   ,    tokenizer=lowercase_   ,    safety_checker=lowercase_   ,    feature_extractor=self.dummy_extractor   ,    )
             __UpperCAmelCase    							=sd_pipe.to(lowercase_			)
             sd_pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""A painting of a squirrel eating a burger"""
  
             __UpperCAmelCase    							=torch.Generator(device=lowercase_			).manual_seed(0			)
             __UpperCAmelCase    							=sd_pipe([prompt]   ,    generator=lowercase_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type="""np"""			)
             __UpperCAmelCase    							=output.images
  
             __UpperCAmelCase    							=torch.Generator(device=lowercase_			).manual_seed(0			)
             __UpperCAmelCase    							=sd_pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type="""np"""   ,    return_dict=lowercase_   ,    )[0]
  
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=image_from_tuple[0, -3:, -3:, -1]
  
             assert image.shape == (1, 64, 64, 3)
             __UpperCAmelCase    							=np.array([0.5_753, 0.6_114, 0.5_001, 0.5_034, 0.5_470, 0.4_729, 0.4_971, 0.4_867, 0.4_867]			)
  
             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 _a       (							self			:    str			)			->       Optional[Any]:
             __UpperCAmelCase    							="""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __UpperCAmelCase    							=self.dummy_cond_unet
             __UpperCAmelCase    							=PNDMScheduler(skip_prk_steps=lowercase_			)
             __UpperCAmelCase    							=self.dummy_vae
             __UpperCAmelCase    							=self.dummy_text_encoder
             __UpperCAmelCase    							=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
             # make sure here that pndm scheduler skips prk
             __UpperCAmelCase    							=StableDiffusionPipeline(
                 unet=lowercase_   ,    scheduler=lowercase_   ,    vae=lowercase_   ,    text_encoder=lowercase_   ,    tokenizer=lowercase_   ,    safety_checker=lowercase_   ,    feature_extractor=self.dummy_extractor   ,    )
             __UpperCAmelCase    							=sd_pipe.to(lowercase_			)
             sd_pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""A painting of a squirrel eating a burger"""
             __UpperCAmelCase    							=torch.Generator(device=lowercase_			).manual_seed(0			)
             __UpperCAmelCase    							=sd_pipe([prompt]   ,    generator=lowercase_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type="""np"""			)
  
             __UpperCAmelCase    							=output.images
  
             __UpperCAmelCase    							=torch.Generator(device=lowercase_			).manual_seed(0			)
             __UpperCAmelCase    							=sd_pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type="""np"""   ,    return_dict=lowercase_   ,    )[0]
  
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=image_from_tuple[0, -3:, -3:, -1]
  
             assert image.shape == (1, 64, 64, 3)
             __UpperCAmelCase    							=np.array([0.5_122, 0.5_712, 0.4_825, 0.5_053, 0.5_646, 0.4_769, 0.5_179, 0.4_894, 0.4_994]			)
  
             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 _a       (							self			:    Union[str, Any]			)			->       int:
             __UpperCAmelCase    							=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
  
             __UpperCAmelCase    							=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_			)
                    __UpperCAmelCase    							=StableDiffusionPipeline.from_pretrained(lowercase_			)
  
             # sanity check that the pipeline still works
             assert pipe.safety_checker is None
             __UpperCAmelCase    							=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 _a       (							self			:    str			)			->       List[str]:
             __UpperCAmelCase    							=self.dummy_cond_unet
             __UpperCAmelCase    							=PNDMScheduler(skip_prk_steps=lowercase_			)
             __UpperCAmelCase    							=self.dummy_vae
             __UpperCAmelCase    							=self.dummy_text_encoder
             __UpperCAmelCase    							=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
             # put models in fp16
             __UpperCAmelCase    							=unet.half()
             __UpperCAmelCase    							=vae.half()
             __UpperCAmelCase    							=bert.half()
  
             # make sure here that pndm scheduler skips prk
             __UpperCAmelCase    							=StableDiffusionPipeline(
                 unet=lowercase_   ,    scheduler=lowercase_   ,    vae=lowercase_   ,    text_encoder=lowercase_   ,    tokenizer=lowercase_   ,    safety_checker=lowercase_   ,    feature_extractor=self.dummy_extractor   ,    )
             __UpperCAmelCase    							=sd_pipe.to(lowercase_			)
             sd_pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""A painting of a squirrel eating a burger"""
             __UpperCAmelCase    							=sd_pipe([prompt]   ,    num_inference_steps=2   ,    output_type="""np"""			).images
  
             assert image.shape == (1, 64, 64, 3)
  
  
  
  
  @nightly
  @require_torch_gpu
  class 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      def _a       (							self			:    List[Any]			)			->       Dict:
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[str]:
             __UpperCAmelCase    							="""cuda"""
             __UpperCAmelCase    							=StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
             __UpperCAmelCase    							=pipe.to(lowercase_			)
             pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""a photo of a cat"""
             __UpperCAmelCase    							={
                 """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,
             }
  
             __UpperCAmelCase    							=3
             __UpperCAmelCase    							=7
  
             # no sega enabled
             __UpperCAmelCase    							=torch.Generator(lowercase_			)
             generator.manual_seed(lowercase_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.34_673_113,
                 0.38_492_733,
                 0.37_597_352,
                 0.34_086_335,
                 0.35_650_748,
                 0.35_579_205,
                 0.3_384_763,
                 0.34_340_236,
                 0.3_573_271,
             ]
  
             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_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    **lowercase_   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.41_887_826,
                 0.37_728_766,
                 0.30_138_272,
                 0.41_416_335,
                 0.41_664_985,
                 0.36_283_392,
                 0.36_191_246,
                 0.43_364_465,
                 0.43_001_732,
             ]
  
             assert image.shape == (1, 512, 512, 3)
  
             assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
  
  
  
      def _a       (							self			:    Tuple			)			->       Tuple:
             __UpperCAmelCase    							="""cuda"""
             __UpperCAmelCase    							=StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
             __UpperCAmelCase    							=pipe.to(lowercase_			)
             pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""an image of a crowded boulevard, realistic, 4k"""
             __UpperCAmelCase    							={
                 """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,
             }
  
             __UpperCAmelCase    							=9
             __UpperCAmelCase    							=7
  
             # no sega enabled
             __UpperCAmelCase    							=torch.Generator(lowercase_			)
             generator.manual_seed(lowercase_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.43_497_998,
                 0.91_814_065,
                 0.7_540_739,
                 0.55_580_205,
                 0.8_467_265,
                 0.5_389_691,
                 0.62_574_506,
                 0.58_897_763,
                 0.50_926_757,
             ]
  
             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_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    **lowercase_   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.3_089_719,
                 0.30_500_144,
                 0.29_016_042,
                 0.30_630_964,
                 0.325_687,
                 0.29_419_225,
                 0.2_908_091,
                 0.28_723_598,
                 0.27_696_294,
             ]
  
             assert image.shape == (1, 512, 512, 3)
  
             assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
  
  
  
      def _a       (							self			:    List[str]			)			->       Tuple:
             __UpperCAmelCase    							="""cuda"""
             __UpperCAmelCase    							=StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
             __UpperCAmelCase    							=pipe.to(lowercase_			)
             pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""a castle next to a river"""
             __UpperCAmelCase    							={
                 """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,
             }
  
             __UpperCAmelCase    							=48
             __UpperCAmelCase    							=7
  
             # no sega enabled
             __UpperCAmelCase    							=torch.Generator(lowercase_			)
             generator.manual_seed(lowercase_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.75_163_555,
                 0.76_037_145,
                 0.61_785,
                 0.9_189_673,
                 0.8_627_701,
                 0.85_189_694,
                 0.8_512_813,
                 0.87_012_076,
                 0.8_312_857,
             ]
  
             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_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    **lowercase_   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.73_553_365,
                 0.7_537_271,
                 0.74_341_905,
                 0.66_480_356,
                 0.6_472_925,
                 0.63_039_416,
                 0.64_812_905,
                 0.6_749_717,
                 0.6_517_102,
             ]
  
             assert image.shape == (1, 512, 512, 3)
  
             assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[str]:
             __UpperCAmelCase    							="""cuda"""
             __UpperCAmelCase    							=StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""   ,    torch_dtype=torch.floataa			)
             __UpperCAmelCase    							=pipe.to(lowercase_			)
             pipe.set_progress_bar_config(disable=lowercase_			)
  
             __UpperCAmelCase    							="""a photo of a cat"""
             __UpperCAmelCase    							={
                 """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,
             }
  
             __UpperCAmelCase    							=3
             __UpperCAmelCase    							=7
  
             # no sega enabled
             __UpperCAmelCase    							=torch.Generator(lowercase_			)
             generator.manual_seed(lowercase_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.34_887_695,
                 0.3_876_953,
                 0.375,
                 0.34_423_828,
                 0.3_581_543,
                 0.35_717_773,
                 0.3_383_789,
                 0.34_570_312,
                 0.359_375,
             ]
  
             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_			)
             __UpperCAmelCase    							=pipe(
                 [prompt]   ,    generator=lowercase_   ,    guidance_scale=lowercase_   ,    num_inference_steps=50   ,    output_type="""np"""   ,    width=512   ,    height=512   ,    **lowercase_   ,    )
  
             __UpperCAmelCase    							=output.images
             __UpperCAmelCase    							=image[0, -3:, -3:, -1]
             __UpperCAmelCase    							=[
                 0.42_285_156,
                 0.36_914_062,
                 0.29_077_148,
                 0.42_041_016,
                 0.41_918_945,
                 0.35_498_047,
                 0.3_618_164,
                 0.4_423_828,
                 0.43_115_234,
             ]
  
             assert image.shape == (1, 512, 512, 3)
  
             assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from collections import defaultdict
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	int = 5		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=defaultdict(A_		)
         __UpperCAmelCase    							=0
  
         while True:
                __UpperCAmelCase    							=get_digits(A_		)
                freqs[digits].append(A_		)
  
                if len(freqs[digits]		) == max_base:
                       __UpperCAmelCase    							=freqs[digits][0] ** 3
                       return base
  
                num += 1
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	int		)  ->							str:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         return "".join(sorted(str(num**3		)		)		)
  
  
  if __name__ == "__main__":
     print(F"""{solution() = }""")
  
  
  
  
  