docs: def get_cell_node_coord(self, var, coords=None, axis='x', nans=None):
          """
          Checks whether the bounds in the variable attribute are triangular
  
          Parameters
          ----------
          var: xarray.Variable or xarray.DataArray
              The variable to check
          coords: dict
              Coordinates to use. If None, the coordinates of the dataset in the
              :attr:`ds` attribute are used.
          axis: {'x', 'y'}
              The spatial axis to check
          nans: {None, 'skip', 'only'}
              Determines whether values with nan shall be left (None), skipped
              (``'skip'``) or shall be the only one returned (``'only'``)
  
          Returns
          -------
          xarray.DataArray or None
              the bounds corrdinate (if existent)"""
          if coords is None:
              coords = self.ds.coords
          axis = axis.lower()
          get_coord = self.get_x if axis == 'x' else self.get_y
          coord = get_coord(var, coords=coords)
          if coord is not None:
              bounds = self._get_coord_cell_node_coord(coord, coords, nans,
                                                       var=var)
              if bounds is None:
                  bounds = self.get_plotbounds(coord)
                  dim0 = coord.dims[-1]
  
                  bounds = xr.DataArray(
                      np.dstack([bounds[:-1], bounds[1:]])[0],
                      dims=(dim0, '_bnds'),  attrs=coord.attrs.copy(),
                      name=coord.name + '_bnds')
              if bounds is not None and bounds.shape[-1] == 2:
                  # normal CF-Conventions for rectangular grids
                  arr = bounds.values
                  if axis == 'y':
                      stacked = np.repeat(
                          np.dstack([arr, arr]).reshape((-1, 4)),
                          len(self.get_x(var, coords)), axis=0)
                  else:
                      stacked = np.tile(np.c_[arr, arr[:, ::-1]],
                                        (len(self.get_y(var, coords)), 1))
                  bounds = xr.DataArray(
                      stacked,
                      dims=('cell', bounds.dims[1]), name=bounds.name,
                      attrs=bounds.attrs)
  
              return bounds
          return None