


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


   '''simple docstring'''







   lowercase					:	List[str]									=IFImgaImgSuperResolutionPipeline
   lowercase					:	Optional[Any]									=TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
   lowercase					:	Optional[int]									=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}     )
   lowercase					:	List[str]									=PipelineTesterMixin.required_optional_params - {"""latents"""}
   def 		UpperCamelCase  (     self		):
        return self._get_superresolution_dummy_components()
   def 		UpperCamelCase  (     self   ,							UpperCamelCase_   ,							UpperCamelCase_=0		):
        if str(UpperCamelCase_		).startswith('''mps'''		):
             lowercase_       :List[str]     =       torch.manual_seed(UpperCamelCase_		)
        else:
             lowercase_       :Any     =       torch.Generator(device=UpperCamelCase_		).manual_seed(UpperCamelCase_		)

        lowercase_       :Optional[int]     =       floats_tensor((1, 3, 32, 32)   ,							rng=random.Random(UpperCamelCase_		)		).to(UpperCamelCase_		)
        lowercase_       :Optional[int]     =       floats_tensor((1, 3, 16, 16)   ,							rng=random.Random(UpperCamelCase_		)		).to(UpperCamelCase_		)

        lowercase_       :Optional[Any]     =       {
            '''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 		UpperCamelCase  (     self		):
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)
   def 		UpperCamelCase  (     self		):
        self._test_save_load_optional_components()
   @unittest.skipIf(torch_device != '''cuda'''   ,							reason='''float16 requires CUDA'''		)
   def 		UpperCamelCase  (     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 		UpperCamelCase  (     self		):
        self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)
   def 		UpperCamelCase  (     self		):
        self._test_save_load_local()




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





def     UpperCamelCase    (      _a		)					->							int:
     '''simple docstring'''





     assert isinstance(_a       ,		_a		), f"The input value of [n={number}] is not an integer"

     if number == 1:
          return 2
     elif number < 1:
          lowercase_       :str     =       f"The input value of [n={number}] has to be > 0"
          raise ValueError(_a		)
     else:
          lowercase_       :List[str]     =       sylvester(number - 1		)
          lowercase_       :Union[str, Any]     =       num - 1
          lowercase_       :List[str]     =       num
          return lower * upper + 1


if __name__ == "__main__":
   print(f"The 8th number in Sylvester's sequence: {sylvester(8)}")

