

import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
					import onnxruntime as ort






class        A_		(       SCREAMING_SNAKE_CASE			,							unittest.TestCase				):
							_UpperCAmelCase    :  Tuple						      =      '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''
							def     lowerCAmelCase     (		self		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			str=0):
								__lowerCamelCase				:				Tuple					       = np.random.RandomState(SCREAMING_SNAKE_CASE__)
								__lowerCamelCase				:				Any					       = {
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs
							def     lowerCAmelCase     (		self		:			List[str]):
								__lowerCamelCase				:				Tuple					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Dict					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Tuple					       = pipe(**SCREAMING_SNAKE_CASE__).images
								__lowerCamelCase				:				Optional[Any]					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				Any					       = np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			Dict):
								__lowerCamelCase				:				List[str]					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								__lowerCamelCase				:				Optional[int]					       = PNDMScheduler.from_config(pipe.scheduler.config   ,skip_prk_steps=SCREAMING_SNAKE_CASE__)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Tuple					       = self.get_dummy_inputs()
								__lowerCamelCase				:				List[Any]					       = pipe(**SCREAMING_SNAKE_CASE__).images
								__lowerCamelCase				:				List[Any]					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				Union[str, Any]					       = np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			Tuple):
								__lowerCamelCase				:				int					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								__lowerCamelCase				:				Optional[Any]					       = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				List[str]					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Dict					       = pipe(**SCREAMING_SNAKE_CASE__).images
								__lowerCamelCase				:				Any					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				List[str]					       = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			List[str]):
								__lowerCamelCase				:				str					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								__lowerCamelCase				:				List[Any]					       = EulerDiscreteScheduler.from_config(pipe.scheduler.config)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Tuple					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Optional[Any]					       = pipe(**SCREAMING_SNAKE_CASE__).images
								__lowerCamelCase				:				List[str]					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				List[Any]					       = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			int):
								__lowerCamelCase				:				List[Any]					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								__lowerCamelCase				:				str					       = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Any					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Optional[int]					       = pipe(**SCREAMING_SNAKE_CASE__).images
								__lowerCamelCase				:				Optional[Any]					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				List[Any]					       = np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			Dict):
								__lowerCamelCase				:				Tuple					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								__lowerCamelCase				:				List[Any]					       = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

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

								assert image.shape == (1, 1_2_8, 1_2_8, 3)
								__lowerCamelCase				:				List[str]					       = np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
							def     lowerCAmelCase     (		self		:			Dict):
								__lowerCamelCase				:				Optional[Any]					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Dict					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Optional[int]					       = 3 * [inputs['prompt']]

								# forward
								__lowerCamelCase				:				List[Any]					       = pipe(**SCREAMING_SNAKE_CASE__)
								__lowerCamelCase				:				Union[str, Any]					       = output.images[0, -3:, -3:, -1]

								__lowerCamelCase				:				Union[str, Any]					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Union[str, Any]					       = 3 * [inputs.pop('prompt')]

								__lowerCamelCase				:				Tuple					       = pipe.tokenizer(
								    SCREAMING_SNAKE_CASE__   ,padding='max_length'   ,max_length=pipe.tokenizer.model_max_length   ,truncation=SCREAMING_SNAKE_CASE__   ,return_tensors='np'   ,)
								__lowerCamelCase				:				List[Any]					       = text_inputs['input_ids']

								__lowerCamelCase				:				Dict					       = pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0]

								__lowerCamelCase				:				List[Any]					       = prompt_embeds

								# forward
								__lowerCamelCase				:				Optional[int]					       = pipe(**SCREAMING_SNAKE_CASE__)
								__lowerCamelCase				:				Dict					       = output.images[0, -3:, -3:, -1]

								assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1E-4


							def     lowerCAmelCase     (		self		:			Optional[Any]):
								__lowerCamelCase				:				Optional[int]					       = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,provider='CPUExecutionProvider')
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Any					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Dict					       = 3 * ['this is a negative prompt']
								__lowerCamelCase				:				Dict					       = negative_prompt
								__lowerCamelCase				:				Any					       = 3 * [inputs['prompt']]

								# forward
								__lowerCamelCase				:				Dict					       = pipe(**SCREAMING_SNAKE_CASE__)
								__lowerCamelCase				:				List[str]					       = output.images[0, -3:, -3:, -1]

								__lowerCamelCase				:				Any					       = self.get_dummy_inputs()
								__lowerCamelCase				:				Dict					       = 3 * [inputs.pop('prompt')]

								__lowerCamelCase				:				Optional[int]					       = []
								for p in [prompt, negative_prompt]:
									__lowerCamelCase				:				Any					       = pipe.tokenizer(
									    SCREAMING_SNAKE_CASE__   ,padding='max_length'   ,max_length=pipe.tokenizer.model_max_length   ,truncation=SCREAMING_SNAKE_CASE__   ,return_tensors='np'   ,)
									__lowerCamelCase				:				Optional[int]					       = text_inputs['input_ids']

									embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0])

								__lowerCamelCase       , __lowerCamelCase				:				Optional[int]					       = embeds

								# forward
								__lowerCamelCase				:				Optional[Any]					       = pipe(**SCREAMING_SNAKE_CASE__)
								__lowerCamelCase				:				List[str]					       = output.images[0, -3:, -3:, -1]

								assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1E-4






