



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_					( _UpperCAmelCase     ,      unittest.TestCase):
							lowerCamelCase__         =	"""hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""







							def      snake_case__   (     self,    __a=0):

														'''simple docstring'''

														_lowerCAmelCase  :							List[str]				     =					np.random.RandomState(lowercase__)
														_lowerCAmelCase  :							List[str]				     =					{
														    """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      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Dict				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							Union[str, Any]				     =					np.array([0.65_072, 0.58_492, 0.48_219, 0.55_521, 0.53_180, 0.55_939, 0.50_697, 0.39_800, 0.46_455])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														_lowerCAmelCase  :							Union[str, Any]				     =					PNDMScheduler.from_config(pipe.scheduler.config,    skip_prk_steps=lowercase__)
														pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							Tuple				     =					np.array([0.65_863, 0.59_425, 0.49_326, 0.56_313, 0.53_875, 0.56_627, 0.51_065, 0.39_777, 0.46_330])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														_lowerCAmelCase  :							Any				     =					LMSDiscreteScheduler.from_config(pipe.scheduler.config)
														pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							Dict				     =					np.array([0.53_755, 0.60_786, 0.47_402, 0.49_488, 0.51_869, 0.49_819, 0.47_985, 0.38_957, 0.44_279])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[Any]				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														_lowerCAmelCase  :							Optional[int]				     =					EulerDiscreteScheduler.from_config(pipe.scheduler.config)
														pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							Tuple				     =					np.array([0.53_755, 0.60_786, 0.47_402, 0.49_488, 0.51_869, 0.49_819, 0.47_985, 0.38_957, 0.44_279])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							int				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														_lowerCAmelCase  :							Optional[int]				     =					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
														pipe.set_progress_bar_config(disable=lowercase__)

														_lowerCAmelCase  :							Union[str, Any]				     =					self.get_dummy_inputs()
														_lowerCAmelCase  :							Optional[Any]				     =					pipe(**lowercase__).images
														_lowerCAmelCase  :							Dict				     =					image[0, -3:, -3:, -1]

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							str				     =					np.array([0.53_817, 0.60_812, 0.47_384, 0.49_530, 0.51_894, 0.49_814, 0.47_984, 0.38_958, 0.44_271])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														_lowerCAmelCase  :							Union[str, Any]				     =					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
														pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 128, 128, 3)
														_lowerCAmelCase  :							Tuple				     =					np.array([0.53_895, 0.60_808, 0.47_933, 0.49_608, 0.51_886, 0.49_950, 0.48_053, 0.38_957, 0.44_200])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Dict				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														pipe.set_progress_bar_config(disable=lowercase__)

														_lowerCAmelCase  :							Tuple				     =					self.get_dummy_inputs()
														_lowerCAmelCase  :							List[Any]				     =					3 * [inputs["""prompt"""]]

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

														_lowerCAmelCase  :							Optional[int]				     =					self.get_dummy_inputs()
														_lowerCAmelCase  :							Optional[int]				     =					3 * [inputs.pop("prompt")]

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

														_lowerCAmelCase  :							Dict				     =					pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0]

														_lowerCAmelCase  :							Optional[int]				     =					prompt_embeds

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

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint,    provider="CPUExecutionProvider")
														pipe.set_progress_bar_config(disable=lowercase__)

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

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

														_lowerCAmelCase  :							Optional[int]				     =					self.get_dummy_inputs()
														_lowerCAmelCase  :							List[Any]				     =					3 * [inputs.pop("prompt")]

														_lowerCAmelCase  :							List[Any]				     =					[]
														for p in [prompt, negative_prompt]:
																					_lowerCAmelCase  :							str				     =					pipe.tokenizer(
																					    lowercase__,    padding="max_length",    max_length=pipe.tokenizer.model_max_length,    truncation=lowercase__,    return_tensors="np",    )
																					_lowerCAmelCase  :							Any				     =					text_inputs["""input_ids"""]

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

														_lowerCAmelCase  :							str				     =					embeds

														# forward
														_lowerCAmelCase  :							str				     =					pipe(**lowercase__)
														_lowerCAmelCase  :							int				     =					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      snake_case__   (     self):

														'''simple docstring'''

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







							@property
							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					ort.SessionOptions()
														_lowerCAmelCase  :							Any				     =					False
														return options







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[Any]				     =					OnnxStableDiffusionPipeline.from_pretrained(
														    "CompVis/stable-diffusion-v1-4",    revision="onnx",    safety_checker=lowercase__,    feature_extractor=lowercase__,    provider=self.gpu_provider,    sess_options=self.gpu_options,    )
														sd_pipe.set_progress_bar_config(disable=lowercase__)

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

														_lowerCAmelCase  :							Optional[Any]				     =					image[0, -3:, -3:, -1]

														assert image.shape == (1, 512, 512, 3)
														_lowerCAmelCase  :							Dict				     =					np.array([0.0_452, 0.0_390, 0.0_087, 0.0_350, 0.0_617, 0.0_364, 0.0_544, 0.0_523, 0.0_720])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					DDIMScheduler.from_pretrained(
														    "runwayml/stable-diffusion-v1-5",    subfolder="scheduler",    revision="onnx")
														_lowerCAmelCase  :							List[str]				     =					OnnxStableDiffusionPipeline.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,    )
														sd_pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 512, 512, 3)
														_lowerCAmelCase  :							str				     =					np.array([0.2_867, 0.1_974, 0.1_481, 0.7_294, 0.7_251, 0.6_667, 0.4_194, 0.5_642, 0.6_486])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[Any]				     =					LMSDiscreteScheduler.from_pretrained(
														    "runwayml/stable-diffusion-v1-5",    subfolder="scheduler",    revision="onnx")
														_lowerCAmelCase  :							List[Any]				     =					OnnxStableDiffusionPipeline.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,    )
														sd_pipe.set_progress_bar_config(disable=lowercase__)

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

														assert image.shape == (1, 512, 512, 3)
														_lowerCAmelCase  :							Optional[int]				     =					np.array([0.2_306, 0.1_959, 0.1_593, 0.6_549, 0.6_394, 0.5_408, 0.5_065, 0.6_010, 0.6_161])

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					0

														def test_callback_fn(__a,    __a,    __a) -> None:
																					_lowerCAmelCase  :							Optional[int]				     =					True
																					nonlocal number_of_steps
																					number_of_steps += 1
																					if step == 0:
																												assert latents.shape == (1, 4, 64, 64)
																												_lowerCAmelCase  :							str				     =					latents[0, -3:, -3:, -1]
																												_lowerCAmelCase  :							str				     =					np.array(
																												    [-0.6_772, -0.3_835, -1.2_456, 0.1_905, -1.0_974, 0.6_967, -1.9_353, 0.0_178, 1.0_167])

																												assert np.abs(latents_slice.flatten() - expected_slice).max() < 1E-3
																					elif step == 5:
																												assert latents.shape == (1, 4, 64, 64)
																												_lowerCAmelCase  :							Union[str, Any]				     =					latents[0, -3:, -3:, -1]
																												_lowerCAmelCase  :							Optional[Any]				     =					np.array(
																												    [-0.3_351, 0.2_241, -0.1_837, -0.2_325, -0.6_577, 0.3_393, -0.0_241, 0.5_899, 1.3_875])

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

														_lowerCAmelCase  :							Union[str, Any]				     =					False

														_lowerCAmelCase  :							Any				     =					OnnxStableDiffusionPipeline.from_pretrained(
														    "runwayml/stable-diffusion-v1-5",    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  :							Optional[int]				     =					"""Andromeda galaxy in a bottle"""

														_lowerCAmelCase  :							Union[str, Any]				     =					np.random.RandomState(0)
														pipe(
														    prompt=lowercase__,    num_inference_steps=5,    guidance_scale=7.5,    generator=lowercase__,    callback=lowercase__,    callback_steps=1,    )
														assert test_callback_fn.has_been_called
														assert number_of_steps == 6







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					OnnxStableDiffusionPipeline.from_pretrained(
														    "runwayml/stable-diffusion-v1-5",    revision="onnx",    safety_checker=lowercase__,    feature_extractor=lowercase__,    provider=self.gpu_provider,    sess_options=self.gpu_options,    )
														assert isinstance(lowercase__,    lowercase__)
														assert pipe.safety_checker is None

														_lowerCAmelCase  :							int				     =					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(lowercase__)
																					_lowerCAmelCase  :							int				     =					OnnxStableDiffusionPipeline.from_pretrained(lowercase__)

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











import requests
from bsa import BeautifulSoup






def        A       (      _lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							_lowerCAmelCase  :							List[str]				     =					BeautifulSoup(requests.get(_lowerCamelCase       ,				params=_lowerCamelCase						).content       ,				"html.parser"						)
							_lowerCAmelCase  :							Any				     =					soup.find("div"       ,				attrs={"class": "gs_ri"}						)
							_lowerCAmelCase  :							str				     =					div.find("div"       ,				attrs={"class": "gs_fl"}						).find_all("a"						)
							return anchors[2].get_text()


if __name__ == "__main__":
						_snake_case	=						{
						    "title": (
						        "Precisely geometry controlled microsupercapacitors for ultrahigh areal "
						        "capacitance, volumetric capacitance, and energy density"
						    ),
						    "journal": "Chem. Mater.",
						    "volume": 30,
						    "pages": "3979-3990",
						    "year": 2018,
						    "hl": "en",
						}
						print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
