






'''simple docstring'''
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        _UpperCAmelCase						(		snake_case				,					unittest.TestCase			):
    __lowerCamelCase:   str		       =    'hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'




    def 				lowerCAmelCase__				(			self  :       Any  ,     a  :       Tuple=0			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     np.random.RandomState(a			)
       lowercase_	:    Dict           =     {
           "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]			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    str           =     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 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       lowercase_	:    List[Any]           =     PNDMScheduler.from_config(pipe.scheduler.config  ,     skip_prk_steps=a			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    List[str]           =     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 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       lowercase_	:    Any           =     LMSDiscreteScheduler.from_config(pipe.scheduler.config			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    Any           =     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 				lowerCAmelCase__				(			self  :       Tuple			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       lowercase_	:    List[Any]           =     EulerDiscreteScheduler.from_config(pipe.scheduler.config			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    int           =     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 				lowerCAmelCase__				(			self  :       int			):






       '''simple docstring'''






       lowercase_	:    Optional[Any]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       lowercase_	:    str           =     EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    str           =     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 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       lowercase_	:    Dict           =     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
       pipe.set_progress_bar_config(disable=a			)

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

       assert image.shape == (1, 1_2_8, 1_2_8, 3)
       lowercase_	:    List[Any]           =     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 				lowerCAmelCase__				(			self  :       Optional[Any]			):






       '''simple docstring'''






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

       lowercase_	:    Dict           =     self.get_dummy_inputs()
       lowercase_	:    Dict           =     3 * [inputs["prompt"]]

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

       lowercase_	:    List[str]           =     self.get_dummy_inputs()
       lowercase_	:    Optional[int]           =     3 * [inputs.pop("prompt"			)]

       lowercase_	:    Dict           =     pipe.tokenizer(
           a  ,     padding="max_length"  ,     max_length=pipe.tokenizer.model_max_length  ,     truncation=a  ,     return_tensors="np"  ,     )
       lowercase_	:    List[str]           =     text_inputs["input_ids"]

       lowercase_	:    Optional[int]           =     pipe.text_encoder(input_ids=text_inputs.astype(np.intaa			)			)[0]

       lowercase_	:    Dict           =     prompt_embeds

       # forward
       lowercase_	:    Dict           =     pipe(**a			)
       lowercase_	:    Union[str, Any]           =     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]			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,     provider="CPUExecutionProvider"			)
       pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    Union[str, Any]           =     self.get_dummy_inputs()
       lowercase_	:    Any           =     3 * ["this is a negative prompt"]
       lowercase_	:    Optional[Any]           =     negative_prompt
       lowercase_	:    Optional[Any]           =     3 * [inputs["prompt"]]

       # forward
       lowercase_	:    List[str]           =     pipe(**a			)
       lowercase_	:    Optional[int]           =     output.images[0, -3:, -3:, -1]

       lowercase_	:    Any           =     self.get_dummy_inputs()
       lowercase_	:    Optional[int]           =     3 * [inputs.pop("prompt"			)]

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

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

       lowercase_    ,		lowercase_	:    Any           =     embeds

       # forward
       lowercase_	:    Optional[Any]           =     pipe(**a			)
       lowercase_	:    int           =     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        _UpperCAmelCase						(		unittest.TestCase			):




    @property
    def 				lowerCAmelCase__				(			self  :       List[str]			):






       '''simple docstring'''






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




    @property
    def 				lowerCAmelCase__				(			self  :       Any			):






       '''simple docstring'''






       lowercase_	:    Optional[int]           =     ort.SessionOptions()
       lowercase_	:    Tuple           =     False
       return options




    def 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






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

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

       lowercase_	:    int           =     image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowercase_	:    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  :       Optional[Any]			):






       '''simple docstring'''






       lowercase_	:    Tuple           =     DDIMScheduler.from_pretrained(
           "runwayml/stable-diffusion-v1-5"  ,     subfolder="scheduler"  ,     revision="onnx"			)
       lowercase_	:    Union[str, Any]           =     OnnxStableDiffusionPipeline.from_pretrained(
           "runwayml/stable-diffusion-v1-5"  ,     revision="onnx"  ,     scheduler=a  ,     safety_checker=a  ,     feature_extractor=a  ,     provider=self.gpu_provider  ,     sess_options=self.gpu_options  ,     )
       sd_pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    Any           =     "open neural network exchange"
       lowercase_	:    List[str]           =     np.random.RandomState(0			)
       lowercase_	:    Tuple           =     sd_pipe([prompt]  ,     guidance_scale=7.5  ,     num_inference_steps=1_0  ,     generator=a  ,     output_type="np"			)
       lowercase_	:    Any           =     output.images
       lowercase_	:    str           =     image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowercase_	:    str           =     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  :       Optional[int]			):






       '''simple docstring'''






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

       lowercase_	:    Tuple           =     "open neural network exchange"
       lowercase_	:    Tuple           =     np.random.RandomState(0			)
       lowercase_	:    Any           =     sd_pipe([prompt]  ,     guidance_scale=7.5  ,     num_inference_steps=1_0  ,     generator=a  ,     output_type="np"			)
       lowercase_	:    str           =     output.images
       lowercase_	:    Union[str, Any]           =     image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowercase_	:    Optional[int]           =     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  :       List[str]			):






       '''simple docstring'''






       lowercase_	:    Any           =     0

       def test_callback_fn(a  :       int  ,     a  :       int  ,     a  :       np.ndarray			) -> None:
          lowercase_	:    List[str]           =     True
          nonlocal number_of_steps
          number_of_steps += 1
          if step == 0:
             assert latents.shape == (1, 4, 6_4, 6_4)
             lowercase_	:    List[str]           =     latents[0, -3:, -3:, -1]
             lowercase_	:    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)
             lowercase_	:    List[Any]           =     latents[0, -3:, -3:, -1]
             lowercase_	:    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

       lowercase_	:    Any           =     False

       lowercase_	:    Union[str, Any]           =     OnnxStableDiffusionPipeline.from_pretrained(
           "runwayml/stable-diffusion-v1-5"  ,     revision="onnx"  ,     safety_checker=a  ,     feature_extractor=a  ,     provider=self.gpu_provider  ,     sess_options=self.gpu_options  ,     )
       pipe.set_progress_bar_config(disable=a			)

       lowercase_	:    Union[str, Any]           =     "Andromeda galaxy in a bottle"

       lowercase_	:    Union[str, Any]           =     np.random.RandomState(0			)
       pipe(
           prompt=a  ,     num_inference_steps=5  ,     guidance_scale=7.5  ,     generator=a  ,     callback=a  ,     callback_steps=1  ,     )
       assert test_callback_fn.has_been_called
       assert number_of_steps == 6





    def 				lowerCAmelCase__				(			self  :       Dict			):






       '''simple docstring'''






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

       lowercase_	:    List[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(a			)
          lowercase_	:    int           =     OnnxStableDiffusionPipeline.from_pretrained(a			)

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












'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase = 200							):


   """simple docstring"""




   lowercase_	:    Optional[int]           =     [1, 2, 5, 10, 20, 50, 100, 200]
   lowercase_	:    str           =     [0] * (pence + 1)
   lowercase_	:    Dict           =     1  # base case: 1 way to make 0 pence

   for coin in coins:
      for i in range(_UpperCamelCase						,		pence + 1						,		1							):
         number_of_ways[i] += number_of_ways[i - coin]
   return number_of_ways[pence]


if __name__ == "__main__":
 assert solution(200) == 73682




