






lowerCamelCase : Optional[Any]						   =       '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''
def       snake_case_		(     lowerCAmelCase_       :						bytes      ):
							# Make sure the supplied data is a bytes-like object
							if not isinstance(lowerCAmelCase_       ,       lowerCAmelCase_      ):
														__lowercase      :							str				=     F"a bytes-like object is required, not '{data.__class__.__name__}'"
														raise TypeError(lowerCAmelCase_      )

							__lowercase      :							List[Any]				=     """""".join(bin(lowerCAmelCase_      )[2:].zfill(8      ) for byte in data      )

							__lowercase      :							Dict				=     len(lowerCAmelCase_      ) % 6 != 0

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

							__lowercase      :							List[str]				=     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      :							Optional[int]				=     encoded_data[:-padding]

														__lowercase      :							int				=     """""".join(
														    bin(B64_CHARSET.index(lowerCAmelCase_      )      )[2:].zfill(6      ) for char in encoded_data      )[: -padding * 2]
							else:
														__lowercase      :							str				=     """""".join(
														    bin(B64_CHARSET.index(lowerCAmelCase_      )      )[2:].zfill(6      ) for char in encoded_data      )

							__lowercase      :							Optional[Any]				=     [
							    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_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase : int						   =       {
    '''configuration_funnel''': ['''FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FunnelConfig'''],
    '''convert_funnel_original_tf_checkpoint_to_pytorch''': [],
    '''tokenization_funnel''': ['''FunnelTokenizer'''],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase : List[str]						   =       ['''FunnelTokenizerFast''']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase : Union[str, Any]						   =       [
	    '''FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''FunnelBaseModel''',
	    '''FunnelForMaskedLM''',
	    '''FunnelForMultipleChoice''',
	    '''FunnelForPreTraining''',
	    '''FunnelForQuestionAnswering''',
	    '''FunnelForSequenceClassification''',
	    '''FunnelForTokenClassification''',
	    '''FunnelModel''',
	    '''FunnelPreTrainedModel''',
	    '''load_tf_weights_in_funnel''',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase : str						   =       [
	    '''TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''TFFunnelBaseModel''',
	    '''TFFunnelForMaskedLM''',
	    '''TFFunnelForMultipleChoice''',
	    '''TFFunnelForPreTraining''',
	    '''TFFunnelForQuestionAnswering''',
	    '''TFFunnelForSequenceClassification''',
	    '''TFFunnelForTokenClassification''',
	    '''TFFunnelModel''',
	    '''TFFunnelPreTrainedModel''',
	]


if TYPE_CHECKING:
	from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
	from .tokenization_funnel import FunnelTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_funnel_fast import FunnelTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_funnel import (
		    FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
		    FunnelBaseModel,
		    FunnelForMaskedLM,
		    FunnelForMultipleChoice,
		    FunnelForPreTraining,
		    FunnelForQuestionAnswering,
		    FunnelForSequenceClassification,
		    FunnelForTokenClassification,
		    FunnelModel,
		    FunnelPreTrainedModel,
		    load_tf_weights_in_funnel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_funnel import (
		    TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFFunnelBaseModel,
		    TFFunnelForMaskedLM,
		    TFFunnelForMultipleChoice,
		    TFFunnelForPreTraining,
		    TFFunnelForQuestionAnswering,
		    TFFunnelForSequenceClassification,
		    TFFunnelForTokenClassification,
		    TFFunnelModel,
		    TFFunnelPreTrainedModel,
		)

else:
	import sys

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