Utility method to try to use provided conversion_finder to convert attr_value into desired_attr_type.
        If no conversion is required, the conversion finder is not even used (it can be None)

        :param conversion_finder:
        :param attr_name:
        :param attr_value:
        :param desired_attr_type:
        :param logger:
        :param options:
        :return:

def _try_convert_value(conversion_finder, attr_name: str, attr_value: S, desired_attr_type: Type[T], logger: Logger,
                           options: Dict[str, Dict[str, Any]]) -> T:
        """
        Utility method to try to use provided conversion_finder to convert attr_value into desired_attr_type.
        If no conversion is required, the conversion finder is not even used (it can be None)

        :param conversion_finder:
        :param attr_name:
        :param attr_value:
        :param desired_attr_type:
        :param logger:
        :param options:
        :return:
        """

        # check if we need additional conversion

        # (a) a collection with details about the internal item type
        if is_typed_collection(desired_attr_type):
            return ConversionFinder.convert_collection_values_according_to_pep(coll_to_convert=attr_value,
                                                                               desired_type=desired_attr_type,
                                                                               conversion_finder=conversion_finder,
                                                                               logger=logger,
                                                                               **options)
        # --- typing types do not work with isinstance so there is a special check here
        elif not robust_isinstance(attr_value, desired_attr_type):
            if conversion_finder is not None:
                return conversion_finder.find_and_convert(attr_name,
                                                          attr_value,
                                                          desired_attr_type,
                                                          logger, options)
            else:
                raise NoConverterFoundForObjectType.create(conversion_finder,
                                                           attr_value,
                                                           desired_attr_type)
        else:
            # we can safely use the value: it is already of the correct type
            return attr_value