xarray to and from iris

.travis.yml

@@ -12,7 +12,7 @@ matrix:
   - python: 2.7
     env: CONDA_ENV=py27-min
   - python: 2.7
-    env: CONDA_ENV=py27-cdat+pynio
+    env: CONDA_ENV=py27-cdat+iris+pynio
   - python: 3.4
     env: CONDA_ENV=py34
   - python: 3.5

ci/requirements-py27-cdat+pynio.yml → ci/requirements-py27-cdat+iris+pynio.yml

@@ -2,6 +2,7 @@ name: test_env
 channels:
   - ajdawson  # cdat
   - dbrown  # pynio
+  - scitools # iris
 dependencies:
   - python=2.7
   - cdat-lite
@@ -11,6 +12,7 @@ dependencies:
   - pandas>=0.15.0
   - pynio
   - scipy
+  - iris
   - pip:
     - coveralls
     - pytest-cov

xarray/convert.py

@@ -3,24 +3,40 @@
 import numpy as np
 
 from .core.dataarray import DataArray
+from .core.pycompat import OrderedDict
 from .conventions import (
     maybe_encode_timedelta, maybe_encode_datetime, decode_cf)
 
-ignored_attrs = set(['name', 'tileIndex'])
+cdms2_ignored_attrs = set(['name', 'tileIndex'])
+iris_forbidden_keys = set(
+    ['standard_name', 'long_name', 'units', 'bounds', 'axis',
+     'calendar', 'leap_month', 'leap_year', 'month_lengths',
+     'coordinates', 'grid_mapping', 'climatology',
+     'cell_methods', 'formula_terms', 'compress',
+     'missing_value', 'add_offset', 'scale_factor',
+     'valid_max', 'valid_min', 'valid_range', '_FillValue'])
+cell_methods_strings = set(['point', 'sum', 'maximum', 'median', 'mid_range',
+                            'minimum', 'mean', 'mode', 'standard_deviation',
+                            'variance'])
+
+
+def encode(var):
+    return maybe_encode_timedelta(maybe_encode_datetime(var.variable))
+
+
+def filter_attrs(_attrs, ignored_attrs):
+    return dict((k, v) for k, v in _attrs.items() if k not in ignored_attrs)
 
 
 def from_cdms2(variable):
     """Convert a cdms2 variable into an DataArray
     """
-    def get_cdms2_attrs(var):
-        return dict((k, v) for k, v in var.attributes.items()
-                    if k not in ignored_attrs)
-
     values = np.asarray(variable)
     name = variable.id
