Make compatible with numpy version 1.26

Author: lshaw8317

src/blosc2/__init__.py

@@ -171,15 +171,81 @@ class Tuner(Enum):
 # For array-api compatibility
 iinfo = np.iinfo
 finfo = np.finfo
-isdtype = np.isdtype
+
+
+def isdtype(a_dtype: np.dtype, kind: str | np.dtype | tuple):
+    """
+    Returns a boolean indicating whether a provided dtype is of a specified data type "kind".
+
+    Parameters
+    ----------
+    dtype: dtype
+        The input dtype.
+
+    kind: str | dtype | Tuple[str, dtype]
+        Data type kind.
+
+        If kind is a dtype, return boolean indicating whether the input dtype is equal to the dtype specified by kind.
+
+        If kind is a string, return boolean indicating whether the input dtype is of a specified data type kind.
+        The following dtype kinds are supporte:
+
+            * 'bool': boolean data types (e.g., bool).
+
+            * 'signed integer': signed integer data types (e.g., int8, int16, int32, int64).
+
+            * 'unsigned integer': unsigned integer data types (e.g., uint8, uint16, uint32, uint64).
+
+            * 'integral': integer data types. Shorthand for ('signed integer', 'unsigned integer').
+
+            * 'real floating': real-valued floating-point data types (e.g., float32, float64).
+
+            * 'complex floating': complex floating-point data types (e.g., complex64, complex128).
+
+            * 'numeric': numeric data types. Shorthand for ('integral', 'real floating', 'complex floating').
+
+    Returns
+    -------
+    out: bool
+        Boolean indicating whether a provided dtype is of a specified data type kind.
+    """
+    kind = (kind,) if not isinstance(kind, tuple) else kind
+    for _ in kind:
+        if a_dtype == kind:
+            return True
+
+    _complex, _signedint, _uint, _rfloat = False, False, False, False
+    if a_dtype in (complex64, complex128):
+        _complex = True
+        if "complex floating" in kind:
+            return True
+    if a_dtype == bool_ and "bool" in kind:
+        return True
+    if a_dtype in (int8, int16, int32, int64):
+        _signedint = True
+        if "signed integer" in kind:
+            return True
+    if a_dtype in (uint8, uint16, uint32, uint64):
+        _uint = True
+        if "unsigned integer" in kind:
+            return True
+    if a_dtype in (float16, float32, float64):
+        _rfloat = True
+        if "real floating" in kind:
+            return True
+    if "integral" in kind and (_signedint or _uint):
+        return True
+    return "numeric" in kind and (
+        _signedint or _uint or _rfloat or _complex
+    )  # checked everything, otherwise False
+
 
 # dtypes for array-api
 str_ = np.str_
 bytes_ = np.bytes_
 object_ = np.object_
 
 from numpy import (
-    bool,
     bool_,
     complex64,
     complex128,
@@ -202,6 +268,8 @@ class Tuner(Enum):
     uint64,
 )
 
+bool = bool
+
 DEFAULT_COMPLEX = complex128
 """
 Default complex floating dtype."""

src/blosc2/lazyexpr.py

