"""simple docstring"""






import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class   UpperCAmelCase__				(    __lowerCamelCase,      __lowerCamelCase,      unittest.TestCase			):


	"""simple docstring"""
	lowerCAmelCase__    :					Union[str, Any]						      =							IFImgaImgPipeline
	lowerCAmelCase__    :					str						      =							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
	lowerCAmelCase__    :					Any						      =							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	lowerCAmelCase__    :					Any						      =							PipelineTesterMixin.required_optional_params - {"""latents"""}







	def       A    (			self )    ->	List[str]:
							return self._get_dummy_components()







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE=0 )    ->	Union[str, Any]:
							if str(_SCREAMING_SNAKE_CASE ).startswith("mps" ):
													a_							:			List[str]     		=					torch.manual_seed(_SCREAMING_SNAKE_CASE )
							else:
													a_							:			Union[str, Any]     		=					torch.Generator(device=_SCREAMING_SNAKE_CASE ).manual_seed(_SCREAMING_SNAKE_CASE )

							a_							:			Optional[int]     		=					floats_tensor((1, 3, 3_2, 3_2)       ,     rng=random.Random(_SCREAMING_SNAKE_CASE ) ).to(_SCREAMING_SNAKE_CASE )

							a_							:			Optional[int]     		=					{
							    "prompt": "A painting of a squirrel eating a burger",
							    "image": image,
							    "generator": generator,
							    "num_inference_steps": 2,
							    "output_type": "numpy",
							}

							return inputs







	def       A    (			self )    ->	Optional[Any]:
							self._test_save_load_optional_components()







	@unittest.skipIf(
	    torch_device != "cuda" or not is_xformers_available()       ,     reason="XFormers attention is only available with CUDA and `xformers` installed"       ,     )
	def       A    (			self )    ->	Union[str, Any]:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )







	@unittest.skipIf(torch_device != "cuda"       ,     reason="float16 requires CUDA" )
	def       A    (			self )    ->	Tuple:
							# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
							super().test_save_load_floataa(expected_max_diff=1E-1 )







	@unittest.skipIf(torch_device != "cuda"       ,     reason="float16 requires CUDA" )
	def       A    (			self )    ->	Dict:
							super().test_floataa_inference(expected_max_diff=1E-1 )







	def       A    (			self )    ->	List[Any]:
							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )







	def       A    (			self )    ->	Optional[Any]:
							self._test_save_load_local()







	def       A    (			self )    ->	Optional[int]:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2       ,     )





"""simple docstring"""






def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:str  )				-> int:
						a_							:			Optional[int]     		=					0
						for letter in data:
												a_							:			Union[str, Any]     		=					(hash_ << 4) + ord(_SCREAMING_SNAKE_CASE  )
												a_							:			Optional[int]     		=					hash_ & 0xf000_0000
												if x != 0:
																		hash_ ^= x >> 24
												hash_ &= ~x
						return hash_


if __name__ == "__main__":
				import doctest

				doctest.testmod()




