docs: def WRatio(s1, s2, force_ascii=True, full_process=True):
      """
      Return a measure of the sequences' similarity between 0 and 100, using different algorithms.
  
      **Steps in the order they occur**
  
      #. Run full_process from utils on both strings
      #. Short circuit if this makes either string empty
      #. Take the ratio of the two processed strings (fuzz.ratio)
      #. Run checks to compare the length of the strings
          * If one of the strings is more than 1.5 times as long as the other
            use partial_ratio comparisons - scale partial results by 0.9
            (this makes sure only full results can return 100)
          * If one of the strings is over 8 times as long as the other
            instead scale by 0.6
  
      #. Run the other ratio functions
          * if using partial ratio functions call partial_ratio,
            partial_token_sort_ratio and partial_token_set_ratio
            scale all of these by the ratio based on length
          * otherwise call token_sort_ratio and token_set_ratio
          * all token based comparisons are scaled by 0.95
            (on top of any partial scalars)
  
      #. Take the highest value from these results
         round it and return it as an integer.
  
      :param s1:
      :param s2:
      :param force_ascii: Allow only ascii characters
      :type force_ascii: bool
      :full_process: Process inputs, used here to avoid double processing in extract functions (Default: True)
      :return:
      """
  
      if full_process:
          p1 = utils.full_process(s1, force_ascii=force_ascii)
          p2 = utils.full_process(s2, force_ascii=force_ascii)
      else:
          p1 = s1
          p2 = s2
  
      if not utils.validate_string(p1):
          return 0
      if not utils.validate_string(p2):
          return 0
  
      # should we look at partials?
      try_partial = True
      unbase_scale = .95
      partial_scale = .90
  
      base = ratio(p1, p2)
      len_ratio = float(max(len(p1), len(p2))) / min(len(p1), len(p2))
  
      # if strings are similar length, don't use partials
      if len_ratio < 1.5:
          try_partial = False
  
      # if one string is much much shorter than the other
      if len_ratio > 8:
          partial_scale = .6
  
      if try_partial:
          partial = partial_ratio(p1, p2) * partial_scale
          ptsor = partial_token_sort_ratio(p1, p2, full_process=False) \
              * unbase_scale * partial_scale
          ptser = partial_token_set_ratio(p1, p2, full_process=False) \
              * unbase_scale * partial_scale
  
          return utils.intr(max(base, partial, ptsor, ptser))
      else:
          tsor = token_sort_ratio(p1, p2, full_process=False) * unbase_scale
          tser = token_set_ratio(p1, p2, full_process=False) * unbase_scale
  
          return utils.intr(max(base, tsor, tser))