
'''simple docstring'''





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__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     Union[str, Any]    					=       IFSuperResolutionPipeline
 UpperCAmelCase__     :     str    					=       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
 UpperCAmelCase__     :     List[Any]    					=       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 UpperCAmelCase__     :     Optional[Any]    					=       PipelineTesterMixin.required_optional_params - {'latents'}






 def 						lowercase_    (      self	:Any      )					->      Dict:







       '''simple docstring'''



       return self._get_superresolution_dummy_components()






 def 						lowercase_    (      self	:Optional[int]						,					_A	:Optional[int]						,					_A	:Optional[Any]=0      )					->      List[str]:







       '''simple docstring'''



       if str(_A      ).startswith('mps'      ):
             __A													=      torch.manual_seed(_A      )
       else:
             __A													=      torch.Generator(device=_A      ).manual_seed(_A      )

       __A													=      floats_tensor((1, 3, 32, 32)						,					rng=random.Random(_A      )      ).to(_A      )

       __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 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''simple docstring'''



       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )






 def 						lowercase_    (      self	:Union[str, Any]      )					->      str:







       '''simple docstring'''



       self._test_save_load_optional_components()






 @unittest.skipIf(torch_device != 'cuda'						,					reason='float16 requires CUDA'      )
 def 						lowercase_    (      self	:List[str]      )					->      Union[str, Any]:







       '''simple docstring'''



       super().test_save_load_floataa(expected_max_diff=1E-1      )






 def 						lowercase_    (      self	:Union[str, Any]      )					->      str:







       '''simple docstring'''



       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      Any:







       '''simple docstring'''



       self._test_save_load_local()






 def 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''simple docstring'''



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










"""simple docstring"""







from ..utils import DummyObject, requires_backends






class 		_A    (    metaclass=_a    ):







    """simple docstring"""




    UpperCAmelCase			:				int      =			["""torch""", """transformers""", """invisible_watermark"""]






    def __init__(   self							:       int							,					*__UpperCAmelCase							:       List[Any]							,					**__UpperCAmelCase							:       Optional[int]):
      requires_backends(self							,					["torch", "transformers", "invisible_watermark"])






    @classmethod
    def       __snake_case				(   cls							:       Optional[Any]							,					*__UpperCAmelCase							:       Any							,					**__UpperCAmelCase							:       int):
      requires_backends(cls							,					["torch", "transformers", "invisible_watermark"])






    @classmethod
    def       __snake_case				(   cls							:       List[Any]							,					*__UpperCAmelCase							:       Optional[Any]							,					**__UpperCAmelCase							:       Tuple):
      requires_backends(cls							,					["torch", "transformers", "invisible_watermark"])






class 		_A    (    metaclass=_a    ):







    """simple docstring"""




    UpperCAmelCase			:				Optional[int]      =			["""torch""", """transformers""", """invisible_watermark"""]






    def __init__(   self							:       int							,					*__UpperCAmelCase							:       Tuple							,					**__UpperCAmelCase							:       Tuple):
      requires_backends(self							,					["torch", "transformers", "invisible_watermark"])






    @classmethod
    def       __snake_case				(   cls							:       int							,					*__UpperCAmelCase							:       str							,					**__UpperCAmelCase							:       Optional[int]):
      requires_backends(cls							,					["torch", "transformers", "invisible_watermark"])






    @classmethod
    def       __snake_case				(   cls							:       Any							,					*__UpperCAmelCase							:       Optional[int]							,					**__UpperCAmelCase							:       Union[str, Any]):
      requires_backends(cls							,					["torch", "transformers", "invisible_watermark"])






