




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






			'''simple docstring'''



			def 					A_    (  self  ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
			def 					A_    (  self  ):
							_lowerCamelCase     :			Tuple    =    StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'  )
							_lowerCamelCase     :			Any    =    sd_pipe.to(lowercase  )
							sd_pipe.set_progress_bar_config(disable=lowercase  )

							sd_pipe.set_scheduler('sample_euler'  )

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

							_lowerCamelCase     :			Union[str, Any]    =    output.images

							_lowerCamelCase     :			Any    =    image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							_lowerCamelCase     :			Dict    =    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 					A_    (  self  ):
							_lowerCamelCase     :			Any    =    StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'  )
							_lowerCamelCase     :			Any    =    sd_pipe.to(lowercase  )
							sd_pipe.set_progress_bar_config(disable=lowercase  )

							sd_pipe.set_scheduler('sample_euler'  )

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

							_lowerCamelCase     :			Optional[int]    =    output.images

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

							assert image.shape == (1, 512, 512, 3)
							_lowerCamelCase     :			List[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 					A_    (  self  ):
							_lowerCamelCase     :			Union[str, Any]    =    StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'  )
							_lowerCamelCase     :			int    =    sd_pipe.to(lowercase  )
							sd_pipe.set_progress_bar_config(disable=lowercase  )

							sd_pipe.set_scheduler('sample_dpmpp_2m'  )

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

							_lowerCamelCase     :			List[Any]    =    output.images

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

							assert image.shape == (1, 512, 512, 3)
							_lowerCamelCase     :			Any    =    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





"""simple docstring"""






lowercase__     						=						{
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
lowercase__     						=						{
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 12,
    """Pm""": 15,
    """Em""": 18,
    """Zm""": 21,
    """Ym""": 24,
}







def      _snake_case			(				lowercase__							,    lowercase__							,    lowercase__		):
				_lowerCamelCase     :			List[Any]    =    from_type.lower().strip('s'		)
				_lowerCamelCase     :			List[Any]    =    to_type.lower().strip('s'		)

				_lowerCamelCase     :			Optional[int]    =    UNIT_SYMBOL.get(lowercase__							,    lowercase__		)
				_lowerCamelCase     :			Any    =    UNIT_SYMBOL.get(lowercase__							,    lowercase__		)

				if from_sanitized not in METRIC_CONVERSION:
								_lowerCamelCase     :			Tuple    =    (
								    f'''Invalid \'from_type\' value: {from_type!r}.\n'''
								    f'''Conversion abbreviations are: {', '.join(lowercase__		)}'''
								)
								raise ValueError(lowercase__		)
				if to_sanitized not in METRIC_CONVERSION:
								_lowerCamelCase     :			Any    =    (
								    f'''Invalid \'to_type\' value: {to_type!r}.\n'''
								    f'''Conversion abbreviations are: {', '.join(lowercase__		)}'''
								)
								raise ValueError(lowercase__		)
				_lowerCamelCase     :			List[Any]    =    METRIC_CONVERSION[from_sanitized]
				_lowerCamelCase     :			int    =    METRIC_CONVERSION[to_sanitized]
				_lowerCamelCase     :			List[str]    =    1

				if from_exponent > to_exponent:
								_lowerCamelCase     :			List[str]    =    from_exponent - to_exponent
				else:
								_lowerCamelCase     :			List[Any]    =    -(to_exponent - from_exponent)

				return value * pow(10							,    lowercase__		)


if __name__ == "__main__":
			from doctest import testmod

			testmod()