


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


  '''simple docstring'''







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






  def        _a							(							self :       int	,_a :       Optional[int]=0 ):

     '''simple docstring'''




     A_						:  Any          =				np.random.RandomState(_a )
     A_						:  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        _a							(							self :       Union[str, Any] ):

     '''simple docstring'''




     A_						:  Union[str, Any]          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     pipe.set_progress_bar_config(disable=_a )

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

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

     '''simple docstring'''




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

     A_						:  Dict          =				self.get_dummy_inputs()
     A_						:  Union[str, Any]          =				pipe(**_a ).images
     A_						:  int          =				image[0, -3:, -3:, -1]

     assert image.shape == (1, 128, 128, 3)
     A_						:  int          =				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 :       Dict ):

     '''simple docstring'''




     A_						:  Any          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     A_						:  Dict          =				LMSDiscreteScheduler.from_config(pipe.scheduler.config )
     pipe.set_progress_bar_config(disable=_a )

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

     assert image.shape == (1, 128, 128, 3)
     A_						:  int          =				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 :       Union[str, Any] ):

     '''simple docstring'''




     A_						:  List[Any]          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     A_						:  List[str]          =				EulerDiscreteScheduler.from_config(pipe.scheduler.config )
     pipe.set_progress_bar_config(disable=_a )

     A_						:  Dict          =				self.get_dummy_inputs()
     A_						:  Union[str, Any]          =				pipe(**_a ).images
     A_						:  int          =				image[0, -3:, -3:, -1]

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

     '''simple docstring'''




     A_						:  List[str]          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     A_						:  Tuple          =				EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config )
     pipe.set_progress_bar_config(disable=_a )

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

     assert image.shape == (1, 128, 128, 3)
     A_						:  Tuple          =				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] ):

     '''simple docstring'''




     A_						:  Any          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     A_						:  Optional[int]          =				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
     pipe.set_progress_bar_config(disable=_a )

     A_						:  Tuple          =				self.get_dummy_inputs()
     A_						:  int          =				pipe(**_a ).images
     A_						:  List[str]          =				image[0, -3:, -3:, -1]

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

     '''simple docstring'''




     A_						:  Any          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     pipe.set_progress_bar_config(disable=_a )

     A_						:  str          =				self.get_dummy_inputs()
     A_						:  List[str]          =				3 * [inputs["""prompt"""]]

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

     A_						:  str          =				self.get_dummy_inputs()
     A_						:  Tuple          =				3 * [inputs.pop("""prompt""" )]

     A_						:  List[Any]          =				pipe.tokenizer(
         _a	,padding="""max_length"""	,max_length=pipe.tokenizer.model_max_length	,truncation=_a	,return_tensors="""np"""	,)
     A_						:  Union[str, Any]          =				text_inputs["""input_ids"""]

     A_						:  Tuple          =				pipe.text_encoder(input_ids=text_inputs.astype(np.intaa ) )[0]

     A_						:  Optional[int]          =				prompt_embeds

     # forward
     A_						:  int          =				pipe(**_a )
     A_						:  Union[str, Any]          =				output.images[0, -3:, -3:, -1]

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






  def        _a							(							self :       Dict ):

     '''simple docstring'''




     A_						:  int          =				OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint	,provider="""CPUExecutionProvider""" )
     pipe.set_progress_bar_config(disable=_a )

     A_						:  Tuple          =				self.get_dummy_inputs()
     A_						:  Union[str, Any]          =				3 * ["""this is a negative prompt"""]
     A_						:  Any          =				negative_prompt
     A_						:  Optional[Any]          =				3 * [inputs["""prompt"""]]

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

     A_						:  List[Any]          =				self.get_dummy_inputs()
     A_						:  List[str]          =				3 * [inputs.pop("""prompt""" )]

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

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

     A_						:  Union[str, Any]          =				embeds

     # forward
     A_						:  List[Any]          =				pipe(**_a )
     A_						:  str          =				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        _a							(							self :       Tuple ):

     '''simple docstring'''




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






  @property
  def        _a							(							self :       Any ):

     '''simple docstring'''




     A_						:  Union[str, Any]          =				ort.SessionOptions()
     A_						:  int          =				False
     return options






  def        _a							(							self :       Any ):

     '''simple docstring'''




     A_						:  Tuple          =				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 )

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

     A_						:  List[Any]          =				image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     A_						:  Tuple          =				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 :       Optional[int] ):

     '''simple docstring'''




     A_						:  Dict          =				DDIMScheduler.from_pretrained(
         """runwayml/stable-diffusion-v1-5"""	,subfolder="""scheduler"""	,revision="""onnx""" )
     A_						:  int          =				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 )

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

     assert image.shape == (1, 512, 512, 3)
     A_						:  str          =				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 :       Any ):

     '''simple docstring'''




     A_						:  str          =				LMSDiscreteScheduler.from_pretrained(
         """runwayml/stable-diffusion-v1-5"""	,subfolder="""scheduler"""	,revision="""onnx""" )
     A_						:  List[str]          =				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 )

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

     assert image.shape == (1, 512, 512, 3)
     A_						:  str          =				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 :       Any ):

     '''simple docstring'''




     A_						:  int          =				0

     def test_callback_fn(_a :       int	,_a :       int	,_a :       np.ndarray ) -> None:
        A_						:  Any          =				True
        nonlocal number_of_steps
        number_of_steps += 1
        if step == 0:
           assert latents.shape == (1, 4, 64, 64)
           A_						:  Union[str, Any]          =				latents[0, -3:, -3:, -1]
           A_						:  str          =				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)
           A_						:  Any          =				latents[0, -3:, -3:, -1]
           A_						:  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

     A_						:  int          =				False

     A_						:  int          =				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 )

     A_						:  List[str]          =				"""Andromeda galaxy in a bottle"""

     A_						:  List[Any]          =				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        _a							(							self :       Dict ):

     '''simple docstring'''




     A_						:  Optional[Any]          =				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

     A_						:  List[str]          =				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 )
        A_						:  Tuple          =				OnnxStableDiffusionPipeline.from_pretrained(_a )

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




'''simple docstring'''


from __future__ import annotations




def      lowerCamelCase					(      lowerCamelCase  :      dict							,						lowerCamelCase  :      str):
      A_   ,					A_						:  List[Any]          =				set(lowerCamelCase), [start]

      while stack:
            A_						:  Optional[Any]          =				stack.pop()
            explored.add(lowerCamelCase)
            # Differences from BFS:
            # 1) pop last element instead of first one
            # 2) add adjacent elements to stack without exploring them
            for adj in reversed(graph[v]):
                  if adj not in explored:
                        stack.append(lowerCamelCase)
      return explored


__magic_name__			=      {
    'A': ['B', 'C', 'D'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B', 'D'],
    'E': ['B', 'F'],
    'F': ['C', 'E', 'G'],
    'G': ['F'],
}

if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(depth_first_search(G, 'A'))
