





import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
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							(	_a			,_a			,unittest.TestCase      ):
       __snake_case						:   Optional[Any]      =		IFSuperResolutionPipeline
       __snake_case						:   Dict      =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
       __snake_case						:   str      =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       __snake_case						:   Optional[Any]      =		PipelineTesterMixin.required_optional_params - {'latents'}



       def  A							(     self	:   Optional[int]			):
           return self._get_superresolution_dummy_components()



       def  A							(     self	:   Optional[int]					,			UpperCAmelCase	:   List[Any]					,			UpperCAmelCase	:   Optional[int]=0			):
           if str(UpperCAmelCase			).startswith("""mps"""			):
               lowerCAmelCase_					:	Optional[Any]						=   torch.manual_seed(UpperCAmelCase			)
           else:
               lowerCAmelCase_					:	List[Any]						=   torch.Generator(device=UpperCAmelCase			).manual_seed(UpperCAmelCase			)

           lowerCAmelCase_					:	List[str]						=   floats_tensor((1, 3, 32, 32)					,			rng=random.Random(UpperCAmelCase			)			).to(UpperCAmelCase			)

           lowerCAmelCase_					:	str						=   {
               """prompt""": """A painting of a squirrel eating a burger""",
               """image""": 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	:   List[str]			):
           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)



       def  A							(     self	:   Optional[int]			):
           self._test_save_load_optional_components()



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



       def  A							(     self	:   Dict			):
           self._test_save_load_local()



       def  A							(     self	:   Tuple			):
           self._test_inference_batch_single_identical(
               expected_max_diff=1e-2					,			)









def 			__UpperCamelCase				(			lowercase__	:       set		,    lowercase__	:       set		)	->      set:
    '''simple docstring'''





    assert isinstance(lowercase__		,    lowercase__		), f'The input value of [set_a={set_a}] is not a set'
    assert isinstance(lowercase__		,    lowercase__		), f'The input value of [set_b={set_b}] is not a set'

    return {a + b for a in set_a for b in set_b}


if __name__ == "__main__":
  from doctest import testmod

  testmod()


