Fix device-aware dtype handling in identity, gradient functions (#2835)

This PR ensures that default dtype selection respects device-specific
capabilities across multiple functions.

The PR includes changes:
- `dpnp.identity`: Remove redundant default dtype handling. The function
now delegates dtype resolution to dpnp.eye(), which already handles
device-aware default types correctly.
- `dpnp.gradient`: Pass sycl_queue parameter to default_float_type()
calls to ensure the selected float type is compatible with the device
where the array resides. This prevents issues when converting integer
arrays on devices with different dtype support.

The PR also updates SYCL queue tests to fix the parametrization to
generate device-dtype pairs using a new get_all_dev_dtypes() helper.
Each device is now tested only with dtypes it actually supports (e.g.,
devices without fp64 support won't test fp64), preventing false failures
and unnecessary test combinations.

Author: antonwolfy

CHANGELOG.md

@@ -83,6 +83,7 @@ Also, that release drops support for Python 3.9, making Python 3.10 the minimum
 * Fixed `.data.ptr` property on array views to correctly return the pointer to the view's data location instead of the base allocation pointer [#2812](https://github.com/IntelPython/dpnp/pull/2812)
 * Resolved an issue with strides calculation in `dpnp.diagonal` to return correct values for empty diagonals [#2814](https://github.com/IntelPython/dpnp/pull/2814)
 * Fixed test tolerance issues for float16 intermediate precision that became visible when testing against conda-forge's NumPy [#2828](https://github.com/IntelPython/dpnp/pull/2828)
+* Ensured device aware dtype handling in `dpnp.identity` and `dpnp.gradient` [#2835](https://github.com/IntelPython/dpnp/pull/2835)
 
 ### Security
 

dpnp/dpnp_iface_arraycreation.py

@@ -2664,10 +2664,9 @@ def identity(
 
     dpnp.check_limitations(like=like)
 
-    _dtype = dpnp.default_float_type() if dtype is None else dtype
     return dpnp.eye(
         n,
-        dtype=_dtype,
+        dtype=dtype,
         device=device,
         usm_type=usm_type,
         sycl_queue=sycl_queue,

dpnp/dpnp_iface_mathematical.py

@@ -141,7 +141,9 @@ def _gradient_build_dx(f, axes, *varargs):
             if dpnp.issubdtype(distances.dtype, dpnp.integer):
                 # Convert integer types to default float type to avoid modular
                 # arithmetic in dpnp.diff(distances).
-                distances = distances.astype(dpnp.default_float_type())
+                distances = distances.astype(
+                    dpnp.default_float_type(sycl_queue=f.sycl_queue)
+                )
             diffx = dpnp.diff(distances)
 
             # if distances are constant reduce to the scalar case
@@ -2707,9 +2709,9 @@ def gradient(f, *varargs, axis=None, edge_order=1):
         # All other types convert to floating point.
         # First check if f is a dpnp integer type; if so, convert f to default
         # float type to avoid modular arithmetic when computing changes in f.
-        if dpnp.issubdtype(otype, dpnp.integer):
-            f = f.astype(dpnp.default_float_type())
-        otype = dpnp.default_float_type()
+        otype = dpnp.default_float_type(sycl_queue=f.sycl_queue)
+        if dpnp.issubdtype(f.dtype, dpnp.integer):
+            f = f.astype(otype)
 
     for axis_, ax_dx in zip(axes, dx):
         if f.shape[axis_] < edge_order + 1:

dpnp/tests/test_sycl_queue.py

@@ -54,6 +54,23 @@ def assert_sycl_queue_equal(result, expected):
     assert exec_queue is not None
 
 
+def get_all_dev_dtypes(no_float16=True, no_none=True):
+    """
+    Build a list of (device, dtype) combinations for each device's
+    supported dtype.
+
+    """
+
+    device_dtype_pairs = []
+    for device in valid_dev:
+        dtypes = get_all_dtypes(
+            no_float16=no_float16, no_none=no_none, device=device
+        )
+        for dtype in dtypes:
+            device_dtype_pairs.append((device, dtype))
+    return device_dtype_pairs
+
+
 @pytest.mark.parametrize(
     "func, arg, kwargs",
     [
@@ -1082,11 +1099,10 @@ def test_array_creation_from_dpctl(copy, device):
     assert isinstance(result, dpnp_array)
 
 
-@pytest.mark.parametrize("device", valid_dev, ids=dev_ids)
-@pytest.mark.parametrize("arr_dtype", get_all_dtypes(no_float16=True))
+@pytest.mark.parametrize("device, dt", get_all_dev_dtypes())
 @pytest.mark.parametrize("shape", [tuple(), (2,), (3, 0, 1), (2, 2, 2)])
-def test_from_dlpack(arr_dtype, shape, device):
-    X = dpnp.ones(shape=shape, dtype=arr_dtype, device=device)
+def test_from_dlpack(shape, device, dt):
+    X = dpnp.ones(shape=shape, dtype=dt, device=device)
     Y = dpnp.from_dlpack(X)
     assert_array_equal(X, Y)
     assert X.__dlpack_device__() == Y.__dlpack_device__()
@@ -1098,10 +1114,9 @@ def test_from_dlpack(arr_dtype, shape, device):
         assert V.strides == W.strides
 
 
-@pytest.mark.parametrize("device", valid_dev, ids=dev_ids)
-@pytest.mark.parametrize("arr_dtype", get_all_dtypes(no_float16=True))
-def test_from_dlpack_with_dpt(arr_dtype, device):
-    X = dpt.ones((64,), dtype=arr_dtype, device=device)
+@pytest.mark.parametrize("device, dt", get_all_dev_dtypes())
+def test_from_dlpack_with_dpt(device, dt):
+    X = dpt.ones((64,), dtype=dt, device=device)
     Y = dpnp.from_dlpack(X)
     assert_array_equal(X, Y)
     assert isinstance(Y, dpnp.dpnp_array.dpnp_array)