CLN: Consistent pandas.util.testing imports in pandas/tests/series

pandas/tests/series/test_api.py

@@ -20,7 +20,6 @@
 from pandas.core.arrays import PeriodArray
 from pandas.core.indexes.datetimes import Timestamp
 import pandas.util.testing as tm
-from pandas.util.testing import assert_series_equal, ensure_clean
 
 import pandas.io.formats.printing as printing
 
@@ -110,15 +109,15 @@ def test_getitem_preserve_name(self, datetime_series):
 
     def test_pickle_datetimes(self, datetime_series):
         unp_ts = self._pickle_roundtrip(datetime_series)
-        assert_series_equal(unp_ts, datetime_series)
+        tm.assert_series_equal(unp_ts, datetime_series)
 
     def test_pickle_strings(self, string_series):
         unp_series = self._pickle_roundtrip(string_series)
-        assert_series_equal(unp_series, string_series)
+        tm.assert_series_equal(unp_series, string_series)
 
     def _pickle_roundtrip(self, obj):
 
-        with ensure_clean() as path:
+        with tm.ensure_clean() as path:
             obj.to_pickle(path)
             unpickled = pd.read_pickle(path)
             return unpickled
@@ -399,16 +398,16 @@ def test_copy_tzaware(self):
             # default deep is True
             if deep is None or deep is True:
                 # Did not modify original Series
-                assert_series_equal(s2, expected2)
-                assert_series_equal(s, expected)
+                tm.assert_series_equal(s2, expected2)
+                tm.assert_series_equal(s, expected)
             else:
                 # we DID modify the original Series
-                assert_series_equal(s2, expected2)
-                assert_series_equal(s, expected2)
+                tm.assert_series_equal(s2, expected2)
+                tm.assert_series_equal(s, expected2)
 
     def test_axis_alias(self):
         s = Series([1, 2, np.nan])
-        assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
+        tm.assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
         assert s.dropna().sum("rows") == 3
         assert s._get_axis_number("rows") == 0
         assert s._get_axis_name("rows") == "index"
@@ -490,7 +489,7 @@ def test_str_attribute(self):
         s = Series([" jack", "jill ", " jesse ", "frank"])
         for method in methods:
             expected = Series([getattr(str, method)(x) for x in s.values])
-            assert_series_equal(getattr(Series.str, method)(s.str), expected)
+            tm.assert_series_equal(getattr(Series.str, method)(s.str), expected)
 
         # str accessor only valid with string values
         s = Series(range(5))

pandas/tests/series/test_apply.py

@@ -8,7 +8,6 @@
 from pandas import DataFrame, Index, Series, isna
 from pandas.conftest import _get_cython_table_params
 import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 class TestSeriesApply:
@@ -47,12 +46,12 @@ def test_apply_same_length_inference_bug(self):
 
         result = s.apply(f)
         expected = s.map(f)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
         s = Series([1, 2, 3])
         result = s.apply(f)
         expected = s.map(f)
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_apply_dont_convert_dtype(self):
         s = Series(np.random.randn(10))
@@ -184,42 +183,42 @@ def test_transform(self, string_series):
             # ufunc
             result = string_series.transform(np.sqrt)
             expected = f_sqrt.copy()
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
             result = string_series.apply(np.sqrt)
-            assert_series_equal(result, expected)
+            tm.assert_series_equal(result, expected)
 
             # list-like
             result = string_series.transform([np.sqrt])
             expected = f_sqrt.to_frame().copy()
             expected.columns = ["sqrt"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform([np.sqrt])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform(["sqrt"])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # multiple items in list
             # these are in the order as if we are applying both functions per
             # series and then concatting
             expected = pd.concat([f_sqrt, f_abs], axis=1)
             expected.columns = ["sqrt", "absolute"]
             result = string_series.apply([np.sqrt, np.abs])
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             result = string_series.transform(["sqrt", "abs"])
             expected.columns = ["sqrt", "abs"]
-            assert_frame_equal(result, expected)
+            tm.assert_frame_equal(result, expected)
 
             # dict, provide renaming
             expected = pd.concat([f_sqrt, f_abs], axis=1)
             expected.columns = ["foo", "bar"]
             expected = expected.unstack().rename("series")
 
             result = string_series.apply({"foo": np.sqrt, "bar": np.abs})
-            assert_series_equal(result.reindex_like(expected), expected)
+            tm.assert_series_equal(result.reindex_like(expected), expected)
 
     def test_transform_and_agg_error(self, string_series):
         # we are trying to transform with an aggregator
@@ -317,7 +316,7 @@ def test_replicate_describe(self, string_series):
                 ]
             )
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_reduce(self, string_series):
         # reductions with named functions
@@ -327,7 +326,7 @@ def test_reduce(self, string_series):
             ["sum", "mean"],
             name=string_series.name,
         )
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_non_callable_aggregates(self):
         # test agg using non-callable series attributes
@@ -341,7 +340,7 @@ def test_non_callable_aggregates(self):
         # test when mixed w/ callable reducers
         result = s.agg(["size", "count", "mean"])
         expected = Series(OrderedDict([("size", 3.0), ("count", 2.0), ("mean", 1.5)]))
