



"""simple docstring"""






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 			__snake_case			(      SCREAMING_SNAKE_CASE__    ,	unittest.TestCase):
  snake_case__							:  Tuple         =		"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"




  def 		SCREAMING_SNAKE_CASE							(					self	:		Dict		,   __lowerCAmelCase	:		int=0						):






         """simple docstring"""






         _lowerCamelCase		:							Any            =					floats_tensor((1, 3, 1_2_8, 1_2_8)		,   rng=random.Random(_lowercase						)						)
         _lowerCamelCase		:							List[Any]            =					np.random.RandomState(_lowercase						)
         _lowerCamelCase		:							int            =					{
             "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 		SCREAMING_SNAKE_CASE							(					self	:		Dict						):






         """simple docstring"""






         _lowerCamelCase		:							str            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         pipe.set_progress_bar_config(disable=_lowercase						)

         _lowerCamelCase		:							int            =					self.get_dummy_inputs()
         _lowerCamelCase		:							Dict            =					pipe(**_lowercase						).images
         _lowerCamelCase		:							Optional[int]            =					image[0, -3:, -3:, -1].flatten()

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






         """simple docstring"""






         _lowerCamelCase		:							Union[str, Any]            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         _lowerCamelCase		:							int            =					PNDMScheduler.from_config(pipe.scheduler.config		,   skip_prk_steps=_lowercase						)
         pipe.set_progress_bar_config(disable=_lowercase						)

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

         assert image.shape == (1, 1_2_8, 1_2_8, 3)
         _lowerCamelCase		:							Any            =					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 		SCREAMING_SNAKE_CASE							(					self	:		Union[str, Any]						):






         """simple docstring"""






         _lowerCamelCase		:							Dict            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         _lowerCamelCase		:							Optional[int]            =					LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
         pipe.set_progress_bar_config(disable=_lowercase						)

         # warmup pass to apply optimizations
         _lowerCamelCase		:							Union[str, Any]            =					pipe(**self.get_dummy_inputs()						)

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

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






         """simple docstring"""






         _lowerCamelCase		:							List[Any]            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         _lowerCamelCase		:							Optional[Any]            =					EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
         pipe.set_progress_bar_config(disable=_lowercase						)

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

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






         """simple docstring"""






         _lowerCamelCase		:							Optional[int]            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         _lowerCamelCase		:							List[str]            =					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
         pipe.set_progress_bar_config(disable=_lowercase						)

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

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






         """simple docstring"""






         _lowerCamelCase		:							Tuple            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,   provider='''CPUExecutionProvider'''						)
         _lowerCamelCase		:							Tuple            =					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
         pipe.set_progress_bar_config(disable=_lowercase						)

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

         assert image.shape == (1, 1_2_8, 1_2_8, 3)
         _lowerCamelCase		:							Optional[Any]            =					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 			__snake_case			(      unittest.TestCase):




  @property
  def 		SCREAMING_SNAKE_CASE							(					self	:		int						):






         """simple docstring"""






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




  @property
  def 		SCREAMING_SNAKE_CASE							(					self	:		str						):






         """simple docstring"""






         _lowerCamelCase		:							str            =					ort.SessionOptions()
         _lowerCamelCase		:							Optional[int]            =					False
         return options




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[Any]						):






         """simple docstring"""






         _lowerCamelCase		:							List[Any]            =					load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/img2img/sketch-mountains-input.jpg'''						)
         _lowerCamelCase		:							List[str]            =					init_image.resize((7_6_8, 5_1_2)						)
         # using the PNDM scheduler by default
         _lowerCamelCase		:							Union[str, Any]            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(
             '''CompVis/stable-diffusion-v1-4'''		,   revision='''onnx'''		,   safety_checker=_lowercase		,   feature_extractor=_lowercase		,   provider=self.gpu_provider		,   sess_options=self.gpu_options		,   )
         pipe.set_progress_bar_config(disable=_lowercase						)

         _lowerCamelCase		:							Union[str, Any]            =					"A fantasy landscape, trending on artstation"

         _lowerCamelCase		:							int            =					np.random.RandomState(0						)
         _lowerCamelCase		:							List[str]            =					pipe(
             prompt=_lowercase		,   image=_lowercase		,   strength=0.75		,   guidance_scale=7.5		,   num_inference_steps=1_0		,   generator=_lowercase		,   output_type='''np'''		,   )
         _lowerCamelCase		:							Optional[int]            =					output.images
         _lowerCamelCase		:							Union[str, Any]            =					images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

         assert images.shape == (1, 5_1_2, 7_6_8, 3)
         _lowerCamelCase		:							str            =					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 		SCREAMING_SNAKE_CASE							(					self	:		Any						):






         """simple docstring"""






         _lowerCamelCase		:							List[str]            =					load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/img2img/sketch-mountains-input.jpg'''						)
         _lowerCamelCase		:							str            =					init_image.resize((7_6_8, 5_1_2)						)
         _lowerCamelCase		:							Dict            =					LMSDiscreteScheduler.from_pretrained(
             '''runwayml/stable-diffusion-v1-5'''		,   subfolder='''scheduler'''		,   revision='''onnx'''						)
         _lowerCamelCase		:							Optional[int]            =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(
             '''runwayml/stable-diffusion-v1-5'''		,   revision='''onnx'''		,   scheduler=_lowercase		,   safety_checker=_lowercase		,   feature_extractor=_lowercase		,   provider=self.gpu_provider		,   sess_options=self.gpu_options		,   )
         pipe.set_progress_bar_config(disable=_lowercase						)

         _lowerCamelCase		:							List[Any]            =					"A fantasy landscape, trending on artstation"

         _lowerCamelCase		:							int            =					np.random.RandomState(0						)
         _lowerCamelCase		:							Union[str, Any]            =					pipe(
             prompt=_lowercase		,   image=_lowercase		,   strength=0.75		,   guidance_scale=7.5		,   num_inference_steps=2_0		,   generator=_lowercase		,   output_type='''np'''		,   )
         _lowerCamelCase		:							Dict            =					output.images
         _lowerCamelCase		:							Optional[Any]            =					images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

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







