code: def format_records(records):  # , print_globals=False):
      # Loop over all records printing context and info
      frames = []
      abspath = os.path.abspath
      for frame, file, lnum, func, lines, index in records:
          try:
              file = file and abspath(file) or "?"
          except OSError:
              # if file is '<console>' or something not in the filesystem,
              # the abspath call will throw an OSError.  Just ignore it and
              # keep the original file string.
              pass
  
          if file.endswith(".pyc"):
              file = file[:-4] + ".py"
  
          link = file
  
          args, varargs, varkw, locals = inspect.getargvalues(frame)
  
          if func == "?":
              call = ""
          else:
              # Decide whether to include variable details or not
              try:
                  call = "in %s%s" % (
                      func,
                      inspect.formatargvalues(
                          args,
                          varargs,
                          varkw,
                          locals,
                          formatvalue=eq_repr,
                      ),
                  )
              except KeyError:
                  # Very odd crash from inspect.formatargvalues().  The
                  # scenario under which it appeared was a call to
                  # view(array,scale) in NumTut.view.view(), where scale had
                  # been defined as a scalar (it should be a tuple). Somehow
                  # inspect messes up resolving the argument list of view()
                  # and barfs out. At some point I should dig into this one
                  # and file a bug report about it.
                  print("\nJoblib's exception reporting continues...\n")
                  call = (
                      "in %s(***failed resolving arguments***)" % func
                  )
  
          # Initialize a list of names on the current line, which the
          # tokenizer below will populate.
          names = []
  
          def tokeneater(token_type, token, start, end, line):
              """Stateful tokeneater which builds dotted names.
  
              The list of names it appends to (from the enclosing scope) can
              contain repeated composite names.  This is unavoidable, since
              there is no way to disambiguate partial dotted structures until
              the full list is known.  The caller is responsible for pruning
              the final list of duplicates before using it."""
  
              # build composite names
              if token == ".":
                  try:
                      names[-1] += "."
                      # store state so the next token is added for x.y.z names
                      tokeneater.name_cont = True
                      return
                  except IndexError:
                      pass
              if (
                  token_type == tokenize.NAME
                  and token not in keyword.kwlist
              ):
                  if tokeneater.name_cont:
                      # Dotted names
                      names[-1] += token
                      tokeneater.name_cont = False
                  else:
                      # Regular new names.  We append everything, the caller
                      # will be responsible for pruning the list later.  It's
                      # very tricky to try to prune as we go, b/c composite
                      # names can fool us.  The pruning at the end is easy
                      # to do (or the caller can print a list with repeated
                      # names if so desired.
                      names.append(token)
              elif token_type == tokenize.NEWLINE:
                  raise IndexError
  
          # we need to store a bit of state in the tokenizer to build
          # dotted names
          tokeneater.name_cont = False
  
          def linereader(
              file=file, lnum=[lnum], getline=linecache.getline
          ):
              line = getline(file, lnum[0])
              lnum[0] += 1
              return line
  
          # Build the list of names on this line of code where the exception
          # occurred.
          try:
              # This builds the names list in-place by capturing it from the
              # enclosing scope.
              for token in generate_tokens(linereader):
                  tokeneater(*token)
          except (IndexError, UnicodeDecodeError, SyntaxError):
              # signals exit of tokenizer
              # SyntaxError can happen when trying to tokenize
              # a compiled (e.g. .so or .pyd) extension
              pass
          except tokenize.TokenError as msg:
              _m = (
                  "An unexpected error occurred while tokenizing input file %s\n"
                  "The following traceback may be corrupted or invalid\n"
                  "The error message is: %s\n" % (file, msg)
              )
              print(_m)
  
          # prune names list of duplicates, but keep the right order
          unique_names = uniq_stable(names)
  
          # Start loop over vars
          lvals = []
          for name_full in unique_names:
              name_base = name_full.split(".", 1)[0]
              if name_base in frame.f_code.co_varnames:
                  if name_base in locals.keys():
                      try:
                          value = safe_repr(eval(name_full, locals))
                      except:
                          value = "undefined"
                  else:
                      value = "undefined"
                  name = name_full
                  lvals.append("%s = %s" % (name, value))
              # elif print_globals:
              #    if frame.f_globals.has_key(name_base):
              #        try:
              #            value = safe_repr(eval(name_full,frame.f_globals))
              #        except:
              #            value = "undefined"
              #    else:
              #        value = "undefined"
              #    name = 'global %s' % name_full
              #    lvals.append('%s = %s' % (name,value))
          if lvals:
              lvals = "%s%s" % (INDENT, ("\n%s" % INDENT).join(lvals))
          else:
              lvals = ""
  
          level = "%s\n%s %s\n" % (75 * ".", link, call)
  
          if index is None:
              frames.append(level)
          else:
              frames.append(
                  "%s%s"
                  % (
                      level,
                      "".join(
                          _format_traceback_lines(
                              lnum, index, lines, lvals
                          )
                      ),
                  )
              )
  
      return frames
  
file_path: catboost/contrib/python/scikit-learn/py2/sklearn/externals/joblib/format_stack.py
imports: import inspect
  import keyword
  import linecache
  import os
  import pydoc
  import sys
  import time
  import tokenize
  import traceback
label_desc: Use image node_id 7 for calling a global function with example usage: format_records(records) and returns: frames, line