@nightly
@require_onnxruntime
@require_torch_gpu
class        A_		(       unittest.TestCase				):
							@property
							def     lowerCAmelCase     (		self		:			str):
								return (
								    "CUDAExecutionProvider",
								    {
								        "gpu_mem_limit": "15000000000",  # 15GB
								        "arena_extend_strategy": "kSameAsRequested",
								    },
								)
							@property
							def     lowerCAmelCase     (		self		:			str):
								__lowerCamelCase				:				List[Any]					       = ort.SessionOptions()
								__lowerCamelCase				:				Any					       = False
								return options
							def     lowerCAmelCase     (		self		:			Union[str, Any]):
								# using the PNDM scheduler by default
								__lowerCamelCase				:				Optional[Any]					       = OnnxStableDiffusionPipeline.from_pretrained(
								    'CompVis/stable-diffusion-v1-4'   ,revision='onnx'   ,safety_checker=SCREAMING_SNAKE_CASE__   ,feature_extractor=SCREAMING_SNAKE_CASE__   ,provider=self.gpu_provider   ,sess_options=self.gpu_options   ,)
								sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Optional[int]					       = 'A painting of a squirrel eating a burger'
								np.random.seed(0)
								__lowerCamelCase				:				Dict					       = sd_pipe([prompt]   ,guidance_scale=6.0   ,num_inference_steps=1_0   ,output_type='np')
								__lowerCamelCase				:				Union[str, Any]					       = output.images

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

								assert image.shape == (1, 5_1_2, 5_1_2, 3)
								__lowerCamelCase				:				Optional[int]					       = np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
							def     lowerCAmelCase     (		self		:			str):
								__lowerCamelCase				:				Any					       = DDIMScheduler.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,subfolder='scheduler'   ,revision='onnx')
								__lowerCamelCase				:				List[Any]					       = OnnxStableDiffusionPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,revision='onnx'   ,scheduler=SCREAMING_SNAKE_CASE__   ,safety_checker=SCREAMING_SNAKE_CASE__   ,feature_extractor=SCREAMING_SNAKE_CASE__   ,provider=self.gpu_provider   ,sess_options=self.gpu_options   ,)
								sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				int					       = 'open neural network exchange'
								__lowerCamelCase				:				Union[str, Any]					       = np.random.RandomState(0)
								__lowerCamelCase				:				int					       = sd_pipe([prompt]   ,guidance_scale=7.5   ,num_inference_steps=1_0   ,generator=SCREAMING_SNAKE_CASE__   ,output_type='np')
								__lowerCamelCase				:				Union[str, Any]					       = output.images
								__lowerCamelCase				:				Dict					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 5_1_2, 5_1_2, 3)
								__lowerCamelCase				:				Union[str, Any]					       = np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
							def     lowerCAmelCase     (		self		:			List[Any]):
								__lowerCamelCase				:				List[str]					       = LMSDiscreteScheduler.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,subfolder='scheduler'   ,revision='onnx')
								__lowerCamelCase				:				Optional[Any]					       = OnnxStableDiffusionPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,revision='onnx'   ,scheduler=SCREAMING_SNAKE_CASE__   ,safety_checker=SCREAMING_SNAKE_CASE__   ,feature_extractor=SCREAMING_SNAKE_CASE__   ,provider=self.gpu_provider   ,sess_options=self.gpu_options   ,)
								sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				Optional[int]					       = 'open neural network exchange'
								__lowerCamelCase				:				Dict					       = np.random.RandomState(0)
								__lowerCamelCase				:				Optional[int]					       = sd_pipe([prompt]   ,guidance_scale=7.5   ,num_inference_steps=1_0   ,generator=SCREAMING_SNAKE_CASE__   ,output_type='np')
								__lowerCamelCase				:				Union[str, Any]					       = output.images
								__lowerCamelCase				:				str					       = image[0, -3:, -3:, -1]

								assert image.shape == (1, 5_1_2, 5_1_2, 3)
								__lowerCamelCase				:				List[str]					       = np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161])

								assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
							def     lowerCAmelCase     (		self		:			int):
								__lowerCamelCase				:				List[str]					       = 0

								def test_callback_fn(SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			np.ndarray) -> None:
									__lowerCamelCase				:				Any					       = True
									nonlocal number_of_steps
									number_of_steps += 1
									if step == 0:
										assert latents.shape == (1, 4, 6_4, 6_4)
										__lowerCamelCase				:				Dict					       = latents[0, -3:, -3:, -1]
										__lowerCamelCase				:				Dict					       = np.array(
										    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167])

										assert np.abs(latents_slice.flatten() - expected_slice).max() < 1E-3
									elif step == 5:
										assert latents.shape == (1, 4, 6_4, 6_4)
										__lowerCamelCase				:				Tuple					       = latents[0, -3:, -3:, -1]
										__lowerCamelCase				:				Optional[int]					       = np.array(
										    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875])

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

								__lowerCamelCase				:				int					       = False

								__lowerCamelCase				:				Optional[int]					       = OnnxStableDiffusionPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,revision='onnx'   ,safety_checker=SCREAMING_SNAKE_CASE__   ,feature_extractor=SCREAMING_SNAKE_CASE__   ,provider=self.gpu_provider   ,sess_options=self.gpu_options   ,)
								pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__)

								__lowerCamelCase				:				List[str]					       = 'Andromeda galaxy in a bottle'

								__lowerCamelCase				:				str					       = np.random.RandomState(0)
								pipe(
								    prompt=SCREAMING_SNAKE_CASE__   ,num_inference_steps=5   ,guidance_scale=7.5   ,generator=SCREAMING_SNAKE_CASE__   ,callback=SCREAMING_SNAKE_CASE__   ,callback_steps=1   ,)
								assert test_callback_fn.has_been_called
								assert number_of_steps == 6


							def     lowerCAmelCase     (		self		:			List[str]):
								__lowerCamelCase				:				Any					       = OnnxStableDiffusionPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'   ,revision='onnx'   ,safety_checker=SCREAMING_SNAKE_CASE__   ,feature_extractor=SCREAMING_SNAKE_CASE__   ,provider=self.gpu_provider   ,sess_options=self.gpu_options   ,)
								assert isinstance(SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__)
								assert pipe.safety_checker is None

								__lowerCamelCase				:				Union[str, Any]					       = pipe('example prompt'   ,num_inference_steps=2).images[0]
								assert image is not None

								# check that there's no error when saving a pipeline with one of the models being None
								with tempfile.TemporaryDirectory() as tmpdirname:
									pipe.save_pretrained(SCREAMING_SNAKE_CASE__)
									__lowerCamelCase				:				Tuple					       = OnnxStableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE__)

								# sanity check that the pipeline still works
								assert pipe.safety_checker is None
								__lowerCamelCase				:				Tuple					       = pipe('example prompt'   ,num_inference_steps=2).images[0]
								assert image is not None









"""simple docstring"""
from collections.abc import Callable

import numpy as np

def       _snake_case						(						UpperCamelCase						:		Callable			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 UpperCAmelCase	:					Any	=	int(np.ceil((x_end - xa) / step_size						)						)
 UpperCAmelCase	:					Optional[Any]	=	np.zeros((n + 1,)						)
 UpperCAmelCase	:					Optional[int]	=	ya
 UpperCAmelCase	:					int	=	xa

 for k in range(UpperCamelCase						):
  UpperCAmelCase	:					Optional[int]	=	y[k] + step_size * ode_func(UpperCamelCase			,		y[k]						)
  UpperCAmelCase	:					Optional[int]	=	y[k] + (
      (step_size / 2) * (ode_func(UpperCamelCase			,		y[k]						) + ode_func(x + step_size			,		UpperCamelCase						))
  )
  x += step_size

 return y


if __name__ == "__main__":
      import doctest

      doctest.testmod()
