ENH: Silence numpy warnings from certain expressions computed during tests.

Author: rkern

pandas/computation/tests/test_eval.py

@@ -1613,7 +1613,8 @@ def test_unary_functions(self):
         for fn in self.unary_fns:
             expr = "{0}(a)".format(fn)
             got = self.eval(expr)
-            expect = getattr(np, fn)(a)
+            with np.errstate(all='ignore'):
+                expect = getattr(np, fn)(a)
             tm.assert_series_equal(got, expect, check_names=False)
 
     def test_binary_functions(self):
@@ -1624,7 +1625,8 @@ def test_binary_functions(self):
         for fn in self.binary_fns:
             expr = "{0}(a, b)".format(fn)
             got = self.eval(expr)
-            expect = getattr(np, fn)(a, b)
+            with np.errstate(all='ignore'):
+                expect = getattr(np, fn)(a, b)
             tm.assert_almost_equal(got, expect, check_names=False)
 
     def test_df_use_case(self):

pandas/sparse/tests/test_array.py

@@ -516,15 +516,17 @@ def _check_inplace_op(op):
             tmp = arr1.copy()
             self.assertRaises(NotImplementedError, op, tmp, arr2)
 
-        bin_ops = [operator.add, operator.sub, operator.mul, operator.truediv,
-                   operator.floordiv, operator.pow]
-        for op in bin_ops:
-            _check_op(op, arr1, arr2)
-            _check_op(op, farr1, farr2)
-
-        inplace_ops = ['iadd', 'isub', 'imul', 'itruediv', 'ifloordiv', 'ipow']
-        for op in inplace_ops:
-            _check_inplace_op(getattr(operator, op))
+        with np.errstate(all='ignore'):
+            bin_ops = [operator.add, operator.sub, operator.mul,
+                       operator.truediv, operator.floordiv, operator.pow]
+            for op in bin_ops:
+                _check_op(op, arr1, arr2)
+                _check_op(op, farr1, farr2)
+
+            inplace_ops = ['iadd', 'isub', 'imul', 'itruediv', 'ifloordiv',
+                           'ipow']
+            for op in inplace_ops:
+                _check_inplace_op(getattr(operator, op))
 
     def test_pickle(self):
         def _check_roundtrip(obj):

pandas/tests/formats/test_format.py

@@ -1668,7 +1668,7 @@ def test_string_repr_encoding(self):
 
     def test_repr_corner(self):
         # representing infs poses no problems
-        df = DataFrame({'foo': np.inf * np.empty(10)})
+        df = DataFrame({'foo': [-np.inf, np.inf]})
         repr(df)
 
     def test_frame_info_encoding(self):

pandas/tests/frame/test_apply.py

@@ -22,18 +22,19 @@ class TestDataFrameApply(tm.TestCase, TestData):
     _multiprocess_can_split_ = True
 
     def test_apply(self):
-        # ufunc
-        applied = self.frame.apply(np.sqrt)
-        assert_series_equal(np.sqrt(self.frame['A']), applied['A'])
+        with np.errstate(all='ignore'):
+            # ufunc
+            applied = self.frame.apply(np.sqrt)
+            assert_series_equal(np.sqrt(self.frame['A']), applied['A'])
 
-        # aggregator
-        applied = self.frame.apply(np.mean)
-        self.assertEqual(applied['A'], np.mean(self.frame['A']))
+            # aggregator
+            applied = self.frame.apply(np.mean)
+            self.assertEqual(applied['A'], np.mean(self.frame['A']))
 
-        d = self.frame.index[0]
-        applied = self.frame.apply(np.mean, axis=1)
-        self.assertEqual(applied[d], np.mean(self.frame.xs(d)))
-        self.assertIs(applied.index, self.frame.index)  # want this
+            d = self.frame.index[0]
+            applied = self.frame.apply(np.mean, axis=1)
+            self.assertEqual(applied[d], np.mean(self.frame.xs(d)))
+            self.assertIs(applied.index, self.frame.index)  # want this
 
         # invalid axis
         df = DataFrame(
@@ -187,10 +188,11 @@ def _checkit(axis=0, raw=False):
             _checkit(raw=True)
             _checkit(axis=0, raw=True)
 
-        _check(no_cols, lambda x: x)
-        _check(no_cols, lambda x: x.mean())
-        _check(no_index, lambda x: x)
-        _check(no_index, lambda x: x.mean())
+        with np.errstate(all='ignore'):
+            _check(no_cols, lambda x: x)
+            _check(no_cols, lambda x: x.mean())
+            _check(no_index, lambda x: x)
+            _check(no_index, lambda x: x.mean())
 
         result = no_cols.apply(lambda x: x.mean(), broadcast=True)
         tm.assertIsInstance(result, DataFrame)

pandas/tests/frame/test_misc_api.py

@@ -207,7 +207,8 @@ def test_new_empty_index(self):
         self.assertIsNone(df2.index.name)
 
     def test_array_interface(self):
-        result = np.sqrt(self.frame)
+        with np.errstate(all='ignore'):
+            result = np.sqrt(self.frame)
         tm.assertIsInstance(result, type(self.frame))
         self.assertIs(result.index, self.frame.index)
         self.assertIs(result.columns, self.frame.columns)

pandas/tests/frame/test_operators.py

@@ -217,7 +217,9 @@ def test_modulo(self):
         assert_frame_equal(result, expected)
 
         # numpy has a slightly different (wrong) treatement
-        result2 = DataFrame(p.values % p.values, index=p.index,
+        with np.errstate(all='ignore'):
+            arr = p.values % p.values
+        result2 = DataFrame(arr, index=p.index,
                             columns=p.columns, dtype='float64')
         result2.iloc[0:3, 1] = np.nan
         assert_frame_equal(result2, expected)
@@ -227,8 +229,9 @@ def test_modulo(self):
         assert_frame_equal(result, expected)
 
         # numpy has a slightly different (wrong) treatement
-        result2 = DataFrame(p.values.astype('float64') %
-                            0, index=p.index, columns=p.columns)
+        with np.errstate(all='ignore'):
+            arr = p.values.astype('float64') % 0
+        result2 = DataFrame(arr, index=p.index, columns=p.columns)
         assert_frame_equal(result2, expected)
 
         # not commutative with series
@@ -248,7 +251,9 @@ def test_div(self):
                               'second': Series([nan, nan, nan, 1])})
         assert_frame_equal(result, expected)
 
