

_lowerCamelCase    :       Union[str, Any]        =							"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

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

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

  UpperCAmelCase	:							Optional[int]						=			len(UpperCAmelCase      ) % 6 != 0

  if padding_needed:
    # The padding that will be added later
    UpperCAmelCase	:							List[Any]						=			b'''=''' * ((6 - len(UpperCAmelCase      ) % 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(UpperCAmelCase      ) % 6)
  else:
    UpperCAmelCase	:							Tuple						=			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(UpperCAmelCase      )    ,			6      )      ).encode()
      + padding
  )

def       a__					(		UpperCAmelCase							:      str      )  ->						bytes:
  # Make sure encoded_data is either a string or a bytes-like object
  if not isinstance(UpperCAmelCase    ,			UpperCAmelCase      ) and not isinstance(UpperCAmelCase    ,			UpperCAmelCase      ):
    UpperCAmelCase	:							Union[str, Any]						=			(
        '''argument should be a bytes-like object or ASCII string, '''
        f'''not \'{encoded_data.__class__.__name__}\''''
    )
    raise TypeError(UpperCAmelCase      )

  # 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(UpperCAmelCase    ,			UpperCAmelCase      ):
    try:
      UpperCAmelCase	:							Any						=			encoded_data.decode('''utf-8'''      )
    except UnicodeDecodeError:
      raise ValueError('''base64 encoded data should only contain ASCII characters'''      )

  UpperCAmelCase	:							Union[str, Any]						=			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(UpperCAmelCase      ) % 4 == 0 and padding < 3, "Incorrect padding"

  if padding:
    # Remove padding if there is one
    UpperCAmelCase	:							int						=			encoded_data[:-padding]

    UpperCAmelCase	:							List[str]						=			''''''.join(
        bin(B64_CHARSET.index(UpperCAmelCase      )      )[2:].zfill(6      ) for char in encoded_data      )[: -padding * 2]
  else:
    UpperCAmelCase	:							Optional[Any]						=			''''''.join(
        bin(B64_CHARSET.index(UpperCAmelCase      )      )[2:].zfill(6      ) for char in encoded_data      )

  UpperCAmelCase	:							Any						=			[
      int(binary_stream[index : index + 8]    ,			2      )
      for index in range(0    ,			len(UpperCAmelCase      )    ,			8      )
  ]

  return bytes(UpperCAmelCase      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()








from typing import TYPE_CHECKING

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


_lowerCamelCase    :       str        =							{"configuration_xlnet": ["XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLNetConfig"]}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       List[Any]        =							["XLNetTokenizer"]

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Optional[Any]        =							["XLNetTokenizerFast"]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Dict        =							[
         "XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
         "XLNetForMultipleChoice",
         "XLNetForQuestionAnswering",
         "XLNetForQuestionAnsweringSimple",
         "XLNetForSequenceClassification",
         "XLNetForTokenClassification",
         "XLNetLMHeadModel",
         "XLNetModel",
         "XLNetPreTrainedModel",
         "load_tf_weights_in_xlnet",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Union[str, Any]        =							[
         "TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
         "TFXLNetForMultipleChoice",
         "TFXLNetForQuestionAnsweringSimple",
         "TFXLNetForSequenceClassification",
         "TFXLNetForTokenClassification",
         "TFXLNetLMHeadModel",
         "TFXLNetMainLayer",
         "TFXLNetModel",
         "TFXLNetPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_xlnet import XLNetTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_xlnet_fast import XLNetTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_xlnet import (
              XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
              XLNetForMultipleChoice,
              XLNetForQuestionAnswering,
              XLNetForQuestionAnsweringSimple,
              XLNetForSequenceClassification,
              XLNetForTokenClassification,
              XLNetLMHeadModel,
              XLNetModel,
              XLNetPreTrainedModel,
              load_tf_weights_in_xlnet,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_xlnet import (
              TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFXLNetForMultipleChoice,
              TFXLNetForQuestionAnsweringSimple,
              TFXLNetForSequenceClassification,
              TFXLNetForTokenClassification,
              TFXLNetLMHeadModel,
              TFXLNetMainLayer,
              TFXLNetModel,
              TFXLNetPreTrainedModel,
          )

else:
     import sys

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





