Options to binary ops kwargs

xarray/core/dataarray.py

@@ -23,6 +23,7 @@
                        assert_unique_multiindex_level_names)
 from .formatting import format_item
 from .utils import decode_numpy_dict_values, ensure_us_time_resolution
+from .options import OPTIONS
 
 
 def _infer_coords_and_dims(shape, coords, dims):
@@ -1377,13 +1378,15 @@ def func(self, *args, **kwargs):
         return func
 
     @staticmethod
-    def _binary_op(f, reflexive=False, join='inner', **ignored_kwargs):
+    def _binary_op(f, reflexive=False, join=None, **ignored_kwargs):
         @functools.wraps(f)
         def func(self, other):
             if isinstance(other, (Dataset, groupby.GroupBy)):
                 return NotImplemented
             if hasattr(other, 'indexes'):
-                self, other = align(self, other, join=join, copy=False)
+                # if user does not specify join, default to OPTIONS['join']
+                how_to_join = join or OPTIONS['join']
+                self, other = align(self, other, join=how_to_join, copy=False)
             other_variable = getattr(other, 'variable', other)
             other_coords = getattr(other, 'coords', None)
 

xarray/core/dataset.py

@@ -25,6 +25,7 @@
 from .pycompat import (iteritems, basestring, OrderedDict,
                        dask_array_type)
 from .combine import concat
+from .options import OPTIONS
 
 
 # list of attributes of pd.DatetimeIndex that are ndarrays of time info
@@ -2018,13 +2019,15 @@ def func(self, *args, **kwargs):
         return func
 
     @staticmethod
-    def _binary_op(f, reflexive=False, join='inner', fillna=False):
+    def _binary_op(f, reflexive=False, join=None, fillna=False):
         @functools.wraps(f)
         def func(self, other):
             if isinstance(other, groupby.GroupBy):
                 return NotImplemented
             if hasattr(other, 'indexes'):
-                self, other = align(self, other, join=join, copy=False)
+                # if user does not specify join, default to OPTIONS['join']
+                how_to_join = join or OPTIONS['join']
+                self, other = align(self, other, join=how_to_join, copy=False)
             g = f if not reflexive else lambda x, y: f(y, x)
             ds = self._calculate_binary_op(g, other, fillna=fillna)
             return ds

xarray/core/options.py

@@ -1,4 +1,5 @@
-OPTIONS = {'display_width': 80}
+OPTIONS = {'display_width': 80,
+           'join': "inner"}
 
 
 class set_options(object):

xarray/test/test_dataarray.py

@@ -2268,3 +2268,35 @@ def test_dot(self):
             da.dot(dm.values)
         with self.assertRaisesRegexp(ValueError, 'no shared dimensions'):
             da.dot(DataArray(1))
+
+    def test_binary_op_join_setting(self):
+        """
+        A test method to verify the ability to set binary operation join kwarg
+        ("inner", "outer", "left", "right") via xr.set_options().
+        """
+        # First we set up a data array
+        xdim, ydim, zdim = 'x', 'y', 'z'
+        xcoords, ycoords, zcoords = ['a', 'b', 'c'], [-2, 0, 2], [0, 1, 2]
+        total_size = len(xcoords) * len(ycoords) * len(zcoords)
+        # create a 3-by-3-by-3 data array
+        arr = xr.DataArray(np.arange(total_size).\
+                           reshape(len(xcoords),len(ycoords),len(zcoords)),
+                           [(xdim, xcoords), (ydim, ycoords),(zdim, zcoords)])
+        # now create a data array with the last x slice missing
+        missing_last_x = arr[0:-1,:,:].copy()
+        # create another data array with the last z slice missing
+        missing_last_z = arr[:,:,0:-1].copy()
+        # because the default in OPTIONS is join="inner", we test "outer" first
+        xr.set_options(join="outer")
+        result = missing_last_x + missing_last_z
+        self.assertTrue(result.shape == arr.shape)
+        self.assertTrue(result[-1,:,:].isnull().all())
+        self.assertTrue(result[:,:,-1].isnull().all())
+        # now revert back to join="inner"
+        xr.set_options(join="inner")
+        result = missing_last_x + missing_last_z
+        self.assertTrue(result.shape == \
+                        (len(xcoords)-1, len(ycoords), len(zcoords)-1))
+        self.assertTrue(result.notnull().all())
+        self.assertFalse('c' in list(result['x']))
+        self.assertFalse(2 in list(result['z']))

xarray/test/test_dataset.py

@@ -12,6 +12,7 @@
 
 import numpy as np
 import pandas as pd
+import xarray as xr
 import pytest
 
 from xarray import (align, broadcast, concat, merge, conventions, backends,
@@ -2916,6 +2917,44 @@ def test_filter_by_attrs(self):
         for var in new_ds.data_vars:
             self.assertEqual(new_ds[var].height, '10 m')
 
+    def test_binary_op_join_setting(self):
+        """
+        A test method to verify the ability to set binary operation join kwarg
+        ("inner", "outer", "left", "right") via xr.set_options().
+        """
+        # First we set up a data array
+        xdim, ydim, zdim = 'x', 'y', 'z'
+        xcoords, ycoords, zcoords = ['a', 'b', 'c'], [-2, 0, 2], [0, 1, 2]
+        total_size = len(xcoords) * len(ycoords) * len(zcoords)
+        # create a 3-by-3-by-3 data array
+        arr = DataArray(np.arange(total_size).\
+                        reshape(len(xcoords),len(ycoords),len(zcoords)),
+                        [(xdim, xcoords), (ydim, ycoords),(zdim, zcoords)])
+        # now create a data array with the last x slice missing
+        arr1 = arr[0:-1,:,:].copy()
+        missing_last_x = arr1.to_dataset(name='foo')
+        # create another data array with the last z slice missing
+        arr2 = arr[:,:,0:-1].copy()
+        missing_last_z = arr2.to_dataset(name='foo') # needs to be name='foo' as well
+        # because the default in OPTIONS is join="inner", we test "outer" first
+        xr.set_options(join="outer")
+        result = missing_last_x + missing_last_z
+        self.assertTrue(result.foo.shape == arr.shape)
+        self.assertTrue(result.foo[-1,:,:].isnull().all())
+        self.assertTrue(result.foo[:,:,-1].isnull().all())
+        # now revert back to join="inner"
+        xr.set_options(join="inner")
+        result = missing_last_x + missing_last_z
+        self.assertTrue(result.foo.shape == \
+                        (len(xcoords)-1, len(ycoords), len(zcoords)-1))
+        self.assertTrue(result.foo.notnull().all())
+        self.assertFalse('c' in list(result.foo['x']))
+        self.assertFalse(2 in list(result.foo['z']))
+        # just for kicks, what happens when the dataarrays have different names?
+        misnomer = arr1.to_dataset(name='bar')
+        result = missing_last_x + misnomer
+        self.assertTrue(len(result.data_vars)==0) # empty dataset
+
 
 ### Py.test tests