TST: Capture warnings in _check_plot_works

Author: TomAugspurger

ci/requirements-3.4.run

@@ -11,7 +11,6 @@ beautiful-soup
 scipy
 numexpr
 pytables
-matplotlib=1.3.1
 lxml
 sqlalchemy
 bottleneck

pandas/tests/test_graphics.py

@@ -800,8 +800,8 @@ def test_hist_legacy(self):
         _check_plot_works(self.ts.hist)
         _check_plot_works(self.ts.hist, grid=False)
         _check_plot_works(self.ts.hist, figsize=(8, 10))
-        _check_plot_works(self.ts.hist, by=self.ts.index.month)
-        _check_plot_works(self.ts.hist, by=self.ts.index.month, bins=5)
+        _check_plot_works(self.ts.hist, filterwarnings='ignore', by=self.ts.index.month)
+        _check_plot_works(self.ts.hist, filterwarnings='ignore', by=self.ts.index.month, bins=5)
 
         fig, ax = self.plt.subplots(1, 1)
         _check_plot_works(self.ts.hist, ax=ax)
@@ -835,25 +835,32 @@ def test_hist_layout(self):
     def test_hist_layout_with_by(self):
         df = self.hist_df
 
-        axes = _check_plot_works(df.height.hist, by=df.gender, layout=(2, 1))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.gender, layout=(2, 1))
         self._check_axes_shape(axes, axes_num=2, layout=(2, 1))
 
-        axes = _check_plot_works(df.height.hist, by=df.gender, layout=(3, -1))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.gender, layout=(3, -1))
         self._check_axes_shape(axes, axes_num=2, layout=(3, 1))
 
-        axes = _check_plot_works(df.height.hist, by=df.category, layout=(4, 1))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.category, layout=(4, 1))
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
-        axes = _check_plot_works(df.height.hist, by=df.category, layout=(2, -1))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.category, layout=(2, -1))
         self._check_axes_shape(axes, axes_num=4, layout=(2, 2))
 
-        axes = _check_plot_works(df.height.hist, by=df.category, layout=(3, -1))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.category, layout=(3, -1))
         self._check_axes_shape(axes, axes_num=4, layout=(3, 2))
 
-        axes = _check_plot_works(df.height.hist, by=df.category, layout=(-1, 4))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.category, layout=(-1, 4))
         self._check_axes_shape(axes, axes_num=4, layout=(1, 4))
 
-        axes = _check_plot_works(df.height.hist, by=df.classroom, layout=(2, 2))
+        axes = _check_plot_works(df.height.hist, filterwarnings='ignore',
+                                 by=df.classroom, layout=(2, 2))
         self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
 
         axes = df.height.hist(by=df.category, layout=(4, 2), figsize=(12, 7))
@@ -1247,14 +1254,16 @@ def setUp(self):
     @slow
     def test_plot(self):
         df = self.tdf
-        _check_plot_works(df.plot, grid=False)
-        axes = _check_plot_works(df.plot, subplots=True)
+        _check_plot_works(df.plot, filterwarnings='ignore', grid=False)
+        axes = _check_plot_works(df.plot, filterwarnings='ignore', subplots=True)
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
-        axes = _check_plot_works(df.plot, subplots=True, layout=(-1, 2))
+        axes = _check_plot_works(df.plot, filterwarnings='ignore',
+                                 subplots=True, layout=(-1, 2))
         self._check_axes_shape(axes, axes_num=4, layout=(2, 2))
 
-        axes = _check_plot_works(df.plot, subplots=True, use_index=False)
+        axes = _check_plot_works(df.plot, filterwarnings='ignore',
+                                 subplots=True, use_index=False)
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
         df = DataFrame({'x': [1, 2], 'y': [3, 4]})
@@ -1263,13 +1272,14 @@ def test_plot(self):
 
         df = DataFrame(np.random.rand(10, 3),
                        index=list(string.ascii_letters[:10]))
