docs: def formatted_print(
      response_data,
      simple_text=None,
      text_preamble=None,
      text_epilog=None,
      text_format=FORMAT_TEXT_TABLE,
      json_converter=None,
      fields=None,
      response_key=None,
  ):
      """
      A generic output formatter. Consumes the following pieces of data:
  
      ``response_data`` is a dict or GlobusResponse object. It contains either an
      API response or synthesized data for printing.
  
      ``simple_text`` is a text override -- normal printing is skipped and this
      string is printed instead (text output only)
      ``text_preamble`` is text which prints before normal printing (text output
      only)
      ``text_epilog`` is text which prints after normal printing (text output
      only)
      ``text_format`` is one of the FORMAT_TEXT_* constants OR a callable which
      takes ``response_data`` and prints output. Note that when a callable is
      given, it does the actual printing
  
      ``json_converter`` is a callable that does preprocessing of JSON output. It
      must take ``response_data`` and produce another dict or dict-like object
      (json/unix output only)
  
      ``fields`` is an iterable of (fieldname, keyfunc) tuples. When keyfunc is
      a string, it is implicitly converted to `lambda x: x[keyfunc]` (text output
      only)
  
      ``response_key`` is a key into the data to print. When used with table
      printing, it must get an iterable out, and when used with raw printing, it
      gets a string. Necessary for certain formats like text table (text output
      only)
      """
  
      def _assert_fields():
          if fields is None:
              raise ValueError(
                  "Internal Error! Output format requires fields; none given. "
                  "You can workaround this error by using `--format JSON`"
              )
  
      def _print_as_json():
          print_json_response(
              json_converter(response_data) if json_converter else response_data
          )
  
      def _print_as_unix():
          print_unix_response(
              json_converter(response_data) if json_converter else response_data
          )
  
      def _print_as_text():
          # if we're given simple text, print that and exit
          if simple_text is not None:
              safeprint(simple_text)
              return
  
          # if there's a preamble, print it beofre any other text
          if text_preamble is not None:
              safeprint(text_preamble)
  
          # if there's a response key, key into it
          data = response_data if response_key is None else response_data[response_key]
  
          #  do the various kinds of printing
          if text_format == FORMAT_TEXT_TABLE:
              _assert_fields()
              print_table(data, fields)
          elif text_format == FORMAT_TEXT_RECORD:
              _assert_fields()
              colon_formatted_print(data, fields)
          elif text_format == FORMAT_TEXT_RAW:
              safeprint(data)
          elif text_format == FORMAT_TEXT_CUSTOM:
              _custom_text_formatter(data)
  
          # if there's an epilog, print it after any text
          if text_epilog is not None:
              safeprint(text_epilog)
  
      if isinstance(text_format, six.string_types):
          text_format = text_format
          _custom_text_formatter = None
      else:
          _custom_text_formatter = text_format
          text_format = FORMAT_TEXT_CUSTOM
  
      if outformat_is_json():
          _print_as_json()
      elif outformat_is_unix():
          _print_as_unix()
      else:
          # silent does nothing
          if text_format == FORMAT_SILENT:
              return
          _print_as_text()