Read grid mapping and bounds as coords

xarray/conventions.py

@@ -235,6 +235,11 @@ def encode_cf_variable(var, needs_copy=True, name=None):
     var = maybe_default_fill_value(var)
     var = maybe_encode_bools(var)
     var = ensure_dtype_not_object(var, name=name)
+
+    if var.encoding.get('grid_mapping', None) is not None:
+        var.attrs['grid_mapping'] = var.encoding.pop('grid_mapping')
+    if var.encoding.get('bounds', None) is not None:
+        var.attrs['bounds'] = var.encoding.pop('bounds')
     return var
 
 
@@ -408,6 +413,20 @@ 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)
+                del var_attrs['bounds']
+            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)
+                del var_attrs['grid_mapping']
 
     if decode_coords and 'coordinates' in attributes:
         attributes = OrderedDict(attributes)
@@ -535,6 +554,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 +563,12 @@ def _encode_coordinates(variables, attributes, non_dim_coord_names):
                 variable_coordinates[k].add(coord_name)
                 global_coordinates.discard(coord_name)
 
+            encoding_val = v.encoding.get
+            if ((encoding_val('bounds', None) == coord_name or
+                 encoding_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 +579,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,46 @@ 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]])),
+            dict(
+                latitude=('latitude',
+                          [0, 1],
+                          {'units': 'degrees_north'}),
+                longitude=('longitude',
+                           [0, 1],
+                           {'units': 'degrees_east'}),
+                latlon=((), -1, {'grid_mapping_name': 'latitude_longitude'}),
+                latitude_bnds=(('latitude', 'bnds2'),
+                               [[0, 1], [1, 2]]),
+                longitude_bnds=(('longitude', 'bnds2'),
+                                [[0, 1], [1, 2]])
+            )
+        )
+        original['variable'].encoding['grid_mapping'] = 'latlon'
+        original.coords['latitude'].encoding.update(
+            dict(grid_mapping='latlon',
+                 bounds='latitude_bnds')
+        )
+        original.coords['longitude'].encoding.update(
+            dict(grid_mapping='latlon',
+                 bounds='longitude_bnds')
+        )
+        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
+
+        with self.roundtrip(original) as actual:
+            assert_identical(actual, original)
+
     def test_coordinates_encoding(self):
         def equals_latlon(obj):
             return obj == 'lat lon' or obj == 'lon lat'