





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 				__snake_case  (     _a ,    _a ,    unittest.TestCase						):


    '''simple docstring'''







    lowerCamelCase__						:		Optional[Any]							=  IFSuperResolutionPipeline
    lowerCamelCase__						:		Dict							=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
    lowerCamelCase__						:		str							=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
    lowerCamelCase__						:		Optional[Any]							=  PipelineTesterMixin.required_optional_params - {'latents'}



    def    lowercase_				(					self    ):





        '''simple docstring'''

        return self._get_superresolution_dummy_components()



    def    lowercase_				(					self      ,							A_      ,							A_=0    ):





        '''simple docstring'''

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

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

        SCREAMING_SNAKE_CASE__       							= {
            '''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    ):





        '''simple docstring'''

        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )



    def    lowercase_				(					self    ):





        '''simple docstring'''

        self._test_save_load_optional_components()



    @unittest.skipIf(torch_device != '''cuda'''      ,							reason='''float16 requires CUDA'''    )
    def    lowercase_				(					self    ):





        '''simple docstring'''

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



    def    lowercase_				(					self    ):





        '''simple docstring'''

        self._test_attention_slicing_forward_pass(expected_max_diff=1E-2    )



    def    lowercase_				(					self    ):





        '''simple docstring'''

        self._test_save_load_local()




    def    lowercase_				(					self    ):





        '''simple docstring'''

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








import numpy as np

_A				:							List[Any]							= [
    ["""a""", """b""", """c""", """d""", """e"""],
    ["""f""", """g""", """h""", """i""", """k"""],
    ["""l""", """m""", """n""", """o""", """p"""],
    ["""q""", """r""", """s""", """t""", """u"""],
    ["""v""", """w""", """x""", """y""", """z"""],
]



class 				__snake_case  :


    '''simple docstring'''







    def __init__(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= np.array(A_    )



    def    lowercase_				(					self      ,							A_    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__       							= np.where(letter == self.SQUARE    )
        SCREAMING_SNAKE_CASE__       							= np.concatenate([indexa + 1, indexa + 1]    )
        return indexes



    def    lowercase_				(					self      ,							A_      ,							A_    ):





        '''simple docstring'''

        return self.SQUARE[indexa - 1, indexa - 1]



    def    lowercase_				(					self      ,							A_    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= message.lower()
        SCREAMING_SNAKE_CASE__       							= message.replace('''j'''      ,							'''i'''    )

        SCREAMING_SNAKE_CASE__       							= ''''''
        for letter_index in range(len(A_    )    ):
            if message[letter_index] != " ":
                SCREAMING_SNAKE_CASE__       							= self.letter_to_numbers(message[letter_index]    )
                SCREAMING_SNAKE_CASE__       							= encoded_message + str(numbers[0]    ) + str(numbers[1]    )
            elif message[letter_index] == " ":
                SCREAMING_SNAKE_CASE__       							= encoded_message + ''' '''

        return encoded_message




    def    lowercase_				(					self      ,							A_    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= message.replace(''' '''      ,							'''  '''    )
        SCREAMING_SNAKE_CASE__       							= ''''''
        for numbers_index in range(int(len(A_    ) / 2    )    ):
            if message[numbers_index * 2] != " ":
                SCREAMING_SNAKE_CASE__       							= message[numbers_index * 2]
                SCREAMING_SNAKE_CASE__       							= message[numbers_index * 2 + 1]

                SCREAMING_SNAKE_CASE__       							= self.numbers_to_letter(int(A_    )      ,							int(A_    )    )
                SCREAMING_SNAKE_CASE__       							= decoded_message + letter
            elif message[numbers_index * 2] == " ":
                SCREAMING_SNAKE_CASE__       							= decoded_message + ''' '''

        return decoded_message
