



_lowerCamelCase						    =  """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





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

 __SCREAMING_SNAKE_CASE       :    List[str]       =	"".join(bin(__lowerCamelCase     )[2:].zfill(8     ) for byte in data     )

 __SCREAMING_SNAKE_CASE       :    Any       =	len(__lowerCamelCase     ) % 6 != 0

 if padding_needed:
  # The padding that will be added later
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	b"=" * ((6 - len(__lowerCamelCase     ) % 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(__lowerCamelCase     ) % 6)
 else:
  __SCREAMING_SNAKE_CASE       :    Optional[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(__lowerCamelCase     )		,	6     )     ).encode()
     + padding
 )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     str     ):



 """simple docstring"""





 if not isinstance(__lowerCamelCase		,	__lowerCamelCase     ) and not isinstance(__lowerCamelCase		,	__lowerCamelCase     ):
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	(
      "argument should be a bytes-like object or ASCII string, "
      F"""not '{encoded_data.__class__.__name__}'"""
  )
  raise TypeError(__lowerCamelCase     )

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

 __SCREAMING_SNAKE_CASE       :    Tuple       =	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(__lowerCamelCase     ) % 4 == 0 and padding < 3, "Incorrect padding"

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

  __SCREAMING_SNAKE_CASE       :    str       =	"".join(
      bin(B64_CHARSET.index(__lowerCamelCase     )     )[2:].zfill(6     ) for char in encoded_data     )[: -padding * 2]
 else:
  __SCREAMING_SNAKE_CASE       :    str       =	"".join(
      bin(B64_CHARSET.index(__lowerCamelCase     )     )[2:].zfill(6     ) for char in encoded_data     )

 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	[
     int(binary_stream[index : index + 8]		,	2     )
     for index in range(0		,	len(__lowerCamelCase     )		,	8     )
 ]

 return bytes(__lowerCamelCase     )


if __name__ == "__main__":
      import doctest

      doctest.testmod()











from diffusers.utils.testing_utils import require_onnxruntime

@require_onnxruntime
class       _SCREAMING_SNAKE_CASE	:
     pass






