





'''simple docstring'''






__lowerCamelCase						: str		=   'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'


def 					_a   (__SCREAMING_SNAKE_CASE   )     ->   Optional[int]:


  """simple docstring"""

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

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

  _UpperCamelCase       			=len(lowerCAmelCase__   ) % 6 != 0

  if padding_needed:
    # The padding that will be added later
    _UpperCamelCase       			=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:
    _UpperCamelCase       			=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   (__SCREAMING_SNAKE_CASE   )     ->   Tuple:


  """simple docstring"""

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

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

    _UpperCamelCase       			=''''''.join(
        bin(B64_CHARSET.index(lowerCAmelCase__   )   )[2:].zfill(6   ) for char in encoded_data   )[: -padding * 2]
  else:
    _UpperCamelCase       			=''''''.join(
        bin(B64_CHARSET.index(lowerCAmelCase__   )   )[2:].zfill(6   ) for char in encoded_data   )

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













'''simple docstring'''






from typing import TYPE_CHECKING

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


__lowerCamelCase						: str		=   {
    'configuration_speech_to_text': ['SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Speech2TextConfig'],
    'processing_speech_to_text': ['Speech2TextProcessor'],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: List[str]		=   ['Speech2TextTokenizer']

try:
      if not is_speech_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: str		=   ['Speech2TextFeatureExtractor']

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: Optional[Any]		=   [
          'TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFSpeech2TextForConditionalGeneration',
          'TFSpeech2TextModel',
          'TFSpeech2TextPreTrainedModel',
      ]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: Union[str, Any]		=   [
          'SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
          'Speech2TextForConditionalGeneration',
          'Speech2TextModel',
          'Speech2TextPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
      from .processing_speech_to_text import SpeechaTextProcessor

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_speech_to_text import SpeechaTextTokenizer

      try:
            if not is_speech_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_speech_to_text import (
                TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFSpeechaTextForConditionalGeneration,
                TFSpeechaTextModel,
                TFSpeechaTextPreTrainedModel,
            )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_speech_to_text import (
                SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                SpeechaTextForConditionalGeneration,
                SpeechaTextModel,
                SpeechaTextPreTrainedModel,
            )

else:
      import sys

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






