def METHOD_NAME(string, check_accuracy=True):
    """
    Parse the string and try to return the smallest numerical type to use for
    a safe conversion. It has some known issues: precission loss.
    :param str string: Representation of a float/integer with text
    :param bool check_accuracy: If true, a warning is pushed on the logger
        in case there is a loss of accuracy.
    :raise ValueError: When the string is not a numerical value
    :retrun: A numpy numerical type
    """
    if string == "":
        raise ValueError("Not a numerical value")
    match = _parse_numeric_value.match(string)
    if match is None:
        raise ValueError("Not a numerical value")
    number, decimal, exponent = match.groups()
    if decimal is None and exponent is None:
        # It's an integer
        # TODO: We could find the int type without converting the number
        value = int(string)
        return numpy.min_scalar_type(value).type
    # Try floating-point
    try:
        value = _biggest_float(string)
    except ValueError:
        raise ValueError("Not a numerical value")
    if number is None:
        number = ""
    if decimal is None:
        decimal = ""
    if exponent is None:
        exponent = "0"
    nb_precision_digits = int(exponent) - len(decimal) - 1
    precision = _biggest_float(10) ** nb_precision_digits * 1.2
    previous_type = _biggest_float
    for numpy_type in _float_types:
        if numpy_type == _biggest_float:
            # value was already casted using the bigger type
            continue
        reduced_value = numpy_type(value)
        if not numpy.isfinite(reduced_value):
            break
        # numpy isclose(atol=is not accurate enough)
        diff = value - reduced_value
        # numpy 1.8.2 looks to do the substraction using float64...
        # we lose precision here
        diff = numpy.abs(diff)
        if diff > precision:
            break
        previous_type = numpy_type
    # It's the smaller float type which fit with enougth precision
    numpy_type = previous_type
    if check_accuracy and numpy_type == _biggest_float:
        # Check the precision using the original string
        expected = number + decimal
        # This format the number without python convertion
        try:
            result = numpy.array2string(value, precision=len(number) + len(decimal), floatmode="fixed")
        except TypeError:
            # numpy 1.8.2 do not have floatmode argument
            _logger.warning("Not able to check accuracy of the conversion of '%s' using %s", string, _biggest_float)
            return numpy_type
        result = result.replace(".", "").replace("-", "")
        if not result.startswith(expected):
            _logger.warning("Not able to convert '%s' using %s without losing precision", string, _biggest_float)
    return numpy_type