





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 				__snake_case  (     unittest.TestCase						):


    '''simple docstring'''







    def    lowercase_				(					self    ):





        '''simple docstring'''

        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()



    @property
    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= 1
        SCREAMING_SNAKE_CASE__       							= 3
        SCREAMING_SNAKE_CASE__       							= (32, 32)

        SCREAMING_SNAKE_CASE__       							= floats_tensor((batch_size, num_channels) + sizes      ,							rng=random.Random(0    )    ).to(A_    )
        return image



    @property
    def    lowercase_				(					self    ):





        '''simple docstring'''

        torch.manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= 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    lowercase_				(					self    ):





        '''simple docstring'''

        torch.manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= 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    lowercase_				(					self    ):





        '''simple docstring'''

        torch.manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= 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=10_00      ,							)
        return CLIPTextModel(A_    )



    @property
    def    lowercase_				(					self    ):





        '''simple docstring'''

        def extract(*A_      ,							**A_    ):



            class 				__snake_case  :


                '''simple docstring'''







                def __init__(					self    ):





                    '''simple docstring'''

                    SCREAMING_SNAKE_CASE__       							= torch.ones([0]    )




                def    lowercase_				(					self      ,							A_    ):





                    '''simple docstring'''

                    self.pixel_values.to(A_    )
                    return self





            return Out()

        return extract



    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        SCREAMING_SNAKE_CASE__       							= self.dummy_cond_unet
        SCREAMING_SNAKE_CASE__       							= DDIMScheduler(
            beta_start=0.00085      ,							beta_end=0.012      ,							beta_schedule='''scaled_linear'''      ,							clip_sample=A_      ,							set_alpha_to_one=A_      ,							)

        SCREAMING_SNAKE_CASE__       							= self.dummy_vae
        SCREAMING_SNAKE_CASE__       							= self.dummy_text_encoder
        SCREAMING_SNAKE_CASE__       							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

        # make sure here that pndm scheduler skips prk
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline(
            unet=A_      ,							scheduler=A_      ,							vae=A_      ,							text_encoder=A_      ,							tokenizer=A_      ,							safety_checker=A_      ,							feature_extractor=self.dummy_extractor      ,							)
        SCREAMING_SNAKE_CASE__       							= sd_pipe.to(A_    )
        sd_pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''A painting of a squirrel eating a burger'''

        SCREAMING_SNAKE_CASE__       							= torch.Generator(device=A_    ).manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= sd_pipe([prompt]      ,							generator=A_      ,							guidance_scale=6.0      ,							num_inference_steps=2      ,							output_type='''np'''    )
        SCREAMING_SNAKE_CASE__       							= output.images

        SCREAMING_SNAKE_CASE__       							= torch.Generator(device=A_    ).manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= sd_pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=6.0      ,							num_inference_steps=2      ,							output_type='''np'''      ,							return_dict=A_      ,							)[0]

        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        SCREAMING_SNAKE_CASE__       							= 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    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        SCREAMING_SNAKE_CASE__       							= self.dummy_cond_unet
        SCREAMING_SNAKE_CASE__       							= PNDMScheduler(skip_prk_steps=A_    )
        SCREAMING_SNAKE_CASE__       							= self.dummy_vae
        SCREAMING_SNAKE_CASE__       							= self.dummy_text_encoder
        SCREAMING_SNAKE_CASE__       							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

        # make sure here that pndm scheduler skips prk
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline(
            unet=A_      ,							scheduler=A_      ,							vae=A_      ,							text_encoder=A_      ,							tokenizer=A_      ,							safety_checker=A_      ,							feature_extractor=self.dummy_extractor      ,							)
        SCREAMING_SNAKE_CASE__       							= sd_pipe.to(A_    )
        sd_pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''A painting of a squirrel eating a burger'''
        SCREAMING_SNAKE_CASE__       							= torch.Generator(device=A_    ).manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= sd_pipe([prompt]      ,							generator=A_      ,							guidance_scale=6.0      ,							num_inference_steps=2      ,							output_type='''np'''    )

        SCREAMING_SNAKE_CASE__       							= output.images

        SCREAMING_SNAKE_CASE__       							= torch.Generator(device=A_    ).manual_seed(0    )
        SCREAMING_SNAKE_CASE__       							= sd_pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=6.0      ,							num_inference_steps=2      ,							output_type='''np'''      ,							return_dict=A_      ,							)[0]

        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        SCREAMING_SNAKE_CASE__       							= 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    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained(
            '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''      ,							safety_checker=A_    )
        assert isinstance(A_      ,							A_    )
        assert isinstance(pipe.scheduler      ,							A_    )
        assert pipe.safety_checker is None

        SCREAMING_SNAKE_CASE__       							= 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(A_    )
            SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained(A_    )

        # sanity check that the pipeline still works
        assert pipe.safety_checker is None
        SCREAMING_SNAKE_CASE__       							= 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    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= self.dummy_cond_unet
        SCREAMING_SNAKE_CASE__       							= PNDMScheduler(skip_prk_steps=A_    )
        SCREAMING_SNAKE_CASE__       							= self.dummy_vae
        SCREAMING_SNAKE_CASE__       							= self.dummy_text_encoder
        SCREAMING_SNAKE_CASE__       							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

        # put models in fp16
        SCREAMING_SNAKE_CASE__       							= unet.half()
        SCREAMING_SNAKE_CASE__       							= vae.half()
        SCREAMING_SNAKE_CASE__       							= bert.half()

        # make sure here that pndm scheduler skips prk
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline(
            unet=A_      ,							scheduler=A_      ,							vae=A_      ,							text_encoder=A_      ,							tokenizer=A_      ,							safety_checker=A_      ,							feature_extractor=self.dummy_extractor      ,							)
        SCREAMING_SNAKE_CASE__       							= sd_pipe.to(A_    )
        sd_pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''A painting of a squirrel eating a burger'''
        SCREAMING_SNAKE_CASE__       							= sd_pipe([prompt]      ,							num_inference_steps=2      ,							output_type='''np'''    ).images

        assert image.shape == (1, 64, 64, 3)





@nightly
@require_torch_gpu
class 				__snake_case  (     unittest.TestCase						):


    '''simple docstring'''







    def    lowercase_				(					self    ):





        '''simple docstring'''

        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()



    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cuda'''
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''    )
        SCREAMING_SNAKE_CASE__       							= pipe.to(A_    )
        pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''a photo of a cat'''
        SCREAMING_SNAKE_CASE__       							= {
            '''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,
        }

        SCREAMING_SNAKE_CASE__       							= 3
        SCREAMING_SNAKE_CASE__       							= 7

        # no sega enabled
        SCREAMING_SNAKE_CASE__       							= torch.Generator(A_    )
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.34673113,
            0.38492733,
            0.37597352,
            0.34086335,
            0.35650748,
            0.35579205,
            0.3384763,
            0.34340236,
            0.3573271,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2

        # with sega enabled
        # generator = torch.manual_seed(seed)
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							**A_      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.41887826,
            0.37728766,
            0.30138272,
            0.41416335,
            0.41664985,
            0.36283392,
            0.36191246,
            0.43364465,
            0.43001732,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2



    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cuda'''
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''    )
        SCREAMING_SNAKE_CASE__       							= pipe.to(A_    )
        pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''an image of a crowded boulevard, realistic, 4k'''
        SCREAMING_SNAKE_CASE__       							= {
            '''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,
        }

        SCREAMING_SNAKE_CASE__       							= 9
        SCREAMING_SNAKE_CASE__       							= 7

        # no sega enabled
        SCREAMING_SNAKE_CASE__       							= torch.Generator(A_    )
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.43497998,
            0.91814065,
            0.7540739,
            0.55580205,
            0.8467265,
            0.5389691,
            0.62574506,
            0.58897763,
            0.50926757,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2

        # with sega enabled
        # generator = torch.manual_seed(seed)
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							**A_      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.3089719,
            0.30500144,
            0.29016042,
            0.30630964,
            0.325687,
            0.29419225,
            0.2908091,
            0.28723598,
            0.27696294,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2



    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cuda'''
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''    )
        SCREAMING_SNAKE_CASE__       							= pipe.to(A_    )
        pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''a castle next to a river'''
        SCREAMING_SNAKE_CASE__       							= {
            '''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,
        }

        SCREAMING_SNAKE_CASE__       							= 48
        SCREAMING_SNAKE_CASE__       							= 7

        # no sega enabled
        SCREAMING_SNAKE_CASE__       							= torch.Generator(A_    )
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.75163555,
            0.76037145,
            0.61785,
            0.9189673,
            0.8627701,
            0.85189694,
            0.8512813,
            0.87012076,
            0.8312857,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2

        # with sega enabled
        # generator = torch.manual_seed(seed)
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							**A_      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.73553365,
            0.7537271,
            0.74341905,
            0.66480356,
            0.6472925,
            0.63039416,
            0.64812905,
            0.6749717,
            0.6517102,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2




    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= '''cuda'''
        SCREAMING_SNAKE_CASE__       							= StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''      ,							torch_dtype=torch.floataa    )
        SCREAMING_SNAKE_CASE__       							= pipe.to(A_    )
        pipe.set_progress_bar_config(disable=A_    )

        SCREAMING_SNAKE_CASE__       							= '''a photo of a cat'''
        SCREAMING_SNAKE_CASE__       							= {
            '''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,
        }

        SCREAMING_SNAKE_CASE__       							= 3
        SCREAMING_SNAKE_CASE__       							= 7

        # no sega enabled
        SCREAMING_SNAKE_CASE__       							= torch.Generator(A_    )
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.34887695,
            0.3876953,
            0.375,
            0.34423828,
            0.3581543,
            0.35717773,
            0.3383789,
            0.34570312,
            0.359375,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2

        # with sega enabled
        # generator = torch.manual_seed(seed)
        generator.manual_seed(A_    )
        SCREAMING_SNAKE_CASE__       							= pipe(
            [prompt]      ,							generator=A_      ,							guidance_scale=A_      ,							num_inference_steps=50      ,							output_type='''np'''      ,							width=5_12      ,							height=5_12      ,							**A_      ,							)

        SCREAMING_SNAKE_CASE__       							= output.images
        SCREAMING_SNAKE_CASE__       							= image[0, -3:, -3:, -1]
        SCREAMING_SNAKE_CASE__       							= [
            0.42285156,
            0.36914062,
            0.29077148,
            0.42041016,
            0.41918945,
            0.35498047,
            0.3618164,
            0.4423828,
            0.43115234,
        ]

        assert image.shape == (1, 5_12, 5_12, 3)

        assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2







from __future__ import annotations

from collections.abc import Generator


def        __snake_case       (						lowerCAmelCase_  )							->	Generator[int, None, None]:
    if not isinstance(lowerCAmelCase_   ,       lowerCAmelCase_  ) or n < 1:
        raise Exception('''Sequence only defined for positive integers'''  )

    yield n
    while n != 1:
        if n % 2 == 0:
            n //= 2
        else:
            SCREAMING_SNAKE_CASE__       							= 3 * n + 1
        yield n


def        __snake_case       (						)							->	str:
    SCREAMING_SNAKE_CASE__       							= 4_3
    SCREAMING_SNAKE_CASE__       							= tuple(collatz_sequence(lowerCAmelCase_  )  )
    print(lowerCAmelCase_  )
    print(f'''Collatz sequence from {n} took {len(lowerCAmelCase_  )} steps.'''  )


if __name__ == "__main__":
  main()
