BUG: also fix DataFrame.__radd__, GH #353

Author: wesm

pandas/core/frame.py

@@ -332,10 +332,10 @@ def __contains__(self, key):
     sub = _arith_method(operator.sub, 'subtract')
     div = _arith_method(lambda x, y: x / y, 'divide')
 
-    radd = _arith_method(operator.add, 'add')
-    rmul = _arith_method(operator.mul, 'multiply')
-    rsub = _arith_method(lambda x, y: y - x, 'subtract')
-    rdiv = _arith_method(lambda x, y: y / x, 'divide')
+    radd = _arith_method(lambda x, y: y + x, 'radd')
+    rmul = _arith_method(operator.mul, 'rmultiply')
+    rsub = _arith_method(lambda x, y: y - x, 'rsubtract')
+    rdiv = _arith_method(lambda x, y: y / x, 'rdivide')
 
     __add__ = _arith_method(operator.add, '__add__', default_axis=None)
     __sub__ = _arith_method(operator.sub, '__sub__', default_axis=None)
@@ -346,7 +346,7 @@ def __contains__(self, key):
                                default_axis=None)
     __pow__ = _arith_method(operator.pow, '__pow__', default_axis=None)
 
-    __radd__ = _arith_method(operator.add, '__radd__', default_axis=None)
+    __radd__ = _arith_method(lambda x, y: y + x, '__radd__', default_axis=None)
     __rmul__ = _arith_method(operator.mul, '__rmul__', default_axis=None)
     __rsub__ = _arith_method(lambda x, y: y - x, '__rsub__', default_axis=None)
     __rtruediv__ = _arith_method(lambda x, y: y / x, '__rtruediv__',

pandas/tests/test_series.py

@@ -15,7 +15,7 @@
 import pandas.core.datetools as datetools
 from pandas.util import py3compat
 from pandas.util.testing import assert_series_equal, assert_almost_equal
-import pandas.util.testing as common
+import pandas.util.testing as tm
 
 #-------------------------------------------------------------------------------
 # Series test cases
@@ -138,13 +138,13 @@ def test_to_sparse_pass_name(self):
 class TestSeries(unittest.TestCase, CheckNameIntegration):
 
     def setUp(self):
-        self.ts = common.makeTimeSeries()
+        self.ts = tm.makeTimeSeries()
         self.ts.name = 'ts'
 
-        self.series = common.makeStringSeries()
+        self.series = tm.makeStringSeries()
         self.series.name = 'series'
 
-        self.objSeries = common.makeObjectSeries()
+        self.objSeries = tm.makeObjectSeries()
         self.objSeries.name = 'objects'
 
         self.empty = Series([], index=[])
@@ -157,7 +157,7 @@ def test_constructor(self):
         derived = Series(self.ts)
         self.assert_(isinstance(derived, TimeSeries))
 
-        self.assert_(common.equalContents(derived.index, self.ts.index))
+        self.assert_(tm.equalContents(derived.index, self.ts.index))
         # Ensure new index is not created
         self.assertEquals(id(self.ts.index), id(derived.index))
 
@@ -181,7 +181,7 @@ def test_constructor_default_index(self):
         assert_almost_equal(s.index, np.arange(3))
 
     def test_constructor_corner(self):
-        df = common.makeTimeDataFrame()
+        df = tm.makeTimeDataFrame()
         objs = [df, df]
         s = Series(objs, index=[0, 1])
         self.assert_(isinstance(s, Series))
@@ -204,7 +204,7 @@ def test_fromDict(self):
         data = {'a' : 0, 'b' : 1, 'c' : 2, 'd' : 3}
 
         series = Series(data)
-        self.assert_(common.is_sorted(series.index))
+        self.assert_(tm.is_sorted(series.index))
 
         data = {'a' : 0, 'b' : '1', 'c' : '2', 'd' : datetime.now()}
         series = Series(data)
@@ -251,7 +251,7 @@ def test_fromValue(self):
         self.assertEqual(len(dates), len(self.ts))
 
     def test_contains(self):
-        common.assert_contains_all(self.ts.index, self.ts)
+        tm.assert_contains_all(self.ts.index, self.ts)
 
     def test_pickle(self):
         unp_series = self._pickle_roundtrip(self.series)
@@ -365,7 +365,7 @@ def test_slice(self):
 
         self.assertEqual(numSlice.index[1], self.series.index[11])
 
-        self.assert_(common.equalContents(numSliceEnd,
+        self.assert_(tm.equalContents(numSliceEnd,
                                           np.array(self.series)[-10:]))
 
         # test return view
@@ -383,8 +383,8 @@ def test_setitem(self):
         self.assert_(not np.isnan(self.ts[2]))
 
         # caught this bug when writing tests
-        series = Series(common.makeIntIndex(20).astype(float),
-                        index=common.makeIntIndex(20))
+        series = Series(tm.makeIntIndex(20).astype(float),
+                        index=tm.makeIntIndex(20))
 
         series[::2] = 0
         self.assert_((series[::2] == 0).all())
@@ -469,7 +469,7 @@ def test_repr(self):
         str(self.series.astype(int))
         str(self.objSeries)
 
-        str(Series(common.randn(1000), index=np.arange(1000)))
+        str(Series(tm.randn(1000), index=np.arange(1000)))
 
         # empty
         str(self.empty)
@@ -647,7 +647,7 @@ def _check_op(other, op):
             cython_or_numpy = op(series, other)
             python = series.combine(other, op)
 
-            common.assert_almost_equal(cython_or_numpy, python)
+            tm.assert_almost_equal(cython_or_numpy, python)
 
         def check(other):
             _check_op(other, operator.add)
@@ -706,8 +706,6 @@ def test_operators_corner(self):
         self.assert_(np.array_equal(added[:-5], expected))
 
     def test_operators_reverse_object(self):
-        from pandas.util.testing import rands
-
         # GH 56
         arr = Series(np.random.randn(10), index=np.arange(10),
                      dtype=object)
@@ -723,18 +721,26 @@ def _check_op(arr, op):
         _check_op(arr, operator.truediv)
         _check_op(arr, operator.floordiv)
 
+    def test_series_frame_radd_bug(self):
+        from pandas.util.testing import rands
+
         # GH 353
         vals = Series([rands(5) for _ in xrange(10)])
         result = 'foo_' + vals
         expected = vals.map(lambda x: 'foo_' + x)
         assert_series_equal(result, expected)
 
+        frame = DataFrame({'vals' : vals})
+        result = 'foo_' + frame
+        expected = DataFrame({'vals' : vals.map(lambda x: 'foo_' + x)})
+        tm.assert_frame_equal(result, expected)
+
     def test_operators_frame(self):
         # rpow does not work with DataFrame
         df = DataFrame({'A' : self.ts})
 
-        common.assert_almost_equal(self.ts + self.ts, (self.ts + df)['A'])
-        common.assert_almost_equal(self.ts ** self.ts, (self.ts ** df)['A'])
+        tm.assert_almost_equal(self.ts + self.ts, (self.ts + df)['A'])
+        tm.assert_almost_equal(self.ts ** self.ts, (self.ts ** df)['A'])
 
     def test_operators_combine(self):
         def _check_fill(meth, op, a, b, fill_value=0):
@@ -782,8 +788,8 @@ def _check_fill(meth, op, a, b, fill_value=0):
             _check_fill(op, equiv_op, a, b, fill_value=fv)
 
     def test_combine_first(self):
-        values = common.makeIntIndex(20).values.astype(float)
-        series = Series(values, index=common.makeIntIndex(20))
+        values = tm.makeIntIndex(20).values.astype(float)
+        series = Series(values, index=tm.makeIntIndex(20))
 
         series_copy = series * 2
         series_copy[::2] = np.NaN
@@ -801,14 +807,14 @@ def test_combine_first(self):
         self.assert_(np.array_equal(combined[1::2], series_copy[1::2]))
 
         # mixed types
-        index = common.makeStringIndex(20)
-        floats = Series(common.randn(20), index=index)
-        strings = Series(common.makeStringIndex(10), index=index[::2])
+        index = tm.makeStringIndex(20)
+        floats = Series(tm.randn(20), index=index)
+        strings = Series(tm.makeStringIndex(10), index=index[::2])
 
         combined = strings.combine_first(floats)
 
-        common.assert_dict_equal(strings, combined, compare_keys=False)
-        common.assert_dict_equal(floats[1::2], combined, compare_keys=False)
+        tm.assert_dict_equal(strings, combined, compare_keys=False)
+        tm.assert_dict_equal(floats[1::2], combined, compare_keys=False)
 
         # corner case
         s = Series([1., 2, 3], index=[0, 1, 2])
@@ -939,7 +945,7 @@ def test_valid(self):
         result = ts.valid()
         self.assertEqual(len(result), ts.count())
 
-        common.assert_dict_equal(result, ts, compare_keys=False)
+        tm.assert_dict_equal(result, ts, compare_keys=False)
 
     def test_isnull(self):
         ser = Series([0,5.4,3,nan,-0.001])
@@ -957,7 +963,7 @@ def test_shift(self):
         shifted = self.ts.shift(1)
         unshifted = shifted.shift(-1)
 
-        common.assert_dict_equal(unshifted.valid(), self.ts, compare_keys=False)
+        tm.assert_dict_equal(unshifted.valid(), self.ts, compare_keys=False)
 
         offset = datetools.bday
         shifted = self.ts.shift(1, offset=offset)
@@ -1055,7 +1061,7 @@ def test_asof(self):
         self.assert_(np.isnan(self.ts.asof(d)))
 
     def test_map(self):
-        index, data = common.getMixedTypeDict()
+        index, data = tm.getMixedTypeDict()
 
         source = Series(data['B'], index=data['C'])
         target = Series(data['C'][:4], index=data['D'][:4])
@@ -1262,8 +1268,8 @@ def test_preserveRefs(self):
     def test_ne(self):
         ts = TimeSeries([3, 4, 5, 6, 7], [3, 4, 5, 6, 7], dtype=float)
         expected = [True, True, False, True, True]
-        self.assert_(common.equalContents(ts.index != 5, expected))
-        self.assert_(common.equalContents(~(ts.index == 5), expected))
+        self.assert_(tm.equalContents(ts.index != 5, expected))
+        self.assert_(tm.equalContents(~(ts.index == 5), expected))
 
     def test_pad_nan(self):
         x = TimeSeries([np.nan, 1., np.nan, 3., np.nan],
@@ -1320,7 +1326,7 @@ def test_isin(self):
 # TimeSeries-specific
 
     def test_fillna(self):
-        ts = Series([0., 1., 2., 3., 4.], index=common.makeDateIndex(5))
+        ts = Series([0., 1., 2., 3., 4.], index=tm.makeDateIndex(5))
 
         self.assert_(np.array_equal(ts, ts.fillna()))