@@ -1382,7 +1382,7 @@ def slices_eval(  # noqa: C901
             # shape_slice in general not equal to final shape:
             # dummy dims (due to ints) will be dealt with by taking final_slice
             shape_slice = ndindex.ndindex(_slice).newshape(shape)
-            mask_slice = np.bool([isinstance(i, int) for i in orig_slice])
+            mask_slice = np.array([isinstance(i, int) for i in orig_slice], dtype=np.bool_)
     else:
         # # out should always have shape of full array
         # if shape is not None and shape != out.shape:
@@ -1769,7 +1769,7 @@ def reduce_slices(  # noqa: C901
 
     _slice = _slice.raw
     shape_slice = shape
-    mask_slice = np.bool([isinstance(i, int) for i in _slice])
+    mask_slice = np.array([isinstance(i, int) for i in _slice], dtype=np.bool_)
     if out is None and _slice != ():
         _slice = tuple(slice(i, i + 1, 1) if isinstance(i, int) else i for i in _slice)
         shape_slice = ndindex.ndindex(_slice).newshape(shape)
@@ -2209,7 +2209,7 @@ def result_type(
     # Follow NumPy rules for scalar-array operations
     # Create small arrays with the same dtypes and let NumPy's type promotion determine the result type
     arrs = [
-        value if not hasattr(value, "dtype") else np.array([0], dtype=value.dtype)
+        value if (np.isscalar(value) or not hasattr(value, "dtype")) else np.array([0], dtype=value.dtype)
         for value in arrays_and_dtypes
     ]
     return np.result_type(*arrs)

src/blosc2/ndarray.py

@@ -2904,6 +2904,16 @@ def chunkwise_logaddexp(inputs, output, offset):
     return blosc2.lazyudf(chunkwise_logaddexp, (x1, x2), dtype=dtype, shape=x1.shape)
 
 
+try:  # handle different numpy versions
+    nplshift = np.bitwise_left_shift
+    nprshift = np.bitwise_right_shift
+    npbinvert = np.bitwise_invert
+except AttributeError:
+    nplshift = np.left_shift
+    nprshift = np.right_shift
+    npbinvert = np.bitwise_not
+
+
 class Operand:
     """Base class for all operands in expressions."""
 
@@ -2957,8 +2967,8 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             np.bitwise_or: "|",
             np.bitwise_xor: "^",
             np.arctan2: "arctan2",
-            np.bitwise_left_shift: "<<",
-            np.bitwise_right_shift: ">>",
+            nplshift: "<<",
+            nprshift: ">>",
             np.remainder: "%",
             np.nextafter: "nextafter",
             np.copysign: "copysign",
@@ -2992,7 +3002,7 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             np.conj: "conj",
             np.real: "real",
             np.imag: "imag",
-            np.bitwise_invert: "~",
+            npbinvert: "~",
             np.isnan: "isnan",
             np.isfinite: "isfinite",
             np.isinf: "isinf",
@@ -3791,11 +3801,11 @@ def get_fselection_numpy(self, key: list | np.ndarray) -> np.ndarray:
                     return_index=True,
                     return_inverse=True,
                 )
+                idx_inv = idx_inv if chunked_arr.shape != idx_inv.shape else idx_inv.squeeze(-1)
                 unique_chunks = chunked_arr[row_ids]
-                idx_order = np.argsort(
-                    idx_inv.squeeze(-1)
-                )  # sort by chunks (can't sort by index since larger index could belong to lower chunk)
+                # sort by chunks (can't sort by index since larger index could belong to lower chunk)
                 # e.g. chunks of (100, 10) means (50, 15) has chunk idx (0,1) but (60,5) has (0, 0)
+                idx_order = np.argsort(idx_inv)
             sorted_idxs = arr[idx_order]
             out = np.empty(flat_shape, dtype=self.dtype)
             shape = np.array(shape)

tests/ndarray/test_concatenate.py

@@ -11,6 +11,11 @@
 
 import blosc2
 
+try:  # handle different versions of numpy
+    npconcat = np.concat
+except AttributeError:
+    npconcat = np.concatenate
+
 
 @pytest.mark.parametrize(
     ("shape1", "shape2", "dtype", "axis"),
@@ -34,7 +39,7 @@ def test_concat2(shape1, shape2, dtype, axis):
     ndarr2 = blosc2.arange(0, int(np.prod(shape2)), 1, dtype=dtype, shape=shape2)
     cparams = blosc2.CParams(clevel=1)
     result = blosc2.concat([ndarr1, ndarr2], axis=axis, cparams=cparams)
-    nparray = np.concat([ndarr1[:], ndarr2[:]], axis=axis)
+    nparray = npconcat([ndarr1[:], ndarr2[:]], axis=axis)
     np.testing.assert_almost_equal(result[:], nparray)
 
 
@@ -60,7 +65,7 @@ def test_concat3(shape1, shape2, shape3, dtype, axis):
     ndarr3 = blosc2.arange(0, int(np.prod(shape3)), 1, dtype=dtype, shape=shape3)
     cparams = blosc2.CParams(codec=blosc2.Codec.BLOSCLZ)
     result = blosc2.concat([ndarr1, ndarr2, ndarr3], axis=axis, cparams=cparams)
-    nparray = np.concat([ndarr1[:], ndarr2[:], ndarr3[:]], axis=axis)
+    nparray = npconcat([ndarr1[:], ndarr2[:], ndarr3[:]], axis=axis)
     np.testing.assert_almost_equal(result[:], nparray)
 
 

tests/ndarray/test_elementwise_funcs.py

@@ -31,7 +31,7 @@
 UNARY_FUNC_PAIRS.append((np.round, blosc2.round))
 UNARY_FUNC_PAIRS.append((np.count_nonzero, blosc2.count_nonzero))
 
-DTYPES = [np.bool_, np.int32, np.int64, np.float32, np.float64, np.complex128]
+DTYPES = [blosc2.bool_, blosc2.int32, blosc2.int64, blosc2.float32, blosc2.float64, blosc2.complex128]
 SHAPES_CHUNKS = [((10,), (3,)), ((20, 20), (4, 7)), ((10, 13, 13), (3, 5, 2))]
 
 
@@ -43,20 +43,20 @@ def test_unary_funcs(np_func, blosc_func, dtype, shape, chunkshape):  # noqa : C
         a_blosc = blosc2.linspace(
             0.01, stop=0.99, num=np.prod(shape), chunks=chunkshape, shape=shape, dtype=dtype
         )
-        if not np.issubdtype(dtype, np.integer):
+        if not blosc2.isdtype(dtype, "integral"):
             a_blosc[tuple(i // 2 for i in shape)] = blosc2.nan
-        if dtype == np.complex128:
+        if dtype == blosc2.complex128:
             a_blosc = (a_blosc * (1 + 1j)).compute()
             a_blosc[tuple(i // 2 for i in shape)] = blosc2.nan + blosc2.nan * 1j
-        if dtype == np.bool and np_func.__name__ == "arctanh":
+        if dtype == blosc2.bool_ and np_func.__name__ == "arctanh":
             a_blosc = blosc2.zeros(chunks=chunkshape, shape=shape, dtype=dtype)
     else:
         a_blosc = blosc2.linspace(
             1, stop=np.prod(shape), num=np.prod(shape), chunks=chunkshape, shape=shape, dtype=dtype
         )
-        if not np.issubdtype(dtype, np.integer):
+        if not blosc2.isdtype(dtype, "integral"):
             a_blosc[tuple(i // 2 for i in shape)] = blosc2.nan
-        if dtype == np.complex128:
+        if dtype == blosc2.complex128:
             a_blosc = (
                 a_blosc
                 + blosc2.linspace(
@@ -87,12 +87,16 @@ def test_unary_funcs(np_func, blosc_func, dtype, shape, chunkshape):  # noqa : C
             # some functions don't support certain dtypes and that's fine
             assert True
         except ValueError as e:
-            if np_func.__name__ == "logical_not" and dtype in (np.float32, np.float64, np.complex128):
+            if np_func.__name__ == "logical_not" and dtype in (
+                blosc2.float32,
+                blosc2.float64,
+                blosc2.complex128,
+            ):
                 assert True
             else:
                 raise e
         except AssertionError as e:
-            if np_func.__name__ in ("tan", "tanh") and dtype == np.complex128:
+            if np_func.__name__ in ("tan", "tanh") and dtype == blosc2.complex128:
                 warnings.showwarning(
                     "tan and tanh do not give correct NaN location",
                     UserWarning,
@@ -123,9 +127,9 @@ def test_binary_funcs(np_func, blosc_func, dtype, shape, chunkshape):  # noqa :
             shape=shape,
             dtype=dtype,
         )
-    if not np.issubdtype(dtype, np.integer):
+    if not blosc2.isdtype(dtype, "integral"):
         a_blosc1[tuple(i // 2 for i in shape)] = blosc2.nan
-    if dtype == np.complex128:
+    if dtype == blosc2.complex128:
         a_blosc1 = (
             a_blosc1
             + blosc2.linspace(
@@ -151,23 +155,26 @@ def test_binary_funcs(np_func, blosc_func, dtype, shape, chunkshape):  # noqa :
             # some functions don't support certain dtypes and that's fine
             assert True
         except ValueError as e:  # shouldn't be allowed for non-booleans
-            if np_func.__name__ in ("logical_and", "logical_or", "logical_xor", "minimum", "maximum"):
+            if np_func.__name__ in ("logical_and", "logical_or", "logical_xor"):
+                assert True
+            if (
+                np_func.__name__ in ("less", "less_equal", "greater", "greater_equal", "minimum", "maximum")
+                and dtype == blosc2.complex128
+            ):  # not supported for complex dtypes
                 assert True
             else:
                 raise e
-        except NotImplementedError as e:  # shouldn't be allowed for non-booleans
+        except NotImplementedError as e:
             if np_func.__name__ in ("left_shift", "right_shift", "floor_divide", "power", "remainder"):
                 assert True
             else:
                 raise e
         except AssertionError as e:
-            if np_func.__name__ == "power" and np.issubdtype(
-                dtype, np.integer
+            if np_func.__name__ == "power" and blosc2.isdtype(
+                dtype, "integral"
             ):  # overflow causes disagreement, no problem
                 assert True
-            elif np_func.__name__ in ("maximum", "minimum") and np.issubdtype(
-                dtype, np.floating
-            ):  # overflow causes disagreement, no problem
+            elif np_func.__name__ in ("maximum", "minimum") and blosc2.isdtype(dtype, "real floating"):
                 warnings.showwarning(
                     "minimum and maximum for numexpr do not match NaN behaviour for numpy",
                     UserWarning,

tests/ndarray/test_evaluate.py

@@ -100,6 +100,9 @@ def test_numpy_funcs(sample_data, func):
     a = a[:]
     b = b[:]
     c = c[:]  # ensure that all operands are numpy arrays
-    npfunc = getattr(np, func)
-    d_numpy = npfunc(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=0)
-    np.testing.assert_equal(d_blosc2, d_numpy)
+    try:
+        npfunc = getattr(np, func)
+        d_numpy = npfunc(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=0)
+        np.testing.assert_equal(d_blosc2, d_numpy)
+    except AttributeError:
+        pytest.skip("NumPy version has no cumulative_sum function.")

tests/ndarray/test_lazyexpr.py

@@ -1375,11 +1375,13 @@ def test_only_ndarrays_or_constructors(obj, getitem, item):
 @pytest.mark.parametrize("func", ["cumsum", "cumulative_sum", "cumprod"])
 def test_numpy_funcs(array_fixture, func):
     a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture
-    npfunc = getattr(np, func)
-    d_blosc2 = npfunc(((a1**3 + blosc2.sin(na2 * 2)) < a3) & (na2 > 0), axis=0)
-    npfunc = getattr(np, func)
-    d_numpy = npfunc(((na1**3 + np.sin(na2 * 2)) < na3) & (na2 > 0), axis=0)
-    np.testing.assert_equal(d_blosc2, d_numpy)
+    try:
+        npfunc = getattr(np, func)
+        d_blosc2 = npfunc(((a1**3 + blosc2.sin(na2 * 2)) < a3) & (na2 > 0), axis=0)
+        d_numpy = npfunc(((na1**3 + np.sin(na2 * 2)) < na3) & (na2 > 0), axis=0)
+        np.testing.assert_equal(d_blosc2, d_numpy)
+    except AttributeError:
+        pytest.skip("NumPy version has no cumulative_sum function.")
 
 
 # Test the LazyExpr when some operands are missing (e.g. removed file)
@@ -1489,8 +1491,8 @@ def test_chain_persistentexpressions():
 def test_scalar_dtypes(values):
     value1, value2 = values
     dtype1 = (value1 + value2).dtype
-    avalue1 = blosc2.asarray(value1) if hasattr(value1, "shape") else value1
-    avalue2 = blosc2.asarray(value2) if hasattr(value2, "shape") else value2
+    avalue1 = blosc2.asarray(value1) if not np.isscalar(value1) else value1
+    avalue2 = blosc2.asarray(value2) if not np.isscalar(value2) else value2
     dtype2 = (avalue1 * avalue2).dtype
     assert dtype1 == dtype2, f"Expected {dtype1} but got {dtype2}"
 

tests/ndarray/test_linalg.py

@@ -741,8 +741,11 @@ def test_matrix_transpose(shape):
 def test_mT(shape):
     arr = blosc2.linspace(0, 1, shape=shape)
     result = arr.mT
-    expected = arr[:].mT
-    np.testing.assert_allclose(result, expected)
+    try:
+        expected = arr[:].mT
+        np.testing.assert_allclose(result, expected)
+    except AttributeError:
+        pytest.skip("np.ndarray object in Numpy version {np.__version__} does not have .mT attribute.")
 
 
 @pytest.mark.parametrize(