



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__(							lowerCamelCase     ,							unittest.TestCase	):

   '''simple docstring'''




   A    :  List[str]       				=    "hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			Tuple=0)	->				Any:




         """simple docstring"""

         lowercase__     =  np.random.RandomState(lowerCAmelCase)
         lowercase__     =  {
             '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 			UpperCAmelCase		(						self  :			Tuple)	->				str:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.6_50_72, 0.5_84_92, 0.4_82_19, 0.5_55_21, 0.5_31_80, 0.5_59_39, 0.5_06_97, 0.3_98_00, 0.4_64_55])

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


   def 			UpperCAmelCase		(						self  :			Dict)	->				int:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         lowercase__     =  PNDMScheduler.from_config(pipe.scheduler.config			,				skip_prk_steps=lowerCAmelCase)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.6_58_63, 0.5_94_25, 0.4_93_26, 0.5_63_13, 0.5_38_75, 0.5_66_27, 0.5_10_65, 0.3_97_77, 0.4_63_30])

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


   def 			UpperCAmelCase		(						self  :			int)	->				int:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         lowercase__     =  LMSDiscreteScheduler.from_config(pipe.scheduler.config)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.5_37_55, 0.6_07_86, 0.4_74_02, 0.4_94_88, 0.5_18_69, 0.4_98_19, 0.4_79_85, 0.3_89_57, 0.4_42_79])

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


   def 			UpperCAmelCase		(						self  :			List[Any])	->				List[Any]:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         lowercase__     =  EulerDiscreteScheduler.from_config(pipe.scheduler.config)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.5_37_55, 0.6_07_86, 0.4_74_02, 0.4_94_88, 0.5_18_69, 0.4_98_19, 0.4_79_85, 0.3_89_57, 0.4_42_79])

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


   def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				str:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         lowercase__     =  EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.5_38_17, 0.6_08_12, 0.4_73_84, 0.4_95_30, 0.5_18_94, 0.4_98_14, 0.4_79_84, 0.3_89_58, 0.4_42_71])

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


   def 			UpperCAmelCase		(						self  :			List[str])	->				int:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         lowercase__     =  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

         assert image.shape == (1, 1_28, 1_28, 3)
         lowercase__     =  np.array([0.5_38_95, 0.6_08_08, 0.4_79_33, 0.4_96_08, 0.5_18_86, 0.4_99_50, 0.4_80_53, 0.3_89_57, 0.4_42_00])

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


   def 			UpperCAmelCase		(						self  :			List[Any])	->				List[Any]:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

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

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

         lowercase__     =  pipe.tokenizer(
             lowerCAmelCase			,				padding='max_length'			,				max_length=pipe.tokenizer.model_max_length			,				truncation=lowerCAmelCase			,				return_tensors='np'			,				)
         lowercase__     =  text_inputs['input_ids']

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

         lowercase__     =  prompt_embeds

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

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



   def 			UpperCAmelCase		(						self  :			Optional[int])	->				Dict:




         """simple docstring"""

         lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint			,				provider='CPUExecutionProvider')
         pipe.set_progress_bar_config(disable=lowerCAmelCase)

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

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

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

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

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

         lowercase__,	lowercase__     =  embeds

         # forward
         lowercase__     =  pipe(**lowerCAmelCase)
         lowercase__     =  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	):

   '''simple docstring'''




   @property
   def 			UpperCAmelCase		(						self  :			int)	->				Dict:




         """simple docstring"""

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


   @property
   def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				List[str]:




         """simple docstring"""

         lowercase__     =  ort.SessionOptions()
         lowercase__     =  False
         return options


   def 			UpperCAmelCase		(						self  :			Tuple)	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  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)

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

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

         assert image.shape == (1, 5_12, 5_12, 3)
         lowercase__     =  np.array([0.04_52, 0.03_90, 0.00_87, 0.03_50, 0.06_17, 0.03_64, 0.05_44, 0.05_23, 0.07_20])

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


   def 			UpperCAmelCase		(						self  :			Optional[int])	->				Dict:




         """simple docstring"""

         lowercase__     =  DDIMScheduler.from_pretrained(
             'runwayml/stable-diffusion-v1-5'			,				subfolder='scheduler'			,				revision='onnx')
         lowercase__     =  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)

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

         assert image.shape == (1, 5_12, 5_12, 3)
         lowercase__     =  np.array([0.28_67, 0.19_74, 0.14_81, 0.72_94, 0.72_51, 0.66_67, 0.41_94, 0.56_42, 0.64_86])

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


   def 			UpperCAmelCase		(						self  :			Any)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  LMSDiscreteScheduler.from_pretrained(
             'runwayml/stable-diffusion-v1-5'			,				subfolder='scheduler'			,				revision='onnx')
         lowercase__     =  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)

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

         assert image.shape == (1, 5_12, 5_12, 3)
         lowercase__     =  np.array([0.23_06, 0.19_59, 0.15_93, 0.65_49, 0.63_94, 0.54_08, 0.50_65, 0.60_10, 0.61_61])

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


   def 			UpperCAmelCase		(						self  :			Tuple)	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  0

         def test_callback_fn(lowerCAmelCase  :			int			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			np.ndarray) -> None:
               lowercase__     =  True
               nonlocal number_of_steps
               number_of_steps += 1
               if step == 0:
                     assert latents.shape == (1, 4, 64, 64)
                     lowercase__     =  latents[0, -3:, -3:, -1]
                     lowercase__     =  np.array(
                         [-0.67_72, -0.38_35, -1.24_56, 0.19_05, -1.09_74, 0.69_67, -1.93_53, 0.01_78, 1.01_67])

                     assert np.abs(latents_slice.flatten() - expected_slice).max() < 1E-3
               elif step == 5:
                     assert latents.shape == (1, 4, 64, 64)
                     lowercase__     =  latents[0, -3:, -3:, -1]
                     lowercase__     =  np.array(
                         [-0.33_51, 0.22_41, -0.18_37, -0.23_25, -0.65_77, 0.33_93, -0.02_41, 0.58_99, 1.38_75])

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

         lowercase__     =  False

         lowercase__     =  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)

         lowercase__     =  'Andromeda galaxy in a bottle'

         lowercase__     =  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 			UpperCAmelCase		(						self  :			str)	->				Any:




         """simple docstring"""

         lowercase__     =  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

         lowercase__     =  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)
               lowercase__     =  OnnxStableDiffusionPipeline.from_pretrained(lowerCAmelCase)

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





