import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


@slow
@require_torch_gpu
class 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Union[str, Any]:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :Dict			  =		StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4''')
        __UpperCamelCase     :List[Any]			  =		sd_pipe.to(__lowercase)
        sd_pipe.set_progress_bar_config(disable=__lowercase)

        sd_pipe.set_scheduler('''sample_euler''')

        __UpperCamelCase     :Tuple			  =		'''A painting of a squirrel eating a burger'''
        __UpperCamelCase     :Union[str, Any]			  =		torch.manual_seed(0)
        __UpperCamelCase     :List[str]			  =		sd_pipe([prompt] , generator=__lowercase , guidance_scale=9.0 , num_inference_steps=20 , output_type='''np''')

        __UpperCamelCase     :str			  =		output.images

        __UpperCamelCase     :List[Any]			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCamelCase     :Optional[int]			  =		np.array([0.04_47, 0.04_92, 0.04_68, 0.04_08, 0.03_83, 0.04_08, 0.03_54, 0.03_80, 0.03_39])

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







    def 			UpperCamelCase__   (	self)       ->	str:
        __UpperCamelCase     :Union[str, Any]			  =		StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''')
        __UpperCamelCase     :Optional[Any]			  =		sd_pipe.to(__lowercase)
        sd_pipe.set_progress_bar_config(disable=__lowercase)

        sd_pipe.set_scheduler('''sample_euler''')

        __UpperCamelCase     :Tuple			  =		'''A painting of a squirrel eating a burger'''
        __UpperCamelCase     :List[str]			  =		torch.manual_seed(0)
        __UpperCamelCase     :List[Any]			  =		sd_pipe([prompt] , generator=__lowercase , guidance_scale=9.0 , num_inference_steps=20 , output_type='''np''')

        __UpperCamelCase     :int			  =		output.images

        __UpperCamelCase     :Dict			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCamelCase     :str			  =		np.array([0.12_37, 0.13_20, 0.14_38, 0.13_59, 0.13_90, 0.11_32, 0.12_77, 0.11_75, 0.11_12])

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







    def 			UpperCamelCase__   (	self)       ->	Tuple:
        __UpperCamelCase     :Union[str, Any]			  =		StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''')
        __UpperCamelCase     :str			  =		sd_pipe.to(__lowercase)
        sd_pipe.set_progress_bar_config(disable=__lowercase)

        sd_pipe.set_scheduler('''sample_dpmpp_2m''')

        __UpperCamelCase     :Optional[int]			  =		'''A painting of a squirrel eating a burger'''
        __UpperCamelCase     :str			  =		torch.manual_seed(0)
        __UpperCamelCase     :Union[str, Any]			  =		sd_pipe(
            [prompt] , generator=__lowercase , guidance_scale=7.5 , num_inference_steps=15 , output_type='''np''' , use_karras_sigmas=__lowercase , )

        __UpperCamelCase     :List[str]			  =		output.images

        __UpperCamelCase     :Union[str, Any]			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCamelCase     :Tuple			  =		np.array(
            [0.11_38_16_89, 0.12_11_29_21, 0.1_38_94_57, 0.12_54_96_06, 0.1_24_49_64, 0.10_83_15_17, 0.11_56_28_66, 0.10_86_78_16, 0.10_49_90_48])

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






def lowerCamelCase  (   SCREAMING_SNAKE_CASE = 1  ,			SCREAMING_SNAKE_CASE = 1_000	):
    '''simple docstring'''







    __UpperCamelCase     :Union[str, Any]			  =		1
    __UpperCamelCase     :Any			  =		0

    for divide_by_number in range(SCREAMING_SNAKE_CASE  ,			digit + 1	):
        __UpperCamelCase     :list[int]			  =		[]
        __UpperCamelCase     :Optional[int]			  =		numerator
        for _ in range(1  ,			digit + 1	):
            if now_divide in has_been_divided:
                if longest_list_length < len(SCREAMING_SNAKE_CASE	):
                    __UpperCamelCase     :Optional[Any]			  =		len(SCREAMING_SNAKE_CASE	)
                    __UpperCamelCase     :int			  =		divide_by_number
            else:
                has_been_divided.append(SCREAMING_SNAKE_CASE	)
                __UpperCamelCase     :Any			  =		now_divide * 10 % divide_by_number

    return the_digit


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()