-    coords = [(v.id, np.asarray(v), get_cdms2_attrs(v))
+    coords = [(v.id, np.asarray(v),
+               filter_attrs(v.attributes, cdms2_ignored_attrs))
               for v in variable.getAxisList()]
-    attrs = get_cdms2_attrs(variable)
+    attrs = filter_attrs(variable.attributes, cdms2_ignored_attrs)
     dataarray = DataArray(values, coords=coords, name=name, attrs=attrs)
     return decode_cf(dataarray.to_dataset())[dataarray.name]
 
@@ -31,12 +47,9 @@ def to_cdms2(dataarray):
     # we don't want cdms2 to be a hard dependency
     import cdms2
 
-    def encode(var):
-        return maybe_encode_timedelta(maybe_encode_datetime(var.variable))
-
-    def set_cdms2_attrs(var, attrs):
+    def set_cdms2_attrs(_var, attrs):
         for k, v in attrs.items():
-            setattr(var, k, v)
+            setattr(_var, k, v)
 
     axes = []
     for dim in dataarray.dims:
@@ -49,3 +62,111 @@ def set_cdms2_attrs(var, attrs):
     cdms2_var = cdms2.createVariable(var.values, axes=axes, id=dataarray.name)
     set_cdms2_attrs(cdms2_var, var.attrs)
     return cdms2_var
+
+
+# TODO: Add converting bounds from xarray to Iris and back
+def to_iris(dataarray):
+    """Convert a DataArray into a Iris Cube
+    """
+    # Iris not a hard dependency
+    import iris
+    try:
+        from iris.fileformats.netcdf import parse_cell_methods
+    except ImportError:
+        # prior to v1.10
+        from iris.fileformats._pyke_rules.compiled_krb.fc_rules_cf_fc \
+            import _parse_cell_methods as parse_cell_methods
+
+    # iris.unit is deprecated in Iris v1.9
+    import cf_units
+
+    def check_attrs(attrs, keys):
+        return dict((k, v) for k, v in attrs.items() if k in keys)
+
+    def get_args(attrs):
+        _args = {'attributes': filter_attrs(attrs, iris_forbidden_keys)}
+        _args.update(check_attrs(attrs, ('standard_name', 'long_name',)))
+        _unit_args = check_attrs(coord.attrs, ('calendar',))
+        if 'units' in attrs:
+            _args['units'] = cf_units.Unit(attrs['units'], **_unit_args)
+        return _args
+
+    dim_coords = []
+    aux_coords = []
+
+    for coord_name in dataarray.coords:
+        coord = encode(dataarray.coords[coord_name])
+        coord_args = get_args(coord.attrs)
+        coord_args['var_name'] = coord_name
+        axis = None
+        if coord.dims:
+            axis = dataarray.get_axis_num(coord.dims)
+        if coord_name in dataarray.dims:
+            iris_coord = iris.coords.DimCoord(coord.values, **coord_args)
+            dim_coords.append((iris_coord, axis))
+        else:
+            iris_coord = iris.coords.AuxCoord(coord.values, **coord_args)
+            aux_coords.append((iris_coord, axis))
+
+    args = get_args(dataarray.attrs)
+    args['var_name'] = dataarray.name
+    args['dim_coords_and_dims'] = dim_coords
+    args['aux_coords_and_dims'] = aux_coords
+    if 'cell_methods' in dataarray.attrs:
+        args['cell_methods'] = \
+            parse_cell_methods(dataarray.name, dataarray.attrs['cell_methods'])
+
+    cube = iris.cube.Cube(dataarray.to_masked_array(), **args)
+    return cube
+
+
+def from_iris(cube):
+    """Convert a Iris cube into an DataArray
+    """
+
+    def get_attr(_obj):
+        attrs = {'standard_name': _obj.standard_name,
+                 'long_name': _obj.long_name}
+        if _obj.units.calendar:
+            attrs['calendar'] = _obj.units.calendar
+        if _obj.units.origin != '1':
+            attrs['units'] = _obj.units.origin
+        attrs.update(_obj.attributes)
+        return dict((k, v) for k, v in attrs.items() if v is not None)
+
+    def get_cell_methods(cell_methods_obj):
+        _cell_methods = []
+        for cell_method in cell_methods_obj:
+            names = ''.join(['{}: '.format(n) for n in cell_method.coord_names])
+            intervals = ' '.join(['interval: {}'.format(interval)
+                                  for interval in cell_method.intervals])
+            comments = ' '.join(['comment: {}'.format(comment)
+                                 for comment in cell_method.comments])
+            extra = ' '.join([intervals, comments]).strip()
+            if extra:
+                extra = ' ({})'.format(extra)
+            _cell_methods.append(names + cell_method.method + extra)
+        return ' '.join(_cell_methods)
+
+    name = cube.var_name
+    dims = [dim.var_name for dim in cube.dim_coords]
+    if not dims:
+        dims = ["dim{}".format(i) for i in range(cube.data.ndim)]
+    coords = OrderedDict()
+
+    for coord in cube.coords():
+        coord_attrs = get_attr(coord)
+        coord_dims = [dims[i] for i in cube.coord_dims(coord)]
+        if coord_dims:
+            coords[coord.var_name] = (coord_dims, coord.points, coord_attrs)
+        else:
+            coords[coord.var_name] = ((),
+                                      np.asscalar(coord.points), coord_attrs)
+
+    array_attrs = get_attr(cube)
+    cell_methods = get_cell_methods(cube.cell_methods)
+    if cell_methods:
+        array_attrs['cell_methods'] = cell_methods
+    dataarray = DataArray(cube.data, coords=coords, name=name,
+                          attrs=array_attrs, dims=dims)
+    return decode_cf(dataarray.to_dataset())[dataarray.name]

xarray/core/dataarray.py

@@ -1099,6 +1099,19 @@ def from_cdms2(cls, variable):
         from ..convert import from_cdms2
         return from_cdms2(variable)
 
+    def to_iris(self):
+        """Convert this array into a iris.cube.Cube
+        """
+        from ..convert import to_iris
+        return to_iris(self)
+
+    @classmethod
+    def from_iris(cls, cube):
+        """Convert a iris.cube.Cube into an xarray.DataArray
+        """
+        from ..convert import from_iris
+        return from_iris(cube)
+
     def _all_compat(self, other, compat_str):
         """Helper function for equals and identical"""
         def compat(x, y):

xarray/test/test_dataarray.py

@@ -8,6 +8,7 @@
                     Coordinate, Variable)
 from xarray.core.pycompat import iteritems, OrderedDict
 from xarray.core.common import _full_like
