




import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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  (							UpperCAmelCase__			,  UpperCAmelCase__			,  unittest.TestCase     ):







						'''simple docstring'''





						lowerCAmelCase_							=  IFImgaImgSuperResolutionPipeline
						lowerCAmelCase_							=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
						lowerCAmelCase_							=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}     )
						lowerCAmelCase_							=  PipelineTesterMixin.required_optional_params - {'''latents'''}






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							return self._get_superresolution_dummy_components()






						def 			snake_case__		(		self				:	Optional[int]			,      __lowercase				:	Union[str, Any]			,      __lowercase				:	int=0		):






							"""simple docstring"""






							if str(__lowercase		).startswith("mps"		):
								snake_case_						       =	torch.manual_seed(__lowercase		)
							else:
								snake_case_						       =	torch.Generator(device=__lowercase		).manual_seed(__lowercase		)

							snake_case_						       =	floats_tensor((1, 3, 32, 32)			,      rng=random.Random(__lowercase		)		).to(__lowercase		)
							snake_case_						       =	floats_tensor((1, 3, 16, 16)			,      rng=random.Random(__lowercase		)		).to(__lowercase		)

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

							return inputs






						@unittest.skipIf(
						    torch_device != "cuda" or not is_xformers_available()			,      reason="XFormers attention is only available with CUDA and `xformers` installed"			,      )
						def 			snake_case__		(		self				:	str		):






							"""simple docstring"""






							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							self._test_save_load_optional_components()






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






							"""simple docstring"""






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






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)






						def 			snake_case__		(		self				:	str		):






							"""simple docstring"""






							self._test_save_load_local()






						def 			snake_case__		(		self				:	Union[str, Any]		):






							"""simple docstring"""






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






def 		lowerCamelCase__       (						_A	,      _A				):







	'''simple docstring'''





	_validate_point(_A				)
	_validate_point(_A				)
	if len(_A				) != len(_A				):
		raise ValueError("Both points must be in the same n-dimensional space"				)

	return float(sum(abs(a - b				) for a, b in zip(_A	,      _A				)				)				)


def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	if point:
		if isinstance(_A	,      _A				):
			for item in point:
				if not isinstance(_A	,      (int, float)				):
					snake_case_						       =	(
					    "Expected a list of numbers as input, found "
					    f"{type(_A				).__name__}"
					)
					raise TypeError(_A				)
		else:
			snake_case_						       =	f"Expected a list of numbers as input, found {type(_A				).__name__}"
			raise TypeError(_A				)
	else:
		raise ValueError("Missing an input"				)


def 		lowerCamelCase__       (						_A	,      _A				):







	'''simple docstring'''





	_validate_point(_A				)
	_validate_point(_A				)
	if len(_A				) != len(_A				):
		raise ValueError("Both points must be in the same n-dimensional space"				)

	return float(sum(abs(x - y				) for x, y in zip(_A	,      _A				)				)				)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
