"""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  ,)


"""simple docstring"""







__SCREAMING_SNAKE_CASE								="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"



def     lowercase__( __SCREAMING_SNAKE_CASE							:  bytes   ):
     # Make sure the supplied data is a bytes-like object
     if not isinstance(__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE   ):
          lowercase_			:       Dict									=			F'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
          raise TypeError(__SCREAMING_SNAKE_CASE   )

     lowercase_			:       List[Any]									=			''.join(bin(__SCREAMING_SNAKE_CASE   )[2:].zfill(8   ) for byte in data   )

     lowercase_			:       List[Any]									=			len(__SCREAMING_SNAKE_CASE   ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          lowercase_			:       Optional[int]									=			b'=' * ((6 - len(__SCREAMING_SNAKE_CASE   ) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(__SCREAMING_SNAKE_CASE   ) % 6)
     else:
          lowercase_			:       List[Any]									=			b''

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]  ,    2   )]
             for index in range(0  ,    len(__SCREAMING_SNAKE_CASE   )  ,    6   )   ).encode()
         + padding
     )



def     lowercase__( __SCREAMING_SNAKE_CASE							:  str   ):
     # Make sure encoded_data is either a string or a bytes-like object
     if not isinstance(__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE   ) and not isinstance(__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE   ):
          lowercase_			:       Tuple									=			(
              'argument should be a bytes-like object or ASCII string, '
              F'''not \'{encoded_data.__class__.__name__}\''''
          )
          raise TypeError(__SCREAMING_SNAKE_CASE   )

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE   ):
          try:
               lowercase_			:       List[str]									=			encoded_data.decode('utf-8'   )
          except UnicodeDecodeError:
               raise ValueError('base64 encoded data should only contain ASCII characters'   )

     lowercase_			:       List[str]									=			encoded_data.count('='   )

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding]   ), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data   ), "Invalid base64 character(s) found."

     # Check the padding
     assert len(__SCREAMING_SNAKE_CASE   ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          lowercase_			:       Union[str, Any]									=			encoded_data[:-padding]

          lowercase_			:       List[Any]									=			''.join(
              bin(B64_CHARSET.index(__SCREAMING_SNAKE_CASE   )   )[2:].zfill(6   ) for char in encoded_data   )[: -padding * 2]
     else:
          lowercase_			:       int									=			''.join(
              bin(B64_CHARSET.index(__SCREAMING_SNAKE_CASE   )   )[2:].zfill(6   ) for char in encoded_data   )

     lowercase_			:       str									=			[
         int(binary_stream[index : index + 8]  ,    2   )
         for index in range(0  ,    len(__SCREAMING_SNAKE_CASE   )  ,    8   )
     ]

     return bytes(__SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
       import doctest

       doctest.testmod()

