COMPAT: fix warnings

remove Period future warning
catch PerformanceWarning in test_groupby
fixup test_sample in test_generic
turn off warnings in computation/test_eval.py
invalid test fix in corrwith

Author: jreback

pandas/computation/tests/test_eval.py

@@ -900,13 +900,13 @@ def testit(r_idx_type, c_idx_type, index_name):
 
         # only test dt with dt, otherwise weird joins result
         args = product(['i', 'u', 's'], ['i', 'u', 's'], ('index', 'columns'))
-        for r_idx_type, c_idx_type, index_name in args:
-            testit(r_idx_type, c_idx_type, index_name)
+        with warnings.catch_warnings(record=True):
+            for r_idx_type, c_idx_type, index_name in args:
+                testit(r_idx_type, c_idx_type, index_name)
 
         # dt with dt
         args = product(['dt'], ['dt'], ('index', 'columns'))
         with warnings.catch_warnings(record=True):
-            warnings.simplefilter('always', RuntimeWarning)
             for r_idx_type, c_idx_type, index_name in args:
                 testit(r_idx_type, c_idx_type, index_name)
 

pandas/tests/frame/test_analytics.py

@@ -175,7 +175,7 @@ def test_corrwith(self):
         a = self.tsframe
         noise = Series(randn(len(a)), index=a.index)
 
-        b = self.tsframe + noise
+        b = self.tsframe.add(noise, axis=0)
 
         # make sure order does not matter
         b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:])

pandas/tests/frame/test_apply.py

@@ -4,6 +4,7 @@
 
 from datetime import datetime
 
+import warnings
 import numpy as np
 
 from pandas import (notnull, DataFrame, Series, MultiIndex, date_range,
@@ -168,7 +169,8 @@ def test_apply_empty_infer_type(self):
         no_index = DataFrame(columns=['a', 'b', 'c'])
 
         def _check(df, f):
-            test_res = f(np.array([], dtype='f8'))
+            with warnings.catch_warnings(record=True):
+                test_res = f(np.array([], dtype='f8'))
             is_reduction = not isinstance(test_res, np.ndarray)
 
             def _checkit(axis=0, raw=False):

pandas/tests/test_generic.py

@@ -456,35 +456,6 @@ def test_sample(self):
         with tm.assertRaises(ValueError):
             o.sample(n=3, weights=nan_weights)
 
-        # A few dataframe test with degenerate weights.
-        easy_weight_list = [0] * 10
-        easy_weight_list[5] = 1
-
-        df = pd.DataFrame({'col1': range(10, 20),
-                           'col2': range(20, 30),
-                           'colString': ['a'] * 10,
-                           'easyweights': easy_weight_list})
-        sample1 = df.sample(n=1, weights='easyweights')
-        assert_frame_equal(sample1, df.iloc[5:6])
-
-        # Ensure proper error if string given as weight for Series, panel, or
-        # DataFrame with axis = 1.
-        s = Series(range(10))
-        with tm.assertRaises(ValueError):
-            s.sample(n=3, weights='weight_column')
-
-        panel = pd.Panel(items=[0, 1, 2], major_axis=[2, 3, 4],
-                         minor_axis=[3, 4, 5])
-        with tm.assertRaises(ValueError):
-            panel.sample(n=1, weights='weight_column')
-
-        with tm.assertRaises(ValueError):
-            df.sample(n=1, weights='weight_column', axis=1)
-
-        # Check weighting key error
-        with tm.assertRaises(KeyError):
-            df.sample(n=3, weights='not_a_real_column_name')
-
         # Check np.nan are replaced by zeros.
         weights_with_nan = [np.nan] * 10
         weights_with_nan[5] = 0.5
@@ -497,90 +468,6 @@ def test_sample(self):
         self._compare(
             o.sample(n=1, axis=0, weights=weights_with_None), o.iloc[5:6])
 
-        # Check that re-normalizes weights that don't sum to one.
-        weights_less_than_1 = [0] * 10
-        weights_less_than_1[0] = 0.5
-        tm.assert_frame_equal(
-            df.sample(n=1, weights=weights_less_than_1), df.iloc[:1])
-
-        ###
-        # Test axis argument
-        ###
-
-        # Test axis argument
-        df = pd.DataFrame({'col1': range(10), 'col2': ['a'] * 10})
-        second_column_weight = [0, 1]
-        assert_frame_equal(
-            df.sample(n=1, axis=1, weights=second_column_weight), df[['col2']])
-
-        # Different axis arg types
-        assert_frame_equal(df.sample(n=1, axis='columns',
-                                     weights=second_column_weight),
-                           df[['col2']])
-
-        weight = [0] * 10
-        weight[5] = 0.5
-        assert_frame_equal(df.sample(n=1, axis='rows', weights=weight),
-                           df.iloc[5:6])
-        assert_frame_equal(df.sample(n=1, axis='index', weights=weight),
-                           df.iloc[5:6])
-
-        # Check out of range axis values
-        with tm.assertRaises(ValueError):
-            df.sample(n=1, axis=2)
-
-        with tm.assertRaises(ValueError):
-            df.sample(n=1, axis='not_a_name')
-
-        with tm.assertRaises(ValueError):
-            s = pd.Series(range(10))
-            s.sample(n=1, axis=1)
-
-        # Test weight length compared to correct axis
-        with tm.assertRaises(ValueError):
-            df.sample(n=1, axis=1, weights=[0.5] * 10)
-
-        # Check weights with axis = 1
-        easy_weight_list = [0] * 3
-        easy_weight_list[2] = 1
-
-        df = pd.DataFrame({'col1': range(10, 20),
-                           'col2': range(20, 30),
-                           'colString': ['a'] * 10})
-        sample1 = df.sample(n=1, axis=1, weights=easy_weight_list)
-        assert_frame_equal(sample1, df[['colString']])
-
-        # Test default axes
-        p = pd.Panel(items=['a', 'b', 'c'], major_axis=[2, 4, 6],
-                     minor_axis=[1, 3, 5])
-        assert_panel_equal(
-            p.sample(n=3, random_state=42), p.sample(n=3, axis=1,
-                                                     random_state=42))
-        assert_frame_equal(
-            df.sample(n=3, random_state=42), df.sample(n=3, axis=0,
-                                                       random_state=42))
-
-        # Test that function aligns weights with frame
-        df = DataFrame(
-            {'col1': [5, 6, 7],
-             'col2': ['a', 'b', 'c'], }, index=[9, 5, 3])
-        s = Series([1, 0, 0], index=[3, 5, 9])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s))
-
-        # Weights have index values to be dropped because not in
-        # sampled DataFrame
-        s2 = Series([0.001, 0, 10000], index=[3, 5, 10])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s2))
-
-        # Weights have empty values to be filed with zeros
-        s3 = Series([0.01, 0], index=[3, 5])
-        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s3))
-
-        # No overlap in weight and sampled DataFrame indices
-        s4 = Series([1, 0], index=[1, 2])
-        with tm.assertRaises(ValueError):
-            df.sample(1, weights=s4)
-
     def test_size_compat(self):
         # GH8846
         # size property should be defined
