code: def inject_argument_info_in_traceback(fn, object_name=None):
      """Add information about call argument values to an error message.
  
      Arguments:
          fn: Function to wrap. Exceptions raised by the this function will be
              re-raised with additional information added to the error message,
              displaying the values of the different arguments that the function
              was called with.
          object_name: String, display name of the class/function being called,
              e.g. `'layer "layer_name" (LayerClass)'`.
  
      Returns:
          A wrapped version of `fn`.
      """
      if backend.backend() == "tensorflow":
          from tensorflow import errors as tf_errors
      else:
          tf_errors = None
  
      @wraps(fn)
      def error_handler(*args, **kwargs):
          if not is_traceback_filtering_enabled():
              return fn(*args, **kwargs)
  
          signature = None
          bound_signature = None
          try:
              return fn(*args, **kwargs)
          except Exception as e:
              if hasattr(e, "_keras_call_info_injected"):
                  # Only inject info for the innermost failing call
                  raise e
              signature = inspect.signature(fn)
              try:
                  # The first argument is `self`, so filter it out
                  bound_signature = signature.bind(*args, **kwargs)
              except TypeError:
                  # Likely unbindable arguments
                  raise e
  
              # Add argument context
              arguments_context = []
              for arg in list(signature.parameters.values()):
                  if arg.name in bound_signature.arguments:
                      value = tree.map_structure(
                          format_argument_value,
                          bound_signature.arguments[arg.name],
                      )
                  else:
                      value = arg.default
                  arguments_context.append(f"  • {arg.name}={value}")
              if arguments_context:
                  arguments_context = "\n".join(arguments_context)
                  # Get original error message and append information to it.
                  if tf_errors is not None and isinstance(
                      e, tf_errors.OpError
                  ):
                      message = e.message
                  elif e.args:
                      # Canonically, the 1st argument in an exception is the error
                      # message. This works for all built-in Python exceptions.
                      message = e.args[0]
                  else:
                      message = ""
                  display_name = (
                      f"{object_name if object_name else fn.__name__}"
                  )
                  message = (
                      f"Exception encountered when calling {display_name}.\n\n"
                      f"\x1b[1m{message}\x1b[0m\n\n"
                      f"Arguments received by {display_name}:\n"
                      f"{arguments_context}"
                  )
  
                  # Reraise exception, with added context
                  if tf_errors is not None and isinstance(
                      e, tf_errors.OpError
                  ):
                      new_e = e.__class__(
                          e.node_def, e.op, message, e.error_code
                      )
                  else:
                      try:
                          # For standard exceptions such as ValueError, TypeError,
                          # etc.
                          new_e = e.__class__(message)
                      except TypeError:
                          # For any custom error that doesn't have a standard
                          # signature.
                          new_e = RuntimeError(message)
                  new_e._keras_call_info_injected = True
              else:
                  new_e = e
              raise new_e.with_traceback(e.__traceback__) from None
          finally:
              del signature
              del bound_signature
  
      return error_handler
  
file_path: keras/keras/utils/traceback_utils.py
imports: import inspect
  import os
  import traceback
  import types
  from functools import wraps
  import tree
  from keras import backend
  from keras.api_export import keras_export
  from keras.backend.common import global_state
label_desc: Use image node_id 7 for calling a global function with example usage: inject_argument_info_in_traceback(fn, object_name) and returns: error_handler, fn, fn