




"""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 					__magic_name__							( lowerCamelCase__		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"





				def      _lowerCAmelCase       ( self	,				_a=0				):





							"""simple docstring"""
							lowerCamelCase       =      np.random.RandomState(__lowerCamelCase				)
							lowerCamelCase       =      {
							    '''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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							lowerCamelCase       =      PNDMScheduler.from_config(pipe.scheduler.config	,				skip_prk_steps=__lowerCamelCase				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							lowerCamelCase       =      LMSDiscreteScheduler.from_config(pipe.scheduler.config				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							lowerCamelCase       =      EulerDiscreteScheduler.from_config(pipe.scheduler.config				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							lowerCamelCase       =      EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							lowerCamelCase       =      DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 128, 128, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

							lowerCamelCase       =      self.get_dummy_inputs()
							lowerCamelCase       =      3 * [inputs['''prompt''']]

							# forward
							lowerCamelCase       =      pipe(**__lowerCamelCase				)
							lowerCamelCase       =      output.images[0, -3:, -3:, -1]

							lowerCamelCase       =      self.get_dummy_inputs()
							lowerCamelCase       =      3 * [inputs.pop("""prompt"""				)]

							lowerCamelCase       =      pipe.tokenizer(
							    __lowerCamelCase	,				padding="""max_length"""	,				max_length=pipe.tokenizer.model_max_length	,				truncation=__lowerCamelCase	,				return_tensors="""np"""	,				)
							lowerCamelCase       =      text_inputs['''input_ids''']

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

							lowerCamelCase       =      prompt_embeds

							# forward
							lowerCamelCase       =      pipe(**__lowerCamelCase				)
							lowerCamelCase       =      output.images[0, -3:, -3:, -1]

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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,				provider="""CPUExecutionProvider"""				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

							lowerCamelCase       =      self.get_dummy_inputs()
							lowerCamelCase       =      3 * ['''this is a negative prompt''']
							lowerCamelCase       =      negative_prompt
							lowerCamelCase       =      3 * [inputs['''prompt''']]

							# forward
							lowerCamelCase       =      pipe(**__lowerCamelCase				)
							lowerCamelCase       =      output.images[0, -3:, -3:, -1]

							lowerCamelCase       =      self.get_dummy_inputs()
							lowerCamelCase       =      3 * [inputs.pop("""prompt"""				)]

							lowerCamelCase       =      []
							for p in [prompt, negative_prompt]:
										lowerCamelCase       =      pipe.tokenizer(
										    __lowerCamelCase	,				padding="""max_length"""	,				max_length=pipe.tokenizer.model_max_length	,				truncation=__lowerCamelCase	,				return_tensors="""np"""	,				)
										lowerCamelCase       =      text_inputs['''input_ids''']

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

							lowerCamelCase       =      embeds

							# forward
							lowerCamelCase       =      pipe(**__lowerCamelCase				)
							lowerCamelCase       =      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 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				@property
				def      _lowerCAmelCase       ( self				):





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





				@property
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      ort.SessionOptions()
							lowerCamelCase       =      False
							return options





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(
							    """CompVis/stable-diffusion-v1-4"""	,				revision="""onnx"""	,				safety_checker=__lowerCamelCase	,				feature_extractor=__lowerCamelCase	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
							sd_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							lowerCamelCase       =      image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      DDIMScheduler.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				subfolder="""scheduler"""	,				revision="""onnx"""				)
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				revision="""onnx"""	,				scheduler=__lowerCamelCase	,				safety_checker=__lowerCamelCase	,				feature_extractor=__lowerCamelCase	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
							sd_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      LMSDiscreteScheduler.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				subfolder="""scheduler"""	,				revision="""onnx"""				)
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				revision="""onnx"""	,				scheduler=__lowerCamelCase	,				safety_checker=__lowerCamelCase	,				feature_extractor=__lowerCamelCase	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
							sd_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

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

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      0

							def test_callback_fn(_a	,				_a	,				_a				) -> None:
										lowerCamelCase       =      True
										nonlocal number_of_steps
										number_of_steps += 1
										if step == 0:
													assert latents.shape == (1, 4, 64, 64)
													lowerCamelCase       =      latents[0, -3:, -3:, -1]
													lowerCamelCase       =      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       =      latents[0, -3:, -3:, -1]
													lowerCamelCase       =      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       =      False

							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				revision="""onnx"""	,				safety_checker=__lowerCamelCase	,				feature_extractor=__lowerCamelCase	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
							pipe.set_progress_bar_config(disable=__lowerCamelCase				)

							lowerCamelCase       =      '''Andromeda galaxy in a bottle'''

							lowerCamelCase       =      np.random.RandomState(0				)
							pipe(
							    prompt=__lowerCamelCase	,				num_inference_steps=5	,				guidance_scale=7.5	,				generator=__lowerCamelCase	,				callback=__lowerCamelCase	,				callback_steps=1	,				)
							assert test_callback_fn.has_been_called
							assert number_of_steps == 6





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""	,				revision="""onnx"""	,				safety_checker=__lowerCamelCase	,				feature_extractor=__lowerCamelCase	,				provider=self.gpu_provider	,				sess_options=self.gpu_options	,				)
							assert isinstance(__lowerCamelCase	,				__lowerCamelCase				)
							assert pipe.safety_checker is None

							lowerCamelCase       =      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(__lowerCamelCase				)
										lowerCamelCase       =      OnnxStableDiffusionPipeline.from_pretrained(__lowerCamelCase				)

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









"""simple docstring"""




from operator import delitem, getitem, setitem

import pytest

from data_structures.hashing.hash_map import HashMap



def 					a__				(       snake_case__       )		->      List[str]:
			return getitem, k



def 					a__				(       snake_case__ ,				snake_case__       )		->      Optional[Any]:
			return setitem, k, v



def 					a__				(       snake_case__       )		->      str:
			return delitem, k



def 					a__				(       snake_case__ ,				snake_case__ ,				*snake_case__       )		->      Union[str, Any]:
			try:
						return fun(snake_case__ ,				*snake_case__       ), None
			except Exception as e:
						return None, e


lowerCAmelCase							:    Optional[int]  							=							(
    _set("""key_a""", """val_a"""),
    _set("""key_b""", """val_b"""),
)

lowerCAmelCase							:    List[Any]  							=							[
    _set("""key_a""", """val_a"""),
    _set("""key_a""", """val_b"""),
]

lowerCAmelCase							:    List[Any]  							=							[
    _set("""key_a""", """val_a"""),
    _set("""key_b""", """val_b"""),
    _del("""key_a"""),
    _del("""key_b"""),
    _set("""key_a""", """val_a"""),
    _del("""key_a"""),
]

lowerCAmelCase							:    List[Any]  							=							[
    _get("""key_a"""),
    _del("""key_a"""),
    _set("""key_a""", """val_a"""),
    _del("""key_a"""),
    _del("""key_a"""),
    _get("""key_a"""),
]

lowerCAmelCase							:    Tuple  							=							[
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
]

lowerCAmelCase							:    Tuple  							=							[
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
    *[_del(x) for x in range(5)],
    _set("""key_a""", """val_b"""),
]



@pytest.mark.parametrize(
    """operations""" ,				(
        pytest.param(_add_items ,				id="""add items"""       ),
        pytest.param(_overwrite_items ,				id="""overwrite items"""       ),
        pytest.param(_delete_items ,				id="""delete items"""       ),
        pytest.param(_access_absent_items ,				id="""access absent items"""       ),
        pytest.param(_add_with_resize_up ,				id="""add with resize up"""       ),
        pytest.param(_add_with_resize_down ,				id="""add with resize down"""       ),
    ) ,				)
def 					a__				(       snake_case__       )		->      Any:
			lowerCamelCase       =      HashMap(initial_block_size=4       )
			lowerCamelCase       =      {}
			for _, (fun, *args) in enumerate(snake_case__       ):
						lowerCamelCase   ,     lowerCamelCase       =      _run_operation(snake_case__ ,				snake_case__ ,				*snake_case__       )
						lowerCamelCase   ,     lowerCamelCase       =      _run_operation(snake_case__ ,				snake_case__ ,				*snake_case__       )
						assert my_res == py_res
						assert str(snake_case__       ) == str(snake_case__       )
						assert set(snake_case__       ) == set(snake_case__       )
						assert len(snake_case__       ) == len(snake_case__       )
						assert set(my.items()       ) == set(py.items()       )



def 					a__				(       )		->      int:
			def is_public(snake_case__       ) -> bool:
						return not name.startswith("""_"""       )

			lowerCamelCase       =      {name for name in dir({}       ) if is_public(snake_case__       )}
			lowerCamelCase       =      {name for name in dir(HashMap()       ) if is_public(snake_case__       )}

			assert dict_public_names > hash_public_names



