



'''simple docstring'''





import unittest

import numpy as np

from diffusers import LMSDiscreteScheduler, OnnxStableDiffusionInpaintPipeline
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
       import onnxruntime as ort







class     UpperCAmelCase_       (       _a		,		unittest.TestCase	):
    """simple docstring"""







    pass







@nightly
@require_onnxruntime
@require_torch_gpu
class     UpperCAmelCase_       (       unittest.TestCase	):
    """simple docstring"""







    @property
    def lowerCamelCase       (    self					:     List[Any]						):
          return (
              "CUDAExecutionProvider",
              {
                  "gpu_mem_limit": "15000000000",  # 15GB
                  "arena_extend_strategy": "kSameAsRequested",
              },
          )




    @property
    def lowerCamelCase       (    self					:     List[str]						):
          snake_case__  :    List[Any]    						=      ort.SessionOptions()
          snake_case__  :    List[Any]    						=      False
          return options




    def lowerCamelCase       (    self					:     str						):
          snake_case__  :    Any    						=      load_image(
              """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
              """/in_paint/overture-creations-5sI6fQgYIuo.png"""						)
          snake_case__  :    Any    						=      load_image(
              """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
              """/in_paint/overture-creations-5sI6fQgYIuo_mask.png"""						)
          snake_case__  :    Optional[Any]    						=      OnnxStableDiffusionInpaintPipeline.from_pretrained(
              """runwayml/stable-diffusion-inpainting""" ,     revision="""onnx""" ,     safety_checker=snake_case_ ,     feature_extractor=snake_case_ ,     provider=self.gpu_provider ,     sess_options=self.gpu_options ,     )
          pipe.set_progress_bar_config(disable=snake_case_						)

          snake_case__  :    List[Any]    						=      """A red cat sitting on a park bench"""

          snake_case__  :    Optional[Any]    						=      np.random.RandomState(0						)
          snake_case__  :    Optional[int]    						=      pipe(
              prompt=snake_case_ ,     image=snake_case_ ,     mask_image=snake_case_ ,     guidance_scale=7.5 ,     num_inference_steps=10 ,     generator=snake_case_ ,     output_type="""np""" ,     )
          snake_case__  :    Optional[Any]    						=      output.images
          snake_case__  :    Dict    						=      images[0, 255:258, 255:258, -1]

          assert images.shape == (1, 512, 512, 3)
          snake_case__  :    Optional[int]    						=      np.array([0.2514, 0.3007, 0.3517, 0.1790, 0.2382, 0.3167, 0.1944, 0.2273, 0.2464]						)

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




    def lowerCamelCase       (    self					:     List[str]						):
          snake_case__  :    int    						=      load_image(
              """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
              """/in_paint/overture-creations-5sI6fQgYIuo.png"""						)
          snake_case__  :    Optional[Any]    						=      load_image(
              """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
              """/in_paint/overture-creations-5sI6fQgYIuo_mask.png"""						)
          snake_case__  :    Tuple    						=      LMSDiscreteScheduler.from_pretrained(
              """runwayml/stable-diffusion-inpainting""" ,     subfolder="""scheduler""" ,     revision="""onnx"""						)
          snake_case__  :    Optional[int]    						=      OnnxStableDiffusionInpaintPipeline.from_pretrained(
              """runwayml/stable-diffusion-inpainting""" ,     revision="""onnx""" ,     scheduler=snake_case_ ,     safety_checker=snake_case_ ,     feature_extractor=snake_case_ ,     provider=self.gpu_provider ,     sess_options=self.gpu_options ,     )
          pipe.set_progress_bar_config(disable=snake_case_						)

          snake_case__  :    List[Any]    						=      """A red cat sitting on a park bench"""

          snake_case__  :    Optional[int]    						=      np.random.RandomState(0						)
          snake_case__  :    Optional[int]    						=      pipe(
              prompt=snake_case_ ,     image=snake_case_ ,     mask_image=snake_case_ ,     guidance_scale=7.5 ,     num_inference_steps=20 ,     generator=snake_case_ ,     output_type="""np""" ,     )
          snake_case__  :    Tuple    						=      output.images
          snake_case__  :    Optional[int]    						=      images[0, 255:258, 255:258, -1]

          assert images.shape == (1, 512, 512, 3)
          snake_case__  :    Union[str, Any]    						=      np.array([0.0086, 0.0077, 0.0083, 0.0093, 0.0107, 0.0139, 0.0094, 0.0097, 0.0125]						)

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




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






		'''simple docstring'''

		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Tuple						=				StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''					)
			__snake_case	:						List[str]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

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

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

			__snake_case	:						List[str]						=				output.images

			__snake_case	:						Tuple						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						Dict						=				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 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[Any]						=				StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''					)
			__snake_case	:						Union[str, Any]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

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

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

			__snake_case	:						Any						=				output.images

			__snake_case	:						Tuple						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						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 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''					)
			__snake_case	:						Union[str, Any]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

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

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

			__snake_case	:						Optional[int]						=				output.images

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

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						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





