__a  :     str       =  """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



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

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

				__lowercase 			=							len(lowercase							) % 6 != 0

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





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



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

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

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

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

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

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

				return bytes(lowercase							)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
from ..utils import DummyObject, requires_backends




class    _UpperCamelCase      (						metaclass=_UpperCAmelCase ):


			"""simple docstring"""






			__a  : Dict			 =						['''keras_nlp''']





			def __init__(   self      ,   *lowerCAmelCase__      ,   **lowerCAmelCase__						)     ->					Tuple:

							'''simple docstring'''


							requires_backends(self      ,   ['''keras_nlp''']						)