Clean imports in frame/test_apply.py

Author: h-vetinari

pandas/tests/frame/test_apply.py

@@ -14,9 +14,11 @@
 from hypothesis import given
 from hypothesis.strategies import composite, dates, integers, sampled_from
 
-from pandas import (notna, DataFrame, Series, MultiIndex, date_range,
-                    Timestamp, compat)
-import pandas as pd
+from pandas import compat
+from pandas import (DataFrame, Series, Index, MultiIndex, DatetimeIndex,
+                    Timestamp, Timedelta, Period, date_range, to_datetime,
+                    to_timedelta, NaT, concat, notna)
+
 from pandas.core.dtypes.dtypes import CategoricalDtype
 from pandas.core.apply import frame_apply
 from pandas.util.testing import (assert_series_equal,
@@ -72,7 +74,7 @@ def test_apply_mixed_datetimelike(self):
         # mixed datetimelike
         # GH 7778
         df = DataFrame({'A': date_range('20130101', periods=3),
-                        'B': pd.to_timedelta(np.arange(3), unit='s')})
+                        'B': to_timedelta(np.arange(3), unit='s')})
         result = df.apply(lambda x: x, axis=1)
         assert_frame_equal(result, df)
 
@@ -106,14 +108,14 @@ def test_apply_with_reduce_empty(self, empty_frame):
         assert_frame_equal(result, empty_frame)
         result = empty_frame.apply(x.append, axis=1, result_type='reduce')
         assert_series_equal(result, Series(
-            [], index=pd.Index([], dtype=object)))
+            [], index=Index([], dtype=object)))
 
         empty_with_cols = DataFrame(columns=['a', 'b', 'c'])
         result = empty_with_cols.apply(x.append, axis=1, result_type='expand')
         assert_frame_equal(result, empty_with_cols)
         result = empty_with_cols.apply(x.append, axis=1, result_type='reduce')
         assert_series_equal(result, Series(
-            [], index=pd.Index([], dtype=object)))
+            [], index=Index([], dtype=object)))
 
         # Ensure that x.append hasn't been called
         assert x == []
@@ -241,7 +243,7 @@ def test_apply_mixed_dtype_corner(self):
         result = df[:0].apply(np.mean, axis=1)
         # the result here is actually kind of ambiguous, should it be a Series
         # or a DataFrame?
