Read grid mapping and bounds as coords

xarray/conventions.py

@@ -408,6 +408,18 @@ def stackable(dim):
                     new_vars[k].encoding['coordinates'] = coord_str
                     del var_attrs['coordinates']
                     coord_names.update(var_coord_names)
+            if 'bounds' in var_attrs:
+                bounds_str = var_attrs['bounds']
+                var_bounds_names = [bounds_str]
+                if all(k in variables for k in var_bounds_names):
+                    new_vars[k].encoding['bounds'] = bounds_str
+                    coord_names.update(var_bounds_names)
+            if 'grid_mapping' in var_attrs:
+                proj_str = var_attrs['grid_mapping']
+                var_proj_names = proj_str.split()
+                if all(k in variables for k in var_proj_names):
+                    new_vars[k].encoding['grid_mapping'] = proj_str
+                    coord_names.update(var_proj_names)
 
     if decode_coords and 'coordinates' in attributes:
         attributes = OrderedDict(attributes)
@@ -535,6 +547,7 @@ def _encode_coordinates(variables, attributes, non_dim_coord_names):
 
     global_coordinates = non_dim_coord_names.copy()
     variable_coordinates = defaultdict(set)
+    not_technically_coordinates = set()
     for coord_name in non_dim_coord_names:
         target_dims = variables[coord_name].dims
         for k, v in variables.items():
@@ -543,6 +556,12 @@ def _encode_coordinates(variables, attributes, non_dim_coord_names):
                 variable_coordinates[k].add(coord_name)
                 global_coordinates.discard(coord_name)
 
+            att_val = v.attrs.get
+            if ((att_val("bounds", None) == coord_name or
+                 att_val("grid_mapping", None) == coord_name)):
+                not_technically_coordinates.add(coord_name)
+                global_coordinates.discard(coord_name)
+
     variables = OrderedDict((k, v.copy(deep=False))
                             for k, v in variables.items())
 
@@ -553,6 +572,12 @@ def _encode_coordinates(variables, attributes, non_dim_coord_names):
             raise ValueError('cannot serialize coordinates because variable '
                              "%s already has an attribute 'coordinates'"
                              % var_name)
+
+        # Only add actual coordinates to coordinates
+        # Exceptions are created using CF mechanisms
+        # Non-CF datasets work as previously
+        for not_coord in not_technically_coordinates:
+            coord_names.discard(not_coord)
         attrs['coordinates'] = ' '.join(map(str, coord_names))
 
     # These coordinates are not associated with any particular variables, so we

xarray/tests/test_backends.py

@@ -714,6 +714,40 @@ def test_roundtrip_mask_and_scale(self, decoded_fn, encoded_fn):
                         actual.variables[k].dtype)
             assert_allclose(decoded, actual, decode_bytes=False)
 
+    def test_grid_mapping_and_bounds_are_coordinates(self):
+        original = Dataset(
+            dict(variable=(('latitude', 'longitude'),
+                           [[0, 1], [2, 3]],
+                           {'grid_mapping': 'latlon'})),
+            dict(
+                latitude=('latitude',
+                          [0, 1],
+                          {'bounds': 'latitude_bnds',
+                           'grid_mapping': 'latlon'}),
+                longitude=('longitude',
+                           [0, 1],
+                           {'bounds': 'longitude_bnds',
+                            'grid_mapping': 'latlon'}),
+                latlon=((), -1, {'grid_mapping_name': 'latitude_longitude'}),
+                latitude_bnds=(('latitude', 'bnds2'),
+                               [[0, 1], [1, 2]]),
+                longitude_bnds=(('longitude', 'bnds2'),
+                                [[0, 1], [1, 2]])
+            )
+        )
+        with self.roundtrip(original) as actual:
+            assert_identical(actual, original)
+
+            with create_tmp_file() as tmp_file:
+                original.to_netcdf(tmp_file)
+                with open_dataset(tmp_file, decode_coords=False) as ds:
+                    assert (ds.coords['latitude'].attrs['bounds'] ==
+                            'latitude_bnds')
+                    assert (ds.coords['longitude'].attrs['bounds'] ==
+                            'longitude_bnds')
+                    assert 'latlon' not in ds['variable'].attrs['coordinates']
+                    assert 'coordinates' not in ds.attrs
+
     def test_coordinates_encoding(self):
         def equals_latlon(obj):
             return obj == 'lat lon' or obj == 'lon lat'