import argparse
import hashlib  # hashlib is only used inside the Test class
import struct



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			Optional[Any]			,				lowerCAmelCase  :			str)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  data
         lowercase__     =  [0X6_7_4_5_2_3_0_1, 0XE_F_C_D_A_B_8_9, 0X9_8_B_A_D_C_F_E, 0X1_0_3_2_5_4_7_6, 0XC_3_D_2_E_1_F_0]


   @staticmethod
   def 			UpperCAmelCase		(						lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int])	->				str:




         """simple docstring"""

         return ((n << b) | (n >> (32 - b))) & 0XF_F_F_F_F_F_F_F


   def 			UpperCAmelCase		(						self  :			Dict)	->				Dict:




         """simple docstring"""

         lowercase__     =  B'\x80' + B'\x00' * (63 - (len(self.data) + 8) % 64)
         lowercase__     =  self.data + padding + struct.pack('>Q'			,				8 * len(self.data))
         return padded_data


   def 			UpperCAmelCase		(						self  :			int)	->				Tuple:




         """simple docstring"""

         return [
             self.padded_data[i : i + 64] for i in range(0			,				len(self.padded_data)			,				64)
         ]


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			int)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  list(struct.unpack('>16L'			,				lowerCAmelCase)) + [0] * 64
         for i in range(16			,				80):
               lowercase__     =  self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])			,				1)
         return w



   def 			UpperCAmelCase		(						self  :			str)	->				Dict:




         """simple docstring"""

         lowercase__     =  self.padding()
         lowercase__     =  self.split_blocks()
         for block in self.blocks:
               lowercase__     =  self.expand_block(lowerCAmelCase)
               lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  self.h
               for i in range(0			,				80):
                     if 0 <= i < 20:
                           lowercase__     =  (b & c) | ((~b) & d)
                           lowercase__     =  0X5_A_8_2_7_9_9_9
                     elif 20 <= i < 40:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0X6_E_D_9_E_B_A_1
                     elif 40 <= i < 60:
                           lowercase__     =  (b & c) | (b & d) | (c & d)
                           lowercase__     =  0X8_F_1_B_B_C_D_C
                     elif 60 <= i < 80:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0XC_A_6_2_C_1_D_6
                     lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  (
                         self.rotate(lowerCAmelCase			,				5) + f + e + k + expanded_block[i] & 0XF_F_F_F_F_F_F_F,
                         a,
                         self.rotate(lowerCAmelCase			,				30),
                         c,
                         d,
                     )
               lowercase__     =  (
                   self.h[0] + a & 0XF_F_F_F_F_F_F_F,
                   self.h[1] + b & 0XF_F_F_F_F_F_F_F,
                   self.h[2] + c & 0XF_F_F_F_F_F_F_F,
                   self.h[3] + d & 0XF_F_F_F_F_F_F_F,
                   self.h[4] + e & 0XF_F_F_F_F_F_F_F,
               )
         return ("{:08x}" * 5).format(*self.h)

def   _lowerCAmelCase   (						):
      lowercase__     =  B'Test String'
      assert SHAaHash(A__	).final_hash() == hashlib.shaa(A__	).hexdigest()  # noqa: S324

def   _lowerCAmelCase   (						):
      lowercase__     =  argparse.ArgumentParser(description='Process some strings or files'	)
      parser.add_argument(
          '--string'						,  dest='input_string'						,  default='Hello World!! Welcome to Cryptography'						,  help='Hash the string'						,  )
      parser.add_argument('--file'						,  dest='input_file'						,  help='Hash contents of a file'	)
      lowercase__     =  parser.parse_args()
      lowercase__     =  args.input_string
      # In any case hash input should be a bytestring
      if args.input_file:
            with open(args.input_file						,  'rb'	) as f:
                  lowercase__     =  f.read()
      else:
            lowercase__     =  bytes(A__						,  'utf-8'	)
      print(SHAaHash(A__	).final_hash()	)


if __name__ == "__main__":
       main()
       import doctest

       doctest.testmod()
