def are_worth_chaining(left_converter, right_converter) -> bool:
        """
        Utility method to check if it makes sense to chain these two converters. Returns True if it brings value to
        chain the first converter with the second converter. To bring value,
        * the second converter's input should not be a parent class of the first converter's input (in that case, it is
          always more interesting to use the second converter directly for any potential input)
        * the second converter's output should not be a parent class of the first converter's input or output. Otherwise
        the chain does not even make any progress :)
        * The first converter has to allow chaining (with converter.can_chain=True)

        :param left_converter:
        :param right_converter:
        :return:
        """
        if not left_converter.can_chain:
            return False

        elif not is_any_type(left_converter.to_type) and is_any_type(right_converter.to_type):
            # we gain the capability to generate any type. So it is interesting.
            return True

        elif issubclass(left_converter.from_type, right_converter.to_type) \
                or issubclass(left_converter.to_type, right_converter.to_type) \
                or issubclass(left_converter.from_type, right_converter.from_type):
            # Not interesting : the outcome of the chain would be not better than one of the converters alone
            return False

        # Note: we dont say that chaining a generic converter with a converter is useless. Indeed it might unlock some
        # capabilities for the user (new file extensions, etc.) that would not be available with the generic parser
        # targetting to_type alone. For example parsing object A from its constructor then converting A to B might
        # sometimes be interesting, rather than parsing B from its constructor

        else:
            # interesting
            return True