



"""simple docstring"""






snake_case   					=				'''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''




def 			snake_case		(		lowerCAmelCase_	)						->				bytes:
  # Make sure the supplied data is a bytes-like object
  if not isinstance(lowerCAmelCase_  ,						lowerCAmelCase_	):
    _snake_case   	=      f"""a bytes-like object is required, not '{data.__class__.__name__}'"""
    raise TypeError(lowerCAmelCase_	)

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

  _snake_case   	=      len(lowerCAmelCase_	) % 6 != 0

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

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

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

  _snake_case   	=      [
      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 abc import ABC, abstractmethod
from argparse import ArgumentParser



class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE  ):



   @staticmethod
   @abstractmethod
   def    __UpperCAmelCase    (       __lowerCamelCase    :	ArgumentParser				):



     """simple docstring"""
     raise NotImplementedError()





   @abstractmethod
   def    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     raise NotImplementedError()





