Merge pull request #124 from csiro-coasts/dataset-dims-future-warning

Fix FutureWarning on Dataset.dims.__getvalue__

Author: mx-moth

docs/releases/development.rst

@@ -2,4 +2,6 @@
 Next release (in development)
 =============================
 
-* ...
+* Fix a ``FutureWarning`` on accessing :attr:`xarray.Dataset.dims`
+  with xarray >= 2023.12.0
+  (:pr:`124`, :pr:`pydata/xarray#8500`).

src/emsarray/conventions/_base.py

@@ -1767,7 +1767,7 @@ def grid_shape(self) -> Dict[GridKind, Sequence[int]]:
         """
         return {
             grid_kind: tuple(
-                self.dataset.dims[dim]
+                self.dataset.sizes[dim]
                 for dim in self.grid_dimensions[grid_kind]
             )
             for grid_kind in self.grid_kinds
@@ -1877,7 +1877,7 @@ def wind(
             grid_kind = self.default_grid_kind
 
         dimensions = self.grid_dimensions[grid_kind]
-        sizes = [self.dataset.dims[dim] for dim in dimensions]
+        sizes = [self.dataset.sizes[dim] for dim in dimensions]
 
         return utils.wind_dimension(
             data_array,

src/emsarray/conventions/arakawa_c.py

@@ -69,7 +69,10 @@ def i_dimension(self) -> Hashable:
     @cached_property
     def shape(self) -> Tuple[int, int]:
         """The shape of this grid, as a tuple of ``(j, i)``."""
-        return (self.dataset.dims[self.j_dimension], self.dataset.dims[self.i_dimension])
+        return (
+            self.dataset.sizes[self.j_dimension],
+            self.dataset.sizes[self.i_dimension],
+        )
 
     @cached_property
     def size(self) -> int:

src/emsarray/conventions/grid.py

@@ -173,8 +173,8 @@ def x_dimension(self) -> Hashable:
     @cached_property
     def shape(self) -> Tuple[int, int]:
         """The shape of this grid, as a tuple of ``(y, x)``."""
-        dims = self.dataset.dims
-        return (dims[self.y_dimension], dims[self.x_dimension])
+        sizes = self.dataset.sizes
+        return (sizes[self.y_dimension], sizes[self.x_dimension])
 
     @cached_property
     def size(self) -> int:
@@ -346,7 +346,7 @@ def _get_or_make_bounds(self, coordinate: xarray.DataArray) -> xarray.DataArray:
             if (
                 len(bounds.dims) == 2
                 and bounds.dims[0] == coordinate.dims[0]
-                and self.dataset.dims[bounds.dims[1]] == 2
+                and self.dataset.sizes[bounds.dims[1]] == 2
             ):
                 return bounds
             else:
@@ -481,7 +481,7 @@ def _get_or_make_bounds(self, coordinate: xarray.DataArray) -> xarray.DataArray:
                 len(bounds.dims) == 3
                 and bounds.dims[0] == self.y_dimension
                 and bounds.dims[1] == self.x_dimension
-                and self.dataset.dims[bounds.dims[2]] == 4
+                and self.dataset.sizes[bounds.dims[2]] == 4
             ):
                 return cast(xarray.DataArray, bounds)
             else:

src/emsarray/conventions/ugrid.py

@@ -890,10 +890,10 @@ def two_dimension(self) -> Hashable:
         """
         two = 'Two'
         # Check for the standard name
-        if two in self.dataset.dims and self.dataset.dims[two] == 2:
+        if two in self.dataset.sizes and self.dataset.sizes[two] == 2:
             return two
         # Check for any other dimension of size 2
-        for name, size in self.dataset.dims.items():
+        for name, size in self.dataset.sizes.items():
             if size == 2:
                 return name
         # Make up a new dimension with the standard name
@@ -975,7 +975,7 @@ def max_node_dimension(self) -> Hashable:
     @property
     def node_count(self) -> int:
         """The number of nodes in the dataset."""
-        return self.dataset.dims[self.node_dimension]
+        return self.dataset.sizes[self.node_dimension]
 
     @property
     def edge_count(self) -> int:
@@ -986,7 +986,7 @@ def edge_count(self) -> int:
         # This dimension may not be defined, so ignore KeyErrors. We can
         # compute it below.
         with suppress(KeyError):
-            return self.dataset.dims[self.edge_dimension]
+            return self.dataset.sizes[self.edge_dimension]
 
         # By computing the edge_node array we can determine how many edges exist
         return self.edge_node_array.shape[0]
@@ -996,12 +996,12 @@ def face_count(self) -> int:
         """
         The number of faces in the dataset.
         """
-        return self.dataset.dims[self.face_dimension]
+        return self.dataset.sizes[self.face_dimension]
 
     @property
     def max_node_count(self) -> int:
         """The maximum number of nodes / edges per face."""
-        return self.dataset.dims[self.max_node_dimension]
+        return self.dataset.sizes[self.max_node_dimension]
 
 
 class UGridKind(str, enum.Enum):

src/emsarray/transect.py

@@ -422,7 +422,7 @@ def make_poly_collection(
                 (distance_bounds[index, 1], depth_bounds[depth_index][0]),
             ]
             for depth_index in range(transect_dataset.coords['depth'].size)
-            for index in range(transect_dataset.dims['index'])
+            for index in range(transect_dataset.sizes['index'])
         ]
         return PolyCollection(vertices, **kwargs)
 
@@ -474,7 +474,7 @@ def make_ocean_floor_poly_collection(
                 (distance_bounds[index, 1], deepest),
                 (distance_bounds[index, 1], bathymetry_values[linear_indices[index]]),
             ]
-            for index in range(transect_dataset.dims['index'])
+            for index in range(transect_dataset.sizes['index'])
         ]
         return PolyCollection(vertices, **kwargs)
 

src/emsarray/utils.py

@@ -454,7 +454,7 @@ def check_data_array_dimensions_match(dataset: xarray.Dataset, data_array: xarra
                 f"Data array has unknown dimension {dimension} of size {data_array_size}"
             )
 
-        dataset_size = dataset.dims[dimension]
+        dataset_size = dataset.sizes[dimension]
         if data_array_size != dataset_size:
             raise ValueError(
                 "Dimension mismatch between dataset and data array: "

tests/cli/commands/test_extract_points.py

@@ -35,7 +35,7 @@ def test_extract_points(
     point_dataset = xarray.open_dataset(out_path)
 
     assert 'point' in point_dataset.dims
-    assert point_dataset.dims['point'] == num_points
+    assert point_dataset.sizes['point'] == num_points
     assert_equal(points_df['name'], point_dataset['name'].values)
     assert_allclose(points_df['lon'], point_dataset['lon'].values)
     assert_allclose(points_df['lat'], point_dataset['lat'].values)

tests/conventions/test_base.py

@@ -398,7 +398,7 @@ def test_select_index():
     ds_point = convention.select_index(SimpleGridIndex(y, x))
 
     # The x and y dims should have been dropped, as they are now of size 1
-    assert ds_point.dims == {'t': 5, 'z': 5}
+    assert ds_point.sizes == {'t': 5, 'z': 5}
     # The x and y coords should be single values
     assert ds_point.coords['x'].values == x
     assert ds_point.coords['y'].values == y

tests/conventions/test_cfgrid1d.py

@@ -348,7 +348,7 @@ def test_drop_geometry(datasets: pathlib.Path):
     dataset = xarray.open_dataset(datasets / 'cfgrid1d.nc')
 
     dropped = dataset.ems.drop_geometry()
-    assert dropped.dims.keys() == {'lon', 'lat'}
+    assert set(dropped.dims) == {'lon', 'lat'}
 
     topology = dataset.ems.topology
     assert topology.longitude_name in dataset.variables
@@ -408,7 +408,7 @@ def test_make_clip_mask():
     assert_equal(mask.data_vars['cell_mask'].values, expected_cells)
 
     assert mask.attrs == {'type': 'CFGrid mask'}
-    assert mask.dims == {
+    assert mask.sizes == {
         topology.longitude_name: topology.longitude.size,
         topology.latitude_name: topology.latitude.size,
     }
@@ -448,7 +448,7 @@ def test_apply_clip_mask(tmp_path):
     # Check that the variable and dimension keys were preserved
     assert set(dataset.data_vars.keys()) == set(clipped.data_vars.keys())
     assert set(dataset.coords.keys()) == set(clipped.coords.keys())
-    assert set(dataset.dims.keys()) == set(clipped.dims.keys())
+    assert set(dataset.dims) == set(clipped.dims)
 
     # Check that the new topology seems reasonable
     assert clipped.ems.topology.longitude.size == 5