docs: def reduce_vocab(tokens, similarity=.85, limit=20, sort_order=-1):
      """Find spelling variations of similar words within a list of tokens to reduce token set size
  
      Lexically sorted in reverse order (unless `reverse=False`), before running through fuzzy-wuzzy
      which results in the longer of identical spellings to be prefered (e.g. "ones" prefered to "one")
      as the key token. Usually you wantThis is usually what you want.
  
      Arguments:
        tokens (list or set or tuple of str): token strings from which to eliminate similar spellings
        similarity (float): portion of characters that should be unchanged in order to be considered a synonym
          as a fraction of the key token length.
          e.g. `0.85` (which means 85%) allows "hon" to match "on" and "honey", but not "one"
  
      Returns:
        dict: { 'token': ('similar_token', 'similar_token2', ...), ...}
  
      Examples:
        FIXME: can't doctest these because tuple order isn't consistent, must convert to sets
        >>> tokens = ('on', 'hon', 'honey', 'ones', 'one', 'two', 'three')
        >>> bool(reduce_vocab(tokens, sort_order=-1))  #  == answer)
        True
  
        >> answer = {'hon': ('on', 'honey'),
        ...           'one': ('ones',),
        ...           'three': (),
        ...           'two': ()}
        >> reduce_vocab(tokens, sort_order=1) == answer
        True
        >> answer = {'honey': ('hon',),
        ...           'ones': ('on', 'one'),
        ...           'three': (),
        ...           'two': ()}
  
  
        >> (reduce_vocab(tokens, similarity=0.3, limit=2, sort_order=-1) ==
        ...  {'ones': (), 'two': ('on', 'hon'), 'three': ('honey', 'one')})
        True
        >> (reduce_vocab(tokens, similarity=0.3, limit=3, sort_order=-1) ==
        ...  {'ones': (), 'two': ('on', 'hon', 'one'), 'three': ('honey',)})
        True
      """
      if 0 <= similarity <= 1:
          similarity *= 100
      if sort_order:
          tokens = set(tokens)
          tokens_sorted = sorted(list(tokens), reverse=bool(sort_order < 0))
      else:
          tokens_sorted = list(tokens)
          tokens = set(tokens)
      # print(tokens)
      thesaurus = {}
      for tok in tokens_sorted:
          try:
              tokens.remove(tok)
          except (KeyError, ValueError):
              continue
          # FIXME: this is slow because the tokens list must be regenerated and reinstantiated with each iteration
          matches = fuzzy.extractBests(tok, list(tokens), score_cutoff=int(similarity), limit=limit)
          if matches:
              thesaurus[tok] = list(zip(*matches))[0]
          else:
              thesaurus[tok] = ()
          for syn in thesaurus[tok]:
              tokens.discard(syn)
      return thesaurus