-        expected = Series(np.nan, index=pd.Index([], dtype='int64'))
+        expected = Series(np.nan, index=Index([], dtype='int64'))
         assert_series_equal(result, expected)
 
         df = DataFrame({'A': ['foo'],
@@ -371,10 +373,10 @@ def transform2(row):
     def test_apply_bug(self):
 
         # GH 6125
-        positions = pd.DataFrame([[1, 'ABC0', 50], [1, 'YUM0', 20],
-                                  [1, 'DEF0', 20], [2, 'ABC1', 50],
-                                  [2, 'YUM1', 20], [2, 'DEF1', 20]],
-                                 columns=['a', 'market', 'position'])
+        positions = DataFrame([[1, 'ABC0', 50], [1, 'YUM0', 20],
+                               [1, 'DEF0', 20], [2, 'ABC1', 50],
+                               [2, 'YUM1', 20], [2, 'DEF1', 20]],
+                              columns=['a', 'market', 'position'])
 
         def f(r):
             return r['market']
@@ -493,47 +495,47 @@ def test_applymap(self, float_frame):
 
         # datetime/timedelta
         df['datetime'] = Timestamp('20130101')
-        df['timedelta'] = pd.Timedelta('1 min')
+        df['timedelta'] = Timedelta('1 min')
         result = df.applymap(str)
         for f in ['datetime', 'timedelta']:
             assert result.loc[0, f] == str(df.loc[0, f])
 
         # see gh-8222
-        empty_frames = [pd.DataFrame(),
-                        pd.DataFrame(columns=list('ABC')),
-                        pd.DataFrame(index=list('ABC')),
-                        pd.DataFrame({'A': [], 'B': [], 'C': []})]
+        empty_frames = [DataFrame(),
+                        DataFrame(columns=list('ABC')),
+                        DataFrame(index=list('ABC')),
+                        DataFrame({'A': [], 'B': [], 'C': []})]
         for frame in empty_frames:
             for func in [round, lambda x: x]:
                 result = frame.applymap(func)
                 tm.assert_frame_equal(result, frame)
 
     def test_applymap_box_timestamps(self):
         # #2689, #2627
-        ser = pd.Series(date_range('1/1/2000', periods=10))
+        ser = Series(date_range('1/1/2000', periods=10))
 
         def func(x):
             return (x.hour, x.day, x.month)
 
         # it works!
-        pd.DataFrame(ser).applymap(func)
+        DataFrame(ser).applymap(func)
 
     def test_applymap_box(self):
         # ufunc will not be boxed. Same test cases as the test_map_box
-        df = pd.DataFrame({'a': [pd.Timestamp('2011-01-01'),
-                                 pd.Timestamp('2011-01-02')],
-                           'b': [pd.Timestamp('2011-01-01', tz='US/Eastern'),
-                                 pd.Timestamp('2011-01-02', tz='US/Eastern')],
-                           'c': [pd.Timedelta('1 days'),
-                                 pd.Timedelta('2 days')],
-                           'd': [pd.Period('2011-01-01', freq='M'),
-                                 pd.Period('2011-01-02', freq='M')]})
+        df = DataFrame({'a': [Timestamp('2011-01-01'),
+                              Timestamp('2011-01-02')],
+                        'b': [Timestamp('2011-01-01', tz='US/Eastern'),
+                              Timestamp('2011-01-02', tz='US/Eastern')],
+                        'c': [Timedelta('1 days'),
+                              Timedelta('2 days')],
+                        'd': [Period('2011-01-01', freq='M'),
+                              Period('2011-01-02', freq='M')]})
 
         res = df.applymap(lambda x: '{0}'.format(x.__class__.__name__))
-        exp = pd.DataFrame({'a': ['Timestamp', 'Timestamp'],
-                            'b': ['Timestamp', 'Timestamp'],
-                            'c': ['Timedelta', 'Timedelta'],
-                            'd': ['Period', 'Period']})
+        exp = DataFrame({'a': ['Timestamp', 'Timestamp'],
+                         'b': ['Timestamp', 'Timestamp'],
+                         'c': ['Timedelta', 'Timedelta'],
+                         'd': ['Period', 'Period']})
         tm.assert_frame_equal(res, exp)
 
     def test_frame_apply_dont_convert_datetime64(self):
@@ -547,14 +549,14 @@ def test_frame_apply_dont_convert_datetime64(self):
 
     def test_apply_non_numpy_dtype(self):
         # See gh-12244
-        df = DataFrame({'dt': pd.date_range(
+        df = DataFrame({'dt': date_range(
             "2015-01-01", periods=3, tz='Europe/Brussels')})
         result = df.apply(lambda x: x)
         assert_frame_equal(result, df)
 
-        result = df.apply(lambda x: x + pd.Timedelta('1day'))
-        expected = DataFrame({'dt': pd.date_range(
-            "2015-01-02", periods=3, tz='Europe/Brussels')})
+        result = df.apply(lambda x: x + Timedelta('1day'))
+        expected = DataFrame({'dt': date_range("2015-01-02", periods=3,
+                                               tz='Europe/Brussels')})
         assert_frame_equal(result, expected)
 
         df = DataFrame({'dt': ['a', 'b', 'c', 'a']}, dtype='category')
@@ -563,8 +565,8 @@ def test_apply_non_numpy_dtype(self):
 
     def test_apply_dup_names_multi_agg(self):
         # GH 21063
-        df = pd.DataFrame([[0, 1], [2, 3]], columns=['a', 'a'])
-        expected = pd.DataFrame([[0, 1]], columns=['a', 'a'], index=['min'])
+        df = DataFrame([[0, 1], [2, 3]], columns=['a', 'a'])
+        expected = DataFrame([[0, 1]], columns=['a', 'a'], index=['min'])
         result = df.agg(['min'])
 
         tm.assert_frame_equal(result, expected)
@@ -578,7 +580,7 @@ class TestInferOutputShape(object):
     def test_infer_row_shape(self):
         # gh-17437
         # if row shape is changing, infer it
-        df = pd.DataFrame(np.random.rand(10, 2))
+        df = DataFrame(np.random.rand(10, 2))
         result = df.apply(np.fft.fft, axis=0)
         assert result.shape == (10, 2)
 
@@ -593,8 +595,8 @@ def test_with_dictlike_columns(self):
         expected = Series([{'s': 3} for t in df.itertuples()])
         assert_series_equal(result, expected)
 
-        df['tm'] = [pd.Timestamp('2017-05-01 00:00:00'),
-                    pd.Timestamp('2017-05-02 00:00:00')]
+        df['tm'] = [Timestamp('2017-05-01 00:00:00'),
+                    Timestamp('2017-05-02 00:00:00')]
         result = df.apply(lambda x: {'s': x['a'] + x['b']},
                           axis=1)
         assert_series_equal(result, expected)
@@ -608,9 +610,9 @@ def test_with_dictlike_columns(self):
         df = DataFrame()
         df["author"] = ["X", "Y", "Z"]
         df["publisher"] = ["BBC", "NBC", "N24"]
-        df["date"] = pd.to_datetime(['17-10-2010 07:15:30',
-                                     '13-05-2011 08:20:35',
-                                     '15-01-2013 09:09:09'])
+        df["date"] = to_datetime(['17-10-2010 07:15:30',
+                                  '13-05-2011 08:20:35',
+                                  '15-01-2013 09:09:09'])
         result = df.apply(lambda x: {}, axis=1)
         expected = Series([{}, {}, {}])
         assert_series_equal(result, expected)
@@ -623,8 +625,8 @@ def test_with_dictlike_columns_with_infer(self):
         expected = DataFrame({'s': [3, 3]})
         assert_frame_equal(result, expected)
 
-        df['tm'] = [pd.Timestamp('2017-05-01 00:00:00'),
-                    pd.Timestamp('2017-05-02 00:00:00')]
+        df['tm'] = [Timestamp('2017-05-01 00:00:00'),
+                    Timestamp('2017-05-02 00:00:00')]
         result = df.apply(lambda x: {'s': x['a'] + x['b']},
                           axis=1, result_type='expand')
         assert_frame_equal(result, expected)
@@ -659,8 +661,8 @@ def test_infer_output_shape_columns(self):
 
         df = DataFrame({'number': [1., 2.],
                         'string': ['foo', 'bar'],
-                        'datetime': [pd.Timestamp('2017-11-29 03:30:00'),
-                                     pd.Timestamp('2017-11-29 03:45:00')]})
+                        'datetime': [Timestamp('2017-11-29 03:30:00'),
+                                     Timestamp('2017-11-29 03:45:00')]})
         result = df.apply(lambda row: (row.number, row.string), axis=1)
         expected = Series([(t.number, t.string) for t in df.itertuples()])
         assert_series_equal(result, expected)
@@ -692,13 +694,13 @@ def test_infer_output_shape_listlike_columns(self):
         assert_series_equal(result, expected)
 
         # gh-17892
-        df = pd.DataFrame({'a': [pd.Timestamp('2010-02-01'),
-                                 pd.Timestamp('2010-02-04'),
-                                 pd.Timestamp('2010-02-05'),
-                                 pd.Timestamp('2010-02-06')],
-                           'b': [9, 5, 4, 3],
-                           'c': [5, 3, 4, 2],
-                           'd': [1, 2, 3, 4]})
+        df = DataFrame({'a': [Timestamp('2010-02-01'),
+                              Timestamp('2010-02-04'),
+                              Timestamp('2010-02-05'),
+                              Timestamp('2010-02-06')],
+                        'b': [9, 5, 4, 3],
+                        'c': [5, 3, 4, 2],
+                        'd': [1, 2, 3, 4]})
 
         def fun(x):
             return (1, 2)
@@ -815,11 +817,11 @@ def zip_frames(frames, axis=1):
     if axis == 1:
         columns = frames[0].columns
         zipped = [f.loc[:, c] for c in columns for f in frames]
-        return pd.concat(zipped, axis=1)
+        return concat(zipped, axis=1)
     else:
         index = frames[0].index
         zipped = [f.loc[i, :] for i in index for f in frames]
-        return pd.DataFrame(zipped)
+        return DataFrame(zipped)
 
 
 class TestDataFrameAggregate():
@@ -847,10 +849,10 @@ def test_agg_transform(self, axis, float_frame):
             result = float_frame.apply([np.sqrt], axis=axis)
             expected = f_sqrt.copy()
             if axis in {0, 'index'}:
-                expected.columns = pd.MultiIndex.from_product(
+                expected.columns = MultiIndex.from_product(
                     [float_frame.columns, ['sqrt']])
             else:
-                expected.index = pd.MultiIndex.from_product(
+                expected.index = MultiIndex.from_product(
                     [float_frame.index, ['sqrt']])
             assert_frame_equal(result, expected)
 
@@ -863,10 +865,10 @@ def test_agg_transform(self, axis, float_frame):
             result = float_frame.apply([np.abs, np.sqrt], axis=axis)
             expected = zip_frames([f_abs, f_sqrt], axis=other_axis)
             if axis in {0, 'index'}:
-                expected.columns = pd.MultiIndex.from_product(
+                expected.columns = MultiIndex.from_product(
                     [float_frame.columns, ['absolute', 'sqrt']])
             else:
-                expected.index = pd.MultiIndex.from_product(
+                expected.index = MultiIndex.from_product(
                     [float_frame.index, ['absolute', 'sqrt']])
             assert_frame_equal(result, expected)
 
@@ -889,7 +891,7 @@ def f():
                 float_frame.transform(['max', 'sqrt'], axis=axis)
         pytest.raises(ValueError, f)
 
-        df = pd.DataFrame({'A': range(5), 'B': 5})
+        df = DataFrame({'A': range(5), 'B': 5})
 
         def f():
             with np.errstate(all='ignore'):
@@ -900,14 +902,14 @@ def f():
     ])
     def test_transform_method_name(self, method):
         # https://github.com/pandas-dev/pandas/issues/19760
-        df = pd.DataFrame({"A": [-1, 2]})
+        df = DataFrame({"A": [-1, 2]})
         result = df.transform(method)
         expected = operator.methodcaller(method)(df)
         tm.assert_frame_equal(result, expected)
 
     def test_demo(self):
         # demonstration tests
-        df = pd.DataFrame({'A': range(5), 'B': 5})
+        df = DataFrame({'A': range(5), 'B': 5})
 
         result = df.agg(['min', 'max'])
         expected = DataFrame({'A': [0, 4], 'B': [5, 5]},
@@ -924,14 +926,14 @@ def test_demo(self):
 
     def test_agg_multiple_mixed_no_warning(self):
         # https://github.com/pandas-dev/pandas/issues/20909
-        mdf = pd.DataFrame({'A': [1, 2, 3],
-                            'B': [1., 2., 3.],
-                            'C': ['foo', 'bar', 'baz'],
-                            'D': pd.date_range('20130101', periods=3)})
-        expected = pd.DataFrame({"A": [1, 6], 'B': [1.0, 6.0],
-                                 "C": ['bar', 'foobarbaz'],
-                                 "D": [pd.Timestamp('2013-01-01'), pd.NaT]},
-                                index=['min', 'sum'])
+        mdf = DataFrame({'A': [1, 2, 3],
+                         'B': [1., 2., 3.],
+                         'C': ['foo', 'bar', 'baz'],
+                         'D': date_range('20130101', periods=3)})
+        expected = DataFrame({'A': [1, 6], 'B': [1.0, 6.0],
+                              'C': ['bar', 'foobarbaz'],
+                              'D': [Timestamp('2013-01-01'), NaT]},
+                             index=['min', 'sum'])
         # sorted index
         with tm.assert_produces_warning(None):
             result = mdf.agg(['min', 'sum'])
@@ -949,7 +951,7 @@ def test_agg_multiple_mixed_no_warning(self):
 
     def test_agg_dict_nested_renaming_depr(self):
 
-        df = pd.DataFrame({'A': range(5), 'B': 5})
+        df = DataFrame({'A': range(5), 'B': 5})
 
         # nested renaming
         with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
@@ -961,10 +963,10 @@ def test_agg_reduce(self, axis, float_frame):
         name1, name2 = float_frame.axes[other_axis].unique()[:2].sort_values()
 
         # all reducers
-        expected = pd.concat([float_frame.mean(axis=axis),
-                              float_frame.max(axis=axis),
-                              float_frame.sum(axis=axis),
-                              ], axis=1)
+        expected = concat([float_frame.mean(axis=axis),
+                           float_frame.max(axis=axis),
+                           float_frame.sum(axis=axis),
+                           ], axis=1)
         expected.columns = ['mean', 'max', 'sum']
         expected = expected.T if axis in {0, 'index'} else expected
 
@@ -1010,15 +1012,15 @@ def test_nuiscance_columns(self):
         df = DataFrame({'A': [1, 2, 3],
                         'B': [1., 2., 3.],
                         'C': ['foo', 'bar', 'baz'],
-                        'D': pd.date_range('20130101', periods=3)})
+                        'D': date_range('20130101', periods=3)})
 
         result = df.agg('min')
-        expected = Series([1, 1., 'bar', pd.Timestamp('20130101')],
+        expected = Series([1, 1., 'bar', Timestamp('20130101')],
                           index=df.columns)
         assert_series_equal(result, expected)
 
         result = df.agg(['min'])
-        expected = DataFrame([[1, 1., 'bar', pd.Timestamp('20130101')]],
+        expected = DataFrame([[1, 1., 'bar', Timestamp('20130101')]],
                              index=['min'], columns=df.columns)
         assert_frame_equal(result, expected)
 
@@ -1058,9 +1060,9 @@ def test_non_callable_aggregates(self):
         result2 = df.agg({'A': ['count', 'size'],
                           'B': ['count', 'size'],
                           'C': ['count', 'size']})
-        expected = pd.DataFrame({'A': {'count': 2, 'size': 3},
-                                 'B': {'count': 2, 'size': 3},
-                                 'C': {'count': 2, 'size': 3}})
+        expected = DataFrame({'A': {'count': 2, 'size': 3},
+                              'B': {'count': 2, 'size': 3},
+                              'C': {'count': 2, 'size': 3}})
 
         assert_frame_equal(result1, result2, check_like=True)
         assert_frame_equal(result2, expected, check_like=True)
@@ -1152,7 +1154,7 @@ def indices(draw, max_length=5):
         periods = draw(integers(0, max_length))
         freq = draw(sampled_from(list("BDHTS")))
         dr = date_range(date, periods=periods, freq=freq)
-        return pd.DatetimeIndex(list(dr))
+        return DatetimeIndex(list(dr))
 
     @given(index=indices(5), num_columns=integers(0, 5))
     def test_frequency_is_original(self, index, num_columns):