






import random
import unittest

import numpy as np
import torch

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionUpscalePipeline,
    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     a    ( lowercase__							,       unittest.TestCase   ):



      """simple docstring"""


      a  : Any							       =	'ssube/stable-diffusion-x4-upscaler-onnx'
      def 	UpperCAmelCase      (      self					:			Optional[int]		,      __lowercase					:			Any=0					)							->      Any:
        __UpperCAmelCase							:	Optional[Any]           =  floats_tensor((1, 3, 128, 128)		,      rng=random.Random(__lowercase					)					)
        __UpperCAmelCase							:	List[Any]           =  torch.manual_seed(__lowercase					)
        __UpperCAmelCase							:	Optional[int]           =  {
            """prompt""": """A painting of a squirrel eating a burger""",
            """image""": image,
            """generator""": generator,
            """num_inference_steps""": 3,
            """guidance_scale""": 7.5,
            """output_type""": """numpy""",
        }
        return inputs
      def 	UpperCAmelCase      (      self					:			Any					)							->      List[Any]:
        __UpperCAmelCase							:	Optional[int]           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""					)
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	Union[str, Any]           =  self.get_dummy_inputs()
        __UpperCAmelCase							:	Optional[int]           =  pipe(**__lowercase					).images
        __UpperCAmelCase							:	Tuple           =  image[0, -3:, -3:, -1].flatten()

        # started as 128, should now be 512
        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	Union[str, Any]           =  np.array(
            [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223]					)
        assert np.abs(image_slice - expected_slice					).max() < 1e-1
      def 	UpperCAmelCase      (      self					:			Any					)							->      Dict:
        __UpperCAmelCase							:	Any           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""					)
        __UpperCAmelCase							:	List[str]           =  PNDMScheduler.from_config(pipe.scheduler.config		,      skip_prk_steps=__lowercase					)
        pipe.set_progress_bar_config(disable=__lowercase					)

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

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	List[str]           =  np.array(
            [0.6_898_892, 0.59_240_556, 0.52_499_527, 0.58_866_215, 0.52_258_235, 0.52_572_715, 0.62_414_473, 0.6_174_387, 0.6_214_964]					)
        assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-1
      def 	UpperCAmelCase      (      self					:			List[str]					)							->      Dict:
        __UpperCAmelCase							:	Union[str, Any]           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""					)
        __UpperCAmelCase							:	Any           =  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config					)
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	str           =  self.get_dummy_inputs()
        __UpperCAmelCase							:	int           =  pipe(**__lowercase					).images
        __UpperCAmelCase							:	Union[str, Any]           =  image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	Dict           =  np.array(
            [0.7_659_278, 0.76_437_664, 0.75_579_107, 0.7_691_116, 0.77_666_986, 0.7_727_672, 0.7_758_664, 0.7_812_226, 0.76_942_515]					)

        assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-1
      def 	UpperCAmelCase      (      self					:			Optional[Any]					)							->      Optional[Any]:
        __UpperCAmelCase							:	Any           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""					)
        __UpperCAmelCase							:	Dict           =  EulerDiscreteScheduler.from_config(pipe.scheduler.config					)
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	Dict           =  self.get_dummy_inputs()
        __UpperCAmelCase							:	Union[str, Any]           =  pipe(**__lowercase					).images
        __UpperCAmelCase							:	str           =  image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	Any           =  np.array(
            [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223]					)
        assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-1




      def 	UpperCAmelCase      (      self					:			Tuple					)							->      str:
        __UpperCAmelCase							:	Dict           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint		,      provider="""CPUExecutionProvider"""					)
        __UpperCAmelCase							:	Optional[int]           =  EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config					)
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	Tuple           =  self.get_dummy_inputs()
        __UpperCAmelCase							:	Tuple           =  pipe(**__lowercase					).images
        __UpperCAmelCase							:	Optional[int]           =  image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	List[Any]           =  np.array(
            [0.77_424_496, 0.773_601, 0.7_645_288, 0.7_769_598, 0.7_772_739, 0.7_738_688, 0.78_187_233, 0.77_879_584, 0.767_043]					)

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


