DEPR: remove tm.makePanel and all usages (#25231)

pandas/tests/frame/test_reshape.py

@@ -4,7 +4,6 @@
 
 from datetime import datetime
 import itertools
-from warnings import catch_warnings, simplefilter
 
 import numpy as np
 import pytest
@@ -49,14 +48,6 @@ def test_pivot(self):
         assert pivoted.index.name == 'index'
         assert pivoted.columns.names == (None, 'columns')
 
-        with catch_warnings(record=True):
-            # pivot multiple columns
-            simplefilter("ignore", FutureWarning)
-            wp = tm.makePanel()
-            lp = wp.to_frame()
-            df = lp.reset_index()
-            tm.assert_frame_equal(df.pivot('major', 'minor'), lp.unstack())
-
     def test_pivot_duplicates(self):
         data = DataFrame({'a': ['bar', 'bar', 'foo', 'foo', 'foo'],
                           'b': ['one', 'two', 'one', 'one', 'two'],

pandas/tests/generic/test_generic.py

@@ -740,23 +740,11 @@ def test_squeeze(self):
             tm.assert_series_equal(s.squeeze(), s)
         for df in [tm.makeTimeDataFrame()]:
             tm.assert_frame_equal(df.squeeze(), df)
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            for p in [tm.makePanel()]:
-                tm.assert_panel_equal(p.squeeze(), p)
 
         # squeezing
         df = tm.makeTimeDataFrame().reindex(columns=['A'])
         tm.assert_series_equal(df.squeeze(), df['A'])
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            p = tm.makePanel().reindex(items=['ItemA'])
-            tm.assert_frame_equal(p.squeeze(), p['ItemA'])
-
-            p = tm.makePanel().reindex(items=['ItemA'], minor_axis=['A'])
-            tm.assert_series_equal(p.squeeze(), p.loc['ItemA', :, 'A'])
-
         # don't fail with 0 length dimensions GH11229 & GH8999
         empty_series = Series([], name='five')
         empty_frame = DataFrame([empty_series])
@@ -789,23 +777,13 @@ def test_numpy_squeeze(self):
         tm.assert_series_equal(np.squeeze(df), df['A'])
 
     def test_transpose(self):
-        msg = (r"transpose\(\) got multiple values for "
-               r"keyword argument 'axes'")
         for s in [tm.makeFloatSeries(), tm.makeStringSeries(),
                   tm.makeObjectSeries()]:
             # calls implementation in pandas/core/base.py
             tm.assert_series_equal(s.transpose(), s)
         for df in [tm.makeTimeDataFrame()]:
             tm.assert_frame_equal(df.transpose().transpose(), df)
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            for p in [tm.makePanel()]:
-                tm.assert_panel_equal(p.transpose(2, 0, 1)
-                                      .transpose(1, 2, 0), p)
-                with pytest.raises(TypeError, match=msg):
-                    p.transpose(2, 0, 1, axes=(2, 0, 1))
-
     def test_numpy_transpose(self):
         msg = "the 'axes' parameter is not supported"
 
@@ -821,13 +799,6 @@ def test_numpy_transpose(self):
         with pytest.raises(ValueError, match=msg):
             np.transpose(df, axes=1)
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            p = tm.makePanel()
-            tm.assert_panel_equal(np.transpose(
-                np.transpose(p, axes=(2, 0, 1)),
-                axes=(1, 2, 0)), p)
-
     def test_take(self):
         indices = [1, 5, -2, 6, 3, -1]
         for s in [tm.makeFloatSeries(), tm.makeStringSeries(),
@@ -843,27 +814,12 @@ def test_take(self):
                                  columns=df.columns)
             tm.assert_frame_equal(out, expected)
 
-        indices = [-3, 2, 0, 1]
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            for p in [tm.makePanel()]:
-                out = p.take(indices)
-                expected = Panel(data=p.values.take(indices, axis=0),
-                                 items=p.items.take(indices),
-                                 major_axis=p.major_axis,
-                                 minor_axis=p.minor_axis)
-                tm.assert_panel_equal(out, expected)
-
     def test_take_invalid_kwargs(self):
         indices = [-3, 2, 0, 1]
         s = tm.makeFloatSeries()
         df = tm.makeTimeDataFrame()
 
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            p = tm.makePanel()
-
-        for obj in (s, df, p):
+        for obj in (s, df):
             msg = r"take\(\) got an unexpected keyword argument 'foo'"
             with pytest.raises(TypeError, match=msg):
                 obj.take(indices, foo=2)
@@ -966,12 +922,6 @@ def test_equals(self):
         assert a.equals(e)
         assert e.equals(f)
 
-    def test_describe_raises(self):
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            with pytest.raises(NotImplementedError):
-                tm.makePanel().describe()
-
     def test_pipe(self):
         df = DataFrame({'A': [1, 2, 3]})
         f = lambda x, y: x ** y

pandas/tests/generic/test_panel.py

@@ -3,11 +3,8 @@
 
 from warnings import catch_warnings, simplefilter
 
-import pandas.util._test_decorators as td
-
 from pandas import Panel
-import pandas.util.testing as tm
-from pandas.util.testing import assert_almost_equal, assert_panel_equal
+from pandas.util.testing import assert_panel_equal
 
 from .test_generic import Generic
 
@@ -16,24 +13,6 @@ class TestPanel(Generic):
     _typ = Panel
     _comparator = lambda self, x, y: assert_panel_equal(x, y, by_blocks=True)
 
-    @td.skip_if_no('xarray', min_version='0.7.0')
-    def test_to_xarray(self):
-        from xarray import DataArray
-
-        with catch_warnings(record=True):
-            simplefilter("ignore", FutureWarning)
-            p = tm.makePanel()
-
-            result = p.to_xarray()
-            assert isinstance(result, DataArray)
-            assert len(result.coords) == 3
-            assert_almost_equal(list(result.coords.keys()),
-                                ['items', 'major_axis', 'minor_axis'])
-            assert len(result.dims) == 3
-
-            # idempotency
-            assert_panel_equal(result.to_pandas(), p)
-
 
 # run all the tests, but wrap each in a warning catcher
 for t in ['test_rename', 'test_get_numeric_data',

pandas/tests/indexing/test_panel.py

@@ -122,28 +122,6 @@ def test_panel_getitem(self):
             test1 = panel.loc[:, "2002"]
             tm.assert_panel_equal(test1, test2)
 
-            # GH8710
-            # multi-element getting with a list
-            panel = tm.makePanel()
-
-            expected = panel.iloc[[0, 1]]
-
-            result = panel.loc[['ItemA', 'ItemB']]
-            tm.assert_panel_equal(result, expected)
-
-            result = panel.loc[['ItemA', 'ItemB'], :, :]
-            tm.assert_panel_equal(result, expected)
-
-            result = panel[['ItemA', 'ItemB']]
-            tm.assert_panel_equal(result, expected)
-
-            result = panel.loc['ItemA':'ItemB']
-            tm.assert_panel_equal(result, expected)
-
-            with catch_warnings(record=True):
-                result = panel.ix[['ItemA', 'ItemB']]
-            tm.assert_panel_equal(result, expected)
-
             # with an object-like
             # GH 9140
             class TestObject(object):

pandas/tests/io/test_sql.py

@@ -605,12 +605,6 @@ def test_to_sql_series(self):
         s2 = sql.read_sql_query("SELECT * FROM test_series", self.conn)
         tm.assert_frame_equal(s.to_frame(), s2)
 
-    @pytest.mark.filterwarnings("ignore:\\nPanel:FutureWarning")
-    def test_to_sql_panel(self):
-        panel = tm.makePanel()
-        pytest.raises(NotImplementedError, sql.to_sql, panel,
-                      'test_panel', self.conn)
-
     def test_roundtrip(self):
         sql.to_sql(self.test_frame1, 'test_frame_roundtrip',
                    con=self.conn)

pandas/tests/reshape/test_reshape.py

@@ -580,23 +580,28 @@ def test_get_dummies_duplicate_columns(self, df):
 
 class TestCategoricalReshape(object):
 
-    @pytest.mark.filterwarnings("ignore:\\nPanel:FutureWarning")
-    def test_reshaping_panel_categorical(self):
+    def test_reshaping_multi_index_categorical(self):
 
-        p = tm.makePanel()
-        p['str'] = 'foo'
-        df = p.to_frame()
+        # construct a MultiIndexed DataFrame formerly created
+        #  via `tm.makePanel().to_frame()`
+        cols = ['ItemA', 'ItemB', 'ItemC']
+        data = {c: tm.makeTimeDataFrame() for c in cols}
+        df = pd.concat({c: data[c].stack() for c in data}, axis='columns')
+        df.index.names = ['major', 'minor']
+        df['str'] = 'foo'
+
+        dti = df.index.levels[0]
 
         df['category'] = df['str'].astype('category')
         result = df['category'].unstack()
 
-        c = Categorical(['foo'] * len(p.major_axis))
+        c = Categorical(['foo'] * len(dti))
         expected = DataFrame({'A': c.copy(),
                               'B': c.copy(),
                               'C': c.copy(),
                               'D': c.copy()},
                              columns=Index(list('ABCD'), name='minor'),
-                             index=p.major_axis.set_names('major'))
+                             index=dti)
         tm.assert_frame_equal(result, expected)