commit: 8901b5e61974c1e6df76de1cd86b72f417ee4221 Author: Marek Szuba <marecki <AT> gentoo <DOT> org> AuthorDate: Fri May 14 21:22:11 2021 +0000 Commit: Marek Szuba <marecki <AT> gentoo <DOT> org> CommitDate: Fri May 14 21:39:01 2021 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=8901b5e6
dev-python/numpy: support python3_10 Needed one commit to be backported from master. Now it builds, tests and installs fine. Signed-off-by: Marek Szuba <marecki <AT> gentoo.org> .../files/numpy-1.20.3-float-hashing-py310.patch | 129 +++++++++++++++++++++ dev-python/numpy/numpy-1.20.3.ebuild | 3 +- 2 files changed, 131 insertions(+), 1 deletion(-) diff --git a/dev-python/numpy/files/numpy-1.20.3-float-hashing-py310.patch b/dev-python/numpy/files/numpy-1.20.3-float-hashing-py310.patch new file mode 100644 index 00000000000..f3b2ea3ef0c --- /dev/null +++ b/dev-python/numpy/files/numpy-1.20.3-float-hashing-py310.patch @@ -0,0 +1,129 @@ +From ad2a73c18dcff95d844c382c94ab7f73b5571cf3 Mon Sep 17 00:00:00 2001 +From: Sebastian Berg <[email protected]> +Date: Tue, 4 May 2021 17:43:26 -0500 +Subject: [PATCH] MAINT: Adjust NumPy float hashing to Python's slightly + changed hash + +This is necessary, since we use the Python double hash and the +semi-private function to calculate it in Python has a new signature +to return the identity-hash when the value is NaN. + +closes gh-18833, gh-18907 +--- + numpy/core/src/common/npy_pycompat.h | 16 ++++++++++ + numpy/core/src/multiarray/scalartypes.c.src | 13 ++++---- + numpy/core/tests/test_scalarmath.py | 34 +++++++++++++++++++++ + 3 files changed, 57 insertions(+), 6 deletions(-) + +diff --git a/numpy/core/src/common/npy_pycompat.h b/numpy/core/src/common/npy_pycompat.h +index aa0b5c1224d..9e94a971090 100644 +--- a/numpy/core/src/common/npy_pycompat.h ++++ b/numpy/core/src/common/npy_pycompat.h +@@ -3,4 +3,20 @@ + + #include "numpy/npy_3kcompat.h" + ++ ++/* ++ * In Python 3.10a7 (or b1), python started using the identity for the hash ++ * when a value is NaN. See https://bugs.python.org/issue43475 ++ */ ++#if PY_VERSION_HEX > 0x030a00a6 ++#define Npy_HashDouble _Py_HashDouble ++#else ++static NPY_INLINE Py_hash_t ++Npy_HashDouble(PyObject *NPY_UNUSED(identity), double val) ++{ ++ return _Py_HashDouble(val); ++} ++#endif ++ ++ + #endif /* _NPY_COMPAT_H_ */ +diff --git a/numpy/core/src/multiarray/scalartypes.c.src b/numpy/core/src/multiarray/scalartypes.c.src +index a001500b0a9..9930f7791d6 100644 +--- a/numpy/core/src/multiarray/scalartypes.c.src ++++ b/numpy/core/src/multiarray/scalartypes.c.src +@@ -3172,7 +3172,7 @@ static npy_hash_t + static npy_hash_t + @lname@_arrtype_hash(PyObject *obj) + { +- return _Py_HashDouble((double) PyArrayScalar_VAL(obj, @name@)); ++ return Npy_HashDouble(obj, (double)PyArrayScalar_VAL(obj, @name@)); + } + + /* borrowed from complex_hash */ +@@ -3180,14 +3180,14 @@ static npy_hash_t + c@lname@_arrtype_hash(PyObject *obj) + { + npy_hash_t hashreal, hashimag, combined; +- hashreal = _Py_HashDouble((double) +- PyArrayScalar_VAL(obj, C@name@).real); ++ hashreal = Npy_HashDouble( ++ obj, (double)PyArrayScalar_VAL(obj, C@name@).real); + + if (hashreal == -1) { + return -1; + } +- hashimag = _Py_HashDouble((double) +- PyArrayScalar_VAL(obj, C@name@).imag); ++ hashimag = Npy_HashDouble( ++ obj, (double)PyArrayScalar_VAL(obj, C@name@).imag); + if (hashimag == -1) { + return -1; + } +@@ -3202,7 +3202,8 @@ c@lname@_arrtype_hash(PyObject *obj) + static npy_hash_t + half_arrtype_hash(PyObject *obj) + { +- return _Py_HashDouble(npy_half_to_double(PyArrayScalar_VAL(obj, Half))); ++ return Npy_HashDouble( ++ obj, npy_half_to_double(PyArrayScalar_VAL(obj, Half))); + } + + static npy_hash_t +diff --git a/numpy/core/tests/test_scalarmath.py b/numpy/core/tests/test_scalarmath.py +index d91b4a39146..09a734284a7 100644 +--- a/numpy/core/tests/test_scalarmath.py ++++ b/numpy/core/tests/test_scalarmath.py +@@ -712,6 +712,40 @@ def test_shift_all_bits(self, type_code, op): + assert_equal(res_arr, res_scl) + + ++class TestHash: ++ @pytest.mark.parametrize("type_code", np.typecodes['AllInteger']) ++ def test_integer_hashes(self, type_code): ++ scalar = np.dtype(type_code).type ++ for i in range(128): ++ assert hash(i) == hash(scalar(i)) ++ ++ @pytest.mark.parametrize("type_code", np.typecodes['AllFloat']) ++ def test_float_and_complex_hashes(self, type_code): ++ scalar = np.dtype(type_code).type ++ for val in [np.pi, np.inf, 3, 6.]: ++ numpy_val = scalar(val) ++ # Cast back to Python, in case the NumPy scalar has less precision ++ if numpy_val.dtype.kind == 'c': ++ val = complex(numpy_val) ++ else: ++ val = float(numpy_val) ++ assert val == numpy_val ++ print(repr(numpy_val), repr(val)) ++ assert hash(val) == hash(numpy_val) ++ ++ if hash(float(np.nan)) != hash(float(np.nan)): ++ # If Python distinguises different NaNs we do so too (gh-18833) ++ assert hash(scalar(np.nan)) != hash(scalar(np.nan)) ++ ++ @pytest.mark.parametrize("type_code", np.typecodes['Complex']) ++ def test_complex_hashes(self, type_code): ++ # Test some complex valued hashes specifically: ++ scalar = np.dtype(type_code).type ++ for val in [np.pi+1j, np.inf-3j, 3j, 6.+1j]: ++ numpy_val = scalar(val) ++ assert hash(complex(numpy_val)) == hash(numpy_val) ++ ++ + @contextlib.contextmanager + def recursionlimit(n): + o = sys.getrecursionlimit() diff --git a/dev-python/numpy/numpy-1.20.3.ebuild b/dev-python/numpy/numpy-1.20.3.ebuild index 10bbd07b87e..5b772a58a6f 100644 --- a/dev-python/numpy/numpy-1.20.3.ebuild +++ b/dev-python/numpy/numpy-1.20.3.ebuild @@ -3,7 +3,7 @@ EAPI=7 -PYTHON_COMPAT=( python3_{7..9} ) +PYTHON_COMPAT=( python3_{7..10} ) PYTHON_REQ_USE="threads(+)" FORTRAN_NEEDED=lapack @@ -46,6 +46,7 @@ BDEPEND=" PATCHES=( "${FILESDIR}"/numpy-1.20.1-no-hardcode-blasv2.patch "${FILESDIR}"/numpy-1.20.2-fix-ccompiler-tests.patch + "${FILESDIR}"/numpy-1.20.3-float-hashing-py310.patch ) distutils_enable_tests pytest
