def METHOD_NAME(future: AbstractFuture) -> str:
    # 1. we want to avoid constructing a large string containing all the serialized values
    # and then hashing that, because its memory footprint is potentially very large, and
    # because we would be duplicating memory usage between the individual value
    # representations and the concatenated result
    # 2. the consequence of applying the hash function multiple times is acceptable
    # 3. we also push the application of the hash to each respective serialized value in
    # order to avoid keeping references to the resulting strings, so that they can be
    # deallocated quickly
    # TODO #403: do these things in a sustainable and efficient way
    input_arg_hashes = {}
    for name, value in future.resolved_kwargs.items():
        type_ = future.function.input_types[name]
        type_serialization = type_to_json_encodable(type_)
        value_serialization = value_to_json_encodable(value, type_)
        json_summary, _ = get_json_encodable_summary(value, type_)
        hashed_value = get_value_and_type_sha1_digest(
            value_serialization, type_serialization, json_summary
        )
        input_arg_hashes[name] = hashed_value
    # we rely on the registered value serializers to provide
    # respective recursive deterministic sorted representations
    input_arg_hashes_dump = json.dumps(input_arg_hashes, sort_keys=True, default=str)
    logger.debug("Input arg hashes: %s", input_arg_hashes)
    return get_str_sha1_digest(input_arg_hashes_dump)