





import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
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       __A     (						a    ,					a    ,					unittest.TestCase    ):
				__A      =				IFInpaintingSuperResolutionPipeline
				__A      =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
				__A      =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}    )
				__A      =				PipelineTesterMixin.required_optional_params - {"""latents"""}


				def _snake_case       (		self							):
								return self._get_superresolution_dummy_components()


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_=0							):
								if str(UpperCAmelCase_							).startswith("""mps"""							):
												lowerCamelCase	 =torch.manual_seed(UpperCAmelCase_							)
								else:
												lowerCamelCase	 =torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)

								lowerCamelCase	 =floats_tensor((1, 3, 16, 16)   , rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase	 =floats_tensor((1, 3, 32, 32)   , rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase	 =floats_tensor((1, 3, 32, 32)   , rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)

								lowerCamelCase	 ={
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": image,
								    """original_image""": original_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 _snake_case       (		self							):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3							)


				def _snake_case       (		self							):
								self._test_save_load_optional_components()


				@unittest.skipIf(torch_device != """cuda"""   , reason="""float16 requires CUDA"""							)
				def _snake_case       (		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 _snake_case       (		self							):
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2							)


				def _snake_case       (		self							):
								self._test_save_load_local()


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












from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
							if not (is_transformers_available() and is_torch_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from ...utils.dummy_torch_and_transformers_objects import KandinskyPipeline, KandinskyPriorPipeline
else:
							from .pipeline_kandinsky import KandinskyPipeline
							from .pipeline_kandinsky_imgaimg import KandinskyImgaImgPipeline
							from .pipeline_kandinsky_inpaint import KandinskyInpaintPipeline
							from .pipeline_kandinsky_prior import KandinskyPriorPipeline, KandinskyPriorPipelineOutput
							from .text_encoder import MultilingualCLIP





