code: def _make_value_key(
      cache_type: CacheType,
      func: types.FunctionType,
      func_args: tuple[Any, ...],
      func_kwargs: dict[str, Any],
      hash_funcs: HashFuncsDict | None,
  ) -> str:
      """Create the key for a value within a cache.
  
      This key is generated from the function's arguments. All arguments
      will be hashed, except for those named with a leading "_".
  
      Raises
      ------
      StreamlitAPIException
          Raised (with a nicely-formatted explanation message) if we encounter
          an un-hashable arg.
      """
  
      # Create a (name, value) list of all *args and **kwargs passed to the
      # function.
      arg_pairs: list[tuple[str | None, Any]] = []
      for arg_idx in range(len(func_args)):
          arg_name = _get_positional_arg_name(func, arg_idx)
          arg_pairs.append((arg_name, func_args[arg_idx]))
  
      for kw_name, kw_val in func_kwargs.items():
          # **kwargs ordering is preserved, per PEP 468
          # https://www.python.org/dev/peps/pep-0468/, so this iteration is
          # deterministic.
          arg_pairs.append((kw_name, kw_val))
  
      # Create the hash from each arg value, except for those args whose name
      # starts with "_". (Underscore-prefixed args are deliberately excluded from
      # hashing.)
      args_hasher = hashlib.new("md5", **HASHLIB_KWARGS)
      for arg_name, arg_value in arg_pairs:
          if arg_name is not None and arg_name.startswith("_"):
              _LOGGER.debug(
                  "Not hashing %s because it starts with _", arg_name
              )
              continue
  
          try:
              update_hash(
                  arg_name,
                  hasher=args_hasher,
                  cache_type=cache_type,
                  hash_source=func,
              )
              # we call update_hash twice here, first time for `arg_name`
              # without `hash_funcs`, and second time for `arg_value` with hash_funcs
              # to evaluate user defined `hash_funcs` only for computing `arg_value` hash.
              update_hash(
                  arg_value,
                  hasher=args_hasher,
                  cache_type=cache_type,
                  hash_funcs=hash_funcs,
                  hash_source=func,
              )
          except UnhashableTypeError as exc:
              raise UnhashableParamError(
                  cache_type, func, arg_name, arg_value, exc
              )
  
      value_key = args_hasher.hexdigest()
      _LOGGER.debug("Cache key: %s", value_key)
  
      return value_key
  
imports: from __future__ import annotations
  import functools
  import hashlib
  import inspect
  import math
  import threading
  import time
  import types
  from abc import abstractmethod
  from collections import defaultdict
  from datetime import timedelta
  from typing import Any, Callable, overload
  from typing_extensions import Literal
  from streamlit import type_util
  from streamlit.elements.spinner import spinner
  from streamlit.logger import get_logger
  from streamlit.runtime.caching.cache_errors import BadTTLStringError, CacheError, CacheKeyNotFoundError, UnevaluatedDataFrameError, UnhashableParamError, UnhashableTypeError, UnserializableReturnValueError, get_cached_func_name_md
  from streamlit.runtime.caching.cache_type import CacheType
  from streamlit.runtime.caching.cached_message_replay import CachedMessageReplayContext, CachedResult, MsgData, replay_cached_messages
  from streamlit.runtime.caching.hashing import HashFuncsDict, update_hash
  from streamlit.util import HASHLIB_KWARGS
label_desc: Use image node_id 5 for calling a global function with example usage: _make_value_key(cache_type, func, func_args, func_kwargs, hash_funcs) and returns: value_key