def is_able_to_parse_detailed(self, desired_type: Type[Any], desired_ext: str, strict: bool) -> Tuple[bool, bool]:
<EOL>if desired_ext is JOKER and desired_type is JOKER:<EOL><INDENT>return True, None<EOL><DEDENT>if desired_ext is not JOKER:<EOL><INDENT>check_var(desired_ext, var_types=str, var_name='<STR_LIT>')<EOL>if desired_ext not in self.supported_exts:<EOL><INDENT>return False, None<EOL><DEDENT>if desired_type is JOKER:<EOL><INDENT>return True, None<EOL><DEDENT><DEDENT>check_var(desired_type, var_types=type, var_name='<STR_LIT>')<EOL>check_var(strict, var_types=bool, var_name='<STR_LIT:strict>')<EOL>if self.is_able_to_parse_func is not None and not self.is_able_to_parse_func(strict, desired_type):<EOL><INDENT>return False, None<EOL><DEDENT>if self.is_generic() or (desired_type in self.supported_types):<EOL><INDENT>return True, True  <EOL><DEDENT>elif (not strict)and any(issubclass(supported, desired_type) for supported in self.supported_types):<EOL><INDENT>return True, False  <EOL><DEDENT>else:<EOL><INDENT>return False, None<EOL><DEDENT>
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)