




snake_case_ : Optional[int]    		=       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"


def    A						(__A   :    bytes       )   ->      bytes:







     """simple docstring"""


     if not isinstance(__A   ,				__A       ):
          UpperCAmelCase_          =							F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
          raise TypeError(__A       )

     UpperCAmelCase_          =							''''''.join(bin(__A       )[2:].zfill(8       ) for byte in data       )

     UpperCAmelCase_          =							len(__A       ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          UpperCAmelCase_          =							B'''=''' * ((6 - len(__A       ) % 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(__A       ) % 6)
     else:
          UpperCAmelCase_          =							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(__A       )   ,				6       )       ).encode()
         + padding
     )


def    A						(__A   :    str       )   ->      bytes:







     """simple docstring"""


     if not isinstance(__A   ,				__A       ) and not isinstance(__A   ,				__A       ):
          UpperCAmelCase_          =							(
              '''argument should be a bytes-like object or ASCII string, '''
              F"""not '{encoded_data.__class__.__name__}'"""
          )
          raise TypeError(__A       )

     # 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(__A   ,				__A       ):
          try:
               UpperCAmelCase_          =							encoded_data.decode('''utf-8'''       )
          except UnicodeDecodeError:
               raise ValueError('''base64 encoded data should only contain ASCII characters'''       )

     UpperCAmelCase_          =							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(__A       ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          UpperCAmelCase_          =							encoded_data[:-padding]

          UpperCAmelCase_          =							''''''.join(
              bin(B64_CHARSET.index(__A       )       )[2:].zfill(6       ) for char in encoded_data       )[: -padding * 2]
     else:
          UpperCAmelCase_          =							''''''.join(
              bin(B64_CHARSET.index(__A       )       )[2:].zfill(6       ) for char in encoded_data       )

     UpperCAmelCase_          =							[
         int(binary_stream[index : index + 8]   ,				2       )
         for index in range(0   ,				len(__A       )   ,				8       )
     ]

     return bytes(__A       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()












from diffusers.utils.testing_utils import require_onnxruntime







@require_onnxruntime
class __snake_case			:
   pass






