docs: def encrypt(claims, jwk, adata='', add_header=None, alg='RSA-OAEP',
          enc='A128CBC-HS256', rng=get_random_bytes, compression=None):
      """ Encrypts the given claims and produces a :class:`~jose.JWE`
  
      :param claims: A `dict` representing the claims for this
                     :class:`~jose.JWE`.
      :param jwk: A `dict` representing the JWK to be used for encryption of
                  the CEK. This parameter is algorithm-specific.
      :param adata: Arbitrary string data to add to the authentication
                    (i.e. HMAC). The same data must be provided during
                    decryption.
      :param add_header: Additional items to be added to the header. Additional
                         headers *will* be authenticated.
      :param alg: The algorithm to use for CEK encryption
      :param enc: The algorithm to use for claims encryption
      :param rng: Random number generator. A string of random bytes is expected
                  as output.
      :param compression: The compression algorithm to use. Currently supports
                  `'DEF'`.
      :rtype: :class:`~jose.JWE`
      :raises: :class:`~jose.Error` if there is an error producing the JWE
      """
      # copy so the injected claim doesn't mutate the input claims
      # this is a temporary hack to allow for graceful deprecation of tokens,
      # ensuring that the library can still handle decrypting tokens issued
      # before the implementation of the fix
      claims = deepcopy(claims)
      assert _TEMP_VER_KEY not in claims
      claims[_TEMP_VER_KEY] = _TEMP_VER
  
      header = dict((add_header or {}).items() + [
          (HEADER_ENC, enc), (HEADER_ALG, alg)])
  
      # promote the temp key to the header
      assert _TEMP_VER_KEY not in header
      header[_TEMP_VER_KEY] = claims[_TEMP_VER_KEY]
  
      plaintext = json_encode(claims)
  
      # compress (if required)
      if compression is not None:
          header[HEADER_ZIP] = compression
          try:
              (compress, _) = COMPRESSION[compression]
          except KeyError:
              raise Error(
                  'Unsupported compression algorithm: {}'.format(compression))
          plaintext = compress(plaintext)
  
      # body encryption/hash
      ((cipher, _), key_size), ((hash_fn, _), hash_mod) = JWA[enc]
      iv = rng(AES.block_size)
      encryption_key = rng(hash_mod.digest_size)
  
      ciphertext = cipher(plaintext, encryption_key[-hash_mod.digest_size/2:], iv)
      hash = hash_fn(_jwe_hash_str(ciphertext, iv, adata),
              encryption_key[:-hash_mod.digest_size/2], hash_mod)
  
      # cek encryption
      (cipher, _), _ = JWA[alg]
      encryption_key_ciphertext = cipher(encryption_key, jwk)
  
      return JWE(*map(b64encode_url,
              (json_encode(header),
              encryption_key_ciphertext,
              iv,
              ciphertext,
              auth_tag(hash))))