Avoid coercing to numpy in as_shared_dtypes

doc/whats-new.rst

@@ -53,6 +53,8 @@ Bug fixes
   By `Tom Nicholas <https://github.com/TomNicholas>`_.
 - Ensure :py:meth:`DataArray.unstack` works when wrapping array API-compliant classes. (:issue:`8666`, :pull:`8668`)
   By `Tom Nicholas <https://github.com/TomNicholas>`_.
+- Avoid coercing to numpy arrays inside :py:func:`~xarray.core.duck_array_ops.as_shared_dtype`. (:pull:`8714`)
+  By `Tom Nicholas <https://github.com/TomNicholas>`_.
 - Preserve chunks when writing time-like variables to zarr by enabling lazy CF
   encoding of time-like variables (:issue:`7132`, :issue:`8230`, :issue:`8432`,
   :pull:`8575`). By `Spencer Clark <https://github.com/spencerkclark>`_ and

xarray/core/duck_array_ops.py

@@ -36,7 +36,7 @@
 from xarray.core import dask_array_ops, dtypes, nputils, pycompat
 from xarray.core.options import OPTIONS
 from xarray.core.parallelcompat import get_chunked_array_type, is_chunked_array
-from xarray.core.pycompat import array_type, is_duck_dask_array
+from xarray.core.pycompat import is_duck_dask_array, to_duck_array
 from xarray.core.utils import is_duck_array, module_available
 
 # remove once numpy 2.0 is the oldest supported version
@@ -219,22 +219,10 @@ def asarray(data, xp=np):
 
 
 def as_shared_dtype(scalars_or_arrays, xp=np):
-    """Cast a arrays to a shared dtype using xarray's type promotion rules."""
-    array_type_cupy = array_type("cupy")
-    if array_type_cupy and any(
-        isinstance(x, array_type_cupy) for x in scalars_or_arrays
-    ):
-        import cupy as cp
-
-        arrays = [asarray(x, xp=cp) for x in scalars_or_arrays]
-    else:
-        arrays = [asarray(x, xp=xp) for x in scalars_or_arrays]
-    # Pass arrays directly instead of dtypes to result_type so scalars
-    # get handled properly.
-    # Note that result_type() safely gets the dtype from dask arrays without
-    # evaluating them.
-    out_type = dtypes.result_type(*arrays)
-    return [astype(x, out_type, copy=False) for x in arrays]
+    """Cast arrays to a shared dtype using xarray's type promotion rules."""
+    duckarrays = [to_duck_array(obj, xp=xp) for obj in scalars_or_arrays]
+    out_type = dtypes.result_type(*duckarrays)
+    return [astype(x, out_type, copy=False) for x in duckarrays]
 
 
 def broadcast_to(array, shape):

xarray/core/pycompat.py

@@ -7,6 +7,7 @@
 import numpy as np
 from packaging.version import Version
 
+from xarray.core.types import T_DuckArray
 from xarray.core.utils import is_duck_array, is_scalar, module_available
 
 integer_types = (int, np.integer)
@@ -86,23 +87,23 @@ def mod_version(mod: ModType) -> Version:
     return _get_cached_duck_array_module(mod).version
 
 
-def is_dask_collection(x):
+def is_dask_collection(x) -> bool:
     if module_available("dask"):
         from dask.base import is_dask_collection
 
         return is_dask_collection(x)
     return False
 
 
-def is_duck_dask_array(x):
+def is_duck_dask_array(x) -> bool:
     return is_duck_array(x) and is_dask_collection(x)
 
 
 def is_chunked_array(x) -> bool:
     return is_duck_dask_array(x) or (is_duck_array(x) and hasattr(x, "chunks"))
 
 
-def is_0d_dask_array(x):
+def is_0d_dask_array(x) -> bool:
     return is_duck_dask_array(x) and is_scalar(x)
 
 
@@ -129,12 +130,20 @@ def to_numpy(data) -> np.ndarray:
     return data
 
 
-def to_duck_array(data):
+def to_duck_array(data, xp=np) -> T_DuckArray:
     from xarray.core.indexing import ExplicitlyIndexed
 
     if isinstance(data, ExplicitlyIndexed):
         return data.get_duck_array()
     elif is_duck_array(data):
         return data
     else:
-        return np.asarray(data)
+        from xarray.core.duck_array_ops import asarray
+
+        array_type_cupy = array_type("cupy")
+        if array_type_cupy and any(isinstance(data, array_type_cupy)):
+            import cupy as cp
+
+            return asarray(data, xp=cp)
+        else:
+            return asarray(data, xp=xp)