code: 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 					UpperCAmelCase_				(							_a     ,     _a     ,     unittest.TestCase    ):
      UpperCAmelCase_			:       Optional[Any]						 =							IFSuperResolutionPipeline
      UpperCAmelCase_			:       Dict						 =							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
      UpperCAmelCase_			:       str						 =							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
      UpperCAmelCase_			:       Optional[Any]						 =							PipelineTesterMixin.required_optional_params - {'latents'}
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[int]   )	-> Union[str, Any]:
        return self._get_superresolution_dummy_components()
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[int]      ,      lowerCAmelCase  :   List[Any]      ,      lowerCAmelCase  :   Optional[int]=0   )	-> Union[str, Any]:
        if str(lowerCAmelCase   ).startswith("mps"   ):
          a__     		=     torch.manual_seed(lowerCAmelCase   )
        else:
          a__     		=     torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
  
        a__     		=     floats_tensor((1, 3, 32, 32)      ,      rng=random.Random(lowerCAmelCase   )   ).to(lowerCAmelCase   )
  
        a__     		=     {
            "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 						__lowerCamelCase (					self  :   List[str]   )	-> List[Any]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[int]   )	-> List[str]:
        self._test_save_load_optional_components()
  
  
  
  
      @unittest.skipIf(torch_device != "cuda"      ,      reason="float16 requires CUDA"   )
      def 						__lowerCamelCase (					self  :   Union[str, Any]   )	-> Tuple:
        # 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 						__lowerCamelCase (					self  :   Any   )	-> List[str]:
        self._test_attention_slicing_forward_pass(expected_max_diff=1e-2   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Dict   )	-> Tuple:
        self._test_save_load_local()
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple   )	-> Tuple:
        self._test_inference_batch_single_identical(
            expected_max_diff=1e-2      ,      )
  
  
style_context: _SCREAMING_SNAKE_CASE   						=    [0.485, 0.456, 0.406]
  _SCREAMING_SNAKE_CASE   						=    [0.229, 0.224, 0.225]
  _SCREAMING_SNAKE_CASE   						=    [0.5, 0.5, 0.5]
  _SCREAMING_SNAKE_CASE   						=    [0.5, 0.5, 0.5]
  _SCREAMING_SNAKE_CASE   						=    [0.48145466, 0.4578275, 0.40821073]
  _SCREAMING_SNAKE_CASE   						=    [0.26862954, 0.26130258, 0.27577711]
  
  