



__UpperCAmelCase          =       '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''
def 		UpperCamelCase	(   snake_case__       :    bytes	)	->     bytes:
   # Make sure the supplied data is a bytes-like object
   if not isinstance(snake_case__       ,     snake_case__	):
      UpperCamelCase    :  str							=	F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
      raise TypeError(snake_case__	)

   UpperCamelCase    :  Dict							=	''.join(bin(snake_case__	)[2:].zfill(8	) for byte in data	)

   UpperCamelCase    :  List[Any]							=	len(snake_case__	) % 6 != 0

   if padding_needed:
      # The padding that will be added later
      UpperCamelCase    :  Union[str, Any]							=	B'=' * ((6 - len(snake_case__	) % 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(snake_case__	) % 6)
   else:
      UpperCamelCase    :  List[str]							=	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(snake_case__	)       ,     6	)	).encode()
       + padding
   )
def 		UpperCamelCase	(   snake_case__       :    str	)	->     bytes:
   # Make sure encoded_data is either a string or a bytes-like object
   if not isinstance(snake_case__       ,     snake_case__	) and not isinstance(snake_case__       ,     snake_case__	):
      UpperCamelCase    :  int							=	(
          'argument should be a bytes-like object or ASCII string, '
          F"""not '{encoded_data.__class__.__name__}'"""
      )
      raise TypeError(snake_case__	)

   # 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(snake_case__       ,     snake_case__	):
      try:
         UpperCamelCase    :  str							=	encoded_data.decode('utf-8'	)
      except UnicodeDecodeError:
         raise ValueError('base64 encoded data should only contain ASCII characters'	)

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

   if padding:
      # Remove padding if there is one
      UpperCamelCase    :  Union[str, Any]							=	encoded_data[:-padding]

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

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

   return bytes(snake_case__	)


if __name__ == "__main__":
    import doctest

    doctest.testmod()








import pytest

from datasets import inspect_metric, list_metrics, load_metric
@pytest.fixture
def 		UpperCamelCase	(   snake_case__       :    str	)	->     Optional[int]:
   monkeypatch.setattr('datasets.utils.deprecation_utils._emitted_deprecation_warnings'       ,     set()	)
@pytest.fixture
def 		UpperCamelCase	(   snake_case__       :    str	)	->     Any:



   class 				lowerCAmelCase_		:
          def __init__(			self,			SCREAMING_SNAKE_CASE_       )     ->		Optional[int]:
             UpperCamelCase    :  Tuple							=	metric_id






   class 				lowerCAmelCase_		:
          UpperCAmelCase__				:					Optional[int]        =  [MetricMock(a__							) for metric_id in ["accuracy", "mse", "precision", "codeparrot/apps_metric"]]
          def 					snake_case_       (			self       )     ->		str:
             return self._metrics






   monkeypatch.setattr('datasets.inspect.huggingface_hub'       ,     HfhMock()	)


@pytest.mark.parametrize(
    'func, args'       ,     [(load_metric, ('metrics/mse',)), (list_metrics, ()), (inspect_metric, ('metrics/mse', 'tmp_path'))]	)
def 		UpperCamelCase	(   snake_case__       :    str       ,     snake_case__       :    Any       ,     snake_case__       :    List[str]       ,     snake_case__       :    Optional[int]       ,     snake_case__       :    Union[str, Any]	)	->     int:
   if "tmp_path" in args:
      UpperCamelCase    :  Dict							=	tuple(arg if arg != 'tmp_path' else tmp_path for arg in args	)
   with pytest.warns(snake_case__       ,     match='https://huggingface.co/docs/evaluate'	):
      func(*snake_case__	)



