


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     a		(_lowerCAmelCase					,    _lowerCAmelCase					,    unittest.TestCase				):




							"""simple docstring"""


							__UpperCAmelCase   :							Optional[Any]					  =  IFImgaImgSuperResolutionPipeline
							__UpperCAmelCase   :							List[str]					  =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
							__UpperCAmelCase   :							Optional[Any]					  =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}				)
							__UpperCAmelCase   :							Tuple					  =  PipelineTesterMixin.required_optional_params - {"latents"}

							def    __snake_case (							self	:  Optional[int]    )     ->   str:
														return self._get_superresolution_dummy_components()

							def    __snake_case (							self	:  Optional[Any]   ,     lowerCamelCase	:  int   ,     lowerCamelCase	:  Any=0    )     ->   Tuple:
														if str(lowerCamelCase    ).startswith("mps"    ):
																					__snake_case		:      Dict										=       torch.manual_seed(lowerCamelCase    )
														else:
																					__snake_case		:      str										=       torch.Generator(device=lowerCamelCase    ).manual_seed(lowerCamelCase    )

														__snake_case		:      Optional[Any]										=       floats_tensor((1, 3, 32, 32)   ,     rng=random.Random(lowerCamelCase    )    ).to(lowerCamelCase    )
														__snake_case		:      List[Any]										=       floats_tensor((1, 3, 16, 16)   ,     rng=random.Random(lowerCamelCase    )    ).to(lowerCamelCase    )

														__snake_case		:      Dict										=       {
														    "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	:  Tuple    )     ->   Tuple:
														self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )

							def    __snake_case (							self	:  Dict    )     ->   List[str]:
														self._test_save_load_optional_components()

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

							def    __snake_case (							self	:  Dict    )     ->   str:
														self._test_save_load_local()






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



from ..utils import DummyObject, requires_backends

class     a		(metaclass=_lowerCAmelCase				):




							"""simple docstring"""


							__UpperCAmelCase   :							int					  =  ["speech"]

							def __init__(							self	:  List[Any]   ,     *lowerCamelCase	:  List[Any]   ,     **lowerCamelCase	:  Optional[Any]    )     ->   Dict:
														requires_backends(self   ,     ["speech"]    )

class     a		(metaclass=_lowerCAmelCase				):




							"""simple docstring"""


							__UpperCAmelCase   :							Optional[Any]					  =  ["speech"]

							def __init__(							self	:  int   ,     *lowerCamelCase	:  List[Any]   ,     **lowerCamelCase	:  List[Any]    )     ->   Optional[int]:
														requires_backends(self   ,     ["speech"]    )

