
'''simple docstring'''



_lowercase    =		'''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''


def A     (__lowerCamelCase				:List[str]		):
						# Make sure the supplied data is a bytes-like object
						if not isinstance(A_			,     A_		):
												_lowerCAmelCase  						=			f'a bytes-like object is required, not \'{data.__class__.__name__}\''
												raise TypeError(A_		)

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

						_lowerCAmelCase  						=			len(A_		) % 6 != 0

						if padding_needed:
												# The padding that will be added later
												_lowerCAmelCase  						=			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:
												_lowerCAmelCase  						=			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     (__lowerCamelCase				:Tuple		):
						# Make sure encoded_data is either a string or a bytes-like object
						if not isinstance(A_			,     A_		) and not isinstance(A_			,     A_		):
												_lowerCAmelCase  						=			(
												    '''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:
																		_lowerCAmelCase  						=			encoded_data.decode("""utf-8"""		)
												except UnicodeDecodeError:
																		raise ValueError("""base64 encoded data should only contain ASCII characters"""		)

						_lowerCAmelCase  						=			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
												_lowerCAmelCase  						=			encoded_data[:-padding]

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

						_lowerCAmelCase  						=			[
						    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()


'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase    =		{
    """configuration_table_transformer""": [
        """TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """TableTransformerConfig""",
        """TableTransformerOnnxConfig""",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase    =		[
						    """TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """TableTransformerForObjectDetection""",
						    """TableTransformerModel""",
						    """TableTransformerPreTrainedModel""",
						]


if TYPE_CHECKING:
						from .configuration_table_transformer import (
						    TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    TableTransformerConfig,
						    TableTransformerOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_table_transformer import (
												    TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TableTransformerForObjectDetection,
												    TableTransformerModel,
												    TableTransformerPreTrainedModel,
												)

else:
						import sys

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