-        result2 = DataFrame(p.values.astype('float') / p.values, index=p.index,
+        with np.errstate(all='ignore'):
+            arr = p.values.astype('float') / p.values
+        result2 = DataFrame(arr, index=p.index,
                             columns=p.columns)
         assert_frame_equal(result2, expected)
 
@@ -258,7 +263,9 @@ def test_div(self):
         assert_frame_equal(result, expected)
 
         # numpy has a slightly different (wrong) treatement
-        result2 = DataFrame(p.values.astype('float64') / 0, index=p.index,
+        with np.errstate(all='ignore'):
+            arr = p.values.astype('float64') / 0
+        result2 = DataFrame(arr, index=p.index,
                             columns=p.columns)
         assert_frame_equal(result2, expected)
 

pandas/tests/indexes/common.py

@@ -712,8 +712,9 @@ def test_numpy_ufuncs(self):
                         func(idx)
                 elif isinstance(idx, (Float64Index, Int64Index)):
                     # coerces to float (e.g. np.sin)
-                    result = func(idx)
-                    exp = Index(func(idx.values), name=idx.name)
+                    with np.errstate(all='ignore'):
+                        result = func(idx)
+                        exp = Index(func(idx.values), name=idx.name)
                     self.assert_index_equal(result, exp)
                     self.assertIsInstance(result, pd.Float64Index)
                 else:

pandas/tests/series/test_analytics.py

@@ -622,39 +622,40 @@ def test_all_any_params(self):
         self.assertRaises(NotImplementedError, s.all, bool_only=True)
 
     def test_modulo(self):
+        with np.errstate(all='ignore'):
+
+            # GH3590, modulo as ints
+            p = DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+            result = p['first'] % p['second']
+            expected = Series(p['first'].values % p['second'].values,
+                              dtype='float64')
+            expected.iloc[0:3] = np.nan
+            assert_series_equal(result, expected)
 
-        # GH3590, modulo as ints
-        p = DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-        result = p['first'] % p['second']
-        expected = Series(p['first'].values % p['second'].values,
-                          dtype='float64')
-        expected.iloc[0:3] = np.nan
-        assert_series_equal(result, expected)
-
-        result = p['first'] % 0
-        expected = Series(np.nan, index=p.index, name='first')
-        assert_series_equal(result, expected)
+            result = p['first'] % 0
+            expected = Series(np.nan, index=p.index, name='first')
+            assert_series_equal(result, expected)
 
-        p = p.astype('float64')
-        result = p['first'] % p['second']
-        expected = Series(p['first'].values % p['second'].values)
-        assert_series_equal(result, expected)
+            p = p.astype('float64')
+            result = p['first'] % p['second']
+            expected = Series(p['first'].values % p['second'].values)
+            assert_series_equal(result, expected)
 
-        p = p.astype('float64')
-        result = p['first'] % p['second']
-        result2 = p['second'] % p['first']
-        self.assertFalse(np.array_equal(result, result2))
+            p = p.astype('float64')
+            result = p['first'] % p['second']
+            result2 = p['second'] % p['first']
+            self.assertFalse(np.array_equal(result, result2))
 
-        # GH 9144
-        s = Series([0, 1])
+            # GH 9144
+            s = Series([0, 1])
 
-        result = s % 0
-        expected = Series([nan, nan])
-        assert_series_equal(result, expected)
+            result = s % 0
+            expected = Series([nan, nan])
+            assert_series_equal(result, expected)
 
-        result = 0 % s
-        expected = Series([nan, 0.0])
-        assert_series_equal(result, expected)
+            result = 0 % s
+            expected = Series([nan, 0.0])
+            assert_series_equal(result, expected)
 
     def test_ops_consistency_on_empty(self):
 

pandas/tests/series/test_apply.py

@@ -18,17 +18,18 @@ class TestSeriesApply(TestData, tm.TestCase):
     _multiprocess_can_split_ = True
 
     def test_apply(self):
-        assert_series_equal(self.ts.apply(np.sqrt), np.sqrt(self.ts))
-
-        # elementwise-apply
-        import math
-        assert_series_equal(self.ts.apply(math.exp), np.exp(self.ts))
-
-        # how to handle Series result, #2316
-        result = self.ts.apply(lambda x: Series(
-            [x, x ** 2], index=['x', 'x^2']))
-        expected = DataFrame({'x': self.ts, 'x^2': self.ts ** 2})
-        tm.assert_frame_equal(result, expected)
+        with np.errstate(all='ignore'):
+            assert_series_equal(self.ts.apply(np.sqrt), np.sqrt(self.ts))
+
+            # elementwise-apply
+            import math
+            assert_series_equal(self.ts.apply(math.exp), np.exp(self.ts))
+
+            # how to handle Series result, #2316
+            result = self.ts.apply(lambda x: Series(
+                [x, x ** 2], index=['x', 'x^2']))
+            expected = DataFrame({'x': self.ts, 'x^2': self.ts ** 2})
+            tm.assert_frame_equal(result, expected)
 
         # empty series
         s = Series(dtype=object, name='foo', index=pd.Index([], name='bar'))