manually define the mapping between str and scalar types in casting.py

Author: Mathieu Scheltienne

nibabel/casting.py

@@ -23,6 +23,15 @@ 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": [np.int8, np.int16, np.int32, np.int64],
+    "uint": [np.uint8, np.uint16, np.uint32, np.uint64],
+    "float": [np.float16, np.float32, np.float64, np.float128],
+    "complex": [np.complex64, np.complex128, np.complex256],
+    "others": [bool, object, bytes, str, np.void],
+}
+
 
 def float_to_int(arr, int_type, nan2zero=True, infmax=False):
     """Convert floating point array `arr` to type `int_type`
@@ -714,7 +723,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.core.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 +759,10 @@ def able_int_type(values):
     mn = min(values)
     mx = max(values)
     if mn >= 0:
-        for ityp in np.core.sctypes['uint']:
+        for ityp in sctypes['uint']:
             if mx <= np.iinfo(ityp).max:
                 return ityp
-    for ityp in np.core.sctypes['int']:
+    for ityp in sctypes['int']:
         info = np.iinfo(ityp)
         if mn >= info.min and mx <= info.max:
             return ityp

nibabel/tests/test_arraywriters.py

@@ -20,14 +20,14 @@
     get_slope_inter,
     make_array_writer,
 )
-from ..casting import int_abs, 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.core.sctypes['float']
-COMPLEX_TYPES = np.core.sctypes['complex']
-INT_TYPES = np.core.sctypes['int']
-UINT_TYPES = np.core.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

nibabel/tests/test_casting.py

@@ -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.core.sctypes['float']:
-        for it in np.core.sctypes['int'] + np.core.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.core.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.core.sctypes['float']:
-        for it in np.core.sctypes['int'] + np.core.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.core.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.core.sctypes['int'] + np.core.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

nibabel/tests/test_floating.py

@@ -18,6 +18,7 @@
     longdouble_precision_improved,
     ok_floats,
     on_powerpc,
+    sctypes,
     type_info,
 )
 from ..testing import suppress_warnings
@@ -43,7 +44,7 @@ def dtt2dict(dtt):
 
 def test_type_info():
     # Test routine to get min, max, nmant, nexp
-    for dtt in np.core.sctypes['int'] + np.core.sctypes['uint']:
+    for dtt in sctypes['int'] + sctypes['uint']:
         info = np.iinfo(dtt)
         infod = type_info(dtt)
         assert infod == dict(
@@ -212,7 +213,7 @@ def test_int_to_float():
 def test_as_int_np_fix():
     # Test as_int works for integers.  We need as_int for integers because of a
     # numpy 1.4.1 bug such that int(np.uint32(2**32-1) == -1
-    for t in np.core.sctypes['int'] + np.core.sctypes['uint']:
+    for t in sctypes['int'] + sctypes['uint']:
         info = np.iinfo(t)
         mn, mx = np.array([info.min, info.max], dtype=t)
         assert (mn, mx) == (as_int(mn), as_int(mx))

nibabel/tests/test_image_api.py

@@ -403,7 +403,7 @@ def _check_array_caching(self, imaker, meth_name, caching):
             return
         # Return original array from get_fdata only if the input array is the
         # requested dtype.
-        float_types = np.core.sctypes['float']
+        float_types = sctypes['float']
         if arr_dtype not in float_types:
             return
         for float_type in float_types:

nibabel/tests/test_proxy_api.py

@@ -41,8 +41,8 @@
 from .. import ecat, minc1, minc2, parrec
 from ..analyze import AnalyzeHeader
 from ..arrayproxy import ArrayProxy, is_proxy
-from ..casting import have_binary128
 from ..deprecator import ExpiredDeprecationError
+from ..casting import have_binary128, sctypes
 from ..externals.netcdf import netcdf_file
 from ..freesurfer.mghformat import MGHHeader
 from ..nifti1 import Nifti1Header
@@ -146,7 +146,7 @@ def validate_array_interface_with_dtype(self, pmaker, params):
             context.__enter__()
             warnings.simplefilter('ignore', np.ComplexWarning)
 
-        for dtype in np.core.sctypes['float'] + np.core.sctypes['int'] + np.core.sctypes['uint']:
+        for dtype in sctypes['float'] + sctypes['int'] + sctypes['uint']:
             # Directly coerce with a dtype
             direct = dtype(prox)
             # Half-precision is imprecise. Obviously. It's a bad idea, but don't break

nibabel/tests/test_round_trip.py

@@ -10,7 +10,7 @@
 
 from .. import Nifti1Header, Nifti1Image
 from ..arraywriters import ScalingError
-from ..casting import best_float, type_info, ulp
+from ..casting import best_float, sctypes, type_info, ulp
 from ..spatialimages import HeaderDataError, supported_np_types
 
 DEBUG = False
@@ -102,7 +102,7 @@ def test_round_trip():
     rng = np.random.RandomState(20111121)
     N = 10000
     sd_10s = range(-20, 51, 5)
-    iuint_types = np.core.sctypes['int'] + np.core.sctypes['uint']
+    iuint_types = sctypes['int'] + sctypes['uint']
     # Remove types which cannot be set into nifti header datatype
     nifti_supported = supported_np_types(Nifti1Header())
     iuint_types = [t for t in iuint_types if t in nifti_supported]

nibabel/tests/test_scaling.py

@@ -15,7 +15,7 @@
 import pytest
 from numpy.testing import assert_array_almost_equal, assert_array_equal
 
-from ..casting import type_info
+from ..casting import sctypes, type_info
 from ..testing import suppress_warnings
 from ..volumeutils import apply_read_scaling, array_from_file, array_to_file, finite_range
 from .test_volumeutils import _calculate_scale
@@ -177,8 +177,8 @@ def test_array_file_scales(in_type, out_type):
     ],
 )
 def test_scaling_in_abstract(category0, category1, overflow):
-    for in_type in np.core.sctypes[category0]:
-        for out_type in np.core.sctypes[category1]:
+    for in_type in sctypes[category0]:
+        for out_type in sctypes[category1]:
             if overflow:
                 with suppress_warnings():
                     check_int_a2f(in_type, out_type)
@@ -191,7 +191,7 @@ def check_int_a2f(in_type, out_type):
     big_floater = np.maximum_sctype(np.float64)
     info = type_info(in_type)
     this_min, this_max = info['min'], info['max']
-    if not in_type in np.core.sctypes['complex']:
+    if not in_type in sctypes['complex']:
         data = np.array([this_min, this_max], in_type)
         # Bug in numpy 1.6.2 on PPC leading to infs - abort
         if not np.all(np.isfinite(data)):

nibabel/tests/test_testing.py

@@ -48,7 +48,7 @@ def test_assert_allclose_safely():
     with pytest.raises(AssertionError):
         assert_allclose_safely(a, b)
     # Test allcloseness of inf, especially np.float128 infs
-    for dtt in np.core.sctypes['float']:
+    for dtt in sctypes['float']:
         a = np.array([-np.inf, 1, np.inf], dtype=dtt)
         b = np.array([-np.inf, 1, np.inf], dtype=dtt)
         assert_allclose_safely(a, b)

nibabel/tests/test_volumeutils.py

@@ -32,7 +32,7 @@
     suppress_warnings,
 )
 
-from ..casting import OK_FLOATS, floor_log2, shared_range, type_info
+from ..casting import OK_FLOATS, floor_log2, sctypes, shared_range, type_info
 from ..openers import BZ2File, ImageOpener, Opener
 from ..optpkg import optional_package
 from ..tmpdirs import InTemporaryDirectory
@@ -59,12 +59,12 @@
 
 pyzstd, HAVE_ZSTD, _ = optional_package('pyzstd')
 
-#: convenience variables for numpy types
-FLOAT_TYPES = np.core.sctypes['float']
-COMPLEX_TYPES = np.core.sctypes['complex']
+# convenience variables for numpy types
+FLOAT_TYPES = sctypes['float']
+COMPLEX_TYPES = sctypes['complex']
 CFLOAT_TYPES = FLOAT_TYPES + COMPLEX_TYPES
-INT_TYPES = np.core.sctypes['int']
-IUINT_TYPES = INT_TYPES + np.core.sctypes['uint']
+INT_TYPES = sctypes['int']
+IUINT_TYPES = INT_TYPES + sctypes['uint']
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
 
 FP_RUNTIME_WARN = Version(np.__version__) >= Version('1.24.0.dev0+239')
@@ -598,7 +598,7 @@ def test_a2f_nanpos():
 def test_a2f_bad_scaling():
     # Test that pathological scalers raise an error
     NUMERICAL_TYPES = sum(
-        [np.core.sctypes[key] for key in ['int', 'uint', 'float', 'complex']], []
+        [sctypes[key] for key in ['int', 'uint', 'float', 'complex']], []
     )
     for in_type, out_type, slope, inter in itertools.product(
         NUMERICAL_TYPES,
@@ -832,10 +832,10 @@ def check_against(f1, f2):
         return f1 if FLOAT_TYPES.index(f1) >= FLOAT_TYPES.index(f2) else f2
 
     for first in FLOAT_TYPES:
-        for other in IUINT_TYPES + np.core.sctypes['complex']:
+        for other in IUINT_TYPES + sctypes['complex']:
             assert better_float_of(first, other) == first
             assert better_float_of(other, first) == first
-            for other2 in IUINT_TYPES + np.core.sctypes['complex']:
+            for other2 in IUINT_TYPES + sctypes['complex']:
                 assert better_float_of(other, other2) == np.float32
                 assert better_float_of(other, other2, np.float64) == np.float64
         for second in FLOAT_TYPES: