TST: skip comparisons on incompat bottleneck functions, xref 9422

Author: jreback

pandas/tests/test_frame.py

@@ -12471,7 +12471,9 @@ def test_stat_operators_attempt_obj_array(self):
                 self.assertEqual(df.values.dtype, np.object_)
                 result = getattr(df, meth)(1)
                 expected = getattr(df.astype('f8'), meth)(1)
-                assert_series_equal(result, expected)
+
+                if not tm._incompat_bottleneck_version(meth):
+                    assert_series_equal(result, expected)
 
     def test_mean(self):
         self._check_stat_op('mean', np.mean, check_dates=True)
@@ -12696,9 +12698,10 @@ def wrapper(x):
         assert_series_equal(result0, frame.apply(skipna_wrapper),
                             check_dtype=check_dtype,
                             check_less_precise=check_less_precise)
-        assert_series_equal(result1, frame.apply(skipna_wrapper, axis=1),
-                            check_dtype=False,
-                            check_less_precise=check_less_precise)
+        if not tm._incompat_bottleneck_version(name):
+            assert_series_equal(result1, frame.apply(skipna_wrapper, axis=1),
+                                check_dtype=False,
+                                check_less_precise=check_less_precise)
 
         # check dtypes
         if check_dtype:
@@ -12727,8 +12730,9 @@ def wrapper(x):
             all_na = self.frame * np.NaN
             r0 = getattr(all_na, name)(axis=0)
             r1 = getattr(all_na, name)(axis=1)
-            self.assertTrue(np.isnan(r0).all())
-            self.assertTrue(np.isnan(r1).all())
+            if not tm._incompat_bottleneck_version(name):
+                self.assertTrue(np.isnan(r0).all())
+                self.assertTrue(np.isnan(r1).all())
 
     def test_mode(self):
         df = pd.DataFrame({"A": [12, 12, 11, 12, 19, 11],

pandas/tests/test_groupby.py

@@ -2014,7 +2014,10 @@ def test_cythonized_aggers(self):
         df = DataFrame(data)
         df.loc[2:10:2,'C'] = nan
 
-        def _testit(op):
+        def _testit(name):
+
+            op = lambda x: getattr(x,name)()
+
             # single column
             grouped = df.drop(['B'], axis=1).groupby('A')
             exp = {}
@@ -2035,18 +2038,19 @@ def _testit(op):
             exp.name = 'C'
 
             result = op(grouped)['C']
-            assert_series_equal(result, exp)
-
-        _testit(lambda x: x.count())
-        _testit(lambda x: x.sum())
-        _testit(lambda x: x.std())
-        _testit(lambda x: x.var())
-        _testit(lambda x: x.sem())
-        _testit(lambda x: x.mean())
-        _testit(lambda x: x.median())
-        _testit(lambda x: x.prod())
-        _testit(lambda x: x.min())
-        _testit(lambda x: x.max())
+            if not tm._incompat_bottleneck_version(name):
+                assert_series_equal(result, exp)
+
+        _testit('count')
+        _testit('sum')
+        _testit('std')
+        _testit('var')
+        _testit('sem')
+        _testit('mean')
+        _testit('median')
+        _testit('prod')
+        _testit('min')
+        _testit('max')
 
     def test_max_min_non_numeric(self):
         # #2700

pandas/tests/test_panel.py

@@ -168,7 +168,8 @@ def wrapper(x):
 
         for i in range(obj.ndim):
             result = f(axis=i)
-            assert_frame_equal(result, obj.apply(skipna_wrapper, axis=i))
+            if not tm._incompat_bottleneck_version(name):
+                assert_frame_equal(result, obj.apply(skipna_wrapper, axis=i))
 
         self.assertRaises(Exception, f, axis=obj.ndim)
 

pandas/tests/test_panel4d.py

@@ -144,7 +144,8 @@ def wrapper(x):
 
         for i in range(obj.ndim):
             result = f(axis=i)
-            assert_panel_equal(result, obj.apply(skipna_wrapper, axis=i))
+            if not tm._incompat_bottleneck_version(name):
+                assert_panel_equal(result, obj.apply(skipna_wrapper, axis=i))
 
         self.assertRaises(Exception, f, axis=obj.ndim)
 

pandas/util/testing.py

@@ -246,6 +246,38 @@ def _skip_if_python26():
         import nose
         raise nose.SkipTest("skipping on python2.6")
 
+def _incompat_bottleneck_version(method):
+    """ skip if we have bottleneck installed
+    and its >= 1.0
+    as we don't match the nansum/nanprod behavior for all-nan
+    ops, see GH9422
+    """
+    if method not in ['sum','prod']:
+        return False
+    try:
+        import bottleneck as bn
+        return bn.__version__ >= LooseVersion('1.0')
+    except ImportError:
+        return False
+
+def skip_if_no_ne(engine='numexpr'):
+    import nose
+    _USE_NUMEXPR = pd.computation.expressions._USE_NUMEXPR
+
+    if engine == 'numexpr':
+        try:
+            import numexpr as ne
+        except ImportError:
+            raise nose.SkipTest("numexpr not installed")
+
+        if not _USE_NUMEXPR:
+            raise nose.SkipTest("numexpr disabled")
+
+        if ne.__version__ < LooseVersion('2.0'):
+            raise nose.SkipTest("numexpr version too low: "
+                                "%s" % ne.__version__)
+
+
 
 #------------------------------------------------------------------------------
 # locale utilities
@@ -1986,24 +2018,6 @@ def assert_produces_warning(expected_warning=Warning, filter_level="always",
                                     % extra_warnings)
 
 
-def skip_if_no_ne(engine='numexpr'):
-    import nose
-    _USE_NUMEXPR = pd.computation.expressions._USE_NUMEXPR
-
-    if engine == 'numexpr':
-        try:
-            import numexpr as ne
-        except ImportError:
-            raise nose.SkipTest("numexpr not installed")
-
-        if not _USE_NUMEXPR:
-            raise nose.SkipTest("numexpr disabled")
-
-        if ne.__version__ < LooseVersion('2.0'):
-            raise nose.SkipTest("numexpr version too low: "
-                                "%s" % ne.__version__)
-
-
 def disabled(t):
     t.disabled = True
     return t