
'''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 						__UpperCAmelCase      (					_lowerCamelCase						,   unittest.TestCase						):
							__lowercase      		=       """hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_=0  ):





								"""simple docstring"""






								_snake_case   						=		floats_tensor((1, 3, 1_28, 1_28)    ,   rng=random.Random(lowerCAmelCase_  )  )
								_snake_case   						=		np.random.RandomState(lowerCAmelCase_  )
								_snake_case   						=		{
								    '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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		PNDMScheduler.from_config(pipe.scheduler.config    ,   skip_prk_steps=lowerCAmelCase_  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		EulerDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

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

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		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 						__UpperCAmelCase      (					unittest.TestCase						):


							@property
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






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


							@property
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






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


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






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

								_snake_case   						=		'A fantasy landscape, trending on artstation'

								_snake_case   						=		np.random.RandomState(0  )
								_snake_case   						=		pipe(
								    prompt=lowerCAmelCase_    ,   image=lowerCAmelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   num_inference_steps=10    ,   generator=lowerCAmelCase_    ,   output_type='np'    ,   )
								_snake_case   						=		output.images
								_snake_case   						=		images[0, 2_55:2_58, 3_83:3_86, -1]

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





								"""simple docstring"""






								_snake_case   						=		load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/img2img/sketch-mountains-input.jpg'  )
								_snake_case   						=		init_image.resize((7_68, 5_12)  )
								_snake_case   						=		LMSDiscreteScheduler.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'    ,   subfolder='scheduler'    ,   revision='onnx'  )
								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.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    ,   )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		'A fantasy landscape, trending on artstation'

								_snake_case   						=		np.random.RandomState(0  )
								_snake_case   						=		pipe(
								    prompt=lowerCAmelCase_    ,   image=lowerCAmelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   num_inference_steps=20    ,   generator=lowerCAmelCase_    ,   output_type='np'    ,   )
								_snake_case   						=		output.images
								_snake_case   						=		images[0, 2_55:2_58, 3_83:3_86, -1]

								assert images.shape == (1, 5_12, 7_68, 3)
								_snake_case   						=		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





from argparse import ArgumentParser

from .add_new_model import AddNewModelCommand
from .add_new_model_like import AddNewModelLikeCommand
from .convert import ConvertCommand
from .download import DownloadCommand
from .env import EnvironmentCommand
from .lfs import LfsCommands
from .pt_to_tf import PTtoTFCommand
from .run import RunCommand
from .serving import ServeCommand
from .user import UserCommands



def 	lowerCAmelCase       (						)->       int:
				lowerCAmelCase_       :					int			 = ArgumentParser('''Transformers CLI tool'''       ,      usage='''transformers-cli <command> [<args>]'''       )
				lowerCAmelCase_       :					Dict			 = parser.add_subparsers(help='''transformers-cli command helpers'''       )

				# Register commands
				ConvertCommand.register_subcommand(lowerCAmelCase_       )
				DownloadCommand.register_subcommand(lowerCAmelCase_       )
				EnvironmentCommand.register_subcommand(lowerCAmelCase_       )
				RunCommand.register_subcommand(lowerCAmelCase_       )
				ServeCommand.register_subcommand(lowerCAmelCase_       )
				UserCommands.register_subcommand(lowerCAmelCase_       )
				AddNewModelCommand.register_subcommand(lowerCAmelCase_       )
				AddNewModelLikeCommand.register_subcommand(lowerCAmelCase_       )
				LfsCommands.register_subcommand(lowerCAmelCase_       )
				PTtoTFCommand.register_subcommand(lowerCAmelCase_       )

				# Let's go
				lowerCAmelCase_       :					Union[str, Any]			 = parser.parse_args()

				if not hasattr(lowerCAmelCase_       ,      '''func'''       ):
								parser.print_help()
								exit(1       )

				# Run
				lowerCAmelCase_       :					List[Any]			 = args.func(lowerCAmelCase_       )
				service.run()


if __name__ == "__main__":
						main()