"""simple docstring"""







import os
import string
import sys


__SCREAMING_SNAKE_CASE								=1 << 8

__SCREAMING_SNAKE_CASE								={
    "tab": ord("\t"),
    "newline": ord("\r"),
    "esc": 27,
    "up": 65 + ARROW_KEY_FLAG,
    "down": 66 + ARROW_KEY_FLAG,
    "right": 67 + ARROW_KEY_FLAG,
    "left": 68 + ARROW_KEY_FLAG,
    "mod_int": 91,
    "undefined": sys.maxsize,
    "interrupt": 3,
    "insert": 50,
    "delete": 51,
    "pg_up": 53,
    "pg_down": 54,
}

__SCREAMING_SNAKE_CASE								=KEYMAP["up"]
__SCREAMING_SNAKE_CASE								=KEYMAP["left"]

if sys.platform == "win32":
       __SCREAMING_SNAKE_CASE								=[]
       __SCREAMING_SNAKE_CASE								={
           B"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
           B"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
           B"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
           B"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
           B"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
           B"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
           B"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
           B"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
       }

for i in range(10):
       __SCREAMING_SNAKE_CASE								=ord(str(i))



def     lowercase__( ):
     if os.name == "nt":
          import msvcrt

          lowercase_			:       Optional[int]									=			'mbcs'
          # Flush the keyboard buffer
          while msvcrt.kbhit():
               msvcrt.getch()
          if len(__SCREAMING_SNAKE_CASE   ) == 0:
               # Read the keystroke
               lowercase_			:       List[str]									=			msvcrt.getch()

               # If it is a prefix char, get second part
               if ch in (b"\x00", b"\xe0"):
                    lowercase_			:       str									=			ch + msvcrt.getch()
                    # Translate actual Win chars to bullet char types
                    try:
                         lowercase_			:       Dict									=			chr(WIN_KEYMAP[cha]   )
                         WIN_CH_BUFFER.append(chr(KEYMAP['mod_int']   )   )
                         WIN_CH_BUFFER.append(__SCREAMING_SNAKE_CASE   )
                         if ord(__SCREAMING_SNAKE_CASE   ) in (
                             KEYMAP["insert"] - 1 << 9,
                             KEYMAP["delete"] - 1 << 9,
                             KEYMAP["pg_up"] - 1 << 9,
                             KEYMAP["pg_down"] - 1 << 9,
                         ):
                              WIN_CH_BUFFER.append(chr(1_26   )   )
                         lowercase_			:       int									=			chr(KEYMAP['esc']   )
                    except KeyError:
                         lowercase_			:       Union[str, Any]									=			cha[1]
               else:
                    lowercase_			:       Optional[Any]									=			ch.decode(__SCREAMING_SNAKE_CASE   )
          else:
               lowercase_			:       Optional[int]									=			WIN_CH_BUFFER.pop(0   )
     elif os.name == "posix":
          import termios
          import tty

          lowercase_			:       Any									=			sys.stdin.fileno()
          lowercase_			:       Dict									=			termios.tcgetattr(__SCREAMING_SNAKE_CASE   )
          try:
               tty.setraw(__SCREAMING_SNAKE_CASE   )
               lowercase_			:       int									=			sys.stdin.read(1   )
          finally:
               termios.tcsetattr(__SCREAMING_SNAKE_CASE  ,    termios.TCSADRAIN  ,    __SCREAMING_SNAKE_CASE   )
     return ch







def     lowercase__( ):
     lowercase_			:       Tuple									=			get_raw_chars()
     if ord(__SCREAMING_SNAKE_CASE   ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
          return char

     elif ord(__SCREAMING_SNAKE_CASE   ) == KEYMAP["esc"]:
          lowercase_			:       int									=			get_raw_chars()
          if ord(__SCREAMING_SNAKE_CASE   ) == KEYMAP["mod_int"]:
               lowercase_			:       List[Any]									=			get_raw_chars()
               if ord(__SCREAMING_SNAKE_CASE   ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(__SCREAMING_SNAKE_CASE   ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
                    return chr(ord(__SCREAMING_SNAKE_CASE   ) + ARROW_KEY_FLAG   )
               else:
                    return KEYMAP["undefined"]
          else:
               return get_raw_chars()

     else:
          if char in string.printable:
               return char
          else:
               return KEYMAP["undefined"]


"""simple docstring"""







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  UpperCamelCase	(    lowercase_		,   lowercase_		,   unittest.TestCase						):
   lowercase							=						IFImgaImgSuperResolutionPipeline
   lowercase							=						TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
   lowercase							=						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}						)
   lowercase							=						PipelineTesterMixin.required_optional_params - {'latents'}
   def     _UpperCAmelCase     (    self    )			->   int:


        '''simple docstring'''


        return self._get_superresolution_dummy_components()
   def     _UpperCAmelCase     (    self  ,__UpperCamelCase  ,__UpperCamelCase=0    )			->   List[str]:


        '''simple docstring'''


        if str(__UpperCamelCase    ).startswith('mps'    ):
             lowercase_			:       Any									=			torch.manual_seed(__UpperCamelCase    )
        else:
             lowercase_			:       int									=			torch.Generator(device=__UpperCamelCase    ).manual_seed(__UpperCamelCase    )

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

        lowercase_			:       Optional[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     _UpperCAmelCase     (    self    )			->   Optional[Any]:


        '''simple docstring'''


        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )
   def     _UpperCAmelCase     (    self    )			->   Dict:


        '''simple docstring'''


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


        '''simple docstring'''


        super().test_save_load_floataa(expected_max_diff=1e-1    )
   def     _UpperCAmelCase     (    self    )			->   Dict:


        '''simple docstring'''


        self._test_attention_slicing_forward_pass(expected_max_diff=1e-2    )
   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


        self._test_save_load_local()







   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


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

