docs: def _stump(f, *args, **kwargs):
      """Worker for the common actions of all stump methods, aka the secret
      sauce.
  
      *Keyword parameters*
      - log :: integer
        - Specifies a custom level of logging to pass to the active logger.
        - Default: INFO
      - print_time :: bool
        - Include timestamp in message
      - print_return :: bool
        - include the return value in the functions exit message
      - postfix_only :: bool
        - omit the functions entering message
      - prefix_only :: bool
        - omit the functions exiting message
  
      *Exceptions:*
      - IndexError and ValueError
        - will be returned if *args contains a string that does not correspond to
          a parameter name of the decorated function, or if there are more '{}'s
          than there are *args.
  
      """
      global LOGGER
  
      def aux(*xs, **kws):
          f_kws = kws.copy()
          f_kws.update(dict(zip(inspect.getfullargspec(f).args, xs)))
  
          level = kwargs.get('log', logging.INFO)
          post = kwargs.get('postfix_only', False)
          pre = kwargs.get('prefix_only', False)
          print_return = kwargs.get('print_return', False)
          print_time = kwargs.get('print_time', False)
  
          # prepare locals for later uses in string interpolation
          fn = f.__name__
          timestr = '%s:' % _timestr() if print_time else ''
  
          # get message
          try:
              message = list(args).pop(0)
              timestr = ':' + timestr
          except IndexError:
              message = fn
              fn = ''
  
          # format message
          try:
              report = '{fn}{timestr}{arg}'.format(**locals(),
                                                   arg=message.format(**f_kws))
          except KeyError:
              report = '{fn}{timestr}{error}'.\
                       format(**locals(), error='KeyError in decorator usage')
  
          if not post:
              LOGGER.log(level, '%s...', report)
          try:
              ret = f(*xs, **kws)
          except Exception as e:
              try:
                  with_message = ' with message %s' % str(e)
                  if str(e) == '':
                      raise Exception()  # use default value
              except:
                  with_message = ''
              LOGGER.log(level, '%s...threw exception %s%s',
                         report, type(e).__name__, with_message)
              raise
          if not pre:
              if print_return:
                  LOGGER.log(level, '%s...done (returning %s)', report, ret)
              else:
                  LOGGER.log(level, '%s...done', report)
          return ret
      return aux