docs: 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