docs: def convert(path, source_fmt, target_fmt, select='result:mrs',
              properties=True, show_status=False, predicate_modifiers=False,
              color=False, pretty_print=False, indent=None):
      """
      Convert between various DELPH-IN Semantics representations.
  
      Args:
          path (str, file): filename, testsuite directory, open file, or
              stream of input representations
          source_fmt (str): convert from this format
          target_fmt (str): convert to this format
          select (str): TSQL query for selecting data (ignored if *path*
              is not a testsuite directory; default: `"result:mrs"`)
          properties (bool): include morphosemantic properties if `True`
              (default: `True`)
          show_status (bool): show disconnected EDS nodes (ignored if
              *target_fmt* is not `"eds"`; default: `False`)
          predicate_modifiers (bool): apply EDS predicate modification
              for certain kinds of patterns (ignored if *target_fmt* is
              not an EDS format; default: `False`)
          color (bool): apply syntax highlighting if `True` and
              *target_fmt* is `"simplemrs"` (default: `False`)
          pretty_print (bool): if `True`, format the output with
              newlines and default indentation (default: `False`)
          indent (int, optional): specifies an explicit number of spaces
              for indentation (implies *pretty_print*)
      Returns:
          str: the converted representation
      """
      if source_fmt.startswith('eds') and not target_fmt.startswith('eds'):
          raise ValueError(
              'Conversion from EDS to non-EDS currently not supported.')
  
      if indent:
          pretty_print = True
          indent = 4 if indent is True else safe_int(indent)
  
      if len(tsql.inspect_query('select ' + select)['projection']) != 1:
          raise ValueError('Exactly 1 column must be given in selection query: '
                           '(e.g., result:mrs)')
  
      # read
      loads = _get_codec(source_fmt)
      if path is None:
          xs = loads(sys.stdin.read())
      elif hasattr(path, 'read'):
          xs = loads(path.read())
      elif os.path.isdir(path):
          ts = itsdb.TestSuite(path)
          xs = [
              next(iter(loads(r[0])), None)
              for r in tsql.select(select, ts)
          ]
      else:
          xs = loads(open(path, 'r').read())
  
      # write
      dumps = _get_codec(target_fmt, load=False)
      kwargs = {}
      if color: kwargs['color'] = color
      if pretty_print: kwargs['pretty_print'] = pretty_print
      if indent: kwargs['indent'] = indent
      if target_fmt == 'eds':
          kwargs['pretty_print'] = pretty_print
          kwargs['show_status'] = show_status
      if target_fmt.startswith('eds'):
          kwargs['predicate_modifiers'] = predicate_modifiers
      kwargs['properties'] = properties
  
      # this is not a great way to improve robustness when converting
      # many representations, but it'll do until v1.0.0. Also, it only
      # improves robustness on the output, not the input.
      # Note that all the code below is to replace the following:
      #     return dumps(xs, **kwargs)
      head, joiner, tail = _get_output_details(target_fmt)
      parts = []
      if pretty_print:
          joiner = joiner.strip() + '\n'
      def _trim(s):
          if head and s.startswith(head):
              s = s[len(head):].lstrip('\n')
          if tail and s.endswith(tail):
              s = s[:-len(tail)].rstrip('\n')
          return s
      for x in xs:
          try:
              s = dumps([x], **kwargs)
          except (PyDelphinException, KeyError, IndexError):
              logging.exception('could not convert representation')
          else:
              s = _trim(s)
              parts.append(s)
      # set these after so head and tail are used correctly in _trim
      if pretty_print:
          if head:
              head += '\n'
          if tail:
              tail = '\n' + tail
      return head + joiner.join(parts) + tail