



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






	'''simple docstring'''

	A__		=	IFImgaImgPipeline
	A__		=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
	A__		=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	A__		=	PipelineTesterMixin.required_optional_params - {'''latents'''}




	def      lowercase__							(  self		:  str					)     ->			List[Any]:




								'''simple docstring'''





								return self._get_dummy_components()




	def      lowercase__							(  self		:  Dict   ,		__A		:  Tuple   ,		__A		:  Union[str, Any]=0					)     ->			str:




								'''simple docstring'''





								if str(__A					).startswith("""mps"""					):
															lowerCAmelCase__  =   torch.manual_seed(__A					)
								else:
															lowerCAmelCase__  =   torch.Generator(device=__A					).manual_seed(__A					)

								lowerCAmelCase__  =   floats_tensor((1, 3, 32, 32)   ,		rng=random.Random(__A					)					).to(__A					)

								lowerCAmelCase__  =   {
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": image,
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}

								return inputs




	def      lowercase__							(  self		:  str					)     ->			Optional[int]:




								'''simple docstring'''





								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      lowercase__							(  self		:  int					)     ->			str:




								'''simple docstring'''





								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3					)




	@unittest.skipIf(torch_device != """cuda"""   ,		reason="""float16 requires CUDA"""					)
	def      lowercase__							(  self		:  List[Any]					)     ->			Any:




								'''simple docstring'''





								super().test_save_load_floataa(expected_max_diff=1E-1					)




	@unittest.skipIf(torch_device != """cuda"""   ,		reason="""float16 requires CUDA"""					)
	def      lowercase__							(  self		:  Optional[int]					)     ->			List[Any]:




								'''simple docstring'''





								super().test_floataa_inference(expected_max_diff=1E-1					)




	def      lowercase__							(  self		:  Tuple					)     ->			Optional[int]:




								'''simple docstring'''





								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2					)




	def      lowercase__							(  self		:  List[Any]					)     ->			Optional[Any]:




								'''simple docstring'''





								self._test_save_load_local()




	def      lowercase__							(  self		:  Dict					)     ->			int:




								'''simple docstring'''





								self._test_inference_batch_single_identical(
								    expected_max_diff=1E-2   ,		)










'''simple docstring'''







from ..utils import DummyObject, requires_backends

class      lowerCamelCase__     (     metaclass=_A				):






	'''simple docstring'''

	A__		=	['''torch''', '''librosa''']




	def __init__(  self		:  Optional[Any]   ,		*__A		:  Tuple   ,		**__A		:  Tuple					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(self   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Dict   ,		*__A		:  List[Any]   ,		**__A		:  List[str]					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Optional[int]   ,		*__A		:  List[str]   ,		**__A		:  Tuple					)     ->			Any:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)





class      lowerCamelCase__     (     metaclass=_A				):






	'''simple docstring'''

	A__		=	['''torch''', '''librosa''']




	def __init__(  self		:  int   ,		*__A		:  Dict   ,		**__A		:  List[Any]					)     ->			List[Any]:




								'''simple docstring'''





								requires_backends(self   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Optional[int]   ,		*__A		:  Optional[int]   ,		**__A		:  List[Any]					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  List[str]   ,		*__A		:  List[str]   ,		**__A		:  int					)     ->			List[str]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)