+from xarray.conventions import maybe_encode_datetime
 from . import (TestCase, ReturnItem, source_ndarray, unittest, requires_dask,
                requires_bottleneck)
 
@@ -1621,15 +1622,15 @@ def test_to_and_from_cdms2(self):
                              [('distance', [-2, 2], {'units': 'meters'}),
                               ('time', pd.date_range('2000-01-01', periods=3))],
                              name='foo', attrs={'baz': 123})
-        expected_coords = [Coordinate('distance', [-2, 2]),
-                           Coordinate('time', [0, 1, 2])]
+
         actual = original.to_cdms2()
         self.assertArrayEqual(actual, original)
         self.assertEqual(actual.id, original.name)
         self.assertItemsEqual(actual.getAxisIds(), original.dims)
-        for axis, coord in zip(actual.getAxisList(), expected_coords):
+        for axis, coord_key in zip(actual.getAxisList(), original.coords):
+            coord = original.coords[coord_key]
             self.assertEqual(axis.id, coord.name)
-            self.assertArrayEqual(axis, coord.values)
+            self.assertArrayEqual(axis, maybe_encode_datetime(coord).values)
         self.assertEqual(actual.baz, original.attrs['baz'])
 
         component_times = actual.getAxis(1).asComponentTime()
@@ -1639,6 +1640,60 @@ def test_to_and_from_cdms2(self):
         roundtripped = DataArray.from_cdms2(actual)
         self.assertDataArrayIdentical(original, roundtripped)
 
+    def test_to_and_from_iris(self):
+        try:
+            import iris
+            import cf_units
+        except ImportError:
+            raise unittest.SkipTest('iris not installed')
+
+        coord_dict = OrderedDict()
+        coord_dict['distance'] = ('distance', [-2, 2], {'units': 'meters'})
+        coord_dict['time'] = ('time', pd.date_range('2000-01-01', periods=3))
+        coord_dict['height'] = 10
+        coord_dict['distance2'] = ('distance', [0, 1], {'foo': 'bar'})
+        coord_dict['time2'] = (('distance', 'time'), [[0, 1, 2], [2, 3, 4]])
+
+        original = DataArray(np.arange(6).reshape(2, 3), coord_dict,
+                             name='Temperature', attrs={'baz': 123,
+                                                        'units': 'Kelvin',
+                                                        'standard_name':
+                                                            'fire_temperature',
+                                                        'long_name':
+                                                            'Fire Temperature'},
+                             dims=('distance', 'time'))
+
+        original.attrs['cell_methods'] = 'height: mean (comment: A cell method)'
+        actual = original.to_iris()
+        self.assertArrayEqual(actual.data, original.data)
+        self.assertEqual(actual.var_name, original.name)
+        self.assertItemsEqual([d.var_name for d in actual.dim_coords],
+                              original.dims)
+        self.assertEqual(actual.cell_methods,
+                         (iris.coords.CellMethod(method='mean',
+                                                 coords=('height',),
+                                                 intervals=(),
+                                                 comments=('A cell method',)),))
+
+        for coord, orginal_key in zip((actual.coords()), original.coords):
+            original_coord = original.coords[orginal_key]
+            self.assertEqual(coord.var_name, original_coord.name)
+            self.assertArrayEqual(coord.points,
+                                  maybe_encode_datetime(original_coord).values)
+            self.assertEqual(actual.coord_dims(coord),
+                             original.get_axis_num
+                             (original.coords[coord.var_name].dims))
+
+        self.assertEqual(actual.coord('distance2').attributes['foo'],
+                         original.coords['distance2'].attrs['foo'])
+        self.assertEqual(actual.coord('distance').units,
+                         cf_units.Unit(original.coords['distance'].units))
+        self.assertEqual(actual.attributes['baz'], original.attrs['baz'])
+        self.assertEqual(actual.standard_name, original.attrs['standard_name'])
+
+        roundtripped = DataArray.from_iris(actual)
+        self.assertDataArrayIdentical(original, roundtripped)
+
     def test_to_dataset_whole(self):
         unnamed = DataArray([1, 2], dims='x')
         with self.assertRaisesRegexp(ValueError, 'unable to convert unnamed'):