





_SCREAMING_SNAKE_CASE      	=		'''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''


def 							SCREAMING_SNAKE_CASE__						(    __a   ):
 # Make sure the supplied data is a bytes-like object
 if not isinstance(_lowercase   , _lowercase   ):
  snake_case_		:			Union[str, Any]											=	f"""a bytes-like object is required, not \'{data.__class__.__name__}\'"""
  raise TypeError(_lowercase   )

 snake_case_		:			int											=	''.join(bin(_lowercase   )[2:].zfill(8   ) for byte in data   )

 snake_case_		:			Dict											=	len(_lowercase   ) % 6 != 0

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


def 							SCREAMING_SNAKE_CASE__						(    __a   ):
 # Make sure encoded_data is either a string or a bytes-like object
 if not isinstance(_lowercase   , _lowercase   ) and not isinstance(_lowercase   , _lowercase   ):
  snake_case_		:			int											=	(
      'argument should be a bytes-like object or ASCII string, '
      f"""not \'{encoded_data.__class__.__name__}\'"""
  )
  raise TypeError(_lowercase   )

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

 snake_case_		:			Optional[int]											=	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(_lowercase   ) % 4 == 0 and padding < 3, "Incorrect padding"

 if padding:
  # Remove padding if there is one
  snake_case_		:			str											=	encoded_data[:-padding]

  snake_case_		:			Tuple											=	''.join(
      bin(B64_CHARSET.index(_lowercase   )   )[2:].zfill(6   ) for char in encoded_data   )[: -padding * 2]
 else:
  snake_case_		:			Union[str, Any]											=	''.join(
      bin(B64_CHARSET.index(_lowercase   )   )[2:].zfill(6   ) for char in encoded_data   )

 snake_case_		:			List[str]											=	[
     int(binary_stream[index : index + 8]   , 2   )
     for index in range(0   , len(_lowercase   )   , 8   )
 ]

 return bytes(_lowercase   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()








import numpy as np


def 							SCREAMING_SNAKE_CASE__						(    __a   ):
	return (2 / (1 + np.exp(-2 * vector   ))) - 1


if __name__ == "__main__":
						import doctest

						doctest.testmod()

