




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 		__lowerCAmelCase	(	__magic_name__      ,       unittest.TestCase ):
							UpperCamelCase__					     =  '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''
							def       lowerCamelCase__							(						self						:Union[str, Any]		,      __magic_name__						:Optional[int]=0				):







								'''simple docstring'''







								a										=							floats_tensor((1, 3, 128, 128)		,      rng=random.Random(__magic_name__				)				)
								a										=							np.random.RandomState(__magic_name__				)
								a										=							{
								    """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       lowerCamelCase__							(						self						:List[Any]				):







								'''simple docstring'''







								a										=							OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""				)
								pipe.set_progress_bar_config(disable=__magic_name__				)

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.69643, 0.58484, 0.50314, 0.58760, 0.55368, 0.59643, 0.51529, 0.41217, 0.49087]				)
								assert np.abs(image_slice - expected_slice				).max() < 1E-1
							def       lowerCamelCase__							(						self						:str				):







								'''simple docstring'''







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

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.61737, 0.54642, 0.53183, 0.54465, 0.52742, 0.60525, 0.49969, 0.40655, 0.48154]				)

								assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1
							def       lowerCamelCase__							(						self						:Any				):







								'''simple docstring'''







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

								# warmup pass to apply optimizations
								a										=							pipe(**self.get_dummy_inputs()				)

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.52761, 0.59977, 0.49033, 0.49619, 0.54282, 0.50311, 0.47600, 0.40918, 0.45203]				)

								assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1
							def       lowerCamelCase__							(						self						:Dict				):







								'''simple docstring'''







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

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304]				)

								assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-1
							def       lowerCamelCase__							(						self						:str				):







								'''simple docstring'''







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

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304]				)

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





							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







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

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

								assert image.shape == (1, 128, 128, 3)
								a										=							np.array([0.65331, 0.58277, 0.48204, 0.56059, 0.53665, 0.56235, 0.50969, 0.40009, 0.46552]				)

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







@nightly
@require_onnxruntime
@require_torch_gpu
class 		__lowerCAmelCase	(	unittest.TestCase ):
							@property
							def       lowerCamelCase__							(						self						:Tuple				):







								'''simple docstring'''







								return (
								    "CUDAExecutionProvider",
								    {
								        "gpu_mem_limit": "15000000000",  # 15GB
								        "arena_extend_strategy": "kSameAsRequested",
								    },
								)
							@property
							def       lowerCamelCase__							(						self						:Tuple				):







								'''simple docstring'''







								a										=							ort.SessionOptions()
								a										=							False
								return options
							def       lowerCamelCase__							(						self						:List[str]				):







								'''simple docstring'''







								a										=							load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/img2img/sketch-mountains-input.jpg"""				)
								a										=							init_image.resize((768, 512)				)
								# using the PNDM scheduler by default
								a										=							OnnxStableDiffusionImgaImgPipeline.from_pretrained(
								    """CompVis/stable-diffusion-v1-4"""		,      revision="""onnx"""		,      safety_checker=__magic_name__		,      feature_extractor=__magic_name__		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
								pipe.set_progress_bar_config(disable=__magic_name__				)

								a										=							"""A fantasy landscape, trending on artstation"""

								a										=							np.random.RandomState(0				)
								a										=							pipe(
								    prompt=__magic_name__		,      image=__magic_name__		,      strength=0.75		,      guidance_scale=7.5		,      num_inference_steps=10		,      generator=__magic_name__		,      output_type="""np"""		,      )
								a										=							output.images
								a										=							images[0, 255:258, 383:386, -1]

								assert images.shape == (1, 512, 768, 3)
								a										=							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       lowerCamelCase__							(						self						:Tuple				):







								'''simple docstring'''







								a										=							load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/img2img/sketch-mountains-input.jpg"""				)
								a										=							init_image.resize((768, 512)				)
								a										=							LMSDiscreteScheduler.from_pretrained(
								    """runwayml/stable-diffusion-v1-5"""		,      subfolder="""scheduler"""		,      revision="""onnx"""				)
								a										=							OnnxStableDiffusionImgaImgPipeline.from_pretrained(
								    """runwayml/stable-diffusion-v1-5"""		,      revision="""onnx"""		,      scheduler=__magic_name__		,      safety_checker=__magic_name__		,      feature_extractor=__magic_name__		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
								pipe.set_progress_bar_config(disable=__magic_name__				)

								a										=							"""A fantasy landscape, trending on artstation"""

								a										=							np.random.RandomState(0				)
								a										=							pipe(
								    prompt=__magic_name__		,      image=__magic_name__		,      strength=0.75		,      guidance_scale=7.5		,      num_inference_steps=20		,      generator=__magic_name__		,      output_type="""np"""		,      )
								a										=							output.images
								a										=							images[0, 255:258, 383:386, -1]

								assert images.shape == (1, 512, 768, 3)
								a										=							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







def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       str:
	if not isinstance(__lowerCamelCase							,			__lowerCamelCase    ):
		raise ValueError("""iterations must be defined as integers"""    )
	if not isinstance(__lowerCamelCase							,			__lowerCamelCase    ) or not number >= 1:
		raise ValueError(
		    """starting number must be
                         and integer and be more than 0"""    )
	if not iterations >= 1:
		raise ValueError("""Iterations must be done more than 0 times to play FizzBuzz"""    )

	a										=							""""""
	while number <= iterations:
		if number % 3 == 0:
			out += "Fizz"
		if number % 5 == 0:
			out += "Buzz"
		if 0 not in (number % 3, number % 5):
			out += str(__lowerCamelCase    )

		# print(out)
		number += 1
		out += " "
	return out


if __name__ == "__main__":
		import doctest

		doctest.testmod()

