
__lowerCAmelCase			:     Tuple           =   'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

def a__    (       A_					):






  '''simple docstring'''





  if not isinstance(A_,     A_					):
    __magic_name__				     =       f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
    raise TypeError(A_					)

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

  __magic_name__				     =       len(A_					) % 6 != 0

  if padding_needed:
    # The padding that will be added later
    __magic_name__				     =       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:
    __magic_name__				     =       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__    (       A_					):






  '''simple docstring'''





  if not isinstance(A_,     A_					) and not isinstance(A_,     A_					):
    __magic_name__				     =       (
        """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:
      __magic_name__				     =       encoded_data.decode("""utf-8"""					)
    except UnicodeDecodeError:
      raise ValueError("""base64 encoded data should only contain ASCII characters"""					)

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

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

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



from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase			:     Any           =   {
    'configuration_mctct': ['MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MCTCTConfig'],
    'feature_extraction_mctct': ['MCTCTFeatureExtractor'],
    'processing_mctct': ['MCTCTProcessor'],
}


try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCAmelCase			:     int           =   [
        'MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'MCTCTForCTC',
        'MCTCTModel',
        'MCTCTPreTrainedModel',
    ]


if TYPE_CHECKING:
    from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
    from .feature_extraction_mctct import MCTCTFeatureExtractor
    from .processing_mctct import MCTCTProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
    import sys

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

