




import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
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_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class     A(		UpperCamelCase				, UpperCamelCase				, unittest.TestCase  ):



 '''simple docstring'''


 UpperCamelCase		  =		IFInpaintingSuperResolutionPipeline
 UpperCamelCase		  =		TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''width''', '''height'''}
 UpperCamelCase		  =		TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({'''original_image'''}  )
 UpperCamelCase		  =		PipelineTesterMixin.required_optional_params - {'''latents'''}

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

       """simple docstring"""






       return self._get_superresolution_dummy_components()

 def 							a__					(							self   :    str		,				A_   :    List[str]		,				A_   :    Tuple=0    )  ->      Tuple:

       """simple docstring"""






       if str(A_    ).startswith('mps'    ):
             lowerCamelCase_							=       torch.manual_seed(A_    )
       else:
             lowerCamelCase_							=       torch.Generator(device=A_    ).manual_seed(A_    )

       lowerCamelCase_							=       floats_tensor((1, 3, 16, 16)		,				rng=random.Random(A_    )    ).to(A_    )
       lowerCamelCase_							=       floats_tensor((1, 3, 32, 32)		,				rng=random.Random(A_    )    ).to(A_    )
       lowerCamelCase_							=       floats_tensor((1, 3, 32, 32)		,				rng=random.Random(A_    )    ).to(A_    )

       lowerCamelCase_							=       {
           'prompt': 'A painting of a squirrel eating a burger',
           'image': image,
           'original_image': original_image,
           'mask_image': mask_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   :    Optional[Any]    )  ->      Tuple:

       """simple docstring"""






       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )

 def 							a__					(							self   :    List[str]    )  ->      List[Any]:

       """simple docstring"""






       self._test_save_load_optional_components()

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

       """simple docstring"""






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

 def 							a__					(							self   :    int    )  ->      Optional[Any]:

       """simple docstring"""






       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2    )

 def 							a__					(							self   :    int    )  ->      List[str]:

       """simple docstring"""






       self._test_save_load_local()





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

       """simple docstring"""






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










'''simple docstring'''






def 					_a						(       _lowerCamelCase ) ->				int:



			"""simple docstring"""


			if not isinstance(_lowerCamelCase    ,	_lowerCamelCase ):
						raise TypeError("""only integers accepted as input""" )
			else:
						__snake_case					:      List[Any]							      =     str(abs(_lowerCamelCase ) )
						__snake_case					:      Union[str, Any]							      =     [list(_lowerCamelCase ) for char in range(len(_lowerCamelCase ) )]
						for index in range(len(_lowerCamelCase ) ):
									num_transpositions[index].pop(_lowerCamelCase )
						return max(
						    int("""""".join(list(_lowerCamelCase ) ) ) for transposition in num_transpositions )


if __name__ == "__main__":
	__import__("doctest").testmod()