@nightly
@require_onnxruntime
@require_torch_gpu
class     a    ( unittest.TestCase   ):



      """simple docstring"""


      @property
      def 	UpperCAmelCase      (      self					:			Dict					)							->      Optional[Any]:
        return (
            "CUDAExecutionProvider",
            {
                "gpu_mem_limit": "15000000000",  # 15GB
                "arena_extend_strategy": "kSameAsRequested",
            },
        )
      @property
      def 	UpperCAmelCase      (      self					:			Dict					)							->      Optional[int]:
        __UpperCAmelCase							:	str           =  ort.SessionOptions()
        __UpperCAmelCase							:	Optional[Any]           =  False
        return options
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      int:
        __UpperCAmelCase							:	Dict           =  load_image(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
            """/img2img/sketch-mountains-input.jpg"""					)
        __UpperCAmelCase							:	Dict           =  init_image.resize((128, 128)					)
        # using the PNDM scheduler by default
        __UpperCAmelCase							:	List[str]           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(
            """ssube/stable-diffusion-x4-upscaler-onnx"""		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	int           =  """A fantasy landscape, trending on artstation"""

        __UpperCAmelCase							:	Tuple           =  torch.manual_seed(0					)
        __UpperCAmelCase							:	List[str]           =  pipe(
            prompt=__lowercase		,      image=__lowercase		,      guidance_scale=7.5		,      num_inference_steps=10		,      generator=__lowercase		,      output_type="""np"""		,      )
        __UpperCAmelCase							:	str           =  output.images
        __UpperCAmelCase							:	List[str]           =  images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	List[str]           =  np.array([0.4_883, 0.4_947, 0.4_980, 0.4_975, 0.4_982, 0.4_980, 0.5_000, 0.5_006, 0.4_972]					)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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




      def 	UpperCAmelCase      (      self					:			str					)							->      str:
        __UpperCAmelCase							:	int           =  load_image(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
            """/img2img/sketch-mountains-input.jpg"""					)
        __UpperCAmelCase							:	Optional[Any]           =  init_image.resize((128, 128)					)
        __UpperCAmelCase							:	Tuple           =  LMSDiscreteScheduler.from_pretrained(
            """ssube/stable-diffusion-x4-upscaler-onnx"""		,      subfolder="""scheduler"""					)
        __UpperCAmelCase							:	str           =  OnnxStableDiffusionUpscalePipeline.from_pretrained(
            """ssube/stable-diffusion-x4-upscaler-onnx"""		,      scheduler=__lowercase		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
        pipe.set_progress_bar_config(disable=__lowercase					)

        __UpperCAmelCase							:	Dict           =  """A fantasy landscape, trending on artstation"""

        __UpperCAmelCase							:	Dict           =  torch.manual_seed(0					)
        __UpperCAmelCase							:	Any           =  pipe(
            prompt=__lowercase		,      image=__lowercase		,      guidance_scale=7.5		,      num_inference_steps=20		,      generator=__lowercase		,      output_type="""np"""		,      )
        __UpperCAmelCase							:	Union[str, Any]           =  output.images
        __UpperCAmelCase							:	Union[str, Any]           =  images[0, 255:258, 383:386, -1]

        assert images.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:	int           =  np.array(
            [0.50_173_753, 0.50_223_356, 0.502_039, 0.50_233_036, 0.5_023_725, 0.5_022_601, 0.5_018_758, 0.50_234_085, 0.50_241_566]					)
        # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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










# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a		:       Union[str, Any]			     = {"configuration_timm_backbone": ["TimmBackboneConfig"]}


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a		:       Tuple			     = ["TimmBackbone"]


if TYPE_CHECKING:
       from .configuration_timm_backbone import TimmBackboneConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_timm_backbone import TimmBackbone

else:
       import sys

       a		:       List[Any]			     = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


