


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












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() = }""")




