build: upgrade gt4py to numpy 2.x (#1852)

Upgrade dace to latest main version to include the support for numpy 2.
All gt4py cartesian and next tests are compatible with both numpy 1.x
and 2.x, except cartesian-dace that is limited by dace v1 to numpy < 2.

src/gt4py/next/ffront/func_to_foast.py

@@ -60,8 +60,9 @@ def func_to_foast(inp: DSL_FOP) -> FOP:
         >>> print(foast_definition.foast_node.id)
         dsl_operator
 
-        >>> print(foast_definition.closure_vars)
-        {'const': 2.0}
+        >>> foast_closure_vars = {k: str(v) for k, v in foast_definition.closure_vars.items()}
+        >>> print(foast_closure_vars)
+        {'const': '2.0'}
     """
     source_def = source_utils.SourceDefinition.from_function(inp.definition)
     closure_vars = source_utils.get_closure_vars_from_function(inp.definition)

src/gt4py/next/iterator/embedded.py

@@ -16,7 +16,6 @@
 import itertools
 import math
 import operator
-import sys
 import warnings
 
 import numpy as np
@@ -677,7 +676,7 @@ def __float__(self):
         return np.nan
 
     def __int__(self):
-        return sys.maxsize
+        return np.iinfo(np.int32).max
 
     def __repr__(self):
         return "_UNDEFINED"

src/gt4py/storage/allocators.py

@@ -211,9 +211,10 @@ def allocate(
 
         # Compute the padding required in the contiguous dimension to get aligned blocks
         dims_layout = [layout_map.index(i) for i in range(len(shape))]
-        padded_shape_lst = list(shape)
+        # Convert shape size to same data type (note that `np.int16` can overflow)
+        padded_shape_lst = [np.int32(x) for x in shape]
         if ndim > 0:
-            padded_shape_lst[dims_layout[-1]] = (
+            padded_shape_lst[dims_layout[-1]] = (  # type: ignore[call-overload]
                 math.ceil(shape[dims_layout[-1]] / items_per_aligned_block)
                 * items_per_aligned_block
             )

src/gt4py/storage/cartesian/utils.py

@@ -12,22 +12,18 @@
 import functools
 import math
 import numbers
-from typing import Any, Final, Literal, Optional, Sequence, Tuple, Union, cast
+from typing import Final, Literal, Optional, Sequence, Tuple, Union, cast
 
 import numpy as np
 import numpy.typing as npt
+from numpy.typing import DTypeLike
 
 from gt4py._core import definitions as core_defs
 from gt4py.cartesian import config as gt_config
 from gt4py.eve.extended_typing import ArrayInterface, CUDAArrayInterface
 from gt4py.storage import allocators
 
 
-if np.lib.NumpyVersion(np.__version__) >= "1.20.0":
-    from numpy.typing import DTypeLike
-else:
-    DTypeLike = Any  # type: ignore[misc]  # assign multiple types in both branches
-
 try:
     import cupy as cp
 except ImportError:

tests/cartesian_tests/integration_tests/feature_tests/test_field_layouts.py

@@ -26,8 +26,8 @@
 def test_numpy_allocators(backend, order):
     xp = get_array_library(backend)
     shape = (20, 10, 5)
-    inp = xp.array(xp.random.randn(*shape), order=order, dtype=xp.float_)
-    outp = xp.zeros(shape=shape, order=order, dtype=xp.float_)
+    inp = xp.array(xp.random.randn(*shape), order=order, dtype=xp.float64)
+    outp = xp.zeros(shape=shape, order=order, dtype=xp.float64)
 
     stencil = gtscript.stencil(definition=copy_stencil, backend=backend)
     stencil(field_a=inp, field_b=outp)
@@ -43,8 +43,8 @@ def test_bad_layout_warns(backend):
 
     shape = (10, 10, 10)
 
-    inp = xp.array(xp.random.randn(*shape), dtype=xp.float_)
-    outp = gt_storage.zeros(backend=backend, shape=shape, dtype=xp.float_, aligned_index=(0, 0, 0))
+    inp = xp.array(xp.random.randn(*shape), dtype=xp.float64)
+    outp = gt_storage.zeros(backend=backend, shape=shape, dtype=xp.float64, aligned_index=(0, 0, 0))
 
     # set up non-optimal storage layout:
     if backend_cls.storage_info["is_optimal_layout"](inp, "IJK"):

tests/cartesian_tests/integration_tests/multi_feature_tests/stencil_definitions.py

@@ -61,7 +61,7 @@ def _register_decorator(actual_func):
     return _register_decorator(func) if func else _register_decorator
 
 
-Field3D = gtscript.Field[np.float_]
+Field3D = gtscript.Field[np.float64]
 Field3DBool = gtscript.Field[np.bool_]
 
 

tests/cartesian_tests/integration_tests/multi_feature_tests/test_code_generation.py

@@ -59,15 +59,15 @@ def test_generation(name, backend):
 @pytest.mark.parametrize("backend", ALL_BACKENDS)
 def test_lazy_stencil(backend):
     @gtscript.lazy_stencil(backend=backend)
-    def definition(field_a: gtscript.Field[np.float_], field_b: gtscript.Field[np.float_]):
+    def definition(field_a: gtscript.Field[np.float64], field_b: gtscript.Field[np.float64]):
         with computation(PARALLEL), interval(...):
             field_a = field_b
 
 
 @pytest.mark.parametrize("backend", ALL_BACKENDS)
 def test_temporary_field_declared_in_if(backend):
     @gtscript.stencil(backend=backend)
-    def definition(field_a: gtscript.Field[np.float_]):
+    def definition(field_a: gtscript.Field[np.float64]):
         with computation(PARALLEL), interval(...):
             if field_a < 0:
                 field_b = -field_a
@@ -79,19 +79,19 @@ def definition(field_a: gtscript.Field[np.float_]):
 @pytest.mark.parametrize("backend", ALL_BACKENDS)
 def test_stage_without_effect(backend):
     @gtscript.stencil(backend=backend)
-    def definition(field_a: gtscript.Field[np.float_]):
+    def definition(field_a: gtscript.Field[np.float64]):
         with computation(PARALLEL), interval(...):
             field_c = 0.0
 
 
 def test_ignore_np_errstate():
     def setup_and_run(backend, **kwargs):
         field_a = gt_storage.zeros(
-            dtype=np.float_, backend=backend, shape=(3, 3, 1), aligned_index=(0, 0, 0)
+            dtype=np.float64, backend=backend, shape=(3, 3, 1), aligned_index=(0, 0, 0)
         )
 
         @gtscript.stencil(backend=backend, **kwargs)
-        def divide_by_zero(field_a: gtscript.Field[np.float_]):
+        def divide_by_zero(field_a: gtscript.Field[np.float64]):
             with computation(PARALLEL), interval(...):
                 field_a = 1.0 / field_a
 
@@ -106,11 +106,11 @@ def divide_by_zero(field_a: gtscript.Field[np.float_]):
 
 @pytest.mark.parametrize("backend", CPU_BACKENDS)
 def test_stencil_without_effect(backend):
-    def definition1(field_in: gtscript.Field[np.float_]):
+    def definition1(field_in: gtscript.Field[np.float64]):
         with computation(PARALLEL), interval(...):
             tmp = 0.0
 
-    def definition2(f_in: gtscript.Field[np.float_]):
+    def definition2(f_in: gtscript.Field[np.float64]):
         from __externals__ import flag
 
         with computation(PARALLEL), interval(...):
@@ -121,7 +121,7 @@ def definition2(f_in: gtscript.Field[np.float_]):
     stencil2 = gtscript.stencil(backend, definition2, externals={"flag": False})
 
     field_in = gt_storage.ones(
-        dtype=np.float_, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
+        dtype=np.float64, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
     )
 
     # test with explicit domain specified
@@ -135,14 +135,14 @@ def definition2(f_in: gtscript.Field[np.float_]):
 @pytest.mark.parametrize("backend", CPU_BACKENDS)
 def test_stage_merger_induced_interval_block_reordering(backend):
     field_in = gt_storage.ones(
-        dtype=np.float_, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
+        dtype=np.float64, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
     )
     field_out = gt_storage.zeros(
-        dtype=np.float_, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
+        dtype=np.float64, backend=backend, shape=(23, 23, 23), aligned_index=(0, 0, 0)
     )
 
     @gtscript.stencil(backend=backend)
-    def stencil(field_in: gtscript.Field[np.float_], field_out: gtscript.Field[np.float_]):
+    def stencil(field_in: gtscript.Field[np.float64], field_out: gtscript.Field[np.float64]):
         with computation(BACKWARD):
             with interval(-2, -1):  # block 1
                 field_out = field_in
@@ -164,9 +164,9 @@ def stencil(field_in: gtscript.Field[np.float_], field_out: gtscript.Field[np.fl
 def test_lower_dimensional_inputs(backend):
     @gtscript.stencil(backend=backend)
     def stencil(
-        field_3d: gtscript.Field[gtscript.IJK, np.float_],
-        field_2d: gtscript.Field[gtscript.IJ, np.float_],
-        field_1d: gtscript.Field[gtscript.K, np.float_],
+        field_3d: gtscript.Field[gtscript.IJK, np.float64],
+        field_2d: gtscript.Field[gtscript.IJ, np.float64],
+        field_1d: gtscript.Field[gtscript.K, np.float64],
     ):
         with computation(PARALLEL):
             with interval(0, -1):
@@ -219,9 +219,9 @@ def stencil(
 def test_lower_dimensional_masked(backend):
     @gtscript.stencil(backend=backend)
     def copy_2to3(
-        cond: gtscript.Field[gtscript.IJK, np.float_],
-        inp: gtscript.Field[gtscript.IJ, np.float_],
-        outp: gtscript.Field[gtscript.IJK, np.float_],
+        cond: gtscript.Field[gtscript.IJK, np.float64],
+        inp: gtscript.Field[gtscript.IJ, np.float64],
+        outp: gtscript.Field[gtscript.IJK, np.float64],
     ):
         with computation(PARALLEL), interval(...):
             if cond > 0.0:
@@ -250,9 +250,9 @@ def copy_2to3(
 def test_lower_dimensional_masked_2dcond(backend):
     @gtscript.stencil(backend=backend)
     def copy_2to3(
-        cond: gtscript.Field[gtscript.IJK, np.float_],
-        inp: gtscript.Field[gtscript.IJ, np.float_],
-        outp: gtscript.Field[gtscript.IJK, np.float_],
+        cond: gtscript.Field[gtscript.IJK, np.float64],
+        inp: gtscript.Field[gtscript.IJ, np.float64],
+        outp: gtscript.Field[gtscript.IJK, np.float64],
     ):
         with computation(FORWARD), interval(...):
             if cond > 0.0:
@@ -281,8 +281,8 @@ def copy_2to3(
 def test_lower_dimensional_inputs_2d_to_3d_forward(backend):
     @gtscript.stencil(backend=backend)
     def copy_2to3(
-        inp: gtscript.Field[gtscript.IJ, np.float_],
-        outp: gtscript.Field[gtscript.IJK, np.float_],
+        inp: gtscript.Field[gtscript.IJ, np.float64],
+        outp: gtscript.Field[gtscript.IJK, np.float64],
     ):
         with computation(FORWARD), interval(...):
             outp[0, 0, 0] = inp
@@ -368,8 +368,8 @@ def stencil(
 def test_variable_offsets(backend):
     @gtscript.stencil(backend=backend)
     def stencil_ij(
-        in_field: gtscript.Field[np.float_],
-        out_field: gtscript.Field[np.float_],
+        in_field: gtscript.Field[np.float64],
+        out_field: gtscript.Field[np.float64],
         index_field: gtscript.Field[gtscript.IJ, int],
     ):
         with computation(FORWARD), interval(...):
@@ -378,8 +378,8 @@ def stencil_ij(
 
     @gtscript.stencil(backend=backend)
     def stencil_ijk(
-        in_field: gtscript.Field[np.float_],
-        out_field: gtscript.Field[np.float_],
+        in_field: gtscript.Field[np.float64],
+        out_field: gtscript.Field[np.float64],
         index_field: gtscript.Field[int],
     ):
         with computation(PARALLEL), interval(...):
@@ -390,10 +390,10 @@ def stencil_ijk(
 def test_variable_offsets_and_while_loop(backend):
     @gtscript.stencil(backend=backend)
     def stencil(
-        pe1: gtscript.Field[np.float_],
-        pe2: gtscript.Field[np.float_],
-        qin: gtscript.Field[np.float_],
-        qout: gtscript.Field[np.float_],
+        pe1: gtscript.Field[np.float64],
+        pe2: gtscript.Field[np.float64],
+        qin: gtscript.Field[np.float64],
+        qout: gtscript.Field[np.float64],
         lev: gtscript.Field[gtscript.IJ, np.int_],
     ):
         with computation(FORWARD), interval(0, -1):
@@ -410,7 +410,7 @@ def stencil(
 @pytest.mark.parametrize("backend", ALL_BACKENDS)
 def test_nested_while_loop(backend):
     @gtscript.stencil(backend=backend)
-    def stencil(field_a: gtscript.Field[np.float_], field_b: gtscript.Field[np.int_]):
+    def stencil(field_a: gtscript.Field[np.float64], field_b: gtscript.Field[np.int_]):
         with computation(PARALLEL), interval(...):
             while field_a < 1:
                 add = 0
@@ -422,7 +422,7 @@ def stencil(field_a: gtscript.Field[np.float_], field_b: gtscript.Field[np.int_]
 @pytest.mark.parametrize("backend", ALL_BACKENDS)
 def test_mask_with_offset_written_in_conditional(backend):
     @gtscript.stencil(backend)
-    def stencil(outp: gtscript.Field[np.float_]):
+    def stencil(outp: gtscript.Field[np.float64]):
         with computation(PARALLEL), interval(...):
             cond = True
             if cond[0, -1, 0] or cond[0, 0, 0]: