sethmmorton / fastnumbers Goto Github PK

View Code? Open in Web Editor NEW

102.0 6.0 13.0 1.47 MB

Super-fast and clean conversions to numbers for Python.

Home Page: https://pypi.org/project/fastnumbers/

License: MIT License

Python 46.88% Shell 0.05% C++ 53.07%

python c-extension utility utility-library conversion numbers optimization

fastnumbers's People

Contributors

Stargazers

Watchers

Forkers

mediakraken-dependancies tonal bmwiedemann rako9000 wiltonwu odidev abhisheknishantpuresoftware prakriti07 edcastaneda pterjan u-ahmedofficial arpitjain799 sysfce2

fastnumbers's Issues

OverflowError when raise_on_invalid=True

Minimum, Complete, Verifiable Example

from fastnumbers import fast_real

a = fast_real("03e106196") # This is OK
try:
  b = fast_real("03e106196", raise_on_invalid=True) # This throws exception
except ValueError:  # It doesn't get caught, as it's not a ValueError
  pass

Error message, Traceback, Desired behavior, Suggestion, Request, or Question

I would expect a ValueError as it's not a valid float. However, instead there's an OverflowError.

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    b = fast_real("03e106196", raise_on_invalid=True) # This throws exception
OverflowError: cannot convert float infinity to integer

It looks like this is because string_contains_intlike_float returns true for this value, but isn't aware about the exponent being really big.

Make most options keyword-only

This frees up the developer to reorder options if needed.

[BUG] FastNumbers can crash with a SystemError due to returning NULL without setting an exception

Describe the bug
Observed in bug 274 of Mikado by myself and @fmarletaz: in certain conditions, FastNumbers crashes the program by returning NULL rather than None.

Expected behavior
FastNumbers should return None or another valid Python value.

Environment (please complete the following information):

Python Version: 3.7
OS: LInux
Compiler (if known): @fmarletaz could check

To Reproduce
Please see the bug above.

Suspicion is that in all instances where there is a
return NULL

in fastnumbers.c (e.g. line 189), the correct line would be instead:

Py_RETURN_NONE

See here for why this is my suspicion.

Python 3.12 support

Please, update fastnumbers for supporting python 3.12

Request for an option to not ignore underscores in numeric literals

Describe the bug
'10117_1109' was converted to '101171109'

Expected behavior
Should not convert to a number.

Fastest way to check is and object is int or float in one pass

Hi,
Is there a way to check if an object is an int or float in one pass?
Right now I am using .isint and .isfloat.
Any help?

Describe the bug
Arch Linux is currently rebuilding all python related things against python3.9.
The python-fastnumbers package has failing tests on python3.9 and looking at the build output I am not entirely sure they can just be ignored.

Expected behavior
python3.9 is supported

Environment (please complete the following information):

fastnumbers version: 3.0.0
Python Version: 3.9.0
OS: Arch Linux
Compiler (if known): gcc 10.2.0

To Reproduce

python setup.py build
local _py3_ver=$(python --version | cut -d " " -f2)
export PYTHONPATH="build/lib.linux-$CARCH-${_py3_ver%"."*}:${PYTHONPATH}"
pytest -v

running build
running build_ext
building 'fastnumbers' extension
creating build
creating build/temp.linux-x86_64-3.9
creating build/temp.linux-x86_64-3.9/src
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/fastnumbers.c -o build/temp.linux-x86_64-3.9/src/fastnumbers.o
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/numbers.c -o build/temp.linux-x86_64-3.9/src/numbers.o
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/objects.c -o build/temp.linux-x86_64-3.9/src/objects.o
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/parsing.c -o build/temp.linux-x86_64-3.9/src/parsing.o
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/strings.c -o build/temp.linux-x86_64-3.9/src/strings.o
In file included from src/strings.c:14:
src/strings.c: In function ‘str_to_PyFloat’:
/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include/fastnumbers/numbers.h:24:55: warning: implicit declaration of function ‘_Py_dg_stdnan’ [-Wimplicit-function-declaration]
   24 | #define PyFloat_from_NaN(negative) PyFloat_FromDouble(_Py_dg_stdnan(negative));
      |                                                       ^~~~~~~~~~~~~
src/strings.c:115:20: note: in expansion of macro ‘PyFloat_from_NaN’
  115 |             return PyFloat_from_NaN(sign < 0);
      |                    ^~~~~~~~~~~~~~~~
gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -fno-semantic-interposition -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O3 -pipe -fno-plt -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 -fPIC -I/build/python-fastnumbers/src/python-fastnumbers-3.0.0/include -I/usr/include/python3.9 -c src/unicode_character.c -o build/temp.linux-x86_64-3.9/src/unicode_character.o
creating build/lib.linux-x86_64-3.9
gcc -pthread -shared -Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now -fno-semantic-interposition -Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now -Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now -march=x86-64 -mtune=generic -O2 -pipe -fno-plt -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.9/src/fastnumbers.o build/temp.linux-x86_64-3.9/src/numbers.o build/temp.linux-x86_64-3.9/src/objects.o build/temp.linux-x86_64-3.9/src/parsing.o build/temp.linux-x86_64-3.9/src/strings.o build/temp.linux-x86_64-3.9/src/unicode_character.o -L/usr/lib -o build/lib.linux-x86_64-3.9/fastnumbers.cpython-39-x86_64-linux-gnu.so

============================= test session starts ==============================
platform linux -- Python 3.9.0, pytest-6.1.2, py-1.9.0, pluggy-0.13.1 -- /usr/bin/python
cachedir: .pytest_cache
hypothesis profile 'default' -> database=DirectoryBasedExampleDatabase('/build/python-fastnumbers/src/python-fastnumbers-3.0.0/.hypothesis/examples')
rootdir: /build/python-fastnumbers/src/python-fastnumbers-3.0.0
plugins: hypothesis-5.41.2
collecting ... collected 233 items

tests/test_builtins.py::GeneralFloatCases::test_error_message PASSED     [  0%]
tests/test_builtins.py::GeneralFloatCases::test_float PASSED             [  0%]
tests/test_builtins.py::GeneralFloatCases::test_float_memoryview PASSED  [  1%]
tests/test_builtins.py::GeneralFloatCases::test_float_with_comma SKIPPED [  1%]
tests/test_builtins.py::GeneralFloatCases::test_floatconversion PASSED   [  2%]
tests/test_builtins.py::GeneralFloatCases::test_keyword_args PASSED      [  2%]
tests/test_builtins.py::GeneralFloatCases::test_non_numeric_input_types PASSED [  3%]
tests/test_builtins.py::GeneralFloatCases::test_underscores PASSED       [  3%]
tests/test_builtins.py::InfNanTest::test_inf_as_str PASSED               [  3%]
tests/test_builtins.py::InfNanTest::test_inf_from_str PASSED             [  4%]
tests/test_builtins.py::InfNanTest::test_inf_signs PASSED                [  4%]
tests/test_builtins.py::InfNanTest::test_nan_as_str PASSED               [  5%]
tests/test_builtins.py::InfNanTest::test_nan_from_str FAILED             [  5%]
tests/test_builtins.py::InfNanTest::test_nan_signs FAILED                [  6%]
tests/test_builtins.py::IntTestCases::test_basic PASSED                  [  6%]
tests/test_builtins.py::IntTestCases::test_error_message PASSED          [  6%]
tests/test_builtins.py::IntTestCases::test_int_base_bad_types PASSED     [  7%]
tests/test_builtins.py::IntTestCases::test_int_base_indexable PASSED     [  7%]
tests/test_builtins.py::IntTestCases::test_int_base_limits PASSED        [  8%]
tests/test_builtins.py::IntTestCases::test_int_memoryview PASSED         [  8%]
tests/test_builtins.py::IntTestCases::test_int_returns_int_subclass PASSED [  9%]
tests/test_builtins.py::IntTestCases::test_int_subclass_with_index PASSED [  9%]
tests/test_builtins.py::IntTestCases::test_int_subclass_with_int PASSED  [  9%]
tests/test_builtins.py::IntTestCases::test_intconversion PASSED          [ 10%]
tests/test_builtins.py::IntTestCases::test_issue31619 PASSED             [ 10%]
tests/test_builtins.py::IntTestCases::test_keyword_args PASSED           [ 11%]
tests/test_builtins.py::IntTestCases::test_no_args PASSED                [ 11%]
tests/test_builtins.py::IntTestCases::test_non_numeric_input_types PASSED [ 12%]
tests/test_builtins.py::IntTestCases::test_small_ints PASSED             [ 12%]
tests/test_builtins.py::IntTestCases::test_string_float PASSED           [ 12%]
tests/test_builtins.py::IntTestCases::test_underscores PASSED            [ 13%]
tests/test_fastnumbers.py::test_version PASSED                           [ 13%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[fast_real] PASSED [ 14%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[fast_float] PASSED [ 14%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[fast_int] PASSED [ 15%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[fast_forceint] PASSED [ 15%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[isreal] PASSED [ 15%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[isfloat] PASSED [ 16%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[isint] PASSED [ 16%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[isintlike] PASSED [ 17%]
tests/test_fastnumbers.py::test_invalid_argument_raises_type_error[real] PASSED [ 17%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[fast_real] PASSED [ 18%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[fast_float] PASSED [ 18%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[fast_int] PASSED [ 18%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[fast_forceint] PASSED [ 19%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[isreal] PASSED [ 19%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[isfloat] PASSED [ 20%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[isint] PASSED [ 20%]
tests/test_fastnumbers.py::test_no_arguments_raises_type_error[isintlike] PASSED [ 21%]
tests/test_fastnumbers.py::test_key_backwards_compatibility[fast_real] PASSED [ 21%]
tests/test_fastnumbers.py::test_key_backwards_compatibility[fast_float] PASSED [ 21%]
tests/test_fastnumbers.py::test_key_backwards_compatibility[fast_int] PASSED [ 22%]
tests/test_fastnumbers.py::test_key_backwards_compatibility[fast_forceint] PASSED [ 22%]
tests/test_fastnumbers.py::test_real_no_arguments_returns_0 PASSED       [ 23%]
tests/test_fastnumbers.py::test_real_returns_same_as_fast_real PASSED    [ 23%]
tests/test_fastnumbers.py::test_numbers_with_underscores_converted_according_to_allow_underscores_option[fast_real] PASSED [ 24%]
tests/test_fastnumbers.py::test_numbers_with_underscores_converted_according_to_allow_underscores_option[fast_float] PASSED [ 24%]
tests/test_fastnumbers.py::test_numbers_with_underscores_converted_according_to_allow_underscores_option[fast_int] PASSED [ 24%]
tests/test_fastnumbers.py::test_numbers_with_underscores_converted_according_to_allow_underscores_option[fast_forceint] PASSED [ 25%]
tests/test_fastnumbers.py::test_numbers_with_underscores_identified_according_to_allow_underscores_option[isreal] PASSED [ 25%]
tests/test_fastnumbers.py::test_numbers_with_underscores_identified_according_to_allow_underscores_option[isfloat] PASSED [ 26%]
tests/test_fastnumbers.py::test_numbers_with_underscores_identified_according_to_allow_underscores_option[isint] PASSED [ 26%]
tests/test_fastnumbers.py::test_numbers_with_underscores_identified_according_to_allow_underscores_option[isintlike] PASSED [ 27%]
tests/test_fastnumbers.py::TestFastReal::test_with_coerce_given_dumb_class_responds_to_internal_valueerror PASSED [ 27%]
tests/test_fastnumbers.py::TestFastReal::test_given_float_returns_float PASSED [ 27%]
tests/test_fastnumbers.py::TestFastReal::test_given_float_returns_int_if_intlike_with_coerce PASSED [ 28%]
tests/test_fastnumbers.py::TestFastReal::test_given_float_returns_float_or_int_with_coerce PASSED [ 28%]
tests/test_fastnumbers.py::TestFastReal::test_given_nan_returns_nan PASSED [ 29%]
tests/test_fastnumbers.py::TestFastReal::test_given_nan_returns_sub_value PASSED [ 29%]
tests/test_fastnumbers.py::TestFastReal::test_given_inf_returns_inf PASSED [ 30%]
tests/test_fastnumbers.py::TestFastReal::test_given_inf_returns_sub_value PASSED [ 30%]
tests/test_fastnumbers.py::TestFastReal::test_given_float_string_returns_float PASSED [ 30%]
tests/test_fastnumbers.py::TestFastReal::test_given_float_string_returns_int_with_coerce_with_intlike PASSED [ 31%]
tests/test_fastnumbers.py::TestFastReal::test_given_nan_string_returns_nan FAILED [ 31%]
tests/test_fastnumbers.py::TestFastReal::test_with_nan_given_nan_string_returns_sub_value PASSED [ 32%]
tests/test_fastnumbers.py::TestFastReal::test_given_inf_string_returns_inf PASSED [ 32%]
tests/test_fastnumbers.py::TestFastReal::test_given_very_large_float_returns_inf_with_coerce_on_or_off PASSED [ 33%]
tests/test_fastnumbers.py::TestFastReal::test_with_inf_given_inf_string_returns_sub_value PASSED [ 33%]
tests/test_fastnumbers.py::TestFastReal::test_given_padded_float_strings_returns_float PASSED [ 33%]
tests/test_fastnumbers.py::TestFastReal::test_given_padded_nan_returns_nan FAILED [ 34%]
tests/test_fastnumbers.py::TestFastReal::test_given_padded_inf_string_returns_inf PASSED [ 34%]
tests/test_fastnumbers.py::TestFastReal::test_given_int_returns_int PASSED [ 35%]
tests/test_fastnumbers.py::TestFastReal::test_given_int_returns_int_with_coerce PASSED [ 35%]
tests/test_fastnumbers.py::TestFastReal::test_given_int_string_returns_int PASSED [ 36%]
tests/test_fastnumbers.py::TestFastReal::test_given_padded_int_string_returns_int PASSED [ 36%]
tests/test_fastnumbers.py::TestFastReal::test_given_unicode_digit_returns_int PASSED [ 36%]
tests/test_fastnumbers.py::TestFastReal::test_given_unicode_numeral_returns_float PASSED [ 37%]
tests/test_fastnumbers.py::TestFastReal::test_given_unicode_non_numeral_returns_as_is PASSED [ 37%]
tests/test_fastnumbers.py::TestFastReal::test_given_unicode_of_more_than_one_char_returns_as_is PASSED [ 38%]
tests/test_fastnumbers.py::TestFastReal::test_given_invalid_string_returns_string_as_is PASSED [ 38%]
tests/test_fastnumbers.py::TestFastReal::test_given_invalid_string_raises_valueerror_if_raise_on_invalid_is_true PASSED [ 39%]
tests/test_fastnumbers.py::TestFastReal::test_given_invalid_type_raises_typeerror PASSED [ 39%]
tests/test_fastnumbers.py::TestFastReal::test_returns_default_value_if_given_invalid_string PASSED [ 39%]
tests/test_fastnumbers.py::TestFastReal::test_raises_valueerror_if_raise_on_invalid_is_true_with_default PASSED [ 40%]
tests/test_fastnumbers.py::TestFastReal::test_returns_input_as_is_if_valid_and_on_fail_is_given PASSED [ 40%]
tests/test_fastnumbers.py::TestFastReal::test_returns_transformed_input_if_invalid_and_on_fail_is_given PASSED [ 41%]
tests/test_fastnumbers.py::TestFastFloat::test_given_dumb_class_responds_to_internal_valueerror PASSED [ 41%]
tests/test_fastnumbers.py::TestFastFloat::test_given_float_returns_float PASSED [ 42%]
tests/test_fastnumbers.py::TestFastFloat::test_given_nan_returns_nan PASSED [ 42%]
tests/test_fastnumbers.py::TestFastFloat::test_given_nan_returns_sub_value PASSED [ 42%]
tests/test_fastnumbers.py::TestFastFloat::test_given_inf_returns_inf PASSED [ 43%]
tests/test_fastnumbers.py::TestFastFloat::test_given_inf_returns_sub_value PASSED [ 43%]
tests/test_fastnumbers.py::TestFastFloat::test_with_range_of_exponents_correctly_parses PASSED [ 44%]
tests/test_fastnumbers.py::TestFastFloat::test_given_float_string_returns_float PASSED [ 44%]
tests/test_fastnumbers.py::TestFastFloat::test_given_nan_string_returns_nan FAILED [ 45%]
tests/test_fastnumbers.py::TestFastFloat::test_given_inf_string_returns_inf PASSED [ 45%]
tests/test_fastnumbers.py::TestFastFloat::test_given_padded_float_strings_returns_float PASSED [ 45%]
tests/test_fastnumbers.py::TestFastFloat::test_given_padded_nan_returns_nan FAILED [ 46%]
tests/test_fastnumbers.py::TestFastFloat::test_given_padded_inf_string_returns_inf PASSED [ 46%]
tests/test_fastnumbers.py::TestFastFloat::test_given_int_returns_float PASSED [ 47%]
tests/test_fastnumbers.py::TestFastFloat::test_given_int_string_returns_float PASSED [ 47%]
tests/test_fastnumbers.py::TestFastFloat::test_given_padded_int_string_returns_float PASSED [ 48%]
tests/test_fastnumbers.py::TestFastFloat::test_given_unicode_digit_returns_float PASSED [ 48%]
tests/test_fastnumbers.py::TestFastFloat::test_given_unicode_numeral_returns_float PASSED [ 48%]
tests/test_fastnumbers.py::TestFastFloat::test_given_unicode_non_numeral_returns_as_is PASSED [ 49%]
tests/test_fastnumbers.py::TestFastFloat::test_given_unicode_of_more_than_one_char_returns_as_is PASSED [ 49%]
tests/test_fastnumbers.py::TestFastFloat::test_given_invalid_string_returns_string_as_is PASSED [ 50%]
tests/test_fastnumbers.py::TestFastFloat::test_given_invalid_string_raises_valueerror_if_raise_on_invalid_is_true PASSED [ 50%]
tests/test_fastnumbers.py::TestFastFloat::test_given_invalid_type_raises_typeerror PASSED [ 51%]
tests/test_fastnumbers.py::TestFastFloat::test_returns_default_value_if_given_invalid_string PASSED [ 51%]
tests/test_fastnumbers.py::TestFastFloat::test_raises_valueerror_if_raise_on_invalid_is_true_with_default PASSED [ 51%]
tests/test_fastnumbers.py::TestFastFloat::test_returns_input_as_is_if_valid_and_on_fail_is_given PASSED [ 52%]
tests/test_fastnumbers.py::TestFastFloat::test_returns_transformed_input_if_invalid_and_on_fail_is_given PASSED [ 52%]
tests/test_fastnumbers.py::TestFastInt::test_given_dumb_class_responds_to_internal_valueerror PASSED [ 53%]
tests/test_fastnumbers.py::TestFastInt::test_given_invalid_base_errors_with_valueerror PASSED [ 53%]
tests/test_fastnumbers.py::TestFastInt::test_given_float_returns_int PASSED [ 54%]
tests/test_fastnumbers.py::TestFastInt::test_given_nan_raises_valueerror_or_returns_as_is_or_returns_default PASSED [ 54%]
tests/test_fastnumbers.py::TestFastInt::test_given_inf_raises_overflowerror PASSED [ 54%]
tests/test_fastnumbers.py::TestFastInt::test_given_float_string_returns_string_as_is PASSED [ 55%]
tests/test_fastnumbers.py::TestFastInt::test_given_float_intlike_string_returns_string_as_is PASSED [ 55%]
tests/test_fastnumbers.py::TestFastInt::test_given_float_string_raises_valueerror_if_raise_on_invalid_is_true PASSED [ 56%]
tests/test_fastnumbers.py::TestFastInt::test_given_int_returns_int PASSED [ 56%]
tests/test_fastnumbers.py::TestFastInt::test_given_int_string_returns_int PASSED [ 57%]
tests/test_fastnumbers.py::TestFastInt::test_given_multiple_zeros_with_base_returns_zero PASSED [ 57%]
tests/test_fastnumbers.py::TestFastInt::test_given_padded_int_string_returns_int PASSED [ 57%]
tests/test_fastnumbers.py::TestFastInt::test_given_unicode_digit_returns_int PASSED [ 58%]
tests/test_fastnumbers.py::TestFastInt::test_given_unicode_numeral_returns_as_is PASSED [ 58%]
tests/test_fastnumbers.py::TestFastInt::test_given_unicode_non_numeral_returns_as_is PASSED [ 59%]
tests/test_fastnumbers.py::TestFastInt::test_given_unicode_of_more_than_one_char_returns_as_is PASSED [ 59%]
tests/test_fastnumbers.py::TestFastInt::test_given_invalid_string_returns_string_as_is PASSED [ 60%]
tests/test_fastnumbers.py::TestFastInt::test_given_invalid_string_raises_valueerror_if_raise_on_invalid_is_true PASSED [ 60%]
tests/test_fastnumbers.py::TestFastInt::test_given_invalid_type_raises_typeerror PASSED [ 60%]
tests/test_fastnumbers.py::TestFastInt::test_returns_default_value_if_given_invalid_string PASSED [ 61%]
tests/test_fastnumbers.py::TestFastInt::test_raises_valueerror_if_raise_on_invalid_is_true_with_default PASSED [ 61%]
tests/test_fastnumbers.py::TestFastInt::test_returns_input_as_is_if_valid_and_on_fail_is_given PASSED [ 62%]
tests/test_fastnumbers.py::TestFastInt::test_returns_transformed_input_if_invalid_and_on_fail_is_given PASSED [ 62%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_dumb_class_responds_to_internal_valueerror PASSED [ 63%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_float_returns_int PASSED [ 63%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_nan_raises_valueerror_or_returns_as_is_or_returns_default PASSED [ 63%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_inf_raises_overflowerror PASSED [ 64%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_float_string_returns_int PASSED [ 64%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_nan_string_raises_valueerror_with_raise_on_invalid_as_true FAILED [ 65%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_inf_string_raises_overflowerror_with_raise_on_invalid_as_true PASSED [ 65%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_padded_float_strings_returns_int PASSED [ 66%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_int_returns_int PASSED [ 66%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_int_string_returns_int PASSED [ 66%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_padded_int_string_returns_int PASSED [ 67%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_unicode_digit_returns_int PASSED [ 67%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_unicode_numeral_returns_int PASSED [ 68%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_unicode_non_numeral_returns_as_is PASSED [ 68%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_unicode_of_more_than_one_char_returns_as_is PASSED [ 69%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_invalid_string_returns_string_as_is PASSED [ 69%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_invalid_string_raises_valueerror_if_raise_on_invalid_is_true PASSED [ 69%]
tests/test_fastnumbers.py::TestFastForceInt::test_given_invalid_type_raises_typeerror PASSED [ 70%]
tests/test_fastnumbers.py::TestFastForceInt::test_returns_default_value_if_given_invalid_string PASSED [ 70%]
tests/test_fastnumbers.py::TestFastForceInt::test_raises_valueerror_if_raise_on_invalid_is_true_with_default PASSED [ 71%]
tests/test_fastnumbers.py::TestFastForceInt::test_returns_input_as_is_if_valid_and_on_fail_is_given PASSED [ 71%]
tests/test_fastnumbers.py::TestFastForceInt::test_returns_transformed_input_if_invalid_and_on_fail_is_given PASSED [ 72%]
tests/test_fastnumbers.py::TestIsReal::test_returns_true_if_given_int PASSED [ 72%]
tests/test_fastnumbers.py::TestIsReal::test_returns_true_if_given_float PASSED [ 72%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_if_given_int_and_str_only_is_true PASSED [ 73%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_if_given_float_and_str_only_is_true PASSED [ 73%]
tests/test_fastnumbers.py::TestIsReal::test_returns_true_if_given_int_string_padded_or_not PASSED [ 74%]
tests/test_fastnumbers.py::TestIsReal::test_returns_true_if_given_float_string_padded_or_not PASSED [ 74%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_if_given_string_and_num_only_is_true PASSED [ 75%]
tests/test_fastnumbers.py::TestIsReal::test_given_unicode_digit_returns_true PASSED [ 75%]
tests/test_fastnumbers.py::TestIsReal::test_given_unicode_numeral_returns_true PASSED [ 75%]
tests/test_fastnumbers.py::TestIsReal::test_given_unicode_non_numeral_returns_false PASSED [ 76%]
tests/test_fastnumbers.py::TestIsReal::test_given_unicode_of_more_than_one_char_returns_false PASSED [ 76%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_if_given_non_number_string PASSED [ 77%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_for_nan_string_unless_allow_nan_is_true PASSED [ 77%]
tests/test_fastnumbers.py::TestIsReal::test_returns_false_for_inf_string_unless_allow_infinity_is_true PASSED [ 78%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_if_given_int PASSED [ 78%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_true_if_given_float PASSED [ 78%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_if_given_float_and_str_only_is_true PASSED [ 79%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_true_if_given_int_string_padded_or_not PASSED [ 79%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_true_if_given_float_string_padded_or_not PASSED [ 80%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_if_given_string_and_num_only_is_true PASSED [ 80%]
tests/test_fastnumbers.py::TestIsFloat::test_given_unicode_digit_returns_true PASSED [ 81%]
tests/test_fastnumbers.py::TestIsFloat::test_given_unicode_numeral_returns_true PASSED [ 81%]
tests/test_fastnumbers.py::TestIsFloat::test_given_unicode_non_numeral_returns_false PASSED [ 81%]
tests/test_fastnumbers.py::TestIsFloat::test_given_unicode_of_more_than_one_char_returns_false PASSED [ 82%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_if_given_non_number_string PASSED [ 82%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_for_nan_string_unless_allow_nan_is_true PASSED [ 83%]
tests/test_fastnumbers.py::TestIsFloat::test_returns_false_for_inf_string_unless_allow_infinity_is_true PASSED [ 83%]
tests/test_fastnumbers.py::TestIsInt::test_returns_true_if_given_int PASSED [ 84%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_if_given_float PASSED [ 84%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_if_given_int_and_str_only_is_true PASSED [ 84%]
tests/test_fastnumbers.py::TestIsInt::test_returns_true_if_given_int_string_padded_or_not PASSED [ 85%]
tests/test_fastnumbers.py::TestIsInt::test_underscores PASSED            [ 85%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_if_given_float_string_padded_or_not PASSED [ 86%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_if_given_string_and_num_only_is_true PASSED [ 86%]
tests/test_fastnumbers.py::TestIsInt::test_given_unicode_digit_returns_true PASSED [ 87%]
tests/test_fastnumbers.py::TestIsInt::test_given_unicode_numeral_returns_false PASSED [ 87%]
tests/test_fastnumbers.py::TestIsInt::test_given_unicode_non_numeral_returns_false PASSED [ 87%]
tests/test_fastnumbers.py::TestIsInt::test_given_unicode_of_more_than_one_char_returns_false PASSED [ 88%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_if_given_non_number_string PASSED [ 88%]
tests/test_fastnumbers.py::TestIsInt::test_returns_false_for_nan_or_inf_string PASSED [ 89%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_true_if_given_int PASSED [ 89%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_non_integer_float PASSED [ 90%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_true_if_given_integer_float PASSED [ 90%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_int_and_str_only_is_true PASSED [ 90%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_integer_float_and_str_only_is_true PASSED [ 91%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_true_if_given_int_string_padded_or_not PASSED [ 91%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_true_if_given_integer_float_string_padded_or_not PASSED [ 92%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_non_integer_float_string_padded_or_not PASSED [ 92%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_string_and_num_only_is_true PASSED [ 93%]
tests/test_fastnumbers.py::TestIsIntLike::test_given_unicode_digit_returns_true PASSED [ 93%]
tests/test_fastnumbers.py::TestIsIntLike::test_given_unicode_non_digit_numeral_returns_false PASSED [ 93%]
tests/test_fastnumbers.py::TestIsIntLike::test_given_unicode_digit_numeral_returns_false PASSED [ 94%]
tests/test_fastnumbers.py::TestIsIntLike::test_given_unicode_non_numeral_returns_false PASSED [ 94%]
tests/test_fastnumbers.py::TestIsIntLike::test_given_unicode_of_more_than_one_char_returns_false PASSED [ 95%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_if_given_non_number_string PASSED [ 95%]
tests/test_fastnumbers.py::TestIsIntLike::test_returns_false_for_nan_or_inf_string PASSED [ 96%]
tests/test_fastnumbers_examples.py::test_fast_real FAILED                [ 96%]
tests/test_fastnumbers_examples.py::test_fast_float FAILED               [ 96%]
tests/test_fastnumbers_examples.py::test_fast_int PASSED                 [ 97%]
tests/test_fastnumbers_examples.py::test_fast_forceint FAILED            [ 97%]
tests/test_fastnumbers_examples.py::test_isreal PASSED                   [ 98%]
tests/test_fastnumbers_examples.py::test_isfloat PASSED                  [ 98%]
tests/test_fastnumbers_examples.py::test_isint PASSED                    [ 99%]
tests/test_fastnumbers_examples.py::test_isintlike PASSED                [ 99%]
tests/test_fastnumbers_examples.py::test_print_limits PASSED             [100%]

FASNUMBERS NUMERICAL LIMITS FOR THIS COMPILER BEFORE PYTHON FALLBACK:
MAXIMUM INTEGER LENTH: 18
MAX NUMBER FLOAT DIGITS: 11
MAXIMUM FLOAT EXPONENT: 99
MINIMUM FLOAT EXPONENT: -98


=================================== FAILURES ===================================
_________________________ InfNanTest.test_nan_from_str _________________________

self = <builtin_tests.py38.builtin_test_float.InfNanTest testMethod=test_nan_from_str>

    def test_nan_from_str(self):
>       self.assertTrue(isnan(float("nan")))
E       AssertionError: False is not true

tests/builtin_tests/py38/builtin_test_float.py:310: AssertionError
__________________________ InfNanTest.test_nan_signs ___________________________

self = <builtin_tests.py38.builtin_test_float.InfNanTest testMethod=test_nan_signs>

    @unittest.skipUnless(
        getattr(sys, "float_repr_style", "") == "short",
        "applies only when using short float repr style",
    )
    def test_nan_signs(self):
        # When using the dtoa.c code, the sign of float('nan') should
        # be predictable.
        self.assertEqual(copysign(1.0, float("nan")), 1.0)
>       self.assertEqual(copysign(1.0, float("-nan")), -1.0)
E       AssertionError: 1.0 != -1.0

tests/builtin_tests/py38/builtin_test_float.py:357: AssertionError
________________ TestFastReal.test_given_nan_string_returns_nan ________________

self = <test_fastnumbers.TestFastReal object at 0x652fc8244610>

    def test_given_nan_string_returns_nan(self):
>       assert math.isnan(fastnumbers.fast_real("nan"))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_real>('nan')
E        +      where <built-in function fast_real> = fastnumbers.fast_real

tests/test_fastnumbers.py:245: AssertionError
________________ TestFastReal.test_given_padded_nan_returns_nan ________________

self = <test_fastnumbers.TestFastReal object at 0x652fcab765b0>

    def test_given_padded_nan_returns_nan(self):
>       assert math.isnan(fastnumbers.fast_real("     nan "))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_real>('     nan ')
E        +      where <built-in function fast_real> = fastnumbers.fast_real

tests/test_fastnumbers.py:272: AssertionError
_______________ TestFastFloat.test_given_nan_string_returns_nan ________________

self = <test_fastnumbers.TestFastFloat object at 0x652fc81a9c10>

    def test_given_nan_string_returns_nan(self):
>       assert math.isnan(fastnumbers.fast_float("nan"))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_float>('nan')
E        +      where <built-in function fast_float> = fastnumbers.fast_float

tests/test_fastnumbers.py:430: AssertionError
_______________ TestFastFloat.test_given_padded_nan_returns_nan ________________

self = <test_fastnumbers.TestFastFloat object at 0x652fc82293d0>

    def test_given_padded_nan_returns_nan(self):
>       assert math.isnan(fastnumbers.fast_float("     nan "))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_float>('     nan ')
E        +      where <built-in function fast_float> = fastnumbers.fast_float

tests/test_fastnumbers.py:450: AssertionError
_ TestFastForceInt.test_given_nan_string_raises_valueerror_with_raise_on_invalid_as_true _

self = <test_fastnumbers.TestFastForceInt object at 0x652fc83ff460>

    def test_given_nan_string_raises_valueerror_with_raise_on_invalid_as_true(self):
        with raises(ValueError):
>           fastnumbers.fast_forceint("nan", raise_on_invalid=True)
E           Failed: DID NOT RAISE <class 'ValueError'>

tests/test_fastnumbers.py:765: Failed
________________________________ test_fast_real ________________________________

    def test_fast_real():
        # 1. float number
        assert fastnumbers.fast_real(-367.3268) == -367.3268
        assert fastnumbers.fast_real(-367.3268, raise_on_invalid=True) == -367.3268
        # 2. signed float string
        assert fastnumbers.fast_real("+367.3268") == +367.3268
        assert fastnumbers.fast_real("+367.3268", raise_on_invalid=True) == +367.3268
        # 3. float string with exponents
        assert fastnumbers.fast_real("-367.3268e207") == -367.3268e207
        assert fastnumbers.fast_real("1.175494351e-3810000000") == 0.0
        # 4. float string with padded whitespace
        assert fastnumbers.fast_real("   -367.04   ") == -367.04
        # 5. int number
        assert fastnumbers.fast_real(499) == 499
        # 6. signed int string
        assert fastnumbers.fast_real("-499") == -499
        # 7. int string with padded whitespace
        assert fastnumbers.fast_real("   +3001   ") == 3001
        # 8. long number
        assert fastnumbers.fast_real(35892482945872302493) == 35892482945872302493
        # 9. long string
        assert fastnumbers.fast_real("35892482945872302493") == 35892482945872302493
        # 10. return type
        assert isinstance(fastnumbers.fast_real(4029), int)
        assert isinstance(fastnumbers.fast_real(4029.0, coerce=False), float)
        assert isinstance(fastnumbers.fast_real(4029), int)
        assert isinstance(fastnumbers.fast_real(4029.0), int)
        assert isinstance(fastnumbers.fast_real(4029.5), float)
        assert isinstance(fastnumbers.fast_real("4029"), int)
        assert isinstance(fastnumbers.fast_real("4029.0"), int)
        assert isinstance(fastnumbers.fast_real("4029.0", coerce=False), float)
        # 11. TypeError for invalid input
        with raises(TypeError):
            fastnumbers.fast_real(["hey"])
        # 12. Invalid input string
        assert fastnumbers.fast_real("not_a_number") == "not_a_number"
        with raises(ValueError):
            assert fastnumbers.fast_real("not_a_number", raise_on_invalid=True)
        # 13. Invalid input string with numbers
        assert fastnumbers.fast_real("26.8 lb") == "26.8 lb"
        with raises(ValueError):
            assert fastnumbers.fast_real("26.8 lb", raise_on_invalid=True)
        # 14. Infinity
        assert fastnumbers.fast_real("inf") == float("inf")
        assert fastnumbers.fast_real("-iNFinity") == float("-inf")
        assert fastnumbers.fast_real("-iNFinity", inf=7608) == 7608
        # 15. NaN
>       assert math.isnan(fastnumbers.fast_real("nan"))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_real>('nan')
E        +      where <built-in function fast_real> = fastnumbers.fast_real

tests/test_fastnumbers_examples.py:79: AssertionError
_______________________________ test_fast_float ________________________________

    def test_fast_float():
        # 1. float number
        assert fastnumbers.fast_float(-367.3268) == -367.3268
        assert fastnumbers.fast_float(-367.3268, raise_on_invalid=True) == -367.3268
        # 2. signed float string
        assert fastnumbers.fast_float("+367.3268") == +367.3268
        assert fastnumbers.fast_float("+367.3268", raise_on_invalid=True) == +367.3268
        # 3. float string with exponents
        assert fastnumbers.fast_float("-367.3268e27") == -367.3268e27
        assert fastnumbers.fast_float("-367.3268E27") == -367.3268e27
        assert fastnumbers.fast_float("-367.3268e207") == -367.3268e207
        assert fastnumbers.fast_float("1.175494351E-3810000000") == 0.0
        # 4. float string with padded whitespace
        assert fastnumbers.fast_float("   -367.04   ") == -367.04
        # 5. int number
        assert fastnumbers.fast_float(499) == 499.0
        # 6. signed int string
        assert fastnumbers.fast_float("-499") == -499.0
        # 7. int string with padded whitespace
        assert fastnumbers.fast_float("   +3001   ") == 3001
        # 8. long number
        assert fastnumbers.fast_float(35892482945872302493) == 35892482945872302493.0
        # 9. long string
        assert fastnumbers.fast_float("35892482945872302493") == 35892482945872302493.0
        # 10. return type
        assert isinstance(fastnumbers.fast_float(4029), float)
        assert isinstance(fastnumbers.fast_float("4029"), float)
        # 11. TypeError for invalid input
        with raises(TypeError):
            fastnumbers.fast_float(["hey"])
        # 12. Invalid input string
        assert fastnumbers.fast_float("not_a_number") == "not_a_number"
        with raises(ValueError):
            assert fastnumbers.fast_float("not_a_number", raise_on_invalid=True)
        # 13. Invalid input string with numbers
        assert fastnumbers.fast_float("26.8 lb") == "26.8 lb"
        with raises(ValueError):
            assert fastnumbers.fast_float("26.8 lb", raise_on_invalid=True)
        # 14. Infinity
        assert fastnumbers.fast_float("inf") == float("inf")
        assert fastnumbers.fast_float("-iNFinity") == float("-inf")
        assert fastnumbers.fast_float("-iNFinity", inf=523) == 523
        # 15. NaN
>       assert math.isnan(fastnumbers.fast_float("nAn"))
E       AssertionError: assert False
E        +  where False = <built-in function isnan>(0.0)
E        +    where <built-in function isnan> = math.isnan
E        +    and   0.0 = <built-in function fast_float>('nAn')
E        +      where <built-in function fast_float> = fastnumbers.fast_float

tests/test_fastnumbers_examples.py:147: AssertionError
______________________________ test_fast_forceint ______________________________

    def test_fast_forceint():
        # 1. float number
        assert fastnumbers.fast_forceint(-367.3268) == -367
        assert fastnumbers.fast_forceint(-367.3268, raise_on_invalid=True) == -367
        # 2. signed float string
        assert fastnumbers.fast_forceint("+367.3268") == 367
        assert fastnumbers.fast_forceint("+367.3268", raise_on_invalid=True) == 367
        # 3. float string with exponents
        assert fastnumbers.fast_forceint("-367.3268e207") == int(-367.3268e207)
        # 4. float string with padded whitespace
        assert fastnumbers.fast_forceint("   -367.04   ") == -367
        # 5. int number
        assert fastnumbers.fast_forceint(499) == 499
        # 6. signed int string
        assert fastnumbers.fast_forceint("-499") == -499
        # 7. int string with padded whitespace
        assert fastnumbers.fast_forceint("   +3001   ") == 3001
        # 8. long number
        assert fastnumbers.fast_forceint(35892482945872302493) == 35892482945872302493
        # 9. long string
        assert fastnumbers.fast_forceint("35892482945872302493") == 35892482945872302493
        # 10. return type
        assert isinstance(fastnumbers.fast_forceint(4029.00), int)
        assert isinstance(fastnumbers.fast_forceint("4029.00"), int)
        # 11. TypeError for invalid input
        with raises(TypeError):
            fastnumbers.fast_forceint(["hey"])
        # 12. Invalid input string
        assert fastnumbers.fast_forceint("not_a_number") == "not_a_number"
        with raises(ValueError):
            assert fastnumbers.fast_forceint("not_a_number", raise_on_invalid=True)
        # 13. Invalid input string with numbers
        assert fastnumbers.fast_forceint("26.8 lb") == "26.8 lb"
        with raises(ValueError):
            assert fastnumbers.fast_forceint("26.8 lb", raise_on_invalid=True)
        # 14. Infinity
        assert fastnumbers.fast_forceint("inf") == "inf"
        assert fastnumbers.fast_forceint("-iNFinity") == "-iNFinity"
        # 15. NaN
>       assert fastnumbers.fast_forceint("nan") == "nan"
E       AssertionError: assert 0 == 'nan'
E         +0
E         -'nan'

tests/test_fastnumbers_examples.py:273: AssertionError
=========================== short test summary info ============================
FAILED tests/test_builtins.py::InfNanTest::test_nan_from_str - AssertionError...
FAILED tests/test_builtins.py::InfNanTest::test_nan_signs - AssertionError: 1...
FAILED tests/test_fastnumbers.py::TestFastReal::test_given_nan_string_returns_nan
FAILED tests/test_fastnumbers.py::TestFastReal::test_given_padded_nan_returns_nan
FAILED tests/test_fastnumbers.py::TestFastFloat::test_given_nan_string_returns_nan
FAILED tests/test_fastnumbers.py::TestFastFloat::test_given_padded_nan_returns_nan
FAILED tests/test_fastnumbers.py::TestFastForceInt::test_given_nan_string_raises_valueerror_with_raise_on_invalid_as_true
FAILED tests/test_fastnumbers_examples.py::test_fast_real - AssertionError: a...
FAILED tests/test_fastnumbers_examples.py::test_fast_float - AssertionError: ...
FAILED tests/test_fastnumbers_examples.py::test_fast_forceint - AssertionErro...
================== 10 failed, 222 passed, 1 skipped in 13.77s ==================

Segfaults on tests for Python 3.7.0

Inconsistently, and at "random" points during testing, I experience segmentation faults on Python 3.7.0. It happens no matter the OS (Mac, Windows, Linux). I strongly believe that this is not a bug in fastnumbers but rather with Python itself. My logic for this conclusion is

There is an open issue on bugs.python.org (https://bugs.python.org/issue34087, called "int(s), float(s) and others may cause segmentation fault") that points out that a change to the unicode handling internal function _PyUnicode_TransformDecimalAndSpaceToASCII that is called by int and float can introduce segfaults.
There is no difference in code within fastnumbers between Python 3.6 and 3.7, and no segfaults occur on Python 3.6.

I will leave this issue open till Python 3.7.1 is released (which has a patch for the segfault) and I can verify that this resolves the issue.

In interesting coincidence - it is the fact that _PyUnicode_TransformDecimalAndSpaceToASCII changed in 3.7 that started PR #16, but it was because its behavior changed, not because of segfaults.

Unit test numeric issues on 32bit arm CPU

Describe the bug
I am getting a lot of unit test failures due to slight numeric issues on armv7

Expected behavior
Unit tests pass

Environment (please complete the following information):

Python Version: 3.7.3
OS openSUSE linux armv7l
Compiler (if known): gcc-9

To Reproduce

Executed pytest with PYTHONPATH set to the installation directory.

============================= test session starts ==============================
platform linux -- Python 3.7.3, pytest-5.0.1, py-1.8.0, pluggy-0.12.0
hypothesis profile 'default' -> database=DirectoryBasedExampleDatabase('/home/abuild/rpmbuild/BUILD/fastnumbers-2.2.1/.hypothesis/examples')
rootdir: /home/abuild/rpmbuild/BUILD/fastnumbers-2.2.1
plugins: hypothesis-4.32.2
collected 228 items

tests/test_builtins.py ..............................                    [ 13%]
tests/test_fastnumbers.py ....................................F......F.. [ 33%]
.............F.......F...............................................F.. [ 64%]
F............F.........................................................  [ 96%]
tests/test_fastnumbers_examples.py .........

FASNUMBERS NUMERICAL LIMITS FOR THIS COMPILER BEFORE PYTHON FALLBACK:
MAXIMUM INTEGER LENTH: 9
MAX NUMBER FLOAT DIGITS: 11
MAXIMUM FLOAT EXPONENT: 99
MINIMUM FLOAT EXPONENT: -98
                             [100%]

=================================== FAILURES ===================================
______________ TestFastReal.test_given_float_string_returns_float ______________

self = <test_fastnumbers.TestFastReal object at 0xb4f9c530>

    @given(floats(allow_nan=False))
>   @example(5.675088586167575e-116)
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_float_string_returns_float(self, x):

tests/test_fastnumbers.py:239: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastReal object at 0xb4f9c530>, x = 3.402823466e+38

    @given(floats(allow_nan=False))
    @example(5.675088586167575e-116)
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_float_string_returns_float(self, x):
        y = repr(x)
>       assert fastnumbers.fast_real(y, coerce=False) == x
E       AssertionError: assert 3.4028234659999998e+38 == 3.402823466e+38
E        +  where 3.4028234659999998e+38 = <built-in function fast_real>('3.402823466e+38', coerce=False)
E        +    where <built-in function fast_real> = fastnumbers.fast_real

tests/test_fastnumbers.py:248: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_given_float_string_returns_float(self=<test_fastnumbers.TestFastReal at 0xb4f9c530>, x=3.402823466e+38)
__________ TestFastReal.test_given_padded_float_strings_returns_float __________

self = <test_fastnumbers.TestFastReal object at 0xb4f97d30>

    @given(floats(allow_nan=False), integers(0, 100), integers(0, 100))
>   @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_padded_float_strings_returns_float(self, x, y, z):

tests/test_fastnumbers.py:287: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastReal object at 0xb4f97d30>, x = 3.402823466e+38
y = '3.402823466e+38', z = 0

    @given(floats(allow_nan=False), integers(0, 100), integers(0, 100))
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_padded_float_strings_returns_float(self, x, y, z):
        y = "".join(repeat(space(), y)) + repr(x) + "".join(repeat(space(), z))
>       assert fastnumbers.fast_real(y, coerce=False) == x
E       AssertionError: assert 3.4028234659999998e+38 == 3.402823466e+38
E        +  where 3.4028234659999998e+38 = <built-in function fast_real>('3.402823466e+38', coerce=False)
E        +    where <built-in function fast_real> = fastnumbers.fast_real

tests/test_fastnumbers.py:295: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_given_padded_float_strings_returns_float(self=<test_fastnumbers.TestFastReal at 0xb4f97d30>, x=3.402823466e+38, y=0, z=0)
_______ TestFastReal.test_returns_input_as_is_if_valid_and_key_is_given ________

self = <test_fastnumbers.TestFastReal object at 0xb4f77c90>

    @given(integers() | floats(allow_nan=False))
>   @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_returns_input_as_is_if_valid_and_key_is_given(self, x):

tests/test_fastnumbers.py:402: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastReal object at 0xb4f77c90>, x = 3.402823466e+38

    @given(integers() | floats(allow_nan=False))
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_returns_input_as_is_if_valid_and_key_is_given(self, x):
        assert fastnumbers.fast_real(x, key=len) == x
>       assert fastnumbers.fast_real(repr(x), key=len) == x
E       AssertionError: assert 340282346599999978372335459157852291072 == 3.402823466e+38
E        +  where 340282346599999978372335459157852291072 = <built-in function fast_real>('3.402823466e+38', key=len)
E        +    where <built-in function fast_real> = fastnumbers.fast_real
E        +    and   '3.402823466e+38' = repr(3.402823466e+38)

tests/test_fastnumbers.py:410: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_returns_input_as_is_if_valid_and_key_is_given(self=<test_fastnumbers.TestFastReal at 0xb4f77c90>, x=3.402823466e+38)
_________ TestFastFloat.test_with_range_of_exponents_correctly_parses __________

self = <test_fastnumbers.TestFastFloat object at 0xb4f9a970>

    def test_with_range_of_exponents_correctly_parses(self):
        for x in range(-300, 300):
            val = "1.0E{0:d}".format(x)
>           assert fastnumbers.fast_float(val) == float(val)
E           AssertionError: assert 1.0000000000000001e-98 == 1e-98
E            +  where 1.0000000000000001e-98 = <built-in function fast_float>('1.0E-98')
E            +    where <built-in function fast_float> = fastnumbers.fast_float
E            +  and   1e-98 = float('1.0E-98')

tests/test_fastnumbers.py:449: AssertionError
_____________ TestFastForceInt.test_given_float_string_returns_int _____________

self = <test_fastnumbers.TestFastForceInt object at 0xb4f97c90>

    @given(floats(allow_nan=False, allow_infinity=False))
>   @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_float_string_returns_int(self, x):

tests/test_fastnumbers.py:821: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastForceInt object at 0xb4f97c90>
x = 3.402823466e+38

    @given(floats(allow_nan=False, allow_infinity=False))
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_float_string_returns_int(self, x):
        y = repr(x)
>       assert fastnumbers.fast_forceint(y) == int(x)
E       AssertionError: assert 340282346599999978372335459157852291072 == 340282346600000016151267322115014000640
E        +  where 340282346599999978372335459157852291072 = <built-in function fast_forceint>('3.402823466e+38')
E        +    where <built-in function fast_forceint> = fastnumbers.fast_forceint
E        +  and   340282346600000016151267322115014000640 = int(3.402823466e+38)

tests/test_fastnumbers.py:829: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_given_float_string_returns_int(self=<test_fastnumbers.TestFastForceInt at 0xb4f97c90>, x=3.402823466e+38)
_________ TestFastForceInt.test_given_padded_float_strings_returns_int _________

self = <test_fastnumbers.TestFastForceInt object at 0xb521f1b0>

    @given(
>       floats(allow_nan=False, allow_infinity=False),
        integers(0, 100),
        integers(0, 100),
    )
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_padded_float_strings_returns_int(self, x, y, z):

tests/test_fastnumbers.py:847: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastForceInt object at 0xb521f1b0>
x = 3.402823466e+38, y = '3.402823466e+38', z = 0

    @given(
        floats(allow_nan=False, allow_infinity=False),
        integers(0, 100),
        integers(0, 100),
    )
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_given_padded_float_strings_returns_int(self, x, y, z):
        y = "".join(repeat(space(), y)) + repr(x) + "".join(repeat(space(), z))
>       assert fastnumbers.fast_forceint(y) == int(x)
E       AssertionError: assert 340282346599999978372335459157852291072 == 340282346600000016151267322115014000640
E        +  where 340282346599999978372335459157852291072 = <built-in function fast_forceint>('3.402823466e+38')
E        +    where <built-in function fast_forceint> = fastnumbers.fast_forceint
E        +  and   340282346600000016151267322115014000640 = int(3.402823466e+38)

tests/test_fastnumbers.py:859: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_given_padded_float_strings_returns_int(self=<test_fastnumbers.TestFastForceInt at 0xb521f1b0>, x=3.402823466e+38, y=0, z=0)
_____ TestFastForceInt.test_returns_input_as_is_if_valid_and_key_is_given ______

self = <test_fastnumbers.TestFastForceInt object at 0xb4f9cbd0>

    @given(integers() | floats(allow_nan=False, allow_infinity=False))
>   @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_returns_input_as_is_if_valid_and_key_is_given(self, x):

tests/test_fastnumbers.py:955: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <test_fastnumbers.TestFastForceInt object at 0xb4f9cbd0>
x = 3.402823466e+38

    @given(integers() | floats(allow_nan=False, allow_infinity=False))
    @mark.xfail(
        is_windows and (is_27 or is_34),
        reason="Non-optimal floating-point handling on older VS versions "
        "creates small errors when creating high-precision doubles.",
        strict=False,
    )
    def test_returns_input_as_is_if_valid_and_key_is_given(self, x):
        assert fastnumbers.fast_forceint(x, key=len) == int(x)
>       assert fastnumbers.fast_forceint(repr(x), key=len) == int(x)
E       AssertionError: assert 340282346599999978372335459157852291072 == 340282346600000016151267322115014000640
E        +  where 340282346599999978372335459157852291072 = <built-in function fast_forceint>('3.402823466e+38', key=len)
E        +    where <built-in function fast_forceint> = fastnumbers.fast_forceint
E        +    and   '3.402823466e+38' = repr(3.402823466e+38)
E        +  and   340282346600000016151267322115014000640 = int(3.402823466e+38)

tests/test_fastnumbers.py:963: AssertionError
---------------------------------- Hypothesis ----------------------------------
Falsifying example: test_returns_input_as_is_if_valid_and_key_is_given(self=<test_fastnumbers.TestFastForceInt at 0xb4f9cbd0>, x=3.402823466e+38)

Push an updated version to the PyPi

I have read the fastnumbers documentation and the README, and my question is still not answered

Proposal: Do not raise an exception on None

Hi @SethMMorton,

It could be possible for fastnumbers to handle None instead of rising and exception?

import fastnumbers
fastnumbers.fast_float(None)
TypeError: float() argument must be a string or a number, not 'NoneType'

Maybe return None?

Improve performance with METH_FASTCALL

Starting in Python 3.7, there is a new way for C functions to define how arguments are passed from python called "fast call" or "vector call" that is supposed to be much faster than the standard method. Taking advantage of this should provide a performance boost for fastnumbers.

Unfortunately, there is as-of-yet no public API for parsing arguments when using this method, so I will have to write one. I will likely heavily borrow from numpy/numpy#15269.

Update documentation and metadata

Describe the bug
Somehow, none of the package data got uploaded to PyPI in version 2.2.0, and the documentation on ReadTheDocs does not match what I would expect.

Expected behavior
All the metadata and documentation should match the code.

Intermittently incorrect return for numbers with very small exponential components.

I have discovered that sometimes an input like '1.5e-312' is returned as 1.0 (clearly incorrect). Interestingly, '1e-312' and '5e-312' return the correct results. This bug is intermittent and difficult to reproduce.

Re-write using C++ and pybind11

While attempting #37 I ran into some troubles with how cumbersome changing things was. Maintenance has become a problem. This is mostly because the code is written in pure C.

When fastnumbers was started, the landscape of packaging and distributing extensions was much poorer than it is today. There were no wheels. Extensions basically had to be compiled by the user when installed every time. I wanted to minimize potential troubles for the user so I chose to write in pure C using the raw Python API. C compilers are more likely to be installed, and compilation typically takes less time than C++. I had considered Cython, but at the time there was no way to define build-time dependencies so users would face problems if they had not pre-installed it on their machine before installing fastnumbers.

Today, things look much better. With the advent of wheels, it basically makes no difference what language or framework I choose. C++ is far more expressive than C, and with templates and OOP I can reduce the maintenance burden. Doing this will make it easier to address problems going forward.

Rename "key" option to "on_fail"

The key option to the fast_* functions is intended to be executed when the input cannot be converted. key is usually something that is executed before the algorithm, not after, so this name has always been a bother. I think on_fail is more descriptive of when the function is executed.

key will remain valid but deprecated/discouraged. If both key and on_fail are given, an error will be raised.

Fastnumbers install on Windows fails

Hey, it's me again! I'm trying to install fastnumbers on a Windows 7 virtualbox and it fails with the following error. I get the same error via easy_install, pip, or setup.py with the source. Is it me?

C:\Python27\fastnumbers-0.5.1>c:\python27\python setup.py install
running install
running bdist_egg
running egg_info
writing fastnumbers.egg-info\PKG-INFO
writing top-level names to fastnumbers.egg-info\top_level.txt
writing dependency_links to fastnumbers.egg-info\dependency_links.txt
reading manifest file 'fastnumbers.egg-info\SOURCES.txt'
reading manifest template 'MANIFEST.in'
no previously-included directories found matching 'tests__pycache__'
writing manifest file 'fastnumbers.egg-info\SOURCES.txt'
installing library code to build\bdist.win32\egg
running install_lib
running build_ext
building 'fastnumbers' extension
creating build
creating build\temp.win32-2.7
creating build\temp.win32-2.7\Release
creating build\temp.win32-2.7\Release\src
C:\Users\w32\AppData\Local\Programs\Common\Microsoft\Visual C++ for Python\9.0\V
C\Bin\cl.exe /c /nologo /Ox /MD /W3 /GS- /DNDEBUG -IC:\Python27\fastnumbers-0.5.
1\include -Ic:\python27\include -Ic:\python27\PC /Tcsrc\fast_atoi.c /Fobuild\tem
p.win32-2.7\Release\src\fast_atoi.obj
fast_atoi.c
c:\python27\fastnumbers-0.5.1\include\fn_bool.h(20) : error C2061: syntax error
: identifier 'Bool'
c:\python27\fastnumbers-0.5.1\include\fn_bool.h(20) : error C2059: syntax error
: ';'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(11) : error C2143: synt
ax error : missing ')' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(11) : error C2081: 'Bo
ol' : name in formal parameter list illegal
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(11) : error C2143: synt
ax error : missing '{' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(11) : error C2143: synt
ax error : missing ';' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(11) : error C2059: synt
ax error : ')'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(12) : error C2143: synt
ax error : missing ')' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(12) : error C2081: 'Bo
ol' : name in formal parameter list illegal
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(12) : error C2143: synt
ax error : missing '{' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(12) : error C2143: synt
ax error : missing ';' before ''
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(12) : error C2059: synt
ax error : ')'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(13) : error C2061: synt
ax error : identifier 'fast_atof_test'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(13) : error C2059: synt
ax error : ';'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(13) : error C2059: synt
ax error : 'type'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(14) : error C2061: synt
ax error : identifier 'fast_atoi_test'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(14) : error C2059: synt
ax error : ';'
C:\Python27\fastnumbers-0.5.1\include\fast_conversions.h(14) : error C2059: synt
ax error : 'type'
src\fast_atoi.c(15) : error C2143: syntax error : missing ')' before ''
src\fast_atoi.c(15) : error C2081: 'Bool' : name in formal parameter list illeg
al
src\fast_atoi.c(15) : error C2143: syntax error : missing '{' before ''
src\fast_atoi.c(15) : error C2143: syntax error : missing ';' before '*'
src\fast_atoi.c(15) : error C2059: syntax error : ')'
src\fast_atoi.c(16) : error C2054: expected '(' to follow 'overflow'
error: command 'C:\Users\w32\AppData\Local\Programs\Common\Microsoft\Vis
ual C++ for Python\9.0\VC\Bin\cl.exe' failed with exit status 2

Add numpy support?

Describe the feature or enhancement

Add support for operating on numpy arrays.

Provide a concrete example of how the feature or enhancement will improve fastnumbers

I'm not 100% if this would be useful... generally, we don't store strings in numpy arrays so I don't know when one would be needing to perform a string to float/int conversion on a numpy array.

It might be useful in pandas, where stringish data is often stored, but pandas has its own very fast conversion functionality, especially when using read_csv, so I'm not sure how much value this would even bring there.

My guess is that if #61 were implemented, it would cover most of the cases where this feature would be needed.

Use fast C++ methods like std::from_chars or fast_float

There is an opportunity for a massive speed bump.

The C++ world alone has about a 10x spread between the slowest string to int/float method (iostream) and the fastest (from_chars). The standard Python int() and float() methods match up with the slowest C++ methods.

I did some benchmarks tailored for a particular application, hence the bytes/second units, but the general magnitudes of the numbers are informative:

I tried fastnumbers and the difference wasn't significant (I could be doing something wrong, I'd love a correction if I am). Even so, the fastnumbers best case promise is only 2x speedup, while even the C standard library offers methods that are significantly faster.

See https://github.com/alugowski/parse-bench for benchmarks

Please strip the shared library

$ file ./work-py27/stage/usr/local/lib/python2.7/site-packages/fastnumbers.so
./work-py27/stage/usr/local/lib/python2.7/site-packages/fastnumbers.so: ELF 64-bit LSB shared object, x86-64, version 1 (FreeBSD), dynamically linked, not stripped

The FreeBSD port always strips it with a separate instruction. It would be better if it would be stripped during build.

Thank you.

Big numbers handling: silencing arbitrary digits beyond least significant bit

Describe the bug

fast_real(3.453e78)

returns

3453000000000000090829207640410620202184021047720495530415184879687805108748288

instead of

3453000000000000000000000000000000000000000000000000000000000000000000000000000

Environment (please complete the following information):

fastnumbers version: 5.0.1 (installed by pip on conda environment)
Python Version: 3.10.11
OS: Windows

Observations

I know that the current behaviour is due to unavoidable numeric representation error, however the result is somewhat "disturbing". IMHO the ideal behaviour should be to round the result to the digit before the least significant bit. It's not a surprise that

math.ulp(3.453e78)

gives

4.113761393303015e+62

which tells us that the last 62 digits of the integer output of fast_real(3.453e78) are, so to say, arbitrary and therefore misleading.

Error: <built-in function isint/isfloat> returned NULL without setting an error

Describe the bug
The following two related errors appeared:
"<built-in function isint> returned NULL without setting an error" and "<built-in function isfloat> returned NULL without setting an error" when running isint('X') / isfloat('X').
The issue happens only in specific situations, but happens consistently when such a situation arises.

Expected behavior
Returns False, and continues with the rest of the program.

Environment (please complete the following information):

fastnumbers version: 3.2.1
Python Version: 3.7
OS: Amazon Linux 2
Compiler (if known): don't know

To Reproduce

import logging
import pandas as pd
from fastnumbers import isfloat, isint

def retrieve(var,dictionary):
    if isint(var):
        return int(var)
    elif isfloat(var):
        return float(var)
    elif var in dictionary:
        return dictionary[var]
    else:
        return var

from flask import Flask
app = Flask(__name__)

@app.route("/1", methods=["POST"])
def project_api_1():
    var_dict = {}
    try:
        variables = ["X", "TestData"]
        *var_list, filename = variables
        csv_file_loc = filename+".csv"
        df = pd.read_csv(csv_file_loc,dtype=str, keep_default_na=False)
        for var in var_list:
            var_dict[var] = list(df[var])
            
        inputvar = 'X'
        inputvar = retrieve(inputvar,var_dict)
        return '', 200
    except Exception as e:
        logging.error(e, exc_info=True)
        return '', 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8003)

Brief description: Upon calling the flask API, the program goes into 'TestData.csv" and imports the column "X". This column contains a list of numbers from 1 to 1048575 (basically filling up the entire column on Excel), and saves it to a dictionary var_dict.

I have the "retrieve" function which, when given a string, checks (hierarchically) if it is an int / float / exists in the dictionary and returns the int / float / dictionary value respectively. Given the value 'X', I would like the function to first of all ascertain "X" is not an int / float, and then return var_dict['X']. However, the isint / isfloat functions both fail to run as expected.

This issue seems to occur only when the size of column "X" in the csv is smaller it works as expected, so it looks like that might be causing an issue, though I'm not sure why. Have tried sizes up to about 500000 and it still works, so the crossover point must be somewhere above that.

Add support for operating on iterables

Describe the feature or enhancement

Add support for conversion on an iterable, either by directly adding that support to existing functions, or providing a new function e.g. map_float or map_try_float. These would behave basically like

map(try_float, some_iterable)

Provide a concrete example of how the feature or enhancement will improve fastnumbers

Every time a function is called in Python, there is some overhead due to memory allocations and whatnot. When operating on a large data set this overhead will start to become a sizable fraction of the net runtime. While it is true that using map() can mitigate this somewhat over standard for-loops or list-comprehensions, it still does not eliminate the problem.

Allowing fastnumbers functions to accept an iterable and then internally loop over the data and return either a list or iterator would circumvent this overhead and provide meaningful speedups for large datasets.

[regression] error: unknown type name 'PyObject'

While trying to update the FreeBSD port to 2.1.0 this new error occurs:

In file included from /usr/ports/devel/py-fastnumbers/work-py27/fastnumbers-2.1.0/include/strings.h:9:
/usr/ports/devel/py-fastnumbers/work-py27/fastnumbers-2.1.0/include/options.h:15:5: error: unknown type name 'PyObject'
    PyObject *retval;
    ^
/usr/ports/devel/py-fastnumbers/work-py27/fastnumbers-2.1.0/include/options.h:16:5: error: unknown type name 'PyObject'
    PyObject *input;
    ^
/usr/ports/devel/py-fastnumbers/work-py27/fastnumbers-2.1.0/include/options.h:17:5: error: unknown type name 'PyObject'
    PyObject *key;
    ^

Speed not better than Python's int/float

I have read the fastnumbers documentation and the README, and my question is still not answered

Hi,

I don't quite see the speed improvement in my own tests.

In [28]: len(numbs)
Out[28]: 1000000

In [29]: numbs[:5]
Out[29]: 
['0.7900414395464864',
 '0.9789330973579582',
 '0.8321431542764068',
 '0.3254459594374661',
 '0.9098654575745327']


In [33]: start_time = time.time()
    ...: for i in numbs:
    ...:     a = float(i)
    ...: print(time.time() - start_time)
    ...: 
0.44566822052001953

In [34]: start_time = time.time()
    ...: for i in numbs:
    ...:     a = fastnumbers.float(i)
    ...: print(time.time() - start_time)
    ...: 
0.5358688831329346

In [36]: %timeit float("3.1939130238")
The slowest run took 25.31 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 5: 140 ns per loop

In [37]: %timeit fastnumbers.float("3.1939130238")
The slowest run took 32.50 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 5: 213 ns per loop

Am I using the package incorrectly?

Missing -lm breaks build on armv7hl

Describe the bug
Build failure on armv7hl

/usr/bin/ld: build/temp.linux-armv8l-3.10/src/numbers.o: in function `_PyFloat_is_Intlike':
/home/iurt/rpmbuild/BUILD/fastnumbers-3.2.1/src/numbers.c:69: undefined reference to `floor'

As the code uses floor() it should set -lm when linking. I guess on other architectures something else is already pulling in -lm so it was not noticed.

Adding extra_link_args=["-lm"]to setup.py fixes it.

Environment (please complete the following information):

fastnumbers version: 3.2.1
Python Version: 3.10
OS: Mageia
Compiler (if known): gcc 11.2

Proposal: change behavior of isfloat function with respect to treatment of strings containing integers

Describe the feature or enhancement
The proposal is to change how isfloat interprets strings. Currently, it has the following behavior:

>>> isfloat("56")
True
>>> isfloat("56.0")
True
>>> isfloat(56)
False
>>> isfloat(56.0)
True

The proposal is to change the behavior to the following:

>>> isfloat("56")
False
>>> isfloat("56.0")
True
>>> isfloat(56)
False
>>> isfloat(56.0)
True

Provide a concrete example of how the feature or enhancement will improve fastnumbers
isfloat is inconsistent. For strings that look like integers, it returns True, but for numeric types it is strict. In fact, isfloat behaves identically to isreal for string input. Users wanting to detect if string input is actually a float an not an int cannot in a single call.

The rational behind this was that for string input, isfloat would return True if fast_float would successfully convert to a float. The intention was to introduce symmetry between the functions, but unfortunately this was not achieved because of how the function behaves with numeric input.

Really, the current behavior of isfloat is acting like isreal.

A successful introduction will have a deprecation schedule, so that users are not completely caught off-guard. At the very least, this needs to be advertised at the top of the README for a while.

NOTE: This was brought up as part of #37 by @argenisleon.

Support for unicode digit/numeric characters in Python 3.7.

Minimum, Complete, Verifiable Example

>>> import fastnumbers
>>> fastnumbers.fast_real('⑦', raise_on_invalid=True)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: '⑦'

Error message, Traceback, Desired behavior, Suggestion, Request, or Question

This works perfectly fine in Python <= 3.6, but fails in Python 3.7. I have traced it to the use of _PyUnicode_TransformDecimalAndSpaceToASCII, which in Python <= 3.6 ignores characters outside the ASCII range that are non-decimal, but in Python 3.7 converts them to the "?" character. This breaks the assumption within fastnumbers that a unicode digit/numeral would be left as-is.

It think it is time for fastnumbers to implement this functionality itself.

Drop support for Python 2.7 and Python 3.4

Describe the feature or enhancement
Remove support for Python 2.7 and Python 3.4, in all of

Provide a concrete example of how the feature or enhancement will improve fastnumbers

The fastnumbers codebase contains many #ifdefs for special Python 2.7 handling, and in some cases also Python 3.4 handling. It is challenging to read and even more challenging to maintain. The EOL for these versions are early 2020 and early 2019, respectively.

I will keep the fastnumbers 2.X branch as "long term support" for Python 2.7 and Python 3.4 and back-port bug fixes to that branch, but new features will not be supported.

Would you be willing to submit a Pull Request for this feature?

PRs are planned 😸

Proposal: change behavior of isfloat with respect to treatment of float("nan")

Is there any param in is_float to check for nan and return False?

I am trying:

x = float("nan")
isfloat(x, allow_nan=False)
True

Fast Numbers on its own isinstance()

I am not sure if it's worth looking into because when importing fastnumbers by simply stating: import fastnumbers An error does not occur, but...

This code causes an error (Python 3.63 windows 10 64bit):

from fastnumbers import *

x = 1

if isinstance(x,int):
    print ("it's an integer")

the error is:

if isinstance(x,int):
TypeError: isinstance() arg 2 must be a type or tuple of types

Segmentation fault on isfloat()

Hello,
I was using fastnumers.isfloat() to know is a string is a float or not. The string format was like "-0.353" most of the time. I used the function on a tons of data. I coud not spoted the string that made the segfault.
As there is a safe_float function I was wondering if this is normal or not.

Hopping this might help.
D.

Nov  5 16:17:54 (none) kernel: [7791607.024856] python[26864]: segfault at 7f4e52560050 ip 00007f4e5373ae42 sp 00007fff79343ad0 error 4 in fastnumbers.cpython-33m.so[7f4e53739000+4000]
Nov  5 16:18:30 (none) kernel: [7791642.889630] python[26905]: segfault at 7f7286bf9050 ip 00007f7287d56e42 sp 00007fffe251bba0 error 4 in fastnumbers.cpython-33m.so[7f7287d55000+4000]

Integrate with numpy and pandas

Since floating point numbers are often used in large datasets and that is where speed is of the utmost importance, would it make sense to integrate this as a drop-in replacement for use in numpy and as a result, also in Pandas?

Although there are other projects to speed up Pandas, they tend not to be stable or mature enough yet to use broadly. If this could approximately double the speed of reading and formatting floats, it would be very useful but it would have to work out-of-the-box with these other packages.

Does it also speed up float comparisons?

What do you think?

fatal error: Python.h: No such file or directory

I receive this error when installing fastnumbers on a raspberry pi 3. Prior to installing I updated "sudo apt-get update" and then "sudo apt-get dist-upgrade", then "sudo rip-update" and reboot.

I then attempted to install fastnumbers. Thank you

 $ sudo pip install fastnumbers
Downloading/unpacking fastnumbers
  Downloading fastnumbers-1.0.0.zip (64kB): 64kB downloaded
  Running setup.py (path:/tmp/pip-build-RJWObW/fastnumbers/setup.py) egg_info for package fastnumbers
    
    warning: no previously-included files matching '*.py[cod]' found anywhere in distribution
    warning: no previously-included files matching '__pycache__' found anywhere in distribution
    warning: no previously-included files matching '*.so' found anywhere in distribution
Installing collected packages: fastnumbers
  Running setup.py install for fastnumbers
    building 'fastnumbers' extension
    arm-linux-gnueabihf-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -fno-strict-aliasing -D_FORTIFY_SOURCE=2 -g -fstack-protector-strong -Wformat -Werror=format-security -fPIC -I/tmp/pip-build-RJWObW/fastnumbers/include -I/usr/include/python2.7 -c src/parse_integer_from_string.c -o build/temp.linux-armv7l-2.7/src/parse_integer_from_string.o
    In file included from src/parse_integer_from_string.c:3:0:
    /tmp/pip-build-RJWObW/fastnumbers/include/parsing.h:4:20: fatal error: Python.h: No such file or directory
     #include <Python.h>
                        ^
    compilation terminated.
    error: command 'arm-linux-gnueabihf-gcc' failed with exit status 1
    Complete output from command /usr/bin/python -c "import setuptools, tokenize;__file__='/tmp/pip-build-RJWObW/fastnumbers/setup.py';exec(compile(getattr(tokenize, 'open', open)(__file__).read().replace('\r\n', '\n'), __file__, 'exec'))" install --record /tmp/pip-KjuPQN-record/install-record.txt --single-version-externally-managed --compile:
    running install

running build

running build_ext

building 'fastnumbers' extension

creating build

creating build/temp.linux-armv7l-2.7

creating build/temp.linux-armv7l-2.7/src

arm-linux-gnueabihf-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -fno-strict-aliasing -D_FORTIFY_SOURCE=2 -g -fstack-protector-strong -Wformat -Werror=format-security -fPIC -I/tmp/pip-build-RJWObW/fastnumbers/include -I/usr/include/python2.7 -c src/parse_integer_from_string.c -o build/temp.linux-armv7l-2.7/src/parse_integer_from_string.o

In file included from src/parse_integer_from_string.c:3:0:

/tmp/pip-build-RJWObW/fastnumbers/include/parsing.h:4:20: fatal error: Python.h: No such file or directory

 #include <Python.h>

                    ^

compilation terminated.

error: command 'arm-linux-gnueabihf-gcc' failed with exit status 1

----------------------------------------
Cleaning up...
Command /usr/bin/python -c "import setuptools, tokenize;__file__='/tmp/pip-build-RJWObW/fastnumbers/setup.py';exec(compile(getattr(tokenize, 'open', open)(__file__).read().replace('\r\n', '\n'), __file__, 'exec'))" install --record /tmp/pip-KjuPQN-record/install-record.txt --single-version-externally-managed --compile failed with error code 1 in /tmp/pip-build-RJWObW/fastnumbers
Storing debug log for failure in /root/.pip/pip.log

Broken 3.2.0 installation

See pypa/cibuildwheel#902.

Because GitHub actions doesn't let me restart just one job, the fact that macos failed cratered my ability to deploy all platforms. Linux got installed but Windows and macos did not.

When the linked issue is resolved I will re-deploy as 3.2.1.

Add support to release Linux aarch64 wheels

Problem

On aarch64, ‘pip install fastnumbers’ builds the wheels from source code and then installs it. It requires the user to have a development environment installed on his system. Also, it takes some time to build the wheels than downloading and extracting the wheels from pypi.

Resolution

On aarch64, ‘pip install fastnumbers’ should download the wheels from pypi

@SethMMorton Please let me know your interest in releasing aarch64 wheels. I can help in this.

[new feature] priority of conversion?

Request

Is there a way if the input can be parsed as int just return as int, otherwise return as float, then as string.

Possible segfault

I'm new to python and debugging things, but I seem to have come across a segfault in fastnumbers. I'm using natsort in my python code, and natsort recommended that I install fastnumbers, so I did. Now on rare occasions my code crashes and I can't figure out why. Unfortunately my code is very long and the file that crashes it is huge. However, here is the crash and backtrace from gdb:

Program received signal SIGSEGV, Segmentation fault.
fast_atoi (p=0xac980034 <error: Cannot access memory at address 0xac980034>, error=0xbfffcc26, overflow=0xbfffcc27) at src/fast_atoi.c:24
24 src/fast_atoi.c: No such file or directory.
(gdb) bt
#0 fast_atoi (p=0xac980034 <error: Cannot access memory at address 0xac980034>, error=0xbfffcc26, overflow=0xbfffcc27) at src/fast_atoi.c:24
#1 0xb01266f8 in fastnumbers_fast_int (self=0x0, args=0xadfc944c, kwargs=0x0) at src/fastnumbers.c:209
#2 0x0810a1bd in PyEval_EvalFrameEx ()
#3 0x08108dbd in PyEval_EvalCodeEx ()
#4 0x0810b975 in PyEval_EvalFrameEx ()
#5 0x0812299d in ?? ()
#6 0x08193e7c in ?? ()
#7 0x08100162 in PyObject_CallFunctionObjArgs ()
#8 0x080ef072 in ?? ()
#9 0x081743d2 in ?? ()
#10 0x0810f286 in PyEval_EvalFrameEx ()
#11 0x08108dbd in PyEval_EvalCodeEx ()
#12 0x0810a86e in PyEval_EvalFrameEx ()
#13 0x0812299d in ?? ()
#14 0x081430ec in ?? ()
#15 0x08111141 in PyEval_CallObjectWithKeywords ()
#16 0xafeff012 in wxPyCallback::EventThunker(wxEvent&) () from /usr/lib/python2.7/dist-packages/wx-2.8-gtk2-unicode/wx/core.so
#17 0xaf92d033 in wxAppConsole::HandleEvent(wxEvtHandler_, void (wxEvtHandler::_)(wxEvent&), wxEvent&) const () from /usr/lib/i386-linux-gnu/libwx_baseu-2.8.so.0
#18 0xaf9c1028 in wxEvtHandler::ProcessEventIfMatches(wxEventTableEntryBase const&, wxEvtHandler*, wxEvent&) () from /usr/lib/i386-linux-gnu/libwx_baseu-2.8.so.0
#19 0xaf9c1404 in wxEvtHandler::SearchDynamicEventTable(wxEvent&) () from /usr/lib/i386-linux-gnu/libwx_baseu-2.8.so.0
#20 0xaf9c14de in wxEvtHandler::ProcessEvent(wxEvent&) () from /usr/lib/i386-linux-gnu/libwx_baseu-2.8.so.0
#21 0xafbe2c96 in ?? () from /usr/lib/i386-linux-gnu/libwx_gtk2u_core-2.8.so.0
#22 0xaf2bf557 in g_cclosure_marshal_VOID__VOIDv () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#23 0xaf2bdabf in ?? () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#24 0xaf2d77a5 in g_signal_emit_valist () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#25 0xaf2d8075 in g_signal_emit () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#26 0xaf46a261 in gtk_button_clicked () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#27 0xaf46b411 in ?? () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#28 0xaf2bf537 in g_cclosure_marshal_VOID__VOIDv () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#29 0xaf2bc332 in ?? () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#30 0xaf2bdabf in ?? () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#31 0xaf2d77a5 in g_signal_emit_valist () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#32 0xaf2d8075 in g_signal_emit () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#33 0xaf46a191 in gtk_button_released () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0

---Type to continue, or q to quit---
#34 0xaf46a1d4 in ?? () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#35 0xaf51742c in ?? () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#36 0xaf2bc3e4 in ?? () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#37 0xaf2bd89b in g_closure_invoke () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#38 0xaf2cf791 in ?? () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#39 0xaf2d7a02 in g_signal_emit_valist () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#40 0xaf2d8075 in g_signal_emit () from /usr/lib/i386-linux-gnu/libgobject-2.0.so.0
#41 0xaf637aac in ?? () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#42 0xaf5157c9 in gtk_propagate_event () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#43 0xaf515cdd in gtk_main_do_event () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#44 0xaf3891c9 in ?? () from /usr/lib/i386-linux-gnu/libgdk-x11-2.0.so.0
#45 0xaf1ced64 in g_main_context_dispatch () from /lib/i386-linux-gnu/libglib-2.0.so.0
#46 0xaf1cf089 in ?? () from /lib/i386-linux-gnu/libglib-2.0.so.0
#47 0xaf1cf439 in g_main_loop_run () from /lib/i386-linux-gnu/libglib-2.0.so.0
#48 0xaf5149a5 in gtk_main () from /usr/lib/i386-linux-gnu/libgtk-x11-2.0.so.0
#49 0xafb97fc3 in wxEventLoop::Run() () from /usr/lib/i386-linux-gnu/libwx_gtk2u_core-2.8.so.0
#50 0xafc249c9 in wxAppBase::MainLoop() () from /usr/lib/i386-linux-gnu/libwx_gtk2u_core-2.8.so.0
#51 0xaff03451 in wxPyApp::MainLoop() () from /usr/lib/python2.7/dist-packages/wx-2.8-gtk2-unicode/wx/core.so
#52 0xaff2bf61 in ?? () from /usr/lib/python2.7/dist-packages/wx-2.8-gtk2-unicode/wx/core.so
#53 0x0810ddcd in PyEval_EvalFrameEx ()
#54 0x0812299d in ?? ()
#55 0x081430ec in ?? ()
#56 0x0810ab8f in PyEval_EvalFrameEx ()
#57 0x0810a6e3 in PyEval_EvalFrameEx ()
#58 0x0810a6e3 in PyEval_EvalFrameEx ()
#59 0x08108dbd in PyEval_EvalCodeEx ()
#60 0x0813dacc in ?? ()
#61 0x08135898 in PyRun_FileExFlags ()
#62 0x08134b05 in PyRun_SimpleFileExFlags ()
#63 0x080dd500 in Py_Main ()
#64 0x080dcf5b in main ()

I think it traces back to fastnumbers. Thanks for taking a look at this, and sorry if I haven't provided enough information.

Make "coerce" of fast_real apply to both string and numeric input

Currently, if a string with an int-like float (i.e. '4.0') is given to fast_real, it will be returned as an int instead of a float. The user has the option to toggle this behavior for numeric input with the coerce option.

I will make the coerce option apply to both string and numeric input, and change the default to True; the default is currently False, but since it only applies to numbers currently and the option was only recently added I feel like making it True will be the least invasive for backwards-compatibility purposes.

sethmmorton / fastnumbers Goto Github PK

fastnumbers's People

Contributors

Stargazers

Watchers

Forkers

fastnumbers's Issues

Minimum, Complete, Verifiable Example

Error message, Traceback, Desired behavior, Suggestion, Request, or Question

Observations

Minimum, Complete, Verifiable Example

Error message, Traceback, Desired behavior, Suggestion, Request, or Question

Problem

Resolution

Request

Recommend Projects

Recommend Topics

Recommend Org

Jobs