a_							=      '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''




def       __lowerCAmelCase      (						A_   : str					)    ->  bytes:
  # Make sure the supplied data is a bytes-like object
  if not isinstance(_lowercase						,	_lowercase					):
    __UpperCAmelCase						    =       F'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
    raise TypeError(_lowercase					)

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

  __UpperCAmelCase						    =       len(_lowercase					) % 6 != 0

  if padding_needed:
    # The padding that will be added later
    __UpperCAmelCase						    =       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:
    __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(_lowercase					)						,	6					)					).encode()
      + padding
  )




def       __lowerCAmelCase      (						A_   : Dict					)    ->  bytes:
  # Make sure encoded_data is either a string or a bytes-like object
  if not isinstance(_lowercase						,	_lowercase					) and not isinstance(_lowercase						,	_lowercase					):
    __UpperCAmelCase						    =       (
        '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:
      __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(_lowercase					) % 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(_lowercase					)					)[2:].zfill(6					) for char in encoded_data					)[: -padding * 2]
  else:
    __UpperCAmelCase						    =       ''.join(
        bin(B64_CHARSET.index(_lowercase					)					)[2:].zfill(6					) for char in encoded_data					)

  __UpperCAmelCase						    =       [
      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 inspect
import unittest


class 			UpperCAmelCase__    (		unittest.TestCase					):



  """simple docstring"""






  def 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> Dict:




    '''simple docstring'''




    try:
      import diffusers  # noqa: F401
    except ImportError:
      assert False






  def 	_UpperCAmelCase				(				self:			Dict   ) -> Dict:




    '''simple docstring'''




    import diffusers
    from diffusers.dependency_versions_table import deps

    __UpperCAmelCase						    =       inspect.getmembers(__lowerCAmelCase				,				inspect.isclass   )

    for cls_name, cls_module in all_classes:
      if "dummy_" in cls_module.__module__:
        for backend in cls_module._backends:
          if backend == "k_diffusion":
            __UpperCAmelCase						    =       "k-diffusion"
          elif backend == "invisible_watermark":
            __UpperCAmelCase						    =       "invisible-watermark"
          assert backend in deps, F'''{backend} is not in the deps table!'''