"""simple docstring"""







import importlib
import inspect
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
A		=						'src/transformers'


# This is to make sure the transformers module imported is the one in the repo.
A		=						importlib.util.spec_from_file_location(
    'transformers',
    os.path.join(PATH_TO_TRANSFORMERS, '__init__.py'),
    submodule_search_locations=[PATH_TO_TRANSFORMERS],
)
A		=						spec.loader.load_module()

A		=						transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
A		=						re.compile('\[(.+?)\]\((https://huggingface\.co/.+?)\)')


A		=						{
    'CLIPConfigMixin',
    'DecisionTransformerConfigMixin',
    'EncoderDecoderConfigMixin',
    'RagConfigMixin',
    'SpeechEncoderDecoderConfigMixin',
    'VisionEncoderDecoderConfigMixin',
    'VisionTextDualEncoderConfigMixin',
}

def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						snake_case   :			Union[str, Any]						    = []

						for config_class in list(CONFIG_MAPPING.values() ):
												snake_case   :			List[str]						    = False

												# source code of `config_class`
												snake_case   :			Optional[int]						    = inspect.getsource(lowerCamelCase_ )
												snake_case   :			Optional[int]						    = _re_checkpoint.findall(lowerCamelCase_ )

												for checkpoint in checkpoints:
																		# Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
																		# For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
																		snake_case    ,			snake_case   :			Tuple						    = checkpoint

																		# verify the checkpoint name corresponds to the checkpoint link
																		snake_case   :			Any						    = f'''https://huggingface.co/{ckpt_name}'''
																		if ckpt_link == ckpt_link_from_name:
																								snake_case   :			List[str]						    = True
																								break

												snake_case   :			Any						    = config_class.__name__
												if not checkpoint_found and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
																		configs_without_checkpoint.append(lowerCamelCase_ )

						if len(lowerCamelCase_ ) > 0:
												snake_case   :			List[str]						    = "\n".join(sorted(lowerCamelCase_ ) )
												raise ValueError(f'''The following configurations don\'t contain any valid checkpoint:\n{message}''' )


if __name__ == "__main__":
			check_config_docstrings_have_checkpoints()



