From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id BBB0C1581C1 for ; Wed, 10 Jul 2024 10:53:13 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 09074E29F8; Wed, 10 Jul 2024 10:53:13 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id D9C9EE29F8 for ; Wed, 10 Jul 2024 10:53:12 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id DD504342FA2 for ; Wed, 10 Jul 2024 10:53:11 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 3F5B11DD0 for ; Wed, 10 Jul 2024 10:53:10 +0000 (UTC) From: "Michał Górny" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Michał Górny" Message-ID: <1720608783.edf6876c43828c4321e0f9b70398f4cc8f51da55.mgorny@gentoo> Subject: [gentoo-commits] repo/gentoo:master commit in: dev-python/tables/files/, dev-python/tables/ X-VCS-Repository: repo/gentoo X-VCS-Files: dev-python/tables/files/tables-3.9.2-numpy-2.patch dev-python/tables/tables-3.9.2-r1.ebuild X-VCS-Directories: dev-python/tables/files/ dev-python/tables/ X-VCS-Committer: mgorny X-VCS-Committer-Name: Michał Górny X-VCS-Revision: edf6876c43828c4321e0f9b70398f4cc8f51da55 X-VCS-Branch: master Date: Wed, 10 Jul 2024 10:53:10 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 455423ec-2065-4be2-ad2b-b53346a835cd X-Archives-Hash: 1330c3aa320f3bec5f4f8a6bbb9243e0 commit: edf6876c43828c4321e0f9b70398f4cc8f51da55 Author: Michał Górny gentoo org> AuthorDate: Wed Jul 10 09:51:50 2024 +0000 Commit: Michał Górny gentoo org> CommitDate: Wed Jul 10 10:53:03 2024 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=edf6876c dev-python/tables: Add a patch for numpy-2 support Signed-off-by: Michał Górny gentoo.org> dev-python/tables/files/tables-3.9.2-numpy-2.patch | 264 +++++++++++++++++++++ dev-python/tables/tables-3.9.2-r1.ebuild | 80 +++++++ 2 files changed, 344 insertions(+) diff --git a/dev-python/tables/files/tables-3.9.2-numpy-2.patch b/dev-python/tables/files/tables-3.9.2-numpy-2.patch new file mode 100644 index 000000000000..a3d56d13f1a8 --- /dev/null +++ b/dev-python/tables/files/tables-3.9.2-numpy-2.patch @@ -0,0 +1,264 @@ +diff --git a/setup.py b/setup.py +index 48dc6ca5..e8957c1f 100755 +--- a/setup.py ++++ b/setup.py +@@ -736,7 +736,10 @@ if __name__ == "__main__": + + # ----------------------------------------------------------------- + +- def_macros = [("NDEBUG", 1)] ++ def_macros = [ ++ ("NDEBUG", 1), ++ ("NPY_TARGET_VERSION", "NPY_1_20_API_VERSION"), ++ ] + + # Define macros for Windows platform + if os.name == "nt": +diff --git a/src/utils.c b/src/utils.c +index 15fce02d..b28dbc90 100644 +--- a/src/utils.c ++++ b/src/utils.c +@@ -765,8 +765,8 @@ hid_t create_ieee_complex64(const char *byteorder) { + return float_id; + } + +- H5Tinsert(complex_id, "r", HOFFSET(npy_complex64, real), float_id); +- H5Tinsert(complex_id, "i", HOFFSET(npy_complex64, imag), float_id); ++ H5Tinsert(complex_id, "r", 0, float_id); ++ H5Tinsert(complex_id, "i", 4, float_id); + H5Tclose(float_id); + return complex_id; + } +@@ -790,8 +790,8 @@ hid_t create_ieee_complex128(const char *byteorder) { + return float_id; + } + +- H5Tinsert(complex_id, "r", HOFFSET(npy_complex128, real), float_id); +- H5Tinsert(complex_id, "i", HOFFSET(npy_complex128, imag), float_id); ++ H5Tinsert(complex_id, "r", 0, float_id); ++ H5Tinsert(complex_id, "i", 8, float_id); + H5Tclose(float_id); + return complex_id; + } +@@ -822,8 +822,8 @@ hid_t create_ieee_complex192(const char *byteorder) { + return err; + } + +- H5Tinsert(complex_id, "r", HOFFSET(npy_complex192, real), float_id); +- H5Tinsert(complex_id, "i", HOFFSET(npy_complex192, imag), float_id); ++ H5Tinsert(complex_id, "r", 0, float_id); ++ H5Tinsert(complex_id, "i", 12, float_id); + H5Tclose(float_id); + return complex_id; + } +@@ -854,8 +854,8 @@ hid_t create_ieee_complex256(const char *byteorder) { + return err; + } + +- H5Tinsert(complex_id, "r", HOFFSET(npy_complex256, real), float_id); +- H5Tinsert(complex_id, "i", HOFFSET(npy_complex256, imag), float_id); ++ H5Tinsert(complex_id, "r", 0, float_id); ++ H5Tinsert(complex_id, "i", 16, float_id); + H5Tclose(float_id); + return complex_id; + } +diff --git a/tables/atom.py b/tables/atom.py +index 56ab6423..5d4fba2b 100644 +--- a/tables/atom.py ++++ b/tables/atom.py +@@ -276,15 +276,15 @@ class Atom(metaclass=MetaAtom): + >>> atom1 = StringAtom(itemsize=10) # same as ``atom2`` + >>> atom2 = Atom.from_kind('string', 10) # same as ``atom1`` + >>> atom3 = IntAtom() +- >>> atom1 == 'foo' ++ >>> bool(atom1 == 'foo') + False +- >>> atom1 == atom2 ++ >>> bool(atom1 == atom2) + True +- >>> atom2 != atom1 ++ >>> bool(atom2 != atom1) + False +- >>> atom1 == atom3 ++ >>> bool(atom1 == atom3) + False +- >>> atom3 != atom2 ++ >>> bool(atom3 != atom2) + True + + """ +diff --git a/tables/index.py b/tables/index.py +index e8c8caf7..28ff37e2 100644 +--- a/tables/index.py ++++ b/tables/index.py +@@ -581,7 +581,8 @@ class Index(NotLoggedMixin, Group, indexesextension.Index): + # Add a second offset in this case + # First normalize the number of rows + offset2 = (nrow % self.nslicesblock) * slicesize // lbucket +- idx += offset2 ++ assert offset2 < 2**(indsize*8) ++ idx += np.asarray(offset2).astype(idx.dtype) + # Add the last row at the beginning of arr & idx (if needed) + if (indsize == 8 and nelementsILR > 0): + # It is possible that the values in LR are already sorted. +@@ -622,11 +623,11 @@ class Index(NotLoggedMixin, Group, indexesextension.Index): + show_stats("Entering final_idx32", tref) + # Do an upcast first in order to add the offset. + idx = idx.astype('uint64') +- idx += offset ++ idx += np.asarray(offset).astype(idx.dtype) + # The next partition is valid up to table sizes of + # 2**30 * 2**18 = 2**48 bytes, that is, 256 Tera-elements, + # which should be a safe figure, at least for a while. +- idx //= self.lbucket ++ idx //= np.asarray(self.lbucket).astype(idx.dtype) + # After the division, we can downsize the indexes to 'uint32' + idx = idx.astype('uint32') + if profile: +@@ -2002,7 +2003,7 @@ class Index(NotLoggedMixin, Group, indexesextension.Index): + else: + self.indicesLR._read_index_slice(start, stop, idx) + if indsize == 8: +- idx //= lbucket ++ idx //= np.asarray(lbucket).astype(idx.dtype) + elif indsize == 2: + # The chunkmap size cannot be never larger than 'int_' + idx = idx.astype("int_") +diff --git a/tables/tests/common.py b/tables/tests/common.py +index 31378a88..1992f39a 100644 +--- a/tables/tests/common.py ++++ b/tables/tests/common.py +@@ -205,7 +205,7 @@ def allequal(a, b, flavor="numpy"): + return result + + +-def areArraysEqual(arr1, arr2): ++def areArraysEqual(arr1, arr2, *, check_type=True): + """Are both `arr1` and `arr2` equal arrays? + + Arguments can be regular NumPy arrays, chararray arrays or +@@ -217,8 +217,8 @@ def areArraysEqual(arr1, arr2): + t1 = type(arr1) + t2 = type(arr2) + +- if not ((hasattr(arr1, 'dtype') and arr1.dtype == arr2.dtype) or +- issubclass(t1, t2) or issubclass(t2, t1)): ++ if check_type and not ((hasattr(arr1, 'dtype') and arr1.dtype == arr2.dtype) or ++ issubclass(t1, t2) or issubclass(t2, t1)): + return False + + return np.all(arr1 == arr2) +diff --git a/tables/tests/test_expression.py b/tables/tests/test_expression.py +index 018d4208..d9c0e990 100644 +--- a/tables/tests/test_expression.py ++++ b/tables/tests/test_expression.py +@@ -265,9 +265,12 @@ class MixedContainersTestCase(common.TempFileMixin, common.PyTablesTestCase): + if common.verbose: + print("Computed expression:", repr(r1), r1.dtype) + print("Should look like:", repr(r2), r2.dtype) +- self.assertTrue( +- r1.shape == r2.shape and r1.dtype == r2.dtype and r1 == r2, +- "Evaluate is returning a wrong value.") ++ msg = f"Evaluate is returning a wrong value: {expr_str}\n{r1=}\n{r2=}" ++ self.assertEqual(r1.shape, r2.shape, msg=msg) ++ # In something like 2 * np.in16(3) + np.int16(2) the result is still a ++ # np.int16 in NumPy 2.0, so we shouldn't actually check this: ++ # self.assertEqual(r1.dtype, r2.dtype, msg=msg) ++ self.assertEqual(r1, r2, msg=msg) + + def test01a_out(self): + """Checking expressions with mixed objects (`out` param)""" +@@ -305,8 +308,9 @@ class MixedContainersTestCase(common.TempFileMixin, common.PyTablesTestCase): + if common.verbose: + print("Computed expression:", repr(r1), r1.dtype) + print("Should look like:", repr(r2), r2.dtype) +- self.assertTrue(common.areArraysEqual(r1, r2), +- "Evaluate is returning a wrong value.") ++ msg = f"Evaluate is returning a wrong value: {expr_str}\n{r1=}\n{r2=}" ++ # On NumPy 2 type promotion is different so don't check type here ++ self.assertTrue(common.areArraysEqual(r1, r2, check_type=False), msg=msg) + + def test02a_sss(self): + """Checking mixed objects and start, stop, step (I)""" +diff --git a/tables/tests/test_indexvalues.py b/tables/tests/test_indexvalues.py +index fac33af8..85ca38c3 100644 +--- a/tables/tests/test_indexvalues.py ++++ b/tables/tests/test_indexvalues.py +@@ -2296,6 +2296,11 @@ class SelectValuesTestCase(common.TempFileMixin, common.PyTablesTestCase): + self.assertFalse(t1var3.index.dirty) + self.assertFalse(t1var4.index.dirty) + ++ # TODO: IT IS DIRTY BECAUSE THIS FIXES THINGS FOR FINSV2aTestCase, ++ # which otherwise fails a test a few lines below! ++ for col in table1.colinstances.values(): ++ col.reindex() ++ + # Do some selections and check the results + # First selection: string + # Convert the limits to the appropriate type +@@ -2318,11 +2323,15 @@ class SelectValuesTestCase(common.TempFileMixin, common.PyTablesTestCase): + # Second selection: bool + results1 = [p["var2"] for p in table1.where('t1var2 == True')] + results2 = [p["var2"] for p in table2 if p["var2"] is True] +- if common.verbose: +- print("Length results:", len(results1)) +- print("Should be:", len(results2)) +- self.assertEqual(len(results1), len(results2)) +- self.assertEqual(results1, results2) ++ t2var1_vals = [p["var1"] for p in table2] ++ t2var2_vals = [p["var2"] for p in table2] ++ msg = ( ++ f"Incorrect results for t1var2[n] == True where\n" ++ f"t2var1_vals={repr(t2var1_vals)}\nt2var2_vals={repr(t2var2_vals)}\n" ++ f"\n{results1=}\n{results2=}" ++ ) ++ self.assertEqual(len(results1), len(results2), msg=msg) ++ self.assertEqual(results1, results2, msg=msg) + + # Third selection: int + # Convert the limits to the appropriate type +@@ -3228,7 +3237,9 @@ class LastRowReuseBuffers(common.PyTablesTestCase): + + + normal_tests = ( +- "SV1aTestCase", "SV2aTestCase", "SV3aTestCase", ++ "SV1aTestCase", ++ "SV2aTestCase", ++ "SV3aTestCase", + ) + + heavy_tests = ( +diff --git a/tables/utils.py b/tables/utils.py +index e11e5ba7..7d786e32 100644 +--- a/tables/utils.py ++++ b/tables/utils.py +@@ -25,6 +25,11 @@ byteorders = { + SizeType = np.int64 + + ++copy_if_needed = ( ++ None if np.lib.NumpyVersion(np.__version__) >= "2.0.0" else False ++) ++ ++ + def correct_byteorder(ptype, byteorder): + """Fix the byteorder depending on the PyTables types.""" + +@@ -78,7 +83,7 @@ def idx2long(index): + # with atom from a generic python type. If copy is stated as True, it + # is assured that it will return a copy of the object and never the same + # object or a new one sharing the same memory. +-def convert_to_np_atom(arr, atom, copy=False): ++def convert_to_np_atom(arr, atom, copy=copy_if_needed): + """Convert a generic object into a NumPy object compliant with atom.""" + + # First, convert the object into a NumPy array +@@ -112,7 +117,7 @@ def convert_to_np_atom2(object, atom): + + # Check whether the object needs to be copied to make the operation + # safe to in-place conversion. +- copy = atom.type in ['time64'] ++ copy = True if atom.type in ['time64'] else copy_if_needed + nparr = convert_to_np_atom(object, atom, copy) + # Finally, check the byteorder and change it if needed + byteorder = byteorders[nparr.dtype.byteorder] diff --git a/dev-python/tables/tables-3.9.2-r1.ebuild b/dev-python/tables/tables-3.9.2-r1.ebuild new file mode 100644 index 000000000000..bdbc563361d3 --- /dev/null +++ b/dev-python/tables/tables-3.9.2-r1.ebuild @@ -0,0 +1,80 @@ +# Copyright 1999-2024 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=8 + +DISTUTILS_EXT=1 +DISTUTILS_USE_PEP517=setuptools +PYTHON_COMPAT=( pypy3 python3_{10..12} ) +PYTHON_REQ_USE="threads(+)" + +inherit distutils-r1 prefix pypi + +DESCRIPTION="Hierarchical datasets for Python" +HOMEPAGE=" + https://www.pytables.org/ + https://github.com/PyTables/PyTables/ + https://pypi.org/project/tables/ +" + +LICENSE="BSD" +SLOT="0" +KEYWORDS="~amd64 ~arm ~arm64 ~ia64 ~loong ~ppc64 ~riscv ~sparc ~x86 ~amd64-linux ~x86-linux" +IUSE="+cpudetection examples test" +RESTRICT="!test? ( test )" + +DEPEND=" + app-arch/bzip2:0= + app-arch/lz4:0= + >=app-arch/zstd-1.0.0:= + >=dev-libs/c-blosc-1.11.1:0= + >=dev-libs/c-blosc2-2.11.0:= + dev-libs/lzo:2= + >=dev-python/numpy-1.19.0:=[${PYTHON_USEDEP}] + >=sci-libs/hdf5-1.8.4:= +" +RDEPEND=" + ${DEPEND} + >=dev-python/numexpr-2.6.2[${PYTHON_USEDEP}] + dev-python/packaging[${PYTHON_USEDEP}] + cpudetection? ( dev-python/py-cpuinfo[${PYTHON_USEDEP}] ) +" +BDEPEND=" + >=dev-python/cython-0.21[${PYTHON_USEDEP}] + virtual/pkgconfig + cpudetection? ( dev-python/py-cpuinfo[${PYTHON_USEDEP}] ) + test? ( + ${RDEPEND} + ) +" + +python_prepare_all() { + local PATCHES=( + # https://github.com/PyTables/PyTables/pull/1176 + "${FILESDIR}/${P}-numpy-2.patch" + ) + + rm -r c-blosc/{blosc,internal-complibs} || die + + distutils-r1_python_prepare_all + + sed -i -e '/blosc2/d' pyproject.toml || die + hprefixify -w '/prefixes =/' setup.py + + export PYTABLES_NO_EMBEDDED_LIBS=1 + export USE_PKGCONFIG=TRUE +} + +python_test() { + cd "${BUILD_DIR}/install$(python_get_sitedir)" || die + "${EPYTHON}" tables/tests/test_all.py -v || die +} + +python_install_all() { + distutils-r1_python_install_all + + if use examples; then + dodoc -r contrib examples + docompress -x /usr/share/doc/${PF}/{contrib,examples} + fi +}