

'''simple docstring'''

import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
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 	A_			(    _snake_case	,       unittest.TestCase							):






     '''simple docstring'''



     UpperCAmelCase_						:     Any  		=  """hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""


     def        UpperCAmelCase_	(		self			:					int					,      lowercase_			:					int=0	)						->     Dict:
      UpperCAmelCase	:     List[Any]						 =			floats_tensor((1, 3, 128, 128)					,      rng=random.Random(lowercase_	)	)
      UpperCAmelCase	:     Any						 =			np.random.RandomState(lowercase_	)
      UpperCAmelCase	:     Tuple						 =			{
          'prompt': 'A painting of a squirrel eating a burger',
          'image': image,
          'generator': generator,
          'num_inference_steps': 3,
          'strength': 0.75,
          'guidance_scale': 7.5,
          'output_type': 'numpy',
      }
      return inputs


     def        UpperCAmelCase_	(		self			:					Dict	)						->     Any:
      UpperCAmelCase	:     List[str]						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     int						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Any						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     int						 =			image[0, -3:, -3:, -1].flatten()

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     int						 =			np.array([0.6_9643, 0.5_8484, 0.5_0314, 0.5_8760, 0.5_5368, 0.5_9643, 0.5_1529, 0.4_1217, 0.4_9087]	)
      assert np.abs(image_slice - expected_slice	).max() < 1E-1


     def        UpperCAmelCase_	(		self			:					Optional[Any]	)						->     List[Any]:
      UpperCAmelCase	:     List[Any]						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      UpperCAmelCase	:     Dict						 =			PNDMScheduler.from_config(pipe.scheduler.config					,      skip_prk_steps=lowercase_	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     Union[str, Any]						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Optional[Any]						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     List[Any]						 =			image[0, -3:, -3:, -1]

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     Union[str, Any]						 =			np.array([0.6_1737, 0.5_4642, 0.5_3183, 0.5_4465, 0.5_2742, 0.6_0525, 0.4_9969, 0.4_0655, 0.4_8154]	)

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


     def        UpperCAmelCase_	(		self			:					Optional[int]	)						->     str:
      UpperCAmelCase	:     List[str]						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      UpperCAmelCase	:     Any						 =			LMSDiscreteScheduler.from_config(pipe.scheduler.config	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      # warmup pass to apply optimizations
      UpperCAmelCase	:     Dict						 =			pipe(**self.get_dummy_inputs()	)

      UpperCAmelCase	:     List[str]						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Optional[int]						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     Union[str, Any]						 =			image[0, -3:, -3:, -1]

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     List[str]						 =			np.array([0.5_2761, 0.5_9977, 0.4_9033, 0.4_9619, 0.5_4282, 0.5_0311, 0.4_7600, 0.4_0918, 0.4_5203]	)

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


     def        UpperCAmelCase_	(		self			:					Dict	)						->     Any:
      UpperCAmelCase	:     Union[str, Any]						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      UpperCAmelCase	:     Union[str, Any]						 =			EulerDiscreteScheduler.from_config(pipe.scheduler.config	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     List[Any]						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Optional[int]						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     str						 =			image[0, -3:, -3:, -1]

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     str						 =			np.array([0.5_2911, 0.6_0004, 0.4_9229, 0.4_9805, 0.5_4502, 0.5_0680, 0.4_7777, 0.4_1028, 0.4_5304]	)

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


     def        UpperCAmelCase_	(		self			:					int	)						->     List[Any]:
      UpperCAmelCase	:     Optional[Any]						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      UpperCAmelCase	:     int						 =			EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     str						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Union[str, Any]						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     int						 =			image[0, -3:, -3:, -1]

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     int						 =			np.array([0.5_2911, 0.6_0004, 0.4_9229, 0.4_9805, 0.5_4502, 0.5_0680, 0.4_7777, 0.4_1028, 0.4_5304]	)

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




     def        UpperCAmelCase_	(		self			:					Optional[int]	)						->     List[Any]:
      UpperCAmelCase	:     str						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint					,      provider='CPUExecutionProvider'	)
      UpperCAmelCase	:     Dict						 =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config	)
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     Union[str, Any]						 =			self.get_dummy_inputs()
      UpperCAmelCase	:     Dict						 =			pipe(**lowercase_	).images
      UpperCAmelCase	:     Union[str, Any]						 =			image[0, -3:, -3:, -1]

      assert image.shape == (1, 128, 128, 3)
      UpperCAmelCase	:     str						 =			np.array([0.6_5331, 0.5_8277, 0.4_8204, 0.5_6059, 0.5_3665, 0.5_6235, 0.5_0969, 0.4_0009, 0.4_6552]	)

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




@nightly
@require_onnxruntime
@require_torch_gpu
class 	A_			(    unittest.TestCase							):






     '''simple docstring'''



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


     @property
     def        UpperCAmelCase_	(		self			:					Dict	)						->     List[str]:
      UpperCAmelCase	:     Optional[int]						 =			ort.SessionOptions()
      UpperCAmelCase	:     Tuple						 =			False
      return options


     def        UpperCAmelCase_	(		self			:					int	)						->     Optional[int]:
      UpperCAmelCase	:     int						 =			load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/img2img/sketch-mountains-input.jpg'	)
      UpperCAmelCase	:     str						 =			init_image.resize((768, 512)	)
      # using the PNDM scheduler by default
      UpperCAmelCase	:     str						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(
          'CompVis/stable-diffusion-v1-4'					,      revision='onnx'					,      safety_checker=lowercase_					,      feature_extractor=lowercase_					,      provider=self.gpu_provider					,      sess_options=self.gpu_options					,      )
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     Tuple						 =			'A fantasy landscape, trending on artstation'

      UpperCAmelCase	:     Any						 =			np.random.RandomState(0	)
      UpperCAmelCase	:     Tuple						 =			pipe(
          prompt=lowercase_					,      image=lowercase_					,      strength=0.75					,      guidance_scale=7.5					,      num_inference_steps=10					,      generator=lowercase_					,      output_type='np'					,      )
      UpperCAmelCase	:     List[str]						 =			output.images
      UpperCAmelCase	:     Tuple						 =			images[0, 255:258, 383:386, -1]

      assert images.shape == (1, 512, 768, 3)
      UpperCAmelCase	:     int						 =			np.array([0.4909, 0.5059, 0.5372, 0.4623, 0.4876, 0.5049, 0.4820, 0.4956, 0.5019]	)
      # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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




     def        UpperCAmelCase_	(		self			:					Dict	)						->     Dict:
      UpperCAmelCase	:     int						 =			load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/img2img/sketch-mountains-input.jpg'	)
      UpperCAmelCase	:     List[Any]						 =			init_image.resize((768, 512)	)
      UpperCAmelCase	:     int						 =			LMSDiscreteScheduler.from_pretrained(
          'runwayml/stable-diffusion-v1-5'					,      subfolder='scheduler'					,      revision='onnx'	)
      UpperCAmelCase	:     int						 =			OnnxStableDiffusionImgaImgPipeline.from_pretrained(
          'runwayml/stable-diffusion-v1-5'					,      revision='onnx'					,      scheduler=lowercase_					,      safety_checker=lowercase_					,      feature_extractor=lowercase_					,      provider=self.gpu_provider					,      sess_options=self.gpu_options					,      )
      pipe.set_progress_bar_config(disable=lowercase_	)

      UpperCAmelCase	:     Any						 =			'A fantasy landscape, trending on artstation'

      UpperCAmelCase	:     str						 =			np.random.RandomState(0	)
      UpperCAmelCase	:     Any						 =			pipe(
          prompt=lowercase_					,      image=lowercase_					,      strength=0.75					,      guidance_scale=7.5					,      num_inference_steps=20					,      generator=lowercase_					,      output_type='np'					,      )
      UpperCAmelCase	:     Optional[Any]						 =			output.images
      UpperCAmelCase	:     List[str]						 =			images[0, 255:258, 383:386, -1]

      assert images.shape == (1, 512, 768, 3)
      UpperCAmelCase	:     List[str]						 =			np.array([0.8043, 0.926, 0.9581, 0.8119, 0.8954, 0.913, 0.7209, 0.7463, 0.7431]	)
      # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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







'''simple docstring'''

from __future__ import annotations




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 if len(UpperCAmelCase_     ) == 0:
  raise ValueError('find_max() arg is an empty sequence'     )
 if (
     left >= len(UpperCAmelCase_     )
     or left < -len(UpperCAmelCase_     )
     or right >= len(UpperCAmelCase_     )
     or right < -len(UpperCAmelCase_     )
 ):
  raise IndexError('list index out of range'     )
 if left == right:
  return nums[left]
 UpperCAmelCase	:     Optional[int]						 =			(left + right) >> 1  # the middle
 UpperCAmelCase	:     Any						 =			find_max(UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     )  # find max in range[left, mid]
 UpperCAmelCase	:     Union[str, Any]						 =			find_max(UpperCAmelCase_  ,	mid + 1  ,	UpperCAmelCase_     )  # find max in range[mid + 1, right]

 return left_max if left_max >= right_max else right_max


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)




