
"""simple docstring"""





__magic_name__			=     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"



def 		_lowerCAmelCase							(							UpperCamelCase_							):
		# Make sure the supplied data is a bytes-like object
		if not isinstance(snake_case__    ,							snake_case__							):
				__SCREAMING_SNAKE_CASE				=					f"a bytes-like object is required, not '{data.__class__.__name__}'"
				raise TypeError(snake_case__							)

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

		__SCREAMING_SNAKE_CASE				=					len(snake_case__							) % 6 != 0

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



def 		_lowerCAmelCase							(							UpperCamelCase_							):
		# Make sure encoded_data is either a string or a bytes-like object
		if not isinstance(snake_case__    ,							snake_case__							) and not isinstance(snake_case__    ,							snake_case__							):
				__SCREAMING_SNAKE_CASE				=					(
				    """argument should be a bytes-like object or ASCII string, """
				    f"not '{encoded_data.__class__.__name__}'"
				)
				raise TypeError(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(snake_case__    ,							snake_case__							):
				try:
						__SCREAMING_SNAKE_CASE				=					encoded_data.decode("""utf-8"""							)
				except UnicodeDecodeError:
						raise ValueError("""base64 encoded data should only contain ASCII characters"""							)

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

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

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

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

		return bytes(snake_case__							)


if __name__ == "__main__":
							import doctest

							doctest.testmod()












"""simple docstring"""
_lowerCAmelCase       =				[
    "Audio",
    "Array2D",
    "Array3D",
    "Array4D",
    "Array5D",
    "ClassLabel",
    "Features",
    "Sequence",
    "Value",
    "Image",
    "Translation",
    "TranslationVariableLanguages",
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages

