





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     :int						   =       'ssube/stable-diffusion-x4-upscaler-onnx'





      def 	__UpperCamelCase(			self	,							A_=0       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       floats_tensor((1, 3, 128, 128)	,							rng=random.Random(A_       )       )
       UpperCamelCase     : int	     =       torch.manual_seed(A_       )
       UpperCamelCase     : Any	     =       {
           "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       ):
       '''simple docstring'''




       UpperCamelCase     : int	     =       OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint	,							provider="CPUExecutionProvider"       )
       pipe.set_progress_bar_config(disable=A_       )

       UpperCamelCase     : int	     =       self.get_dummy_inputs()
       UpperCamelCase     : Dict	     =       pipe(**A_       ).images
       UpperCamelCase     : List[Any]	     =       image[0, -3:, -3:, -1].flatten()

       # started as 128, should now be 512
       assert image.shape == (1, 512, 512, 3)
       UpperCamelCase     : int	     =       np.array(
           [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]       )
       assert np.abs(image_slice - expected_slice       ).max() < 1e-1





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint	,							provider="CPUExecutionProvider"       )
       UpperCamelCase     : Optional[int]	     =       PNDMScheduler.from_config(pipe.scheduler.config	,							skip_prk_steps=A_       )
       pipe.set_progress_bar_config(disable=A_       )

       UpperCamelCase     : Union[str, Any]	     =       self.get_dummy_inputs()
       UpperCamelCase     : List[str]	     =       pipe(**A_       ).images
       UpperCamelCase     : str	     =       image[0, -3:, -3:, -1]

       assert image.shape == (1, 512, 512, 3)
       UpperCamelCase     : Union[str, Any]	     =       np.array(
           [0.6_89_88_92, 0.59_24_05_56, 0.52_49_95_27, 0.58_86_62_15, 0.52_25_82_35, 0.52_57_27_15, 0.62_41_44_73, 0.6_17_43_87, 0.6_21_49_64]       )
       assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-1





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint	,							provider="CPUExecutionProvider"       )
       UpperCamelCase     : Optional[int]	     =       DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
       pipe.set_progress_bar_config(disable=A_       )

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

       assert image.shape == (1, 512, 512, 3)
       UpperCamelCase     : Dict	     =       np.array(
           [0.7_65_92_78, 0.76_43_76_64, 0.75_57_91_07, 0.7_69_11_16, 0.77_66_69_86, 0.7_72_76_72, 0.7_75_86_64, 0.7_81_22_26, 0.76_94_25_15]       )

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





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint	,							provider="CPUExecutionProvider"       )
       UpperCamelCase     : Union[str, Any]	     =       EulerDiscreteScheduler.from_config(pipe.scheduler.config       )
       pipe.set_progress_bar_config(disable=A_       )

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

       assert image.shape == (1, 512, 512, 3)
       UpperCamelCase     : List[str]	     =       np.array(
           [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]       )
       assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-1





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Any	     =       OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint	,							provider="CPUExecutionProvider"       )
       UpperCamelCase     : Dict	     =       EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config       )
       pipe.set_progress_bar_config(disable=A_       )

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

       assert image.shape == (1, 512, 512, 3)
       UpperCamelCase     : Dict	     =       np.array(
           [0.77_42_44_96, 0.77_36_01, 0.7_64_52_88, 0.7_76_95_98, 0.7_77_27_39, 0.7_73_86_88, 0.78_18_72_33, 0.77_87_95_84, 0.76_70_43]       )

       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       ):
       '''simple docstring'''




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





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[Any]	     =       ort.SessionOptions()
       UpperCamelCase     : List[str]	     =       False
       return options





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




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

       UpperCamelCase     : List[str]	     =       "A fantasy landscape, trending on artstation"

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

       assert images.shape == (1, 512, 512, 3)
       UpperCamelCase     : Dict	     =       np.array([0.48_83, 0.49_47, 0.49_80, 0.49_75, 0.49_82, 0.49_80, 0.50_00, 0.50_06, 0.49_72]       )
       # 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       ):
       '''simple docstring'''




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

       UpperCamelCase     : List[str]	     =       "A fantasy landscape, trending on artstation"

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

       assert images.shape == (1, 512, 512, 3)
       UpperCamelCase     : Any	     =       np.array(
           [0.50_17_37_53, 0.50_22_33_56, 0.50_20_39, 0.50_23_30_36, 0.5_02_37_25, 0.5_02_26_01, 0.5_01_87_58, 0.50_23_40_85, 0.50_24_15_66]       )
       # 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

import numpy as np
from numpy import floataa
from numpy.typing import NDArray



def 		A_    (					_lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       )						->			list[float]:
 UpperCamelCase     ,   UpperCamelCase     : List[Any]	     =       coefficient_matrix.shape
 UpperCamelCase     ,   UpperCamelCase     : Optional[int]	     =       constant_matrix.shape

 if rowsa != colsa:
  UpperCamelCase     : List[Any]	     =       F"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
  raise ValueError(_lowerCAmelCase					)

 if colsa != 1:
  UpperCamelCase     : Any	     =       F"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
  raise ValueError(_lowerCAmelCase					)

 if rowsa != rowsa:
  UpperCamelCase     : Tuple	     =       (
      "Coefficient and constant matrices dimensions must be nxn and nx1 but "
      F"""received {rowsa}x{colsa} and {rowsa}x{colsa}"""
  )
  raise ValueError(_lowerCAmelCase					)

 if len(_lowerCAmelCase					) != rowsa:
  UpperCamelCase     : Any	     =       (
      "Number of initial values must be equal to number of rows in coefficient "
      F"""matrix but received {len(_lowerCAmelCase					)} and {rowsa}"""
  )
  raise ValueError(_lowerCAmelCase					)

 if iterations <= 0:
  raise ValueError("Iterations must be at least 1"					)

 UpperCamelCase     : NDArray[floataa]	     =       np.concatenate(
     (coefficient_matrix, constant_matrix)							,       axis=1					)

 UpperCamelCase     ,   UpperCamelCase     : str	     =       table.shape

 strictly_diagonally_dominant(_lowerCAmelCase					)

 # Iterates the whole matrix for given number of times
 for _ in range(_lowerCAmelCase					):
  UpperCamelCase     : Optional[Any]	     =       []
  for row in range(_lowerCAmelCase					):
   UpperCamelCase     : Optional[int]	     =       0
   for col in range(_lowerCAmelCase					):
    if col == row:
     UpperCamelCase     : Union[str, Any]	     =       table[row][col]
    elif col == cols - 1:
     UpperCamelCase     : List[Any]	     =       table[row][col]
    else:
     temp += (-1) * table[row][col] * init_val[col]
   UpperCamelCase     : Dict	     =       (temp + val) / denom
   new_val.append(_lowerCAmelCase					)
  UpperCamelCase     : List[str]	     =       new_val

 return [float(_lowerCAmelCase					) for i in new_val]



def 		A_    (					_lowerCAmelCase					)						->			bool:
 UpperCamelCase     ,   UpperCamelCase     : Dict	     =       table.shape

 UpperCamelCase     : List[Any]	     =       True

 for i in range(0							,       _lowerCAmelCase					):
  UpperCamelCase     : Union[str, Any]	     =       0
  for j in range(0							,       cols - 1					):
   if i == j:
    continue
   else:
    total += table[i][j]

  if table[i][i] <= total:
   raise ValueError("Coefficient matrix is not strictly diagonally dominant"					)

 return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
    import doctest

    doctest.testmod()
