BUG: .sel method fails when label is float differnt from coords float type

casting at a lower level closer to pandas.Index methods

Author: HasanAhmadQ7

xarray/core/dataset.py

@@ -1814,15 +1814,6 @@ def sel(self, indexers=None, method=None, tolerance=None, drop=False,
         DataArray.sel
         """
         indexers = either_dict_or_kwargs(indexers, indexers_kwargs, 'sel')
-        casting_keys = self._get_casting_keys(indexers.keys())
-        from .dataarray import DataArray
-        for k in casting_keys:
-            if isinstance(indexers[k], (slice, DataArray, Variable)):
-                pass
-            else:
-                casting_type = getattr(self.coords[k].values.dtype, "type")
-                indexers[k] = casting_type(indexers[k])
-
         pos_indexers, new_indexes = remap_label_indexers(
             self, indexers=indexers, method=method, tolerance=tolerance)
         result = self.isel(indexers=pos_indexers, drop=drop)
@@ -2331,17 +2322,6 @@ def interp_like(self, other, method='linear', assume_sorted=False,
             ds = self.reindex(object_coords)
         return ds.interp(numeric_coords, method, assume_sorted, kwargs)
 
-    # Helper method for sel()
-    def _get_casting_keys(self, indexers_keys):
-        casting_keys = []
-        coords_keys = self.coords.keys()
-        common_keys = list(set(indexers_keys) & set(coords_keys))
-        for k in common_keys:
-            coords_var = self.coords[k].values
-            if (isinstance(coords_var, np.ndarray) and
-                    coords_var.dtype.kind == 'f'):
-                casting_keys.append(k)
-        return casting_keys
 
     # Helper methods for rename()
     def _rename_vars(self, name_dict, dims_dict):

xarray/core/indexing.py

@@ -10,7 +10,7 @@
 
 from . import duck_array_ops, nputils, utils
 from .pycompat import dask_array_type, integer_types
-from .utils import is_dict_like
+from .utils import is_dict_like, maybe_cast_to_coords_dtype
 
 
 def expanded_indexer(key, ndim):
@@ -248,6 +248,8 @@ def remap_label_indexers(data_obj, indexers, method=None, tolerance=None):
                                  'an associated coordinate.')
             pos_indexers[dim] = label
         else:
+            coords_dtype = data_obj.coords[dim].values.dtype
+            label = maybe_cast_to_coords_dtype(label, coords_dtype)
             idxr, new_idx = convert_label_indexer(index, label,
                                                   dim, method, tolerance)
             pos_indexers[dim] = idxr

xarray/core/utils.py

@@ -66,6 +66,14 @@ def _maybe_cast_to_cftimeindex(index: pd.Index) -> pd.Index:
         return index
 
 
+def maybe_cast_to_coords_dtype(label, coords_dtype):
+    if isinstance(label, float):
+        label = coords_dtype.type(label)
+    elif isinstance(label, list) and coords_dtype.kind == 'f':
+        label = np.asarray(label, dtype=coords_dtype)
+    return label
+
+
 def safe_cast_to_index(array: Any) -> pd.Index:
     """Given an array, safely cast it to a pandas.Index.
 

xarray/tests/test_dataarray.py

@@ -817,15 +817,31 @@ def test_sel_dataarray_datetime(self):
         result = array.sel(delta=slice(array.delta[0], array.delta[-1]))
         assert_equal(result, array)
 
-    def test_sel_float32(self):
+    def test_sel_float(self):
+        data_values = np.arange(4)
+
+        # case coords are float32 and label is list of floats
         float_values = [0., 0.111, 0.222, 0.333]
         coord_values = np.asarray(float_values, dtype='float32')
-        data_values = np.arange(4)
         array = DataArray(data_values, [('float32_coord', coord_values)])
         expected = DataArray(data_values[1:3], [('float32_coord',
                                                  coord_values[1:3])])
         actual = array.sel(float32_coord=float_values[1:3])
+        # case coords are float16 and label is list of floats
+        coord_values_16 = np.asarray(float_values, dtype='float16')
+        expected_16 = DataArray(data_values[1:3], [('float16_coord',
+                                                    coord_values_16[1:3])])
+        array_16 = DataArray(data_values, [('float16_coord', coord_values_16)])
+        actual_16 = array_16.sel(float16_coord=float_values[1:3])
+
+        # case coord, label are scalars
+        expected_scalar = DataArray(data_values[2], coords={
+            'float32_coord': coord_values[2]})
+        actual_scalar = array.sel(float32_coord=float_values[2])
+
         assert_equal(expected, actual)
+        assert_equal(expected_scalar, actual_scalar)
+        assert_equal(expected_16, actual_16)
 
     def test_sel_no_index(self):
         array = DataArray(np.arange(10), dims='x')