



"""simple docstring"""







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







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  List[str]						)					->		List[Any]:






				"""simple docstring"""



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







		def 					UpperCAmelCase    (	self						:  Any						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    int				=			StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''						)
				lowercase__   :    List[Any]				=			sd_pipe.to(_snake_case						)
				sd_pipe.set_progress_bar_config(disable=_snake_case						)

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

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

				lowercase__   :    Dict				=			output.images

				lowercase__   :    Optional[int]				=			image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				lowercase__   :    Union[str, Any]				=			np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]						)

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







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		str:






				"""simple docstring"""



				lowercase__   :    str				=			StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''						)
				lowercase__   :    Any				=			sd_pipe.to(_snake_case						)
				sd_pipe.set_progress_bar_config(disable=_snake_case						)

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

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

				lowercase__   :    Optional[Any]				=			output.images

				lowercase__   :    int				=			image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				lowercase__   :    Tuple				=			np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]						)

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







		def 					UpperCAmelCase    (	self						:  Any						)					->		int:






				"""simple docstring"""



				lowercase__   :    Dict				=			StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''						)
				lowercase__   :    Dict				=			sd_pipe.to(_snake_case						)
				sd_pipe.set_progress_bar_config(disable=_snake_case						)

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

				lowercase__   :    str				=			'''A painting of a squirrel eating a burger'''
				lowercase__   :    Any				=			torch.manual_seed(0						)
				lowercase__   :    List[Any]				=			sd_pipe(
				    [prompt]			,generator=_snake_case			,guidance_scale=7.5			,num_inference_steps=15			,output_type='''np'''			,use_karras_sigmas=_snake_case			,)

				lowercase__   :    List[str]				=			output.images

				lowercase__   :    str				=			image[0, -3:, -3:, -1]

				assert image.shape == (1, 512, 512, 3)
				lowercase__   :    Optional[Any]				=			np.array(
				    [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]						)

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







"""simple docstring"""





def 			UpperCAmelCase__							(  SCREAMING_SNAKE_CASE     :						int							,						SCREAMING_SNAKE_CASE     :						int			):







      '''simple docstring'''




      while b:
            lowerCAmelCase						,		lowerCAmelCase  						=       b, a % b
      return a


def 			UpperCAmelCase__							(  SCREAMING_SNAKE_CASE     :						int							,						SCREAMING_SNAKE_CASE     :						int			):







      '''simple docstring'''




      return a if b == 0 else euclidean_gcd_recursive(SCREAMING_SNAKE_CASE							,						a % b			)


def 			UpperCAmelCase__							(  ):







      '''simple docstring'''




      print(F'euclidean_gcd(3, 5) = {euclidean_gcd(3							,						5			)}'			)
      print(F'euclidean_gcd(5, 3) = {euclidean_gcd(5							,						3			)}'			)
      print(F'euclidean_gcd(1, 3) = {euclidean_gcd(1							,						3			)}'			)
      print(F'euclidean_gcd(3, 6) = {euclidean_gcd(3							,						6			)}'			)
      print(F'euclidean_gcd(6, 3) = {euclidean_gcd(6							,						3			)}'			)

      print(F'euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3							,						5			)}'			)
      print(F'euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5							,						3			)}'			)
      print(F'euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1							,						3			)}'			)
      print(F'euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3							,						6			)}'			)
      print(F'euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6							,						3			)}'			)


if __name__ == "__main__":
       main()






