


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 						A__							(		_lowercase   ,     unittest.TestCase  ):
      UpperCAmelCase             =						'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''




      def 							__UpperCamelCase				(       self					:      List[Any]				,    _a					:      List[str]=0  )							->     Dict:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =floats_tensor((1, 3, 128, 128)				,    rng=random.Random(A_  )  )
          _SCREAMING_SNAKE_CASE			  =np.random.RandomState(A_  )
          _SCREAMING_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 							__UpperCamelCase				(       self					:      str  )							->     Optional[int]:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint				,    provider='''CPUExecutionProvider'''  )
          pipe.set_progress_bar_config(disable=A_  )

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.6_96_43, 0.5_84_84, 0.5_03_14, 0.5_87_60, 0.5_53_68, 0.5_96_43, 0.5_15_29, 0.4_12_17, 0.4_90_87]  )
          assert np.abs(image_slice - expected_slice  ).max() < 1E-1




      def 							__UpperCamelCase				(       self					:      str  )							->     Union[str, Any]:


          """simple docstring"""





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

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.6_17_37, 0.5_46_42, 0.5_31_83, 0.5_44_65, 0.5_27_42, 0.6_05_25, 0.4_99_69, 0.4_06_55, 0.4_81_54]  )

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




      def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     Dict:


          """simple docstring"""





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

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

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.5_27_61, 0.5_99_77, 0.4_90_33, 0.4_96_19, 0.5_42_82, 0.5_03_11, 0.4_76_00, 0.4_09_18, 0.4_52_03]  )

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




      def 							__UpperCamelCase				(       self					:      int  )							->     Optional[int]:


          """simple docstring"""





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

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]  )

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




      def 							__UpperCamelCase				(       self					:      List[str]  )							->     Optional[int]:


          """simple docstring"""





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

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]  )

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




      def 							__UpperCamelCase				(       self					:      str  )							->     Optional[Any]:


          """simple docstring"""





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

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

          assert image.shape == (1, 128, 128, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.6_53_31, 0.5_82_77, 0.4_82_04, 0.5_60_59, 0.5_36_65, 0.5_62_35, 0.5_09_69, 0.4_00_09, 0.4_65_52]  )

          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					:      Any  )							->     Union[str, Any]:


          """simple docstring"""





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




      @property
      def 							__UpperCamelCase				(       self					:      Dict  )							->     str:


          """simple docstring"""





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




      def 							__UpperCamelCase				(       self					:      str  )							->     Tuple:


          """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((768, 512)  )
          # using the PNDM scheduler by default
          _SCREAMING_SNAKE_CASE			  =OnnxStableDiffusionImgaImgPipeline.from_pretrained(
              '''CompVis/stable-diffusion-v1-4'''				,    revision='''onnx'''				,    safety_checker=A_				,    feature_extractor=A_				,    provider=self.gpu_provider				,    sess_options=self.gpu_options				,    )
          pipe.set_progress_bar_config(disable=A_  )

          _SCREAMING_SNAKE_CASE			  ='''A fantasy landscape, trending on artstation'''

          _SCREAMING_SNAKE_CASE			  =np.random.RandomState(0  )
          _SCREAMING_SNAKE_CASE			  =pipe(
              prompt=A_				,    image=A_				,    strength=0.75				,    guidance_scale=7.5				,    num_inference_steps=10				,    generator=A_				,    output_type='''np'''				,    )
          _SCREAMING_SNAKE_CASE			  =output.images
          _SCREAMING_SNAKE_CASE			  =images[0, 255:258, 383:386, -1]

          assert images.shape == (1, 512, 768, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.49_09, 0.50_59, 0.53_72, 0.46_23, 0.48_76, 0.50_49, 0.48_20, 0.49_56, 0.50_19]  )
          # 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					:      Optional[Any]  )							->     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((768, 512)  )
          _SCREAMING_SNAKE_CASE			  =LMSDiscreteScheduler.from_pretrained(
              '''runwayml/stable-diffusion-v1-5'''				,    subfolder='''scheduler'''				,    revision='''onnx'''  )
          _SCREAMING_SNAKE_CASE			  =OnnxStableDiffusionImgaImgPipeline.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				,    )
          pipe.set_progress_bar_config(disable=A_  )

          _SCREAMING_SNAKE_CASE			  ='''A fantasy landscape, trending on artstation'''

          _SCREAMING_SNAKE_CASE			  =np.random.RandomState(0  )
          _SCREAMING_SNAKE_CASE			  =pipe(
              prompt=A_				,    image=A_				,    strength=0.75				,    guidance_scale=7.5				,    num_inference_steps=20				,    generator=A_				,    output_type='''np'''				,    )
          _SCREAMING_SNAKE_CASE			  =output.images
          _SCREAMING_SNAKE_CASE			  =images[0, 255:258, 383:386, -1]

          assert images.shape == (1, 512, 768, 3)
          _SCREAMING_SNAKE_CASE			  =np.array([0.80_43, 0.9_26, 0.95_81, 0.81_19, 0.89_54, 0.9_13, 0.72_09, 0.74_63, 0.74_31]  )
          # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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



import string
from math import logaa







def 						lowerCamelCase(   a__	,a__):
				_SCREAMING_SNAKE_CASE			  =document.translate(
				    str.maketrans(''''''	,''''''	,string.punctuation)).replace('''\n'''	,'''''')
				_SCREAMING_SNAKE_CASE			  =document_without_punctuation.split(''' ''')  # word tokenization
				return len([word for word in tokenize_document if word.lower() == term.lower()])







def 						lowerCamelCase(   a__	,a__):
				_SCREAMING_SNAKE_CASE			  =corpus.lower().translate(
				    str.maketrans(''''''	,''''''	,string.punctuation))  # strip all punctuation and replace it with ''
				_SCREAMING_SNAKE_CASE			  =corpus_without_punctuation.split('''\n''')
				_SCREAMING_SNAKE_CASE			  =term.lower()
				return (len([doc for doc in docs if term in doc]), len(a__))







def 						lowerCamelCase(   a__	,a__	,a__=False):
				if smoothing:
								if n == 0:
												raise ValueError('''log10(0) is undefined.''')
								return round(1 + logaa(n / (1 + df))	,3)

				if df == 0:
								raise ZeroDivisionError('''df must be > 0''')
				elif n == 0:
								raise ValueError('''log10(0) is undefined.''')
				return round(logaa(n / df)	,3)







def 						lowerCamelCase(   a__	,a__):
				return round(tf * idf	,3)