




UpperCAmelCase__				     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 		_A(       UpperCamelCase__							:			bytes				)    -> Union[str, Any]:
							'''simple docstring'''


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

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

							__lowercase      =    len(lowerCAmelCase__				) % 6 != 0

							if padding_needed:
														# The padding that will be added later
														__lowercase      =    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:
														__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(lowerCAmelCase__				)				,       6				)				).encode()
							    + padding
							)







def 		_A(       UpperCamelCase__							:			str				)    -> List[str]:
							'''simple docstring'''


							if not isinstance(lowerCAmelCase__				,       lowerCAmelCase__				) and not isinstance(lowerCAmelCase__				,       lowerCAmelCase__				):
														__lowercase      =    (
														    '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:
																					__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(lowerCAmelCase__				) % 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(lowerCAmelCase__				)				)[2:].zfill(6				) for char in encoded_data				)[: -padding * 2]
							else:
														__lowercase      =    ''.join(
														    bin(B64_CHARSET.index(lowerCAmelCase__				)				)[2:].zfill(6				) for char in encoded_data				)

							__lowercase      =    [
							    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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


UpperCAmelCase__				     = {
    "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"],
    "tokenization_m2m_100": ["M2M100Tokenizer"],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase__				     = [
			    "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "M2M100ForConditionalGeneration",
			    "M2M100Model",
			    "M2M100PreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
			from .tokenization_mam_aaa import MaMaaaTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_mam_aaa import (
						    M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
						    MaMaaaForConditionalGeneration,
						    MaMaaaModel,
						    MaMaaaPreTrainedModel,
						)


else:
			import sys

			UpperCAmelCase__				     = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






