




__UpperCamelCase					:       Any    					=      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"





def 		__A		(	__lowerCamelCase    )      ->       bytes:
	# Make sure the supplied data is a bytes-like object
	if not isinstance(__lowerCamelCase							,			__lowerCamelCase    ):
		a										=							f'a bytes-like object is required, not \'{data.__class__.__name__}\''
		raise TypeError(__lowerCamelCase    )

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

	a										=							len(__lowerCamelCase    ) % 6 != 0

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

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

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

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







# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


__UpperCamelCase					:       List[str]    					=      logging.get_logger(__name__)

__UpperCamelCase					:       Dict[Optional[str], Type[Formatter]]    					=      {}
__UpperCamelCase					:       Dict[Optional[str], str]    					=      {}
__UpperCamelCase					:       Dict[Optional[str], Exception]    					=      {}





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase = None							,			)      ->       Optional[int]:
	a										=							aliases if aliases is not None else []
	if format_type in _FORMAT_TYPES:
		logger.warning(
		    f'Overwriting format type \'{format_type}\' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})'    )
	a										=							formatter_cls
	for alias in set(aliases + [format_type]    ):
		if alias in _FORMAT_TYPES_ALIASES:
			logger.warning(
			    f'Overwriting format type alias \'{alias}\' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})'    )
		a										=							format_type





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase = None    )      ->       List[str]:
	a										=							aliases if aliases is not None else []
	for alias in set(aliases + [format_type]    ):
		a										=							unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["python"])
_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
_register_formatter(CustomFormatter, "custom")

if config.TORCH_AVAILABLE:
		from .torch_formatter import TorchFormatter

		_register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
else:
		__UpperCamelCase					:       str    					=      ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
		_register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])

if config.TF_AVAILABLE:
		from .tf_formatter import TFFormatter

		_register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
else:
		__UpperCamelCase					:       List[str]    					=      ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
		_register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])

if config.JAX_AVAILABLE:
		from .jax_formatter import JaxFormatter

		_register_formatter(JaxFormatter, "jax", aliases=[])
else:
		__UpperCamelCase					:       List[str]    					=      ValueError("JAX needs to be installed to be able to return JAX arrays.")
		_register_unavailable_formatter(_jax_error, "jax", aliases=[])





def 		__A		(	__lowerCamelCase    )      ->       Optional[str]:
	if format_type in _FORMAT_TYPES_ALIASES:
		return _FORMAT_TYPES_ALIASES[format_type]
	else:
		return format_type





def 		__A		(	__lowerCamelCase							,			**__lowerCamelCase    )      ->       Formatter:
	a										=							get_format_type_from_alias(__lowerCamelCase    )
	if format_type in _FORMAT_TYPES:
		return _FORMAT_TYPES[format_type](**__lowerCamelCase    )
	if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
		raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
	else:
		raise ValueError(
		    f'Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None    )}, but got \'{format_type}\''    )

