Utility method to check if a parser is able to parse a given type, either in
        * strict mode (desired_type must be one of the supported ones, or the parser should be generic)
        * inference mode (non-strict) : desired_type may be a parent class of one the parser is able to produce

        :param desired_type: the type of the object that should be parsed,
        :param desired_ext: the file extension that should be parsed
        :param strict: a boolean indicating whether to evaluate in strict mode or not
        :return: a first boolean indicating if there was a match, and a second boolean indicating if that match was
        strict (None if no match)

def is_able_to_parse_detailed(self, desired_type: Type[Any], desired_ext: str, strict: bool) -> Tuple[bool, bool]:
        """
        Utility method to check if a parser is able to parse a given type, either in
        * strict mode (desired_type must be one of the supported ones, or the parser should be generic)
        * inference mode (non-strict) : desired_type may be a parent class of one the parser is able to produce

        :param desired_type: the type of the object that should be parsed,
        :param desired_ext: the file extension that should be parsed
        :param strict: a boolean indicating whether to evaluate in strict mode or not
        :return: a first boolean indicating if there was a match, and a second boolean indicating if that match was
        strict (None if no match)
        """

        # (1) first handle the easy joker+joker case
        if desired_ext is JOKER and desired_type is JOKER:
            return True, None

        # (2) if ext is not a joker we can quickly check if it is supported
        if desired_ext is not JOKER:
            check_var(desired_ext, var_types=str, var_name='desired_ext')
            if desired_ext not in self.supported_exts:
                # ** no match on extension - no need to go further
                return False, None

            # (3) if type=joker and ext is supported => easy
            if desired_type is JOKER:
                # ** only extension match is required - ok.
                return True, None

        # (4) at this point, ext is JOKER OR supported and type is not JOKER. Check type match
        check_var(desired_type, var_types=type, var_name='desired_type_of_output')
        check_var(strict, var_types=bool, var_name='strict')

        # -- first call custom checker if provided
        if self.is_able_to_parse_func is not None and not self.is_able_to_parse_func(strict, desired_type):
            return False, None

        # -- strict match : either the parser is able to parse Anything, or the type is in the list of supported types
        if self.is_generic() or (desired_type in self.supported_types):
            return True, True  # exact match

        # -- non-strict match : if the parser is able to parse a subclass of the desired type, it is ok
        elif (not strict) \
                and any(issubclass(supported, desired_type) for supported in self.supported_types):
            return True, False  # approx match

        # -- no match at all
        else:
            return False, None