



'''simple docstring'''




import random
import unittest

import torch

from diffusers import IFInpaintingPipeline
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_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class      _lowerCAmelCase							(      __UpperCAmelCase				,      __UpperCAmelCase				,      unittest.TestCase			):
	__SCREAMING_SNAKE_CASE       :		Optional[Any]		      = IFInpaintingPipeline
	__SCREAMING_SNAKE_CASE       :		Optional[Any]		      = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'width', 'height'}
	__SCREAMING_SNAKE_CASE       :		Union[str, Any]		      = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	__SCREAMING_SNAKE_CASE       :		int		      = PipelineTesterMixin.required_optional_params - {'latents'}


	def    _a     (self							):
				return self._get_dummy_components()


	def    _a     (self	,				lowercase	,				lowercase=0							):
				if str(lowercase							).startswith("""mps"""							):
							A_     :						Union[str, Any]     =					torch.manual_seed(lowercase							)
				else:
							A_     :						List[Any]     =					torch.Generator(device=lowercase							).manual_seed(lowercase							)

				A_     :						Optional[Any]     =					floats_tensor((1, 3, 32, 32)	,				rng=random.Random(lowercase							)							).to(lowercase							)
				A_     :						Optional[Any]     =					floats_tensor((1, 3, 32, 32)	,				rng=random.Random(lowercase							)							).to(lowercase							)

				A_     :						Optional[Any]     =					{
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """image""": image,
				    """mask_image""": mask_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    _a     (self							):
				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3							)


	def    _a     (self							):
				self._test_save_load_optional_components()


	@unittest.skipIf(torch_device != """cuda"""	,				reason="""float16 requires CUDA"""							)
	def    _a     (self							):
				# 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							)


	def    _a     (self							):
				self._test_attention_slicing_forward_pass(expected_max_diff=1E-2							)


	def    _a     (self							):
				self._test_save_load_local()


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




'''simple docstring'''




def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			if density <= 0:
						raise ValueError("""Impossible fluid density"""   )
			if bulk_modulus <= 0:
						raise ValueError("""Impossible bulk modulus"""   )

			return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
						import doctest

						doctest.testmod()