How to use the rsa.transform.int2bytes function in rsa

def _encrypt(self, message, pub_key):
        keylength = rsa.common.byte_size(pub_key.n)
        padded = self._pad_for_encryption(message, keylength)

        payload = rsa.transform.bytes2int(padded)
        encrypted = rsa.core.encrypt_int(payload, pub_key.e, pub_key.n)
        block = rsa.transform.int2bytes(encrypted, keylength)

        return block

"""

    # Get the ASN1 code for this hash method
    if hash_method not in HASH_ASN1:
        raise ValueError('Invalid hash method: %s' % hash_method)
    asn1code = HASH_ASN1[hash_method]

    # Encrypt the hash with the private key
    cleartext = asn1code + hash_value
    keylength = common.byte_size(priv_key.n)
    padded = _pad_for_signing(cleartext, keylength)

    payload = transform.bytes2int(padded)
    encrypted = priv_key.blinded_encrypt(payload)
    block = transform.int2bytes(encrypted, keylength)

    return block

The hash method is detected automatically from the signature.

    :param message: the signed message. Can be an 8-bit string or a file-like
        object. If ``message`` has a ``read()`` method, it is assumed to be a
        file-like object.
    :param signature: the signature block, as created with :py:func:`rsa.sign`.
    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
    :raise VerificationError: when the signature doesn't match the message.
    :returns: the name of the used hash.

    """

    keylength = common.byte_size(pub_key.n)
    encrypted = transform.bytes2int(signature)
    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
    clearsig = transform.int2bytes(decrypted, keylength)

    # Get the hash method
    method_name = _find_method_hash(clearsig)
    message_hash = compute_hash(message, method_name)

    # Reconstruct the expected padded hash
    cleartext = HASH_ASN1[method_name] + message_hash
    expected = _pad_for_signing(cleartext, keylength)

    # Compare with the signed one
    if expected != clearsig:
        raise VerificationError('Verification failed')

    return method_name

def rVerify(message, signature, pub_key): 
    n, e = pub_key
    blocksize = rsa.common.byte_size(n)
    encrypted = rsa.transform.bytes2int(signature)
    decrypted = rsa.core.decrypt_int(encrypted, e, n)
    clearsig = rsa.transform.int2bytes(decrypted, blocksize)
    try:
        sep_idx = clearsig.index(('\x00'), 2)
    except ValueError:
        print ('How ugly your signature looks...More practice,OK?')
        return False 
        
    signature = clearsig[sep_idx+1:]
    
    # Compare the real hash to the hash in the signature
    if message != signature:
        print `message`
        print `signature`
        print ('wanna cheat me,ah?')
        return False
    return True

def decrypt(message, privateKey):
    """
    @summary: wrapper around rsa.core.decrypt_int function
    @param message: {str} source message
    @param publicKey: {rsa.PrivateKey}
    """
    return rsa.transform.int2bytes(rsa.core.decrypt_int(rsa.transform.bytes2int(message), privateKey['d'], privateKey['n']))

def make_jwk():
	rv = dict(
		kty="RSA",
		n=b64u_encode(rsa.transform.int2bytes(privateKey.n)),
		e=b64u_encode(rsa.transform.int2bytes(privateKey.e)),
		alg="RS256",
		key_ops=["verify"]
	)
	if(args.key_id):
		rv['kid'] = args.key_id
	return rv

def int2bytes(i, fill_size=None):
  """wrapper of rsa.transform.int2bytes"""
  return rsa.transform.int2bytes(i, fill_size)

def decryptRSA(message, privateKey):
  """
    @summary: wrapper around rsa.core.decrypt_int function
    @param message: {str} source message
    @param publicKey: {rsa.PrivateKey}
    """
  return rsa.transform.int2bytes(
      rsa.core.decrypt_int(
          rsa.transform.bytes2int(message), privateKey['d'], privateKey['n']))

def int2bytes(i, fill_size=None):
    """
    @summary: wrapper of rsa.transform.int2bytes
    """
    return rsa.transform.int2bytes(i,fill_size)

def find_signature_hash(signature, pub_key):
    """Returns the hash name detected from the signature.

    If you also want to verify the message, use :py:func:`rsa.verify()` instead.
    It also returns the name of the used hash.

    :param signature: the signature block, as created with :py:func:`rsa.sign`.
    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
    :returns: the name of the used hash.
    """

    keylength = common.byte_size(pub_key.n)
    encrypted = transform.bytes2int(signature)
    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
    clearsig = transform.int2bytes(decrypted, keylength)

    return _find_method_hash(clearsig)