






"""simple docstring"""



import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
						import onnxruntime as ort





class 					_UpperCAmelCase       ( _lowercase   ,						unittest.TestCase							):
					SCREAMING_SNAKE_CASE_		:				str							    =   "hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"




					def   A  (				self     :						List[Any]    ,						A     :						Optional[int]=0   )  ->  List[Any]:
							lowercase_ : Tuple							       =   np.random.RandomState(UpperCamelCase__   )
							lowercase_ : Union[str, Any]							       =   {
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 7.5,
							    """output_type""": """numpy""",
							}
							return inputs




					def   A  (				self     :						int   )  ->  List[Any]:
							lowercase_ : Optional[Any]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : List[Any]							       =   np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]   )

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




					def   A  (				self     :						int   )  ->  Dict:
							lowercase_ : List[Any]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							lowercase_ : Optional[Any]							       =   PNDMScheduler.from_config(pipe.scheduler.config    ,						skip_prk_steps=UpperCamelCase__   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : str							       =   np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]   )

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




					def   A  (				self     :						List[str]   )  ->  int:
							lowercase_ : Union[str, Any]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							lowercase_ : Dict							       =   LMSDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : Union[str, Any]							       =   np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]   )

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




					def   A  (				self     :						Any   )  ->  Dict:
							lowercase_ : Tuple							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							lowercase_ : str							       =   EulerDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : List[str]							       =   np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]   )

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




					def   A  (				self     :						Any   )  ->  Tuple:
							lowercase_ : List[str]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							lowercase_ : Union[str, Any]							       =   EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : Any							       =   np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]   )

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




					def   A  (				self     :						List[Any]   )  ->  Optional[Any]:
							lowercase_ : Optional[Any]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							lowercase_ : Optional[int]							       =   DPMSolverMultistepScheduler.from_config(pipe.scheduler.config   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

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

							assert image.shape == (1, 1_28, 1_28, 3)
							lowercase_ : List[Any]							       =   np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]   )

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




					def   A  (				self     :						Tuple   )  ->  int:
							lowercase_ : List[str]							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : str							       =   self.get_dummy_inputs()
							lowercase_ : int							       =   3 * [inputs["""prompt"""]]

							# forward
							lowercase_ : Optional[Any]							       =   pipe(**UpperCamelCase__   )
							lowercase_ : Optional[int]							       =   output.images[0, -3:, -3:, -1]

							lowercase_ : List[Any]							       =   self.get_dummy_inputs()
							lowercase_ : int							       =   3 * [inputs.pop('''prompt'''   )]

							lowercase_ : Any							       =   pipe.tokenizer(
							    UpperCamelCase__    ,						padding='''max_length'''    ,						max_length=pipe.tokenizer.model_max_length    ,						truncation=UpperCamelCase__    ,						return_tensors='''np'''    ,						)
							lowercase_ : str							       =   text_inputs["""input_ids"""]

							lowercase_ : Optional[Any]							       =   pipe.text_encoder(input_ids=text_inputs.astype(np.intaa   )   )[0]

							lowercase_ : Union[str, Any]							       =   prompt_embeds

							# forward
							lowercase_ : Dict							       =   pipe(**UpperCamelCase__   )
							lowercase_ : str							       =   output.images[0, -3:, -3:, -1]

							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()   ).max() < 1e-4






					def   A  (				self     :						str   )  ->  Dict:
							lowercase_ : Tuple							       =   OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint    ,						provider='''CPUExecutionProvider'''   )
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : List[str]							       =   self.get_dummy_inputs()
							lowercase_ : Tuple							       =   3 * ["""this is a negative prompt"""]
							lowercase_ : Dict							       =   negative_prompt
							lowercase_ : Dict							       =   3 * [inputs["""prompt"""]]

							# forward
							lowercase_ : str							       =   pipe(**UpperCamelCase__   )
							lowercase_ : List[str]							       =   output.images[0, -3:, -3:, -1]

							lowercase_ : List[str]							       =   self.get_dummy_inputs()
							lowercase_ : Optional[Any]							       =   3 * [inputs.pop('''prompt'''   )]

							lowercase_ : Optional[Any]							       =   []
							for p in [prompt, negative_prompt]:
									lowercase_ : List[str]							       =   pipe.tokenizer(
									    UpperCamelCase__    ,						padding='''max_length'''    ,						max_length=pipe.tokenizer.model_max_length    ,						truncation=UpperCamelCase__    ,						return_tensors='''np'''    ,						)
									lowercase_ : Union[str, Any]							       =   text_inputs["""input_ids"""]

									embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa   )   )[0]   )

							lowercase_ : List[Any]							       =   embeds

							# forward
							lowercase_ : Dict							       =   pipe(**UpperCamelCase__   )
							lowercase_ : Any							       =   output.images[0, -3:, -3:, -1]

							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()   ).max() < 1e-4





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




					@property
					def   A  (				self     :						int   )  ->  Union[str, Any]:
							return (
							    "CUDAExecutionProvider",
							    {
							        "gpu_mem_limit": "15000000000",  # 15GB
							        "arena_extend_strategy": "kSameAsRequested",
							    },
							)




					@property
					def   A  (				self     :						Dict   )  ->  List[str]:
							lowercase_ : Tuple							       =   ort.SessionOptions()
							lowercase_ : List[str]							       =   False
							return options




					def   A  (				self     :						Optional[int]   )  ->  Dict:
							# using the PNDM scheduler by default
							lowercase_ : List[Any]							       =   OnnxStableDiffusionPipeline.from_pretrained(
							    '''CompVis/stable-diffusion-v1-4'''    ,						revision='''onnx'''    ,						safety_checker=UpperCamelCase__    ,						feature_extractor=UpperCamelCase__    ,						provider=self.gpu_provider    ,						sess_options=self.gpu_options    ,						)
							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : Tuple							       =   """A painting of a squirrel eating a burger"""
							np.random.seed(0   )
							lowercase_ : Any							       =   sd_pipe([prompt]    ,						guidance_scale=6.0    ,						num_inference_steps=10    ,						output_type='''np'''   )
							lowercase_ : Any							       =   output.images

							lowercase_ : Union[str, Any]							       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							lowercase_ : List[Any]							       =   np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]   )

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




					def   A  (				self     :						int   )  ->  List[str]:
							lowercase_ : str							       =   DDIMScheduler.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						subfolder='''scheduler'''    ,						revision='''onnx'''   )
							lowercase_ : Tuple							       =   OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						revision='''onnx'''    ,						scheduler=UpperCamelCase__    ,						safety_checker=UpperCamelCase__    ,						feature_extractor=UpperCamelCase__    ,						provider=self.gpu_provider    ,						sess_options=self.gpu_options    ,						)
							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : Any							       =   """open neural network exchange"""
							lowercase_ : Optional[int]							       =   np.random.RandomState(0   )
							lowercase_ : Any							       =   sd_pipe([prompt]    ,						guidance_scale=7.5    ,						num_inference_steps=10    ,						generator=UpperCamelCase__    ,						output_type='''np'''   )
							lowercase_ : int							       =   output.images
							lowercase_ : Any							       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							lowercase_ : List[Any]							       =   np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]   )

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




					def   A  (				self     :						List[str]   )  ->  str:
							lowercase_ : Dict							       =   LMSDiscreteScheduler.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						subfolder='''scheduler'''    ,						revision='''onnx'''   )
							lowercase_ : Dict							       =   OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						revision='''onnx'''    ,						scheduler=UpperCamelCase__    ,						safety_checker=UpperCamelCase__    ,						feature_extractor=UpperCamelCase__    ,						provider=self.gpu_provider    ,						sess_options=self.gpu_options    ,						)
							sd_pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : Dict							       =   """open neural network exchange"""
							lowercase_ : List[str]							       =   np.random.RandomState(0   )
							lowercase_ : Optional[Any]							       =   sd_pipe([prompt]    ,						guidance_scale=7.5    ,						num_inference_steps=10    ,						generator=UpperCamelCase__    ,						output_type='''np'''   )
							lowercase_ : List[Any]							       =   output.images
							lowercase_ : List[str]							       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_12, 5_12, 3)
							lowercase_ : Optional[int]							       =   np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]   )

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




					def   A  (				self     :						Dict   )  ->  Any:
							lowercase_ : List[str]							       =   0

							def test_callback_fn(A     :						int    ,						A     :						int    ,						A     :						np.ndarray   ) -> None:
									lowercase_ : str							       =   True
									nonlocal number_of_steps
									number_of_steps += 1
									if step == 0:
											assert latents.shape == (1, 4, 64, 64)
											lowercase_ : Optional[Any]							       =   latents[0, -3:, -3:, -1]
											lowercase_ : Any							       =   np.array(
											    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]   )

											assert np.abs(latents_slice.flatten() - expected_slice   ).max() < 1e-3
									elif step == 5:
											assert latents.shape == (1, 4, 64, 64)
											lowercase_ : List[str]							       =   latents[0, -3:, -3:, -1]
											lowercase_ : Optional[int]							       =   np.array(
											    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]   )

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

							lowercase_ : Tuple							       =   False

							lowercase_ : str							       =   OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						revision='''onnx'''    ,						safety_checker=UpperCamelCase__    ,						feature_extractor=UpperCamelCase__    ,						provider=self.gpu_provider    ,						sess_options=self.gpu_options    ,						)
							pipe.set_progress_bar_config(disable=UpperCamelCase__   )

							lowercase_ : Optional[Any]							       =   """Andromeda galaxy in a bottle"""

							lowercase_ : Optional[int]							       =   np.random.RandomState(0   )
							pipe(
							    prompt=UpperCamelCase__    ,						num_inference_steps=5    ,						guidance_scale=7.5    ,						generator=UpperCamelCase__    ,						callback=UpperCamelCase__    ,						callback_steps=1    ,						)
							assert test_callback_fn.has_been_called
							assert number_of_steps == 6






					def   A  (				self     :						Tuple   )  ->  Union[str, Any]:
							lowercase_ : Dict							       =   OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''    ,						revision='''onnx'''    ,						safety_checker=UpperCamelCase__    ,						feature_extractor=UpperCamelCase__    ,						provider=self.gpu_provider    ,						sess_options=self.gpu_options    ,						)
							assert isinstance(UpperCamelCase__    ,						UpperCamelCase__   )
							assert pipe.safety_checker is None

							lowercase_ : Tuple							       =   pipe('''example prompt'''    ,						num_inference_steps=2   ).images[0]
							assert image is not None

							# check that there's no error when saving a pipeline with one of the models being None
							with tempfile.TemporaryDirectory() as tmpdirname:
									pipe.save_pretrained(UpperCamelCase__   )
									lowercase_ : Dict							       =   OnnxStableDiffusionPipeline.from_pretrained(UpperCamelCase__   )

							# sanity check that the pipeline still works
							assert pipe.safety_checker is None
							lowercase_ : Optional[Any]							       =   pipe('''example prompt'''    ,						num_inference_steps=2   ).images[0]
							assert image is not None











'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


_A	:			Dict         ={'''tokenization_herbert''': ['''HerbertTokenizer''']}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A	:			Optional[int]         =['''HerbertTokenizerFast''']


if TYPE_CHECKING:
			from .tokenization_herbert import HerbertTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_herbert_fast import HerbertTokenizerFast

else:
			import sys

			_A	:			Optional[int]         =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

