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,36 @@
 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 = {'name', 'tileIndex'}
+iris_forbidden_keys = {'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'}
+
+
+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 +43,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 +58,81 @@ 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
+# TODO: Cell methods are not converted between Iris and xarray
+def to_iris(dataarray):
+    """Convert a DataArray into a Iris Cube
+    """
+    # Iris not a hard dependency
+    import iris
+    # 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 attrs.has_key('units'):
+            _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
+        iris_coord = iris.coords.DimCoord(coord.values, **coord_args)
+        axis = None
+        if coord.dims:
+            axis = dataarray.get_axis_num(coord.dims)
+        if coord_name in dataarray.dims:
+            dim_coords.append((iris_coord, axis))
+        else:
+            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
+
+    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)
+
+    name = cube.var_name
+    dims = [dim.var_name for dim in cube.dim_coords]
+    coords = OrderedDict()
+
+    for coord in cube.coords():
+        coord_attrs = get_attr(coord)
+        coord_dims = [cube.coords()[i].var_name 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)
+    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

@@ -1639,6 +1639,50 @@ 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
+        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])
+
+        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'))
+
+        expected_coords = [Coordinate('distance', [-2, 2]),
+                           Coordinate('time', [0, 1, 2]),
+                           Coordinate('height', [10]),
+                           Coordinate('distance2', [0, 1])]
+
+        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)
+
+        for coord, expected_coord in zip((actual.coords()), expected_coords):
+            self.assertEqual(coord.var_name, expected_coord.name)
+            self.assertArrayEqual(coord.points, expected_coord.values)
+            self.assertEqual(actual.coord_dims(coord),
+                             original.get_axis_num
+                             (original.coords[coord.var_name].dims))
+        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'):