Merge pull request #1250 from mscheltienne/np.sctypes

Replace np.sctypes for numpy 2.0 compat

Author: effigies

.zenodo.json

@@ -381,6 +381,11 @@
     {
       "name": "Suter, Peter"
     }
+    {
+      "affiliation": "Human Neuroscience Platform, Fondation Campus Biotech Geneva, Geneva, Switzerland",
+      "name": "Mathieu Scheltienne",
+      "orcid": "0000-0001-8316-7436"
+    },
   ],
   "keywords": [
     "neuroimaging"

doc/source/index.rst

@@ -125,6 +125,7 @@ contributed code and discussion (in rough order of appearance):
 * Jacob Roberts
 * Horea Christian
 * Fabian Perez
+* Mathieu Scheltienne
 
 License reprise
 ===============

nibabel/casting.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import warnings
-from numbers import Integral
 from platform import machine, processor
 
 import numpy as np
@@ -23,6 +22,43 @@ class CastingError(Exception):
 _test_val = 2**63 + 2**11  # Should be exactly representable in float64
 TRUNC_UINT64 = np.float64(_test_val).astype(np.uint64) != _test_val
 
+# np.sctypes is deprecated in numpy 2.0 and np.core.sctypes should not be used instead.
+sctypes = {
+    'int': [
+        getattr(np, dtype) for dtype in ('int8', 'int16', 'int32', 'int64') if hasattr(np, dtype)
+    ],
+    'uint': [
+        getattr(np, dtype)
+        for dtype in ('uint8', 'uint16', 'uint32', 'uint64')
+        if hasattr(np, dtype)
+    ],
+    'float': [
+        getattr(np, dtype)
+        for dtype in ('float16', 'float32', 'float64', 'float96', 'float128')
+        if hasattr(np, dtype)
+    ],
+    'complex': [
+        getattr(np, dtype)
+        for dtype in ('complex64', 'complex128', 'complex192', 'complex256')
+        if hasattr(np, dtype)
+    ],
+    'others': [bool, object, bytes, str, np.void],
+}
+sctypes_aliases = {
+    getattr(np, dtype)
+    for dtype in (
+        'int8', 'byte', 'int16', 'short', 'int32', 'intc', 'int_', 'int64', 'longlong',
+        'uint8', 'ubyte', 'uint16', 'ushort', 'uint32', 'uintc', 'uint', 'uint64', 'ulonglong',  # noqa: E501
+        'float16', 'half', 'float32', 'single', 'float64', 'double', 'float96', 'float128', 'longdouble',  # noqa: E501
+        'complex64', 'csingle', 'complex128', 'cdouble', 'complex192', 'complex256', 'clongdouble',  # noqa: E501
+        # other names of the built-in scalar types
+        'int_', 'float_', 'complex_', 'bytes_', 'str_', 'bool_', 'datetime64', 'timedelta64',  # noqa: E501
+        # other
+        'object_', 'void',
+    )
+    if hasattr(np, dtype)
+}  # fmt:skip
+
 
 def float_to_int(arr, int_type, nan2zero=True, infmax=False):
     """Convert floating point array `arr` to type `int_type`
@@ -252,7 +288,7 @@ def type_info(np_type):
         return ret
     info_64 = np.finfo(np.float64)
     if dt.kind == 'c':
-        assert np_type is np.longcomplex
+        assert np_type is np.clongdouble
         vals = (nmant, nexp, width / 2)
     else:
         assert np_type is np.longdouble
@@ -280,7 +316,7 @@ def type_info(np_type):
     # Oh dear, we don't recognize the type information.  Try some known types
     # and then give up. At this stage we're expecting exotic longdouble or
     # their complex equivalent.
-    if np_type not in (np.longdouble, np.longcomplex) or width not in (16, 32):
+    if np_type not in (np.longdouble, np.clongdouble) or width not in (16, 32):
         raise FloatingError(f'We had not expected type {np_type}')
     if vals == (1, 1, 16) and on_powerpc() and _check_maxexp(np.longdouble, 1024):
         # double pair on PPC.  The _check_nmant routine does not work for this
@@ -290,13 +326,13 @@ def type_info(np_type):
         # Got float64 despite everything
         pass
     elif _check_nmant(np.longdouble, 112) and _check_maxexp(np.longdouble, 16384):
-        # binary 128, but with some busted type information. np.longcomplex
+        # binary 128, but with some busted type information. np.clongdouble
         # seems to break here too, so we need to use np.longdouble and
         # complexify
         two = np.longdouble(2)
         # See: https://matthew-brett.github.io/pydagogue/floating_point.html
         max_val = (two**113 - 1) / (two**112) * two**16383
-        if np_type is np.longcomplex:
+        if np_type is np.clongdouble:
             max_val += 0j
         ret = dict(
             min=-max_val,
@@ -453,9 +489,7 @@ def int_to_float(val, flt_type):
         return flt_type(val)
     # The following works around a nasty numpy 1.4.1 bug such that:
     # >>> int(np.uint32(2**32-1)
-    # -1
-    if not isinstance(val, Integral):
-        val = int(str(val))
+    val = int(val)
     faval = np.longdouble(0)
     while val != 0:
         f64 = np.float64(val)
@@ -714,7 +748,7 @@ def ok_floats():
     Remove longdouble if it has no higher precision than float64
     """
     # copy float list so we don't change the numpy global
-    floats = np.sctypes['float'][:]
+    floats = sctypes['float'][:]
     if best_float() != np.longdouble and np.longdouble in floats:
         floats.remove(np.longdouble)
     return sorted(floats, key=lambda f: type_info(f)['nmant'])
@@ -750,10 +784,10 @@ def able_int_type(values):
     mn = min(values)
     mx = max(values)
     if mn >= 0:
-        for ityp in np.sctypes['uint']:
+        for ityp in sctypes['uint']:
             if mx <= np.iinfo(ityp).max:
                 return ityp
-    for ityp in np.sctypes['int']:
+    for ityp in sctypes['int']:
         info = np.iinfo(ityp)
         if mn >= info.min and mx <= info.max:
             return ityp

nibabel/conftest.py

@@ -1,5 +1,14 @@
+import numpy as np
 import pytest
 
 # Ignore warning requesting help with nicom
 with pytest.warns(UserWarning):
     import nibabel.nicom
+
+
+@pytest.fixture(scope='session', autouse=True)
+def legacy_printoptions():
+    from packaging.version import Version
+
+    if Version(np.__version__) >= Version('1.22'):
+        np.set_printoptions(legacy='1.21')

nibabel/ecat.py

@@ -923,7 +923,7 @@ def _write_data(self, data, stream, pos, dtype=None, endianness=None):
             endianness = native_code
 
         stream.seek(pos)
-        make_array_writer(data.newbyteorder(endianness), dtype).to_fileobj(stream)
+        make_array_writer(data.view(data.dtype.newbyteorder(endianness)), dtype).to_fileobj(stream)
 
     def to_file_map(self, file_map=None):
         """Write ECAT7 image to `file_map` or contained ``self.file_map``

nibabel/freesurfer/io.py

@@ -31,7 +31,7 @@ def _fread3(fobj):
     n : int
         A 3 byte int
     """
-    b1, b2, b3 = np.fromfile(fobj, '>u1', 3)
+    b1, b2, b3 = np.fromfile(fobj, '>u1', 3).astype(np.int64)
     return (b1 << 16) + (b2 << 8) + b3
 
 

nibabel/freesurfer/tests/test_io.py

@@ -4,14 +4,13 @@
 import struct
 import time
 import unittest
-import warnings
 from os.path import isdir
 from os.path import join as pjoin
 from pathlib import Path
 
 import numpy as np
 import pytest
-from numpy.testing import assert_allclose, assert_array_equal
+from numpy.testing import assert_allclose
 
 from ...fileslice import strided_scalar
 from ...testing import clear_and_catch_warnings
@@ -105,8 +104,10 @@ def test_geometry():
     assert np.array_equal(faces, faces2)
 
     # Validate byte ordering
-    coords_swapped = coords.byteswap().newbyteorder()
-    faces_swapped = faces.byteswap().newbyteorder()
+    coords_swapped = coords.byteswap()
+    coords_swapped = coords_swapped.view(coords_swapped.dtype.newbyteorder())
+    faces_swapped = faces.byteswap()
+    faces_swapped = faces_swapped.view(faces_swapped.dtype.newbyteorder())
     assert np.array_equal(coords_swapped, coords)
     assert np.array_equal(faces_swapped, faces)
 

nibabel/freesurfer/tests/test_mghformat.py

@@ -345,7 +345,7 @@ def test_mghheader_default_structarr():
     for endianness in (None,) + BIG_CODES:
         hdr2 = MGHHeader.default_structarr(endianness=endianness)
         assert hdr2 == hdr
-        assert hdr2.newbyteorder('>') == hdr
+        assert hdr2.view(hdr2.dtype.newbyteorder('>')) == hdr
 
     for endianness in LITTLE_CODES:
         with pytest.raises(ValueError):

nibabel/nifti1.py

@@ -89,7 +89,7 @@
 if have_binary128():
     # Only enable 128 bit floats if we really have IEEE binary 128 longdoubles
     _float128t: type[np.generic] = np.longdouble
-    _complex256t: type[np.generic] = np.longcomplex
+    _complex256t: type[np.generic] = np.clongdouble
 else:
     _float128t = np.void
     _complex256t = np.void
@@ -2443,10 +2443,14 @@ def _get_analyze_compat_dtype(arr):
         return np.dtype('int16' if arr.max() <= np.iinfo(np.int16).max else 'int32')
 
     mn, mx = arr.min(), arr.max()
-    if np.can_cast(mn, np.int32) and np.can_cast(mx, np.int32):
-        return np.dtype('int32')
-    if np.can_cast(mn, np.float32) and np.can_cast(mx, np.float32):
-        return np.dtype('float32')
+    if arr.dtype.kind in 'iu':
+        info = np.iinfo('int32')
+        if mn >= info.min and mx <= info.max:
+            return np.dtype('int32')
+    elif arr.dtype.kind == 'f':
+        info = np.finfo('float32')
+        if mn >= info.min and mx <= info.max:
+            return np.dtype('float32')
 
     raise ValueError(
         f'Cannot find analyze-compatible dtype for array with dtype={dtype} (min={mn}, max={mx})'

nibabel/quaternions.py

@@ -29,7 +29,9 @@
 
 import numpy as np
 
-MAX_FLOAT = np.maximum_sctype(float)
+from .casting import sctypes
+
+MAX_FLOAT = sctypes['float'][-1]
 FLOAT_EPS = np.finfo(float).eps
 
 

nibabel/spatialimages.py

@@ -139,6 +139,7 @@
 import numpy as np
 
 from .arrayproxy import ArrayLike
+from .casting import sctypes_aliases
 from .dataobj_images import DataobjImage
 from .filebasedimages import FileBasedHeader, FileBasedImage
 from .fileholders import FileMap
@@ -333,7 +334,7 @@ def _supported_np_types(klass: type[HasDtype]) -> set[type[np.generic]]:
         else:
             raise e
     supported = set()
-    for np_type in set(np.sctypeDict.values()):
+    for np_type in sctypes_aliases:
         try:
             obj.set_data_dtype(np_type)
         except HeaderDataError:

nibabel/streamlines/trk.py

@@ -577,7 +577,7 @@ def _read_header(fileobj):
                 endianness = swapped_code
 
                 # Swap byte order
-                header_rec = header_rec.newbyteorder()
+                header_rec = header_rec.view(header_rec.dtype.newbyteorder())
                 if header_rec['hdr_size'] != TrkFile.HEADER_SIZE:
                     msg = (
                         f"Invalid hdr_size: {header_rec['hdr_size']} "

nibabel/tests/test_analyze.py

@@ -26,8 +26,7 @@
 from .. import imageglobals
 from ..analyze import AnalyzeHeader, AnalyzeImage
 from ..arraywriters import WriterError
-from ..casting import as_int
-from ..loadsave import read_img_data
+from ..casting import as_int, sctypes_aliases
 from ..nifti1 import Nifti1Header
 from ..optpkg import optional_package
 from ..spatialimages import HeaderDataError, HeaderTypeError, supported_np_types
@@ -52,9 +51,7 @@
 def add_duplicate_types(supported_np_types):
     # Update supported numpy types with named scalar types that map to the same set of dtypes
     dtypes = {np.dtype(t) for t in supported_np_types}
-    supported_np_types.update(
-        scalar for scalar in set(np.sctypeDict.values()) if np.dtype(scalar) in dtypes
-    )
+    supported_np_types.update(scalar for scalar in sctypes_aliases if np.dtype(scalar) in dtypes)
 
 
 class TestAnalyzeHeader(tws._TestLabeledWrapStruct):

nibabel/tests/test_arrayproxy.py

@@ -12,7 +12,6 @@
 import contextlib
 import gzip
 import pickle
-import warnings
 from io import BytesIO
 from unittest import mock
 

nibabel/tests/test_arraywriters.py

@@ -20,14 +20,14 @@
     get_slope_inter,
     make_array_writer,
 )
-from ..casting import int_abs, on_powerpc, shared_range, type_info
+from ..casting import int_abs, sctypes, shared_range, type_info
 from ..testing import assert_allclose_safely, suppress_warnings
 from ..volumeutils import _dt_min_max, apply_read_scaling, array_from_file
 
-FLOAT_TYPES = np.sctypes['float']
-COMPLEX_TYPES = np.sctypes['complex']
-INT_TYPES = np.sctypes['int']
-UINT_TYPES = np.sctypes['uint']
+FLOAT_TYPES = sctypes['float']
+COMPLEX_TYPES = sctypes['complex']
+INT_TYPES = sctypes['int']
+UINT_TYPES = sctypes['uint']
 CFLOAT_TYPES = FLOAT_TYPES + COMPLEX_TYPES
 IUINT_TYPES = INT_TYPES + UINT_TYPES
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
@@ -61,7 +61,8 @@ def test_arraywriters():
             assert aw.out_dtype == arr.dtype
             assert_array_equal(arr, round_trip(aw))
             # Byteswapped should be OK
-            bs_arr = arr.byteswap().newbyteorder('S')
+            bs_arr = arr.byteswap()
+            bs_arr = bs_arr.view(bs_arr.dtype.newbyteorder('S'))
             bs_aw = klass(bs_arr)
             bs_aw_rt = round_trip(bs_aw)
             # assert against original array because POWER7 was running into

nibabel/tests/test_casting.py

@@ -5,7 +5,7 @@
 
 import numpy as np
 import pytest
-from numpy.testing import assert_array_almost_equal, assert_array_equal
+from numpy.testing import assert_array_equal
 
 from ..casting import (
     CastingError,
@@ -17,15 +17,16 @@
     int_abs,
     int_to_float,
     longdouble_precision_improved,
+    sctypes,
     shared_range,
     ulp,
 )
 from ..testing import suppress_warnings
 
 
 def test_shared_range():
-    for ft in np.sctypes['float']:
-        for it in np.sctypes['int'] + np.sctypes['uint']:
+    for ft in sctypes['float']:
+        for it in sctypes['int'] + sctypes['uint']:
             # Test that going a bit above or below the calculated min and max
             # either generates the same number when cast, or the max int value
             # (if this system generates that) or something smaller (because of
@@ -54,7 +55,7 @@ def test_shared_range():
                 assert np.all((bit_bigger == casted_mx) | (bit_bigger == imax))
             else:
                 assert np.all(bit_bigger <= casted_mx)
-            if it in np.sctypes['uint']:
+            if it in sctypes['uint']:
                 assert mn == 0
                 continue
             # And something larger for the minimum
@@ -90,8 +91,8 @@ def test_shared_range_inputs():
 
 
 def test_casting():
-    for ft in np.sctypes['float']:
-        for it in np.sctypes['int'] + np.sctypes['uint']:
+    for ft in sctypes['float']:
+        for it in sctypes['int'] + sctypes['uint']:
             ii = np.iinfo(it)
             arr = [ii.min - 1, ii.max + 1, -np.inf, np.inf, np.nan, 0.2, 10.6]
             farr_orig = np.array(arr, dtype=ft)
@@ -140,7 +141,7 @@ def test_casting():
 
 
 def test_int_abs():
-    for itype in np.sctypes['int']:
+    for itype in sctypes['int']:
         info = np.iinfo(itype)
         in_arr = np.array([info.min, info.max], dtype=itype)
         idtype = np.dtype(itype)
@@ -188,7 +189,7 @@ def test_able_int_type():
 
 def test_able_casting():
     # Check the able_int_type function guesses numpy out type
-    types = np.sctypes['int'] + np.sctypes['uint']
+    types = sctypes['int'] + sctypes['uint']
     for in_type in types:
         in_info = np.iinfo(in_type)
         in_mn, in_mx = in_info.min, in_info.max