





'''simple docstring'''

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			( _snake_case, unittest.TestCase      ):
   # TODO: is there an appropriate internal test set?
   __UpperCamelCase :			Optional[Any]						   =						'ssube/stable-diffusion-x4-upscaler-onnx'





   def   UpperCAmelCase__  (       self					:      List[str]					,lowerCamelCase					:      Optional[int]=0     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							floats_tensor((1, 3, 128, 128)					,rng=random.Random(lowerCamelCase     )     )
      __SCREAMING_SNAKE_CASE   				=							torch.manual_seed(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							{
          """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					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint					,provider="""CPUExecutionProvider"""     )
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

      # started as 128, should now be 512
      assert image.shape == (1, 512, 512, 3)
      __SCREAMING_SNAKE_CASE   				=							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					:      Union[str, Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint					,provider="""CPUExecutionProvider"""     )
      __SCREAMING_SNAKE_CASE   				=							PNDMScheduler.from_config(pipe.scheduler.config					,skip_prk_steps=lowerCamelCase     )
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

      assert image.shape == (1, 512, 512, 3)
      __SCREAMING_SNAKE_CASE   				=							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					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint					,provider="""CPUExecutionProvider"""     )
      __SCREAMING_SNAKE_CASE   				=							DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

      assert image.shape == (1, 512, 512, 3)
      __SCREAMING_SNAKE_CASE   				=							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					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint					,provider="""CPUExecutionProvider"""     )
      __SCREAMING_SNAKE_CASE   				=							EulerDiscreteScheduler.from_config(pipe.scheduler.config     )
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint					,provider="""CPUExecutionProvider"""     )
      __SCREAMING_SNAKE_CASE   				=							EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config     )
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

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





   @property
   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

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





   @property
   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

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





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							load_image(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/img2img/sketch-mountains-input.jpg"""     )
      __SCREAMING_SNAKE_CASE   				=							init_image.resize((128, 128)     )
      # using the PNDM scheduler by default
      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(
          """ssube/stable-diffusion-x4-upscaler-onnx"""					,provider=self.gpu_provider					,sess_options=self.gpu_options					,)
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

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

      assert images.shape == (1, 512, 512, 3)
      __SCREAMING_SNAKE_CASE   				=							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					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							load_image(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/img2img/sketch-mountains-input.jpg"""     )
      __SCREAMING_SNAKE_CASE   				=							init_image.resize((128, 128)     )
      __SCREAMING_SNAKE_CASE   				=							LMSDiscreteScheduler.from_pretrained(
          """ssube/stable-diffusion-x4-upscaler-onnx"""					,subfolder="""scheduler"""     )
      __SCREAMING_SNAKE_CASE   				=							OnnxStableDiffusionUpscalePipeline.from_pretrained(
          """ssube/stable-diffusion-x4-upscaler-onnx"""					,scheduler=lowerCamelCase					,provider=self.gpu_provider					,sess_options=self.gpu_options					,)
      pipe.set_progress_bar_config(disable=lowerCamelCase     )

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

      __SCREAMING_SNAKE_CASE   				=							torch.manual_seed(0     )
      __SCREAMING_SNAKE_CASE   				=							pipe(
          prompt=lowerCamelCase					,image=lowerCamelCase					,guidance_scale=7.5					,num_inference_steps=20					,generator=lowerCamelCase					,output_type="""np"""					,)
      __SCREAMING_SNAKE_CASE   				=							output.images
      __SCREAMING_SNAKE_CASE   				=							images[0, 255:258, 383:386, -1]

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











from __future__ import annotations

from fractions import Fraction




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				return (
				    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
				)




def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=[]
				__magic_name__						:						List[Any]										=11
				__magic_name__						:						Tuple										=int("""1""" + """0""" * digit_len )
				for num in range(lowerCamelCase						,  lowerCamelCase ):
								while den <= 99:
												if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
																if is_digit_cancelling(lowerCamelCase						,  lowerCamelCase ):
																				solutions.append(F"{num}/{den}" )
												den += 1
								num += 1
								__magic_name__						:						List[str]										=10
				return solutions




def 		lowerCAmelCase_ (						lowerCamelCase = 2 ):
				__magic_name__						:						str										=1.0
				for fraction in fraction_list(lowerCamelCase ):
								__magic_name__						:						int										=Fraction(lowerCamelCase )
								result *= frac.denominator / frac.numerator
				return int(lowerCamelCase )


if __name__ == "__main__":
							print(solution())




