

a						="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"






def   SCREAMING_SNAKE_CASE__			(    lowerCamelCase__     )    ->	bytes:
	# Make sure the supplied data is a bytes-like object
	if not isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
		__lowerCamelCase							:							Dict   			=					F"a bytes-like object is required, not \'{data.__class__.__name__}\'"
		raise TypeError(lowerCamelCase_     )

	__lowerCamelCase							:							List[str]   			=					''.join(bin(lowerCamelCase_     )[2:].zfill(8     ) for byte in data     )

	__lowerCamelCase							:							Tuple   			=					len(lowerCamelCase_     ) % 6 != 0

	if padding_needed:
		# The padding that will be added later
		__lowerCamelCase							:							Union[str, Any]   			=					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:
		__lowerCamelCase							:							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(lowerCamelCase_     )      ,					6     )     ).encode()
	    + padding
	)






def   SCREAMING_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_     ):
		__lowerCamelCase							:							str   			=					(
		    '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:
			__lowerCamelCase							:							List[Any]   			=					encoded_data.decode('utf-8'     )
		except UnicodeDecodeError:
			raise ValueError('base64 encoded data should only contain ASCII characters'     )

	__lowerCamelCase							:							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(lowerCamelCase_     ) % 4 == 0 and padding < 3, "Incorrect padding"

	if padding:
		# Remove padding if there is one
		__lowerCamelCase							:							Tuple   			=					encoded_data[:-padding]

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

	__lowerCamelCase							:							Tuple   			=					[
	    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()








from maths.prime_factors import prime_factors



def 							UpperCamelCase_( lowerCamelCase_					)       ->		int:
    if not isinstance(lowerCamelCase_				,					lowerCamelCase_					):
        _lowercase			:				str 						=						F'''Input value of [number={number}] must be an integer'''
        raise TypeError(lowerCamelCase_					)
    if number < 1:
        raise ValueError('Input must be a positive integer'					)
    return -1 if len(prime_factors(lowerCamelCase_					)					) % 2 else 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()


