Fix FutureWarning on Dataset.dims.__getvalue__

Fixes FutureWarning introduced by 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)
 

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

tests/conventions/test_cfgrid2d.py

@@ -323,8 +323,8 @@ def test_face_centres():
     face_centres = convention.face_centres
     lons = dataset.variables['longitude'].values
     lats = dataset.variables['latitude'].values
-    for j in range(dataset.dims['j']):
-        for i in range(dataset.dims['i']):
+    for j in range(dataset.sizes['j']):
+        for i in range(dataset.sizes['i']):
             lon = lons[j, i]
             lat = lats[j, i]
             linear_index = convention.ravel_index((j, i))
@@ -391,7 +391,7 @@ def test_wind():
     dataset = make_dataset(j_size=5, i_size=7)
     convention: ShocSimple = dataset.ems
 
-    time_size = dataset.dims['time']
+    time_size = dataset.sizes['time']
     values = numpy.arange(time_size * convention.grid_size[CFGridKind.face])
     flat_array = xarray.DataArray(
         data=values.reshape((time_size, -1)),
@@ -410,7 +410,7 @@ def test_drop_geometry(datasets: pathlib.Path):
     dataset = xarray.open_dataset(datasets / 'cfgrid2d.nc')
 
     dropped = dataset.ems.drop_geometry()
-    assert dropped.dims.keys() == {'i', 'j'}
+    assert set(dropped.dims) == {'i', 'j'}
 
     topology = dataset.ems.topology
     assert topology.longitude_name in dataset.variables

tests/conventions/test_shoc_standard.py

@@ -256,8 +256,8 @@ def test_face_centres():
     face_centres = convention.face_centres
     lons = dataset['x_centre'].values
     lats = dataset['y_centre'].values
-    for j in range(dataset.dims['j_centre']):
-        for i in range(dataset.dims['i_centre']):
+    for j in range(dataset.sizes['j_centre']):
+        for i in range(dataset.sizes['i_centre']):
             lon = lons[j, i]
             lat = lats[j, i]
             linear_index = convention.ravel_index((ArakawaCGridKind.face, j, i))
@@ -375,7 +375,7 @@ def test_select_index_face():
         # because of how xarray handles multidimensional coordinates
         'x_centre', 'y_centre',
     }
-    assert face.dims == {'record': 4, 'k_centre': 5}
+    assert face.sizes == {'record': 4, 'k_centre': 5}
     assert face['x_centre'].values == dataset['x_centre'].values[3, 4]
     assert face['y_centre'].values == dataset['y_centre'].values[3, 4]
 
@@ -393,7 +393,7 @@ def test_select_index_edge():
         # because of how xarray handles multidimensional coordinates
         'x_left', 'y_left'
     }
-    assert left.dims == {'record': 4, 'k_centre': 5}
+    assert left.sizes == {'record': 4, 'k_centre': 5}
 
     back = convention.select_index((ArakawaCGridKind.back, 3, 4))
     assert set(back.data_vars.keys()) == {
@@ -404,7 +404,7 @@ def test_select_index_edge():
         # because of how xarray handles multidimensional coordinates
         'x_back', 'y_back'
     }
-    assert back.dims == {'record': 4, 'k_centre': 5}
+    assert back.sizes == {'record': 4, 'k_centre': 5}
 
 
 def test_select_index_grid():
@@ -420,14 +420,14 @@ def test_select_index_grid():
         # because of how xarray handles multidimensional coordinates
         'x_grid', 'y_grid'
     }
-    assert node.dims == {'record': 4, 'k_centre': 5}
+    assert node.sizes == {'record': 4, 'k_centre': 5}
 
 
 def test_drop_geometry(datasets: pathlib.Path):
     dataset = xarray.open_dataset(datasets / 'shoc_standard.nc')
 
     dropped = dataset.ems.drop_geometry()
-    assert dropped.dims.keys() == {'face_i', 'face_j'}
+    assert set(dropped.dims) == {'face_i', 'face_j'}
     for topology in [dataset.ems.face, dataset.ems.back, dataset.ems.left, dataset.ems.node]:
         assert topology.longitude_name in dataset.variables
         assert topology.longitude_name in dataset.variables
@@ -587,7 +587,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.face.longitude.shape == (3, 3)

tests/conventions/test_ugrid.py

@@ -378,7 +378,7 @@ def test_polygons():
     polygons = dataset.ems.polygons
 
     # Should be one item for every face
-    assert len(polygons) == dataset.dims['nMesh2_face']
+    assert len(polygons) == dataset.sizes['nMesh2_face']
 
     # There should be no empty polygons
     assert all(poly is not None for poly in polygons)
@@ -405,7 +405,7 @@ def test_face_centres_from_variables():
     face_centres = convention.face_centres
     lons = dataset['Mesh2_face_x'].values
     lats = dataset['Mesh2_face_y'].values
