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"""







  lowerCamelCase__   =  '''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''







  def       __A   (							self       :				Any     ,   __magic_name__       :				List[Any]=0      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     np.random.RandomState(__magic_name__      )
        SCREAMING_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       __A   (							self       :				Optional[Any]      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				Tuple      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        SCREAMING_SNAKE_CASE_      =     PNDMScheduler.from_config(pipe.scheduler.config     ,   skip_prk_steps=__magic_name__      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				str      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        SCREAMING_SNAKE_CASE_      =     LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				str      )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        SCREAMING_SNAKE_CASE_      =     EulerDiscreteScheduler.from_config(pipe.scheduler.config      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				Dict      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        SCREAMING_SNAKE_CASE_      =     EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				int      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        SCREAMING_SNAKE_CASE_      =     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 128, 128, 3)
        SCREAMING_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       __A   (							self       :				str      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

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

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

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

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

        SCREAMING_SNAKE_CASE_      =     prompt_embeds

        # forward
        SCREAMING_SNAKE_CASE_      =     pipe(**__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     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:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint     ,   provider="CPUExecutionProvider"      )
        pipe.set_progress_bar_config(disable=__magic_name__      )

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

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

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

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

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

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     embeds

        # forward
        SCREAMING_SNAKE_CASE_      =     pipe(**__magic_name__      )
        SCREAMING_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       __A   (							self       :				Dict      )     ->		Dict:
        return (
            "CUDAExecutionProvider",
            {
                "gpu_mem_limit": "15000000000",  # 15GB
                "arena_extend_strategy": "kSameAsRequested",
            },
        )







  @property
  def       __A   (							self       :				str      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     ort.SessionOptions()
        SCREAMING_SNAKE_CASE_      =     False
        return options







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

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

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

        assert image.shape == (1, 512, 512, 3)
        SCREAMING_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       __A   (							self       :				Optional[Any]      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_      =     DDIMScheduler.from_pretrained(
            "runwayml/stable-diffusion-v1-5"     ,   subfolder="scheduler"     ,   revision="onnx"      )
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(
            "runwayml/stable-diffusion-v1-5"     ,   revision="onnx"     ,   scheduler=__magic_name__     ,   safety_checker=__magic_name__     ,   feature_extractor=__magic_name__     ,   provider=self.gpu_provider     ,   sess_options=self.gpu_options     ,   )
        sd_pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 512, 512, 3)
        SCREAMING_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       __A   (							self       :				List[Any]      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     LMSDiscreteScheduler.from_pretrained(
            "runwayml/stable-diffusion-v1-5"     ,   subfolder="scheduler"     ,   revision="onnx"      )
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(
            "runwayml/stable-diffusion-v1-5"     ,   revision="onnx"     ,   scheduler=__magic_name__     ,   safety_checker=__magic_name__     ,   feature_extractor=__magic_name__     ,   provider=self.gpu_provider     ,   sess_options=self.gpu_options     ,   )
        sd_pipe.set_progress_bar_config(disable=__magic_name__      )

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

        assert image.shape == (1, 512, 512, 3)
        SCREAMING_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       __A   (							self       :				Union[str, Any]      )     ->		Optional[int]:
        SCREAMING_SNAKE_CASE_      =     0

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

        SCREAMING_SNAKE_CASE_      =     False

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

        SCREAMING_SNAKE_CASE_      =     "Andromeda galaxy in a bottle"

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







  def       __A   (							self       :				int      )     ->		int:
        SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(
            "runwayml/stable-diffusion-v1-5"     ,   revision="onnx"     ,   safety_checker=__magic_name__     ,   feature_extractor=__magic_name__     ,   provider=self.gpu_provider     ,   sess_options=self.gpu_options     ,   )
        assert isinstance(__magic_name__     ,   __magic_name__      )
        assert pipe.safety_checker is None

        SCREAMING_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(__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     OnnxStableDiffusionPipeline.from_pretrained(__magic_name__      )

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



def    a__       (						__UpperCamelCase ):
      if not head:
            return True
      # split the list to two parts
      SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     head.next, head
      while fast and fast.next:
            SCREAMING_SNAKE_CASE_      =     fast.next.next
            SCREAMING_SNAKE_CASE_      =     slow.next
      SCREAMING_SNAKE_CASE_      =     slow.next
      SCREAMING_SNAKE_CASE_      =     None  # Don't forget here! But forget still works!
      # reverse the second part
      SCREAMING_SNAKE_CASE_      =     None
      while second:
            SCREAMING_SNAKE_CASE_      =     second.next
            SCREAMING_SNAKE_CASE_      =     node
            SCREAMING_SNAKE_CASE_      =     second
            SCREAMING_SNAKE_CASE_      =     nxt
      # compare two parts
      # second part has the same or one less node
      while node:
            if node.val != head.val:
                  return False
            SCREAMING_SNAKE_CASE_      =     node.next
            SCREAMING_SNAKE_CASE_      =     head.next
      return True


def    a__       (						__UpperCamelCase ):
      if not head or not head.next:
            return True

      # 1. Get the midpoint (slow)
      SCREAMING_SNAKE_CASE_      =     SCREAMING_SNAKE_CASE_      =     SCREAMING_SNAKE_CASE_      =     head
      while fast and fast.next:
            SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     fast.next.next, slow.next

      # 2. Push the second half into the stack
      SCREAMING_SNAKE_CASE_      =     [slow.val]
      while slow.next:
            SCREAMING_SNAKE_CASE_      =     slow.next
            stack.append(slow.val )

      # 3. Comparison
      while stack:
            if stack.pop() != cur.val:
                  return False
            SCREAMING_SNAKE_CASE_      =     cur.next

      return True





def    a__       (						__UpperCamelCase ):
      if not head or not head.next:
            return True
      SCREAMING_SNAKE_CASE_      =     {}
      SCREAMING_SNAKE_CASE_      =     0
      while head:
            if head.val in d:
                  d[head.val].append(__UpperCamelCase )
            else:
                  SCREAMING_SNAKE_CASE_      =     [pos]
            SCREAMING_SNAKE_CASE_      =     head.next
            pos += 1
      SCREAMING_SNAKE_CASE_      =     pos - 1
      SCREAMING_SNAKE_CASE_      =     0
      for v in d.values():
            if len(__UpperCamelCase ) % 2 != 0:
                  middle += 1
            else:
                  SCREAMING_SNAKE_CASE_      =     0
                  for i in range(0   ,					len(__UpperCamelCase ) ):
                        if v[i] + v[len(__UpperCamelCase ) - 1 - step] != checksum:
                              return False
                        step += 1
            if middle > 1:
                  return False
      return True


