docs: def find_all_matching_parsers(self, strict: bool, desired_type: Type[Any] = JOKER, required_ext: str = JOKER) \
              -> Tuple[Tuple[List[Parser], List[Parser], List[Parser]],
                       List[Parser], List[Parser], List[Parser]]:
          """
          Implementation of the parent method by lookin into the registry to find the most appropriate parsers to use in
          order
  
          :param strict:
          :param desired_type: the desired type, or 'JOKER' for a wildcard
          :param required_ext:
          :return: match=(matching_parsers_generic, matching_parsers_approx, matching_parsers_exact),
                   no_type_match_but_ext_match, no_ext_match_but_type_match, no_match
          """
  
          # if desired_type is JOKER and required_ext is JOKER:
          #     # Easy : return everything (GENERIC first, SPECIFIC then) in order (make a copy first :) )
          #     matching_parsers_generic = self._generic_parsers.copy()
          #     matching_parsers_approx = []
          #     matching_parsers_exact = self._specific_parsers.copy()
          #     no_type_match_but_ext_match = []
          #     no_ext_match_but_type_match = []
          #     no_match = []
          # else:
          #
          # Although the above could be thought as an easy way to accelerate the process, it does not any more since the
          # JOKER  special cases are handled in parser.is_able_to_parse and converter.is_able_to_convert functions.
          #
          # It was also dangerous since it prevented us to get consistency across views - hence parser/converter
          # implementors could get the feeling that their parser was correctly registered where it wasn't
  
          check_var(strict, var_types=bool, var_name='strict')
          # first transform any 'Any' type requirement into the official class for that
          desired_type = get_validated_type(desired_type, 'desired_type', enforce_not_joker=False)
  
          matching_parsers_generic = []
          matching_parsers_approx = []
          matching_parsers_exact = []
          no_type_match_but_ext_match = []
          no_ext_match_but_type_match = []
          no_match = []
  
          # handle generic parsers first - except if desired type is Any
          for p in self._generic_parsers:
              match = p.is_able_to_parse(desired_type=desired_type, desired_ext=required_ext, strict=strict)
              if match:
                  # match
                  if is_any_type(desired_type):
                      # special case : what is required is Any, so put in exact match
                      matching_parsers_exact.append(p)
                  else:
                      matching_parsers_generic.append(p)
  
              else:
                  # check if by releasing the constraint on ext it makes a match
                  if p.is_able_to_parse(desired_type=desired_type, desired_ext=JOKER, strict=strict):
                      no_ext_match_but_type_match.append(p)
                  else:
                      # there will be no way to use this: it is a generic parser that is not able to parse this type...
                      # no_type_match_but_ext_match.append(p)
                      pass
  
          # then the specific
          for p in self._specific_parsers:
              match, exact_match = p.is_able_to_parse_detailed(desired_type=desired_type,
                                                               desired_ext=required_ext,
                                                               strict=strict)
              if match:
                  if is_any_type(desired_type):
                      # special case: dont register as a type match
                      no_type_match_but_ext_match.append(p)
                  else:
                      if exact_match is None or exact_match:
                          matching_parsers_exact.append(p)
                      else:
                          matching_parsers_approx.append(p)
  
              else:
                  # try to set the type to a supported type to see if that makes a match
                  if p.is_able_to_parse(desired_type=JOKER, desired_ext=required_ext, strict=strict):
                      no_type_match_but_ext_match.append(p)
  
                  # try to set the ext to a supported ext to see if that makes a match
                  elif p.is_able_to_parse(desired_type=desired_type, desired_ext=JOKER, strict=strict):
                      no_ext_match_but_type_match.append(p)
  
                  # no match at all
                  else:
                      no_match.append(p)
  
          return (matching_parsers_generic, matching_parsers_approx, matching_parsers_exact), \
                 no_type_match_but_ext_match, no_ext_match_but_type_match, no_match