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      ,      )


_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]