-        assert_series_equal(result[expected.index], expected)
+        tm.assert_series_equal(result[expected.index], expected)
 
     @pytest.mark.parametrize(
         "series, func, expected",
@@ -516,7 +515,7 @@ def test_map_compat(self):
         s = Series([True, True, False], index=[1, 2, 3])
         result = s.map({True: "foo", False: "bar"})
         expected = Series(["foo", "foo", "bar"], index=[1, 2, 3])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_int(self):
         left = Series({"a": 1.0, "b": 2.0, "c": 3.0, "d": 4})
@@ -547,7 +546,7 @@ def test_map_na_exclusion(self):
 
         result = s.map(lambda x: x * 2, na_action="ignore")
         exp = s * 2
-        assert_series_equal(result, exp)
+        tm.assert_series_equal(result, exp)
 
     def test_map_dict_with_tuple_keys(self):
         """
@@ -572,15 +571,15 @@ def test_map_counter(self):
         counter["c"] += 1
         result = s.map(counter)
         expected = Series([0, 5, 1], index=[1, 2, 3])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_defaultdict(self):
         s = Series([1, 2, 3], index=["a", "b", "c"])
         default_dict = defaultdict(lambda: "blank")
         default_dict[1] = "stuff"
         result = s.map(default_dict)
         expected = Series(["stuff", "blank", "blank"], index=["a", "b", "c"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_dict_subclass_with_missing(self):
         """
@@ -596,7 +595,7 @@ def __missing__(self, key):
         dictionary = DictWithMissing({3: "three"})
         result = s.map(dictionary)
         expected = Series(["missing", "missing", "three"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_dict_subclass_without_missing(self):
         class DictWithoutMissing(dict):
@@ -606,7 +605,7 @@ class DictWithoutMissing(dict):
         dictionary = DictWithoutMissing({3: "three"})
         result = s.map(dictionary)
         expected = Series([np.nan, np.nan, "three"])
-        assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
 
     def test_map_box(self):
         vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
@@ -729,11 +728,11 @@ def test_apply_series_on_date_time_index_aware_series(self, dti, exp):
         # Calling apply on a localized time series should not cause an error
         index = dti.tz_localize("UTC").index
         result = pd.Series(index).apply(lambda x: pd.Series([1, 2]))
-        assert_frame_equal(result, exp)
+        tm.assert_frame_equal(result, exp)
 
     def test_apply_scaler_on_date_time_index_aware_series(self):
         # GH 25959
         # Calling apply on a localized time series should not cause an error
         series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
         result = pd.Series(series.index).apply(lambda x: 1)
-        assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))
+        tm.assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))

pandas/tests/series/test_combine_concat.py

@@ -6,7 +6,6 @@
 import pandas as pd
 from pandas import DataFrame, DatetimeIndex, Series, date_range
 import pandas.util.testing as tm
-from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
 class TestSeriesCombine:
@@ -28,7 +27,7 @@ def test_append_many(self, datetime_series):
         pieces = [datetime_series[:5], datetime_series[5:10], datetime_series[10:]]
 
         result = pieces[0].append(pieces[1:])
-        assert_series_equal(result, datetime_series)
+        tm.assert_series_equal(result, datetime_series)
 
     def test_append_duplicates(self):
         # GH 13677
@@ -110,15 +109,15 @@ def test_combine_first(self):
         s = Series([1.0, 2, 3], index=[0, 1, 2])
         result = s.combine_first(Series([], index=[]))
         s.index = s.index.astype("O")
-        assert_series_equal(s, result)
+        tm.assert_series_equal(s, result)
 
     def test_update(self):
         s = Series([1.5, np.nan, 3.0, 4.0, np.nan])
         s2 = Series([np.nan, 3.5, np.nan, 5.0])
         s.update(s2)
 
         expected = Series([1.5, 3.5, 3.0, 5.0, np.nan])
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
         # GH 3217
         df = DataFrame([{"a": 1}, {"a": 3, "b": 2}])
@@ -128,7 +127,7 @@ def test_update(self):
         expected = DataFrame(
             [[1, np.nan, "foo"], [3, 2.0, np.nan]], columns=["a", "b", "c"]
         )
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize(
         "other, dtype, expected",
@@ -161,7 +160,7 @@ def test_update_dtypes(self, other, dtype, expected):
         other = Series(other, index=[1, 3])
         s.update(other)
 
-        assert_series_equal(s, expected)
+        tm.assert_series_equal(s, expected)
 
     def test_concat_empty_series_dtypes_roundtrips(self):
 
@@ -226,7 +225,7 @@ def test_combine_first_dt_tz_values(self, tz_naive_fixture):
             tz=tz_naive_fixture,
         )
         exp = pd.Series(exp_vals, name="ser1")
-        assert_series_equal(exp, result)
+        tm.assert_series_equal(exp, result)
 
     def test_concat_empty_series_dtypes(self):
 
@@ -324,13 +323,13 @@ def test_combine_first_dt64(self):
         s1 = to_datetime(Series([np.NaN, "2011"]))
         rs = s0.combine_first(s1)
         xp = to_datetime(Series(["2010", "2011"]))
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
         s0 = to_datetime(Series(["2010", np.NaN]))
         s1 = Series([np.NaN, "2011"])
         rs = s0.combine_first(s1)
         xp = Series([datetime(2010, 1, 1), "2011"])
-        assert_series_equal(rs, xp)
+        tm.assert_series_equal(rs, xp)
 
 
 class TestTimeseries: