docs: def get_token(expected_type, data):
      """
      Given the expected token type and the data, grab the next token and return a tuple of (token, token_type, updated_string)
      :param expected_type: Parts enum value for tthe expected type
      :param data: the str from which to pull next token starting at the beginning
      :return: (token, token_type, new working str)
      """
  
      token_value = i = 0
      next_token_type = TokenType.INVALID
      d_len = len(data)
  
      if len(data) <= 0:
          return 0, TokenType.END, data
  
      if expected_type == TokenType.DIGIT_OR_ZERO and data[i] == '0':
          # Handled leading zeros
          while i < d_len and data[i] == '0':
              i += 1
          next_token_type = TokenType.DIGIT
          token_value = -i
      elif expected_type in [TokenType.DIGIT_OR_ZERO, TokenType.DIGIT, TokenType.SUFFIX_NO, TokenType.REVISION_NO]:
          # Handle numbers
          dig_val = ''
          while i < d_len and data[i].isdigit():
              dig_val += data[i]
              i += 1
          token_value = int(dig_val) if dig_val else 0
      elif expected_type == TokenType.LETTER:
          # Handle letter values
          token_value = ord(data[i])
          i += 1
      elif expected_type == TokenType.SUFFIX:
          idx = -1
          # Is this is a pre-release suffix?
          for s in pre_release_suffixes:
              i = len(s)
              if data.startswith(s):
                  idx = pre_release_suffixes.index(s)
                  break
  
          if idx >= 0:
              token_value = idx - len(pre_release_suffixes)
          else:
              idx = -1
              # Try post-release suffixes for a match
              for s in post_release_suffixes:
                  i = len(s)
                  if data.startswith(s):
                      idx = post_release_suffixes.index(s)
                      break
              if idx < 0:
                  # No match found
                  return -1, TokenType.INVALID, data
              else:
                  token_value = idx
      else:
          return -1, TokenType.INVALID, data
  
      data = data[i:]
      if len(data) == 0:
          next_token_type = TokenType.END
      elif next_token_type != TokenType.INVALID:
          pass
      else:
          next_token_type, data = next_token(expected_type, data)
  
      return token_value, next_token_type, data