-    for face in range(dataset.dims['nMesh2_face']):
+    for face in range(dataset.sizes['nMesh2_face']):
         lon = lons[face]
         lat = lats[face]
         linear_index = convention.ravel_index((UGridKind.face, face))
@@ -417,7 +417,7 @@ def test_face_centres_from_centroids():
     convention: UGrid = dataset.ems
 
     face_centres = convention.face_centres
-    for face in range(dataset.dims['nMesh2_face']):
+    for face in range(dataset.sizes['nMesh2_face']):
         linear_index = convention.ravel_index((UGridKind.face, face))
         polygon = convention.polygons[linear_index]
         lon, lat = polygon.centroid.coords[0]
@@ -459,7 +459,7 @@ def test_make_geojson_geometry():
 def test_ravel():
     dataset = make_dataset(width=3)
     convention: UGrid = dataset.ems
-    for linear_index in range(dataset.dims['nMesh2_face']):
+    for linear_index in range(dataset.sizes['nMesh2_face']):
         index = (UGridKind.face, linear_index)
         assert convention.ravel_index(index) == linear_index
         assert convention.wind_index(linear_index) == index
@@ -524,7 +524,7 @@ def test_drop_geometry_minimal():
     ]
 
     dropped = dataset.ems.drop_geometry()
-    assert dropped.dims.keys() == {
+    assert set(dropped.dims) == {
         # These still exist because there are variables defined on them
         topology.face_dimension, 'Mesh2_layers', 'record'
     }
@@ -576,7 +576,7 @@ def test_drop_geometry_full():
 
     print(list(dataset.variables.keys()))
     dropped = dataset.ems.drop_geometry()
-    assert dropped.dims.keys() == {
+    assert set(dropped.dims) == {
         # These still exist because there are variables defined on them
         topology.face_dimension, topology.edge_dimension,
         'Mesh2_layers', 'record'
@@ -654,7 +654,7 @@ def test_mask_from_face_indices_without_edges():
     node_indices = [12, 13, 14, 17, 18, 19, 20, 23, 24, 25, 26]
 
     mask = mask_from_face_indices(numpy.array(face_indices), topology)
-    assert mask.dims == {
+    assert mask.sizes == {
         'old_node_index': topology.node_count,
         'old_face_index': topology.face_count,
     }
@@ -677,7 +677,7 @@ def test_mask_from_face_indices_with_edges():
     node_indices = [12, 13, 14, 17, 18, 19, 20, 23, 24, 25, 26]
 
     mask = mask_from_face_indices(numpy.array(face_indices), topology)
-    assert mask.dims == {
+    assert mask.sizes == {
         'old_node_index': topology.node_count,
         'old_edge_index': topology.edge_count,
         'old_face_index': topology.face_count,
@@ -713,7 +713,7 @@ def test_apply_clip_mask(tmp_path):
 
     # Check that the variable and dimension keys were preserved
     assert set(dataset.variables.keys()) == set(clipped.variables.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.face_count == len(face_indices)
@@ -762,7 +762,7 @@ def test_make_and_apply_clip_mask(tmp_path):
     # Make a clip mask
     clip_mask = dataset.ems.make_clip_mask(polygon, buffer=1)
     clip_mask.to_netcdf(tmp_path / "clip.nc")
-    assert clip_mask.dims == {
+    assert clip_mask.sizes == {
         'old_face_index': topology.face_count,
         'old_edge_index': topology.edge_count,
         'old_node_index': topology.node_count,

tests/masking/test_mask_dataset.py

@@ -37,7 +37,7 @@ def test_standard_mask_from_centres():
     # The centre should be the same as the input array.
     # Left should be one bigger in the i dimension, back in j.
     # Grid should be one bigger in both j and i dimensions.
-    assert mask.dims == {
+    assert mask.sizes == {
         'j_centre': 6, 'i_centre': 5,
         'j_node': 7, 'i_node': 6,
         'j_left': 6, 'i_left': 6,

tests/operations/depth/test_normalize_depth_variables.py

@@ -108,8 +108,8 @@ def test_normalize_depth_variable(
     assert_equal(out['depth_name'].values, expected_depths)
     assert out['depth_name'].dims == ('depth_dimension',)
 
-    assert out.dims['depth_coord'] == 6
-    assert out.dims['depth_dimension'] == 6
+    assert out.sizes['depth_coord'] == 6
+    assert out.sizes['depth_dimension'] == 6
 
     # Check that a warning was raised if the positive: 'up'/'down' attribute
     # was not set

tests/operations/depth/test_ocean_floor.py

@@ -36,7 +36,7 @@ def test_ocean_floor():
 
     floor_dataset = ocean_floor(dataset, ['depth'], non_spatial_variables=['time'])
 
-    assert floor_dataset.dims == {
+    assert floor_dataset.sizes == {
         't': 5,
         'x': 5,
         'y': 5,