



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 	_lowercase							(   lowerCAmelCase,      unittest.TestCase	):





	"""simple docstring"""
	__A							=							"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"




	def      UpperCamelCase_       (self		,       lowerCamelCase_=0		):
						"""simple docstring"""

						a					     =   np.random.RandomState(lowerCamelCase_		)
						a					     =   {
						    "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      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.6_5072, 0.5_8492, 0.4_8219, 0.5_5521, 0.5_3180, 0.5_5939, 0.5_0697, 0.3_9800, 0.4_6455]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						a					     =   PNDMScheduler.from_config(pipe.scheduler.config		,       skip_prk_steps=lowerCamelCase_		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.6_5863, 0.5_9425, 0.4_9326, 0.5_6313, 0.5_3875, 0.5_6627, 0.5_1065, 0.3_9777, 0.4_6330]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						a					     =   LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						a					     =   EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						a					     =   EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.5_3817, 0.6_0812, 0.4_7384, 0.4_9530, 0.5_1894, 0.4_9814, 0.4_7984, 0.3_8958, 0.4_4271]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						a					     =   DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   pipe(**lowerCamelCase_		).images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 128, 128, 3)
						a					     =   np.array([0.5_3895, 0.6_0808, 0.4_7933, 0.4_9608, 0.5_1886, 0.4_9950, 0.4_8053, 0.3_8957, 0.4_4200]		)

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   3 * [inputs["prompt"]]

						# forward
						a					     =   pipe(**lowerCamelCase_		)
						a					     =   output.images[0, -3:, -3:, -1]

						a					     =   self.get_dummy_inputs()
						a					     =   3 * [inputs.pop("prompt"		)]

						a					     =   pipe.tokenizer(
						    lowerCamelCase_		,       padding="max_length"		,       max_length=pipe.tokenizer.model_max_length		,       truncation=lowerCamelCase_		,       return_tensors="np"		,       )
						a					     =   text_inputs["input_ids"]

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

						a					     =   prompt_embeds

						# forward
						a					     =   pipe(**lowerCamelCase_		)
						a					     =   output.images[0, -3:, -3:, -1]

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint		,       provider="CPUExecutionProvider"		)
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   self.get_dummy_inputs()
						a					     =   3 * ["this is a negative prompt"]
						a					     =   negative_prompt
						a					     =   3 * [inputs["prompt"]]

						# forward
						a					     =   pipe(**lowerCamelCase_		)
						a					     =   output.images[0, -3:, -3:, -1]

						a					     =   self.get_dummy_inputs()
						a					     =   3 * [inputs.pop("prompt"		)]

						a					     =   []
						for p in [prompt, negative_prompt]:
											a					     =   pipe.tokenizer(
											    lowerCamelCase_		,       padding="max_length"		,       max_length=pipe.tokenizer.model_max_length		,       truncation=lowerCamelCase_		,       return_tensors="np"		,       )
											a					     =   text_inputs["input_ids"]

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

						a     ,				a					     =   embeds

						# forward
						a					     =   pipe(**lowerCamelCase_		)
						a					     =   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 	_lowercase							(   unittest.TestCase	):





	"""simple docstring"""




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return (
						    "CUDAExecutionProvider",
						    {
						        "gpu_mem_limit": "15000000000",  # 15GB
						        "arena_extend_strategy": "kSameAsRequested",
						    },
						)




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   ort.SessionOptions()
						a					     =   False
						return options




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(
						    "CompVis/stable-diffusion-v1-4"		,       revision="onnx"		,       safety_checker=lowerCamelCase_		,       feature_extractor=lowerCamelCase_		,       provider=self.gpu_provider		,       sess_options=self.gpu_options		,       )
						sd_pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   "A painting of a squirrel eating a burger"
						np.random.seed(0		)
						a					     =   sd_pipe([prompt]		,       guidance_scale=6.0		,       num_inference_steps=10		,       output_type="np"		)
						a					     =   output.images

						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 512, 512, 3)
						a					     =   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      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   DDIMScheduler.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       subfolder="scheduler"		,       revision="onnx"		)
						a					     =   OnnxStableDiffusionPipeline.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       revision="onnx"		,       scheduler=lowerCamelCase_		,       safety_checker=lowerCamelCase_		,       feature_extractor=lowerCamelCase_		,       provider=self.gpu_provider		,       sess_options=self.gpu_options		,       )
						sd_pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   "open neural network exchange"
						a					     =   np.random.RandomState(0		)
						a					     =   sd_pipe([prompt]		,       guidance_scale=7.5		,       num_inference_steps=10		,       generator=lowerCamelCase_		,       output_type="np"		)
						a					     =   output.images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 512, 512, 3)
						a					     =   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      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   LMSDiscreteScheduler.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       subfolder="scheduler"		,       revision="onnx"		)
						a					     =   OnnxStableDiffusionPipeline.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       revision="onnx"		,       scheduler=lowerCamelCase_		,       safety_checker=lowerCamelCase_		,       feature_extractor=lowerCamelCase_		,       provider=self.gpu_provider		,       sess_options=self.gpu_options		,       )
						sd_pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   "open neural network exchange"
						a					     =   np.random.RandomState(0		)
						a					     =   sd_pipe([prompt]		,       guidance_scale=7.5		,       num_inference_steps=10		,       generator=lowerCamelCase_		,       output_type="np"		)
						a					     =   output.images
						a					     =   image[0, -3:, -3:, -1]

						assert image.shape == (1, 512, 512, 3)
						a					     =   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      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   0

						def test_callback_fn(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_		) -> None:
											a					     =   True
											nonlocal number_of_steps
											number_of_steps += 1
											if step == 0:
																assert latents.shape == (1, 4, 64, 64)
																a					     =   latents[0, -3:, -3:, -1]
																a					     =   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, 64, 64)
																a					     =   latents[0, -3:, -3:, -1]
																a					     =   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

						a					     =   False

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       revision="onnx"		,       safety_checker=lowerCamelCase_		,       feature_extractor=lowerCamelCase_		,       provider=self.gpu_provider		,       sess_options=self.gpu_options		,       )
						pipe.set_progress_bar_config(disable=lowerCamelCase_		)

						a					     =   "Andromeda galaxy in a bottle"

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




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   OnnxStableDiffusionPipeline.from_pretrained(
						    "runwayml/stable-diffusion-v1-5"		,       revision="onnx"		,       safety_checker=lowerCamelCase_		,       feature_extractor=lowerCamelCase_		,       provider=self.gpu_provider		,       sess_options=self.gpu_options		,       )
						assert isinstance(lowerCamelCase_		,       lowerCamelCase_		)
						assert pipe.safety_checker is None

						a					     =   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(lowerCamelCase_		)
											a					     =   OnnxStableDiffusionPipeline.from_pretrained(lowerCamelCase_		)

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





def     a(      A       :    int       )		->       str:
					"""simple docstring"""





					if number > 0:
										raise ValueError("input must be a negative integer"       )
					a					     =   len(bin(A       )[3:]       )
					a					     =   bin(abs(A       ) - (1 << binary_number_length)       )[3:]
					a					     =   (
					    (
					        "1"
					        + "0" * (binary_number_length - len(A       ))
					        + twos_complement_number
					    )
					    if number < 0
					    else "0"
					)
					return "0b" + twos_complement_number


if __name__ == "__main__":
				import doctest

				doctest.testmod()