+
         _check_plot_works(df.plot, use_index=True)
         _check_plot_works(df.plot, sort_columns=False)
         _check_plot_works(df.plot, yticks=[1, 5, 10])
         _check_plot_works(df.plot, xticks=[1, 5, 10])
         _check_plot_works(df.plot, ylim=(-100, 100), xlim=(-100, 100))
 
-        _check_plot_works(df.plot, subplots=True, title='blah')
+        _check_plot_works(df.plot, filterwarnings='ignore', subplots=True, title='blah')
         # We have to redo it here because _check_plot_works does two plots, once without an ax
         # kwarg and once with an ax kwarg and the new sharex behaviour does not remove the
         # visibility of the latter axis (as ax is present).
@@ -2083,7 +2093,7 @@ def test_plot_bar(self):
 
         _check_plot_works(df.plot.bar)
         _check_plot_works(df.plot.bar, legend=False)
-        _check_plot_works(df.plot.bar, subplots=True)
+        _check_plot_works(df.plot.bar, filterwarnings='ignore', subplots=True)
         _check_plot_works(df.plot.bar, stacked=True)
 
         df = DataFrame(randn(10, 15),
@@ -2300,7 +2310,7 @@ def test_boxplot_vertical(self):
         self._check_text_labels(ax.get_yticklabels(), labels)
         self.assertEqual(len(ax.lines), self.bp_n_objects * len(numeric_cols))
 
-        axes = _check_plot_works(df.plot.box, subplots=True,
+        axes = _check_plot_works(df.plot.box, filterwarnings='ignore', subplots=True,
                                  vert=False, logx=True)
         self._check_axes_shape(axes, axes_num=3, layout=(1, 3))
         self._check_ax_scales(axes, xaxis='log')
@@ -2360,7 +2370,7 @@ def test_kde_df(self):
         ax = df.plot(kind='kde', rot=20, fontsize=5)
         self._check_ticks_props(ax, xrot=20, xlabelsize=5, ylabelsize=5)
 
-        axes = _check_plot_works(df.plot, kind='kde', subplots=True)
+        axes = _check_plot_works(df.plot, filterwarnings='ignore', kind='kde', subplots=True)
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
 
         axes = df.plot(kind='kde', logy=True, subplots=True)
@@ -2387,7 +2397,7 @@ def test_hist_df(self):
         expected = [com.pprint_thing(c) for c in df.columns]
         self._check_legend_labels(ax, labels=expected)
 
-        axes = _check_plot_works(df.plot.hist, subplots=True, logy=True)
+        axes = _check_plot_works(df.plot.hist, filterwarnings='ignore', subplots=True, logy=True)
         self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
         self._check_ax_scales(axes, yaxis='log')
 
@@ -3093,7 +3103,7 @@ def test_pie_df(self):
         ax = _check_plot_works(df.plot.pie, y=2)
         self._check_text_labels(ax.texts, df.index)
 
-        axes = _check_plot_works(df.plot.pie, subplots=True)
+        axes = _check_plot_works(df.plot.pie, filterwarnings='ignore', subplots=True)
         self.assertEqual(len(axes), len(df.columns))
         for ax in axes:
             self._check_text_labels(ax.texts, df.index)
@@ -3102,7 +3112,7 @@ def test_pie_df(self):
 
         labels = ['A', 'B', 'C', 'D', 'E']
         color_args = ['r', 'g', 'b', 'c', 'm']
-        axes = _check_plot_works(df.plot.pie, subplots=True,
+        axes = _check_plot_works(df.plot.pie, filterwarnings='ignore', subplots=True,
                                  labels=labels, colors=color_args)
         self.assertEqual(len(axes), len(df.columns))
 
@@ -3156,7 +3166,8 @@ def test_errorbar_plot(self):
             self._check_has_errorbars(ax, xerr=2, yerr=2)
             ax = _check_plot_works(df.plot, xerr=0.2, yerr=0.2, kind=kind)
             self._check_has_errorbars(ax, xerr=2, yerr=2)
-            axes = _check_plot_works(df.plot, yerr=df_err, xerr=df_err, subplots=True, kind=kind)
+            axes = _check_plot_works(df.plot, filterwarnings='ignore', yerr=df_err,
+                                     xerr=df_err, subplots=True, kind=kind)
             self._check_has_errorbars(axes, xerr=1, yerr=1)
 
         ax = _check_plot_works((df+1).plot, yerr=df_err, xerr=df_err, kind='bar', log=True)
@@ -3245,7 +3256,8 @@ def test_errorbar_timeseries(self):
             self._check_has_errorbars(ax, xerr=0, yerr=1)
             ax = _check_plot_works(tdf.plot, yerr=tdf_err, kind=kind)
             self._check_has_errorbars(ax, xerr=0, yerr=2)
-            axes = _check_plot_works(tdf.plot, kind=kind, yerr=tdf_err, subplots=True)
+            axes = _check_plot_works(tdf.plot, filterwarnings='ignore', kind=kind,
+                                     yerr=tdf_err, subplots=True)
             self._check_has_errorbars(axes, xerr=0, yerr=1)
 
     def test_errorbar_asymmetrical(self):
@@ -3690,37 +3702,38 @@ def assert_is_valid_plot_return_object(objs):
                  ''.format(objs.__class__.__name__))
 
 
-def _check_plot_works(f, *args, **kwargs):
+def _check_plot_works(f, filterwarnings='always', **kwargs):
     import matplotlib.pyplot as plt
     ret = None
-
-    try:
+    with warnings.catch_warnings():
+        warnings.simplefilter(filterwarnings)
         try:
-            fig = kwargs['figure']
-        except KeyError:
-            fig = plt.gcf()
+            try:
+                fig = kwargs['figure']
+            except KeyError:
+                fig = plt.gcf()
 
-        plt.clf()
+            plt.clf()
 
-        ax = kwargs.get('ax', fig.add_subplot(211))
-        ret = f(*args, **kwargs)
+            ax = kwargs.get('ax', fig.add_subplot(211))
+            ret = f(**kwargs)
 
-        assert_is_valid_plot_return_object(ret)
-
-        try:
-            kwargs['ax'] = fig.add_subplot(212)
-            ret = f(*args, **kwargs)
-        except Exception:
-            pass
-        else:
             assert_is_valid_plot_return_object(ret)
 
-        with ensure_clean(return_filelike=True) as path:
-            plt.savefig(path)
-    finally:
-        tm.close(fig)
+            try:
+                kwargs['ax'] = fig.add_subplot(212)
+                ret = f(**kwargs)
+            except Exception:
+                pass
+            else:
+                assert_is_valid_plot_return_object(ret)
+
+            with ensure_clean(return_filelike=True) as path:
+                plt.savefig(path)
+        finally:
+            tm.close(fig)
 
-    return ret
+        return ret
 
 def _generate_4_axes_via_gridspec():
     import matplotlib.pyplot as plt

pandas/tests/test_graphics_others.py

@@ -161,22 +161,22 @@ def test_plot_fails_when_ax_differs_from_figure(self):
     @slow
     def test_autocorrelation_plot(self):
         from pandas.tools.plotting import autocorrelation_plot
-        _check_plot_works(autocorrelation_plot, self.ts)
-        _check_plot_works(autocorrelation_plot, self.ts.values)
+        _check_plot_works(autocorrelation_plot, series=self.ts)
+        _check_plot_works(autocorrelation_plot, series=self.ts.values)
 
         ax = autocorrelation_plot(self.ts, label='Test')
         self._check_legend_labels(ax, labels=['Test'])
 
     @slow
     def test_lag_plot(self):
         from pandas.tools.plotting import lag_plot
-        _check_plot_works(lag_plot, self.ts)
-        _check_plot_works(lag_plot, self.ts, lag=5)
+        _check_plot_works(lag_plot, series=self.ts)
+        _check_plot_works(lag_plot, series=self.ts, lag=5)
 
     @slow
     def test_bootstrap_plot(self):
         from pandas.tools.plotting import bootstrap_plot
-        _check_plot_works(bootstrap_plot, self.ts, size=10)
+        _check_plot_works(bootstrap_plot, series=self.ts, size=10)
 
 
 @tm.mplskip
@@ -210,7 +210,7 @@ def test_boxplot_legacy(self):
         _check_plot_works(df.boxplot, column='one', by=['indic', 'indic2'])
         _check_plot_works(df.boxplot, by='indic')
         _check_plot_works(df.boxplot, by=['indic', 'indic2'])
-        _check_plot_works(plotting.boxplot, df['one'], return_type='dict')
+        _check_plot_works(plotting.boxplot, data=df['one'], return_type='dict')
         _check_plot_works(df.boxplot, notch=1, return_type='dict')
         _check_plot_works(df.boxplot, by='indic', notch=1)
 
@@ -304,6 +304,7 @@ def test_boxplot_empty_column(self):
 
     @slow
     def test_hist_df_legacy(self):
+        from matplotlib.patches import Rectangle
         _check_plot_works(self.hist_df.hist)
 
         # make sure layout is handled
@@ -347,7 +348,8 @@ def test_hist_df_legacy(self):
         # make sure kwargs to hist are handled
         ax = ser.hist(normed=True, cumulative=True, bins=4)
         # height of last bin (index 5) must be 1.0
-        self.assertAlmostEqual(ax.get_children()[5].get_height(), 1.0)
+        rects = [x for x in ax.get_children() if isinstance(x, Rectangle)]
+        self.assertAlmostEqual(rects[-1].get_height(), 1.0)
 
         tm.close()
         ax = ser.hist(log=True)
@@ -413,9 +415,9 @@ def scat(**kwds):
         def scat2(x, y, by=None, ax=None, figsize=None):
             return plotting.scatter_plot(df, x, y, by, ax, figsize=None)
 
-        _check_plot_works(scat2, 0, 1)
+        _check_plot_works(scat2, x=0, y=1)
         grouper = Series(np.repeat([1, 2, 3, 4, 5], 20), df.index)
-        _check_plot_works(scat2, 0, 1, by=grouper)
+        _check_plot_works(scat2, x=0, y=1, by=grouper)
 
     def test_scatter_matrix_axis(self):
         tm._skip_if_no_scipy()
@@ -424,15 +426,17 @@ def test_scatter_matrix_axis(self):
         with tm.RNGContext(42):
             df = DataFrame(randn(100, 3))
 
-        axes = _check_plot_works(scatter_matrix, df, range_padding=.1)
+        axes = _check_plot_works(scatter_matrix, filterwarnings='always', frame=df,
+                                 range_padding=.1)
         axes0_labels = axes[0][0].yaxis.get_majorticklabels()
         # GH 5662
         expected = ['-2', '-1', '0', '1', '2']
         self._check_text_labels(axes0_labels, expected)
         self._check_ticks_props(axes, xlabelsize=8, xrot=90, ylabelsize=8, yrot=0)
 
         df[0] = ((df[0] - 2) / 3)
-        axes = _check_plot_works(scatter_matrix, df, range_padding=.1)
+        axes = _check_plot_works(scatter_matrix, filterwarnings='always', frame=df,
+                                 range_padding=.1)
         axes0_labels = axes[0][0].yaxis.get_majorticklabels()
         expected = ['-1.2', '-1.0', '-0.8', '-0.6', '-0.4', '-0.2', '0.0']
         self._check_text_labels(axes0_labels, expected)
@@ -445,17 +449,17 @@ def test_andrews_curves(self):
 
         df = self.iris
 
-        _check_plot_works(andrews_curves, df, 'Name')
+        _check_plot_works(andrews_curves, frame=df, class_column='Name')
 
         rgba = ('#556270', '#4ECDC4', '#C7F464')
-        ax = _check_plot_works(andrews_curves, df, 'Name', color=rgba)
+        ax = _check_plot_works(andrews_curves, frame=df, class_column='Name', color=rgba)
         self._check_colors(ax.get_lines()[:10], linecolors=rgba, mapping=df['Name'][:10])
 
         cnames = ['dodgerblue', 'aquamarine', 'seagreen']
-        ax = _check_plot_works(andrews_curves, df, 'Name', color=cnames)
+        ax = _check_plot_works(andrews_curves, frame=df, class_column='Name', color=cnames)
         self._check_colors(ax.get_lines()[:10], linecolors=cnames, mapping=df['Name'][:10])
 
-        ax = _check_plot_works(andrews_curves, df, 'Name', colormap=cm.jet)
+        ax = _check_plot_works(andrews_curves, frame=df, class_column='Name', colormap=cm.jet)
         cmaps = lmap(cm.jet, np.linspace(0, 1, df['Name'].nunique()))
         self._check_colors(ax.get_lines()[:10], linecolors=cmaps, mapping=df['Name'][:10])
 
@@ -478,23 +482,23 @@ def test_parallel_coordinates(self):
 
         df = self.iris
 
-        ax = _check_plot_works(parallel_coordinates, df, 'Name')
+        ax = _check_plot_works(parallel_coordinates, frame=df, class_column='Name')
         nlines = len(ax.get_lines())
         nxticks = len(ax.xaxis.get_ticklabels())
 
         rgba = ('#556270', '#4ECDC4', '#C7F464')
-        ax = _check_plot_works(parallel_coordinates, df, 'Name', color=rgba)
+        ax = _check_plot_works(parallel_coordinates, frame=df, class_column='Name', color=rgba)
         self._check_colors(ax.get_lines()[:10], linecolors=rgba, mapping=df['Name'][:10])
 
         cnames = ['dodgerblue', 'aquamarine', 'seagreen']
-        ax = _check_plot_works(parallel_coordinates, df, 'Name', color=cnames)
+        ax = _check_plot_works(parallel_coordinates, frame=df, class_column='Name', color=cnames)
         self._check_colors(ax.get_lines()[:10], linecolors=cnames, mapping=df['Name'][:10])
 
-        ax = _check_plot_works(parallel_coordinates, df, 'Name', colormap=cm.jet)
+        ax = _check_plot_works(parallel_coordinates, frame=df, class_column='Name', colormap=cm.jet)
         cmaps = lmap(cm.jet, np.linspace(0, 1, df['Name'].nunique()))
         self._check_colors(ax.get_lines()[:10], linecolors=cmaps, mapping=df['Name'][:10])
 
-        ax = _check_plot_works(parallel_coordinates, df, 'Name', axvlines=False)
+        ax = _check_plot_works(parallel_coordinates, frame=df, class_column='Name', axvlines=False)
         assert len(ax.get_lines()) == (nlines - nxticks)
 
         colors = ['b', 'g', 'r']
@@ -517,20 +521,20 @@ def test_radviz(self):
         from matplotlib import cm
 
         df = self.iris
-        _check_plot_works(radviz, df, 'Name')
+        _check_plot_works(radviz, frame=df, class_column='Name')
 
         rgba = ('#556270', '#4ECDC4', '#C7F464')
-        ax = _check_plot_works(radviz, df, 'Name', color=rgba)
+        ax = _check_plot_works(radviz, frame=df, class_column='Name', color=rgba)
         # skip Circle drawn as ticks
         patches = [p for p in ax.patches[:20] if p.get_label() != '']
         self._check_colors(patches[:10], facecolors=rgba, mapping=df['Name'][:10])
 
         cnames = ['dodgerblue', 'aquamarine', 'seagreen']
-        _check_plot_works(radviz, df, 'Name', color=cnames)
+        _check_plot_works(radviz, frame=df, class_column='Name', color=cnames)
         patches = [p for p in ax.patches[:20] if p.get_label() != '']
         self._check_colors(patches, facecolors=cnames, mapping=df['Name'][:10])
 
-        _check_plot_works(radviz, df, 'Name', colormap=cm.jet)
+        _check_plot_works(radviz, frame=df, class_column='Name', colormap=cm.jet)
         cmaps = lmap(cm.jet, np.linspace(0, 1, df['Name'].nunique()))
         patches = [p for p in ax.patches[:20] if p.get_label() != '']
         self._check_colors(patches, facecolors=cmaps, mapping=df['Name'][:10])