



'''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       _lowerCAmelCase   (   __lowercase					,							unittest.TestCase				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						"hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"

							def 	lowercase							(self  ,  UpperCAmelCase=0  )					->       int:
														_snake_case       =  np.random.RandomState(_a  )
														_snake_case       =  {
														    """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 	lowercase							(self  )					->       str:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.6_5072, 0.5_8492, 0.4_8219, 0.5_5521, 0.5_3180, 0.5_5939, 0.5_0697, 0.3_9800, 0.4_6455]  )

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

							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														_snake_case       =  PNDMScheduler.from_config(pipe.scheduler.config  ,  skip_prk_steps=_a  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.6_5863, 0.5_9425, 0.4_9326, 0.5_6313, 0.5_3875, 0.5_6627, 0.5_1065, 0.3_9777, 0.4_6330]  )

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

							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														_snake_case       =  LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]  )

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

							def 	lowercase							(self  )					->       Any:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														_snake_case       =  EulerDiscreteScheduler.from_config(pipe.scheduler.config  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.5_3755, 0.6_0786, 0.4_7402, 0.4_9488, 0.5_1869, 0.4_9819, 0.4_7985, 0.3_8957, 0.4_4279]  )

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

							def 	lowercase							(self  )					->       List[Any]:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														_snake_case       =  EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.5_3817, 0.6_0812, 0.4_7384, 0.4_9530, 0.5_1894, 0.4_9814, 0.4_7984, 0.3_8958, 0.4_4271]  )

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

							def 	lowercase							(self  )					->       int:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														_snake_case       =  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
														pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 128, 128, 3)
														_snake_case       =  np.array([0.5_3895, 0.6_0808, 0.4_7933, 0.4_9608, 0.5_1886, 0.4_9950, 0.4_8053, 0.3_8957, 0.4_4200]  )

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

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														pipe.set_progress_bar_config(disable=_a  )

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

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

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

														_snake_case       =  pipe.tokenizer(
														    _a  ,  padding="""max_length"""  ,  max_length=pipe.tokenizer.model_max_length  ,  truncation=_a  ,  return_tensors="""np"""  ,  )
														_snake_case       =  text_inputs["""input_ids"""]

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

														_snake_case       =  prompt_embeds

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

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





							def 	lowercase							(self  )					->       int:
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint  ,  provider="""CPUExecutionProvider"""  )
														pipe.set_progress_bar_config(disable=_a  )

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

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

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

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

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

														_snake_case,							_snake_case       =  embeds

														# forward
														_snake_case       =  pipe(**_a  )
														_snake_case       =  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       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

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

							@property
							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  ort.SessionOptions()
														_snake_case       =  False
														return options

							def 	lowercase							(self  )					->       Optional[int]:
														# using the PNDM scheduler by default
														_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(
														    """CompVis/stable-diffusion-v1-4"""  ,  revision="""onnx"""  ,  safety_checker=_a  ,  feature_extractor=_a  ,  provider=self.gpu_provider  ,  sess_options=self.gpu_options  ,  )
														sd_pipe.set_progress_bar_config(disable=_a  )

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

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

														assert image.shape == (1, 512, 512, 3)
														_snake_case       =  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 	lowercase							(self  )					->       Optional[int]:
														_snake_case       =  DDIMScheduler.from_pretrained(
														    """runwayml/stable-diffusion-v1-5"""  ,  subfolder="""scheduler"""  ,  revision="""onnx"""  )
														_snake_case       =  OnnxStableDiffusionPipeline.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  ,  )
														sd_pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 512, 512, 3)
														_snake_case       =  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 	lowercase							(self  )					->       List[str]:
														_snake_case       =  LMSDiscreteScheduler.from_pretrained(
														    """runwayml/stable-diffusion-v1-5"""  ,  subfolder="""scheduler"""  ,  revision="""onnx"""  )
														_snake_case       =  OnnxStableDiffusionPipeline.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  ,  )
														sd_pipe.set_progress_bar_config(disable=_a  )

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

														assert image.shape == (1, 512, 512, 3)
														_snake_case       =  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 	lowercase							(self  )					->       Optional[Any]:
														_snake_case       =  0

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

														_snake_case       =  False

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

														_snake_case       =  """Andromeda galaxy in a bottle"""

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





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

														_snake_case       =  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(_a  )
																					_snake_case       =  OnnxStableDiffusionPipeline.from_pretrained(_a  )

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

'''simple docstring'''
from __future__ import annotations






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE				):
							_snake_case       =  len(_SCREAMING_SNAKE_CASE				)
							# We need to create solution object to save path.
							_snake_case       =  [[0 for _ in range(_SCREAMING_SNAKE_CASE				)] for _ in range(_SCREAMING_SNAKE_CASE				)]
							_snake_case       =  run_maze(_SCREAMING_SNAKE_CASE							, 0							, 0							, _SCREAMING_SNAKE_CASE				)
							if solved:
														print("""\n""".join(str(_SCREAMING_SNAKE_CASE				) for row in solutions				)				)
							else:
														print("""No solution exists!"""				)
							return solved






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				):
							_snake_case       =  len(_SCREAMING_SNAKE_CASE				)
							# Final check point.
							if i == j == (size - 1):
														_snake_case       =  1
														return True

							_snake_case       =  (not i < 0) and (not j < 0)  # Check lower bounds
							_snake_case       =  (i < size) and (j < size)  # Check upper bounds

							if lower_flag and upper_flag:
														# check for already visited and block points.
														_snake_case       =  (not solutions[i][j]) and (not maze[i][j])
														if block_flag:
																					# check visited
																					_snake_case       =  1

																					# check for directions
																					if (
																					    run_maze(_SCREAMING_SNAKE_CASE							, i + 1							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				)
																					    or run_maze(_SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, j + 1							, _SCREAMING_SNAKE_CASE				)
																					    or run_maze(_SCREAMING_SNAKE_CASE							, i - 1							, _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE				)
																					    or run_maze(_SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE							, j - 1							, _SCREAMING_SNAKE_CASE				)
																					):
																												return True

																					_snake_case       =  0
																					return False
							return False


if __name__ == "__main__":
				import doctest

				doctest.testmod()