@@ -1963,6 +1850,9 @@ class TestPanel4D(tm.TestCase, Generic):
     _typ = Panel4D
     _comparator = lambda self, x, y: assert_panel4d_equal(x, y)
 
+    def test_sample(self):
+        raise nose.SkipTest("sample on Panel4D")
+
     def test_to_xarray(self):
 
         tm._skip_if_no_xarray()
@@ -1984,6 +1874,123 @@ def test_to_xarray(self):
 class TestNDFrame(tm.TestCase):
     # tests that don't fit elsewhere
 
+    def test_sample(sel):
+        # Fixes issue: 2419
+        # additional specific object based tests
+
+        # A few dataframe test with degenerate weights.
+        easy_weight_list = [0] * 10
+        easy_weight_list[5] = 1
+
+        df = pd.DataFrame({'col1': range(10, 20),
+                           'col2': range(20, 30),
+                           'colString': ['a'] * 10,
+                           'easyweights': easy_weight_list})
+        sample1 = df.sample(n=1, weights='easyweights')
+        assert_frame_equal(sample1, df.iloc[5:6])
+
+        # Ensure proper error if string given as weight for Series, panel, or
+        # DataFrame with axis = 1.
+        s = Series(range(10))
+        with tm.assertRaises(ValueError):
+            s.sample(n=3, weights='weight_column')
+
+        panel = pd.Panel(items=[0, 1, 2], major_axis=[2, 3, 4],
+                         minor_axis=[3, 4, 5])
+        with tm.assertRaises(ValueError):
+            panel.sample(n=1, weights='weight_column')
+
+        with tm.assertRaises(ValueError):
+            df.sample(n=1, weights='weight_column', axis=1)
+
+        # Check weighting key error
+        with tm.assertRaises(KeyError):
+            df.sample(n=3, weights='not_a_real_column_name')
+
+        # Check that re-normalizes weights that don't sum to one.
+        weights_less_than_1 = [0] * 10
+        weights_less_than_1[0] = 0.5
+        tm.assert_frame_equal(
+            df.sample(n=1, weights=weights_less_than_1), df.iloc[:1])
+
+        ###
+        # Test axis argument
+        ###
+
+        # Test axis argument
+        df = pd.DataFrame({'col1': range(10), 'col2': ['a'] * 10})
+        second_column_weight = [0, 1]
+        assert_frame_equal(
+            df.sample(n=1, axis=1, weights=second_column_weight), df[['col2']])
+
+        # Different axis arg types
+        assert_frame_equal(df.sample(n=1, axis='columns',
+                                     weights=second_column_weight),
+                           df[['col2']])
+
+        weight = [0] * 10
+        weight[5] = 0.5
+        assert_frame_equal(df.sample(n=1, axis='rows', weights=weight),
+                           df.iloc[5:6])
+        assert_frame_equal(df.sample(n=1, axis='index', weights=weight),
+                           df.iloc[5:6])
+
+        # Check out of range axis values
+        with tm.assertRaises(ValueError):
+            df.sample(n=1, axis=2)
+
+        with tm.assertRaises(ValueError):
+            df.sample(n=1, axis='not_a_name')
+
+        with tm.assertRaises(ValueError):
+            s = pd.Series(range(10))
+            s.sample(n=1, axis=1)
+
+        # Test weight length compared to correct axis
+        with tm.assertRaises(ValueError):
+            df.sample(n=1, axis=1, weights=[0.5] * 10)
+
+        # Check weights with axis = 1
+        easy_weight_list = [0] * 3
+        easy_weight_list[2] = 1
+
+        df = pd.DataFrame({'col1': range(10, 20),
+                           'col2': range(20, 30),
+                           'colString': ['a'] * 10})
+        sample1 = df.sample(n=1, axis=1, weights=easy_weight_list)
+        assert_frame_equal(sample1, df[['colString']])
+
+        # Test default axes
+        p = pd.Panel(items=['a', 'b', 'c'], major_axis=[2, 4, 6],
+                     minor_axis=[1, 3, 5])
+        assert_panel_equal(
+            p.sample(n=3, random_state=42), p.sample(n=3, axis=1,
+                                                     random_state=42))
+        assert_frame_equal(
+            df.sample(n=3, random_state=42), df.sample(n=3, axis=0,
+                                                       random_state=42))
+
+        # Test that function aligns weights with frame
+        df = DataFrame(
+            {'col1': [5, 6, 7],
+             'col2': ['a', 'b', 'c'], }, index=[9, 5, 3])
+        s = Series([1, 0, 0], index=[3, 5, 9])
+        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s))
+
+        # Weights have index values to be dropped because not in
+        # sampled DataFrame
+        s2 = Series([0.001, 0, 10000], index=[3, 5, 10])
+        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s2))
+
+        # Weights have empty values to be filed with zeros
+        s3 = Series([0.01, 0], index=[3, 5])
+        assert_frame_equal(df.loc[[3]], df.sample(1, weights=s3))
+
+        # No overlap in weight and sampled DataFrame indices
+        s4 = Series([1, 0], index=[1, 2])
+        with tm.assertRaises(ValueError):
+            df.sample(1, weights=s4)
+
     def test_squeeze(self):
         # noop
         for s in [tm.makeFloatSeries(), tm.makeStringSeries(),

pandas/tests/test_groupby.py

@@ -4284,8 +4284,11 @@ def test_groupby_multiindex_not_lexsorted(self):
 
         # compare the results
         tm.assert_frame_equal(lexsorted_df, not_lexsorted_df)
-        tm.assert_frame_equal(lexsorted_df.groupby('a').mean(),
-                              not_lexsorted_df.groupby('a').mean())
+
+        expected = lexsorted_df.groupby('a').mean()
+        with tm.assert_produces_warning(com.PerformanceWarning):
+            result = not_lexsorted_df.groupby('a').mean()
+        tm.assert_frame_equal(expected, result)
 
     def test_groupby_levels_and_columns(self):
         # GH9344, GH9049

pandas/tests/test_multilevel.py

@@ -2366,7 +2366,7 @@ def test_set_index_period(self):
         idx1 = idx1.append(idx1)
         idx2 = pd.period_range('2013-01-01 09:00', periods=2, freq='H')
         idx2 = idx2.append(idx2).append(idx2)
-        idx3 = pd.period_range('2005', periods=6, freq='Y')
+        idx3 = pd.period_range('2005', periods=6, freq='A')
 
         df = df.set_index(idx1)
         df = df.set_index(idx2, append=True)

pandas/tseries/tests/test_daterange.py

@@ -10,6 +10,7 @@
 from pandas.tseries.offsets import generate_range
 from pandas.tseries.index import cdate_range, bdate_range, date_range
 
+from pandas.core import common as com
 import pandas.core.datetools as datetools
 from pandas.util.testing import assertRaisesRegexp
 import pandas.util.testing as tm
@@ -610,6 +611,7 @@ def test_getitem_matplotlib_hackaround(self):
         self.assert_numpy_array_equal(values, expected)
 
     def test_shift(self):
+
         shifted = self.rng.shift(5)
         self.assertEqual(shifted[0], self.rng[5])
         self.assertEqual(shifted.offset, self.rng.offset)
@@ -622,9 +624,10 @@ def test_shift(self):
         self.assertEqual(shifted[0], self.rng[0])
         self.assertEqual(shifted.offset, self.rng.offset)
 
-        rng = date_range(START, END, freq=datetools.bmonthEnd)
-        shifted = rng.shift(1, freq=datetools.cday)
-        self.assertEqual(shifted[0], rng[0] + datetools.cday)
+        with tm.assert_produces_warning(com.PerformanceWarning):
+            rng = date_range(START, END, freq=datetools.bmonthEnd)
+            shifted = rng.shift(1, freq=datetools.cday)
+            self.assertEqual(shifted[0], rng[0] + datetools.cday)
 
     def test_pickle_unpickle(self):
         unpickled = self.round_trip_pickle(self.rng)