


"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__magic_name__						: int    =				{
    'configuration_electra': ['ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ElectraConfig', 'ElectraOnnxConfig'],
    'tokenization_electra': ['ElectraTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__magic_name__						: Any    =				['ElectraTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__magic_name__						: List[str]    =				[
					    'ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'ElectraForCausalLM',
					    'ElectraForMaskedLM',
					    'ElectraForMultipleChoice',
					    'ElectraForPreTraining',
					    'ElectraForQuestionAnswering',
					    'ElectraForSequenceClassification',
					    'ElectraForTokenClassification',
					    'ElectraModel',
					    'ElectraPreTrainedModel',
					    'load_tf_weights_in_electra',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__magic_name__						: Optional[Any]    =				[
					    'TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFElectraForMaskedLM',
					    'TFElectraForMultipleChoice',
					    'TFElectraForPreTraining',
					    'TFElectraForQuestionAnswering',
					    'TFElectraForSequenceClassification',
					    'TFElectraForTokenClassification',
					    'TFElectraModel',
					    'TFElectraPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__magic_name__						: Dict    =				[
					    'FlaxElectraForCausalLM',
					    'FlaxElectraForMaskedLM',
					    'FlaxElectraForMultipleChoice',
					    'FlaxElectraForPreTraining',
					    'FlaxElectraForQuestionAnswering',
					    'FlaxElectraForSequenceClassification',
					    'FlaxElectraForTokenClassification',
					    'FlaxElectraModel',
					    'FlaxElectraPreTrainedModel',
					]


if TYPE_CHECKING:
					from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
					from .tokenization_electra import ElectraTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_electra_fast import ElectraTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_electra import (
										    ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
										    ElectraForCausalLM,
										    ElectraForMaskedLM,
										    ElectraForMultipleChoice,
										    ElectraForPreTraining,
										    ElectraForQuestionAnswering,
										    ElectraForSequenceClassification,
										    ElectraForTokenClassification,
										    ElectraModel,
										    ElectraPreTrainedModel,
										    load_tf_weights_in_electra,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_electra import (
										    TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFElectraForMaskedLM,
										    TFElectraForMultipleChoice,
										    TFElectraForPreTraining,
										    TFElectraForQuestionAnswering,
										    TFElectraForSequenceClassification,
										    TFElectraForTokenClassification,
										    TFElectraModel,
										    TFElectraPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_electra import (
										    FlaxElectraForCausalLM,
										    FlaxElectraForMaskedLM,
										    FlaxElectraForMultipleChoice,
										    FlaxElectraForPreTraining,
										    FlaxElectraForQuestionAnswering,
										    FlaxElectraForSequenceClassification,
										    FlaxElectraForTokenClassification,
										    FlaxElectraModel,
										    FlaxElectraPreTrainedModel,
										)

else:
					import sys

					__magic_name__						: Optional[Any]    =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)








"""simple docstring"""




__magic_name__						: Optional[Any]    =				'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'





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

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

			__lowerCamelCase          =      len(lowercase__     ) % 6 != 0

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





def       a_ (	lowercase__ :str     ):
			# Make sure encoded_data is either a string or a bytes-like object
			if not isinstance(lowercase__,			lowercase__     ) and not isinstance(lowercase__,			lowercase__     ):
						__lowerCamelCase          =      (
						    """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:
									__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(lowercase__     ) % 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(lowercase__     )     )[2:].zfill(6     ) for char in encoded_data     )[: -padding * 2]
			else:
						__lowerCamelCase          =      """""".join(
						    bin(B64_CHARSET.index(lowercase__     )     )[2:].zfill(6     ) for char in encoded_data     )

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




