





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




   """simple docstring"""



   __A       :    Union[str, Any]	  =  IFImgaImgSuperResolutionPipeline
   __A       :    Union[str, Any]	  =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
   __A       :    Tuple	  =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}     )
   __A       :    int	  =  PipelineTesterMixin.required_optional_params - {'''latents'''}

   def 							__lowercase		( self)      ->						List[str]:







          '''simple docstring'''

          return self._get_superresolution_dummy_components()

   def 							__lowercase		( self ,  lowercase ,  lowercase=0)      ->						Dict:







          '''simple docstring'''

          if str(lowercase).startswith('mps'):
                 a__						:     str			=    torch.manual_seed(lowercase)
          else:
                 a__						:     Optional[int]			=    torch.Generator(device=lowercase).manual_seed(lowercase)

          a__						:     Optional[int]			=    floats_tensor((1, 3, 32, 32) ,  rng=random.Random(lowercase)).to(lowercase)
          a__						:     str			=    floats_tensor((1, 3, 16, 16) ,  rng=random.Random(lowercase)).to(lowercase)

          a__						:     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 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          self._test_save_load_optional_components()

   @unittest.skipIf(torch_device != 'cuda' ,  reason='float16 requires CUDA')
   def 							__lowercase		( self)      ->						Dict:







          '''simple docstring'''

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

   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          self._test_attention_slicing_forward_pass(expected_max_diff=1e-2)

   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          self._test_save_load_local()

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

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









import enum
import shutil
import sys


lowercase						, lowercase				:	List[Any]      						=  shutil.get_terminal_size()

lowercase				:	Union[str, Any]      						=  {"""UP""": """A""", """DOWN""": """B""", """RIGHT""": """C""", """LEFT""": """D"""}





class 			A__   (							enum.Enum     ):




   """simple docstring"""



   __A       :    List[str]	  =  0
   __A       :    str	  =  1



def A_     (		A__		,				A__=""    )  ->		int:
       sys.stdout.write(str(A__    ) + end    )
       sys.stdout.flush()



def A_     (		A__		,				A__		,				A__=""    )  ->		int:
       forceWrite(F'\u001b[{color}m{content}\u001b[0m'		,				A__    )



def A_     (		)  ->		Any:
       forceWrite('\r'    )



def A_     (		A__		,				A__    )  ->		List[str]:
       forceWrite(F'\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}'    )



def A_     (		)  ->		Any:
       forceWrite(' ' * TERMINAL_WIDTH    )
       reset_cursor()



def A_     (		)  ->		Any:
       reset_cursor()
       forceWrite('-' * TERMINAL_WIDTH    )


