Tst return none inplace series

pandas/tests/series/indexing/test_indexing.py

@@ -736,14 +736,16 @@ def test_append_timedelta_does_not_cast(td):
 def test_underlying_data_conversion():
     # GH 4080
     df = DataFrame({c: [1, 2, 3] for c in ["a", "b", "c"]})
-    df.set_index(["a", "b", "c"], inplace=True)
+    return_value = df.set_index(["a", "b", "c"], inplace=True)
+    assert return_value is None
     s = Series([1], index=[(2, 2, 2)])
     df["val"] = 0
     df
     df["val"].update(s)
 
     expected = DataFrame(dict(a=[1, 2, 3], b=[1, 2, 3], c=[1, 2, 3], val=[0, 1, 0]))
-    expected.set_index(["a", "b", "c"], inplace=True)
+    return_value = expected.set_index(["a", "b", "c"], inplace=True)
+    assert return_value is None
     tm.assert_frame_equal(df, expected)
 
     # GH 3970

pandas/tests/series/methods/test_drop_duplicates.py

@@ -22,8 +22,10 @@ def test_drop_duplicates(any_numpy_dtype, keep, expected):
     tm.assert_series_equal(tc.duplicated(keep=keep), expected)
     tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
     sc = tc.copy()
-    sc.drop_duplicates(keep=keep, inplace=True)
+    return_value = return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    assert return_value is None
     tm.assert_series_equal(sc, tc[~expected])
+    assert return_value is None
 
 
 @pytest.mark.parametrize(
@@ -40,8 +42,10 @@ def test_drop_duplicates_bool(keep, expected):
     tm.assert_series_equal(tc.duplicated(keep=keep), expected)
     tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
     sc = tc.copy()
-    sc.drop_duplicates(keep=keep, inplace=True)
+    return_value = return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    assert return_value is None
     tm.assert_series_equal(sc, tc[~expected])
+    assert return_value is None
 
 
 @pytest.mark.parametrize("values", [[], list(range(5))])
@@ -84,22 +88,27 @@ def test_drop_duplicates_categorical_non_bool(self, dtype, ordered):
         tm.assert_series_equal(tc1.duplicated(), expected)
         tm.assert_series_equal(tc1.drop_duplicates(), tc1[~expected])
         sc = tc1.copy()
-        sc.drop_duplicates(inplace=True)
+        return_value = return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc1[~expected])
+        assert return_value is None
 
         expected = Series([False, False, True, False])
         tm.assert_series_equal(tc1.duplicated(keep="last"), expected)
         tm.assert_series_equal(tc1.drop_duplicates(keep="last"), tc1[~expected])
         sc = tc1.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc1[~expected])
 
         expected = Series([False, False, True, True])
         tm.assert_series_equal(tc1.duplicated(keep=False), expected)
         tm.assert_series_equal(tc1.drop_duplicates(keep=False), tc1[~expected])
         sc = tc1.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
+        return_value = return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc1[~expected])
+        assert return_value is None
 
         # Test case 2
         input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
@@ -113,22 +122,28 @@ def test_drop_duplicates_categorical_non_bool(self, dtype, ordered):
         tm.assert_series_equal(tc2.duplicated(), expected)
         tm.assert_series_equal(tc2.drop_duplicates(), tc2[~expected])
         sc = tc2.copy()
-        sc.drop_duplicates(inplace=True)
+        return_value = return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc2[~expected])
+        assert return_value is None
 
         expected = Series([False, True, True, False, False, False, False])
         tm.assert_series_equal(tc2.duplicated(keep="last"), expected)
         tm.assert_series_equal(tc2.drop_duplicates(keep="last"), tc2[~expected])
         sc = tc2.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
+        return_value = return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc2[~expected])
+        assert return_value is None
 
         expected = Series([False, True, True, False, True, True, False])
         tm.assert_series_equal(tc2.duplicated(keep=False), expected)
         tm.assert_series_equal(tc2.drop_duplicates(keep=False), tc2[~expected])
         sc = tc2.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
+        return_value = return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc2[~expected])
+        assert return_value is None
 
     def test_drop_duplicates_categorical_bool(self, ordered):
         tc = Series(
@@ -141,19 +156,25 @@ def test_drop_duplicates_categorical_bool(self, ordered):
         tm.assert_series_equal(tc.duplicated(), expected)
         tm.assert_series_equal(tc.drop_duplicates(), tc[~expected])
         sc = tc.copy()
-        sc.drop_duplicates(inplace=True)
+        return_value = return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc[~expected])
+        assert return_value is None
 
         expected = Series([True, True, False, False])
         tm.assert_series_equal(tc.duplicated(keep="last"), expected)
         tm.assert_series_equal(tc.drop_duplicates(keep="last"), tc[~expected])
         sc = tc.copy()
-        sc.drop_duplicates(keep="last", inplace=True)
+        return_value = return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc[~expected])
+        assert return_value is None
 
         expected = Series([True, True, True, True])
         tm.assert_series_equal(tc.duplicated(keep=False), expected)
         tm.assert_series_equal(tc.drop_duplicates(keep=False), tc[~expected])
         sc = tc.copy()
-        sc.drop_duplicates(keep=False, inplace=True)
+        return_value = return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
         tm.assert_series_equal(sc, tc[~expected])
+        assert return_value is None

pandas/tests/series/methods/test_fillna.py

@@ -67,7 +67,8 @@ def test_fillna_numeric_inplace(self):
         x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
         y = x.copy()
 
-        y.fillna(value=0, inplace=True)
+        return_value = y.fillna(value=0, inplace=True)
+        assert return_value is None
 
         expected = x.fillna(value=0)
         tm.assert_series_equal(y, expected)

pandas/tests/series/methods/test_replace.py

@@ -13,7 +13,8 @@ def test_replace(self, datetime_series):
         ser[6:10] = 0
 
         # replace list with a single value
-        ser.replace([np.nan], -1, inplace=True)
+        return_value = ser.replace([np.nan], -1, inplace=True)
+        assert return_value is None
 
         exp = ser.fillna(-1)
         tm.assert_series_equal(ser, exp)
@@ -48,7 +49,8 @@ def test_replace(self, datetime_series):
         tm.assert_series_equal(rs, rs2)
 
         # replace inplace
-        ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
 
         assert (ser[:5] == -1).all()
         assert (ser[6:10] == -1).all()
@@ -124,7 +126,8 @@ def test_replace_with_single_list(self):
         tm.assert_series_equal(result, pd.Series([0, 0, 0, 0, 4]))
 
         s = ser.copy()
-        s.replace([1, 2, 3], inplace=True)
+        return_value = s.replace([1, 2, 3], inplace=True)
+        assert return_value is None
         tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
 
         # make sure things don't get corrupted when fillna call fails
@@ -134,7 +137,8 @@ def test_replace_with_single_list(self):
             r"\(bfill\)\. Got crash_cymbal"
         )
         with pytest.raises(ValueError, match=msg):
-            s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
+            return_value = s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
+            assert return_value is None
         tm.assert_series_equal(s, ser)
 
     def test_replace_with_empty_list(self):
@@ -156,7 +160,8 @@ def test_replace_mixed_types(self):
         def check_replace(to_rep, val, expected):
             sc = s.copy()
             r = s.replace(to_rep, val)
-            sc.replace(to_rep, val, inplace=True)
+            return_value = sc.replace(to_rep, val, inplace=True)
+            assert return_value is None
             tm.assert_series_equal(expected, r)
             tm.assert_series_equal(expected, sc)
 
@@ -242,7 +247,8 @@ def test_replace2(self):
         tm.assert_series_equal(rs, rs2)
 
         # replace inplace
-        ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
         assert (ser[:5] == -1).all()
         assert (ser[6:10] == -1).all()
         assert (ser[20:30] == -1).all()
@@ -325,11 +331,13 @@ def test_replace_categorical_single(self):
         tm.assert_series_equal(expected, result)
         assert c[2] != "foo"  # ensure non-inplace call does not alter original
 
-        c.replace(c[2], "foo", inplace=True)
+        return_value = c.replace(c[2], "foo", inplace=True)
+        assert return_value is None
         tm.assert_series_equal(expected, c)
 
         first_value = c[0]
-        c.replace(c[1], c[0], inplace=True)
+        return_value = c.replace(c[1], c[0], inplace=True)
+        assert return_value is None
         assert c[0] == c[1] == first_value  # test replacing with existing value
 
     def test_replace_with_no_overflowerror(self):

pandas/tests/series/methods/test_reset_index.py

@@ -22,7 +22,8 @@ def test_reset_index(self):
         # check inplace
         s = ser.reset_index(drop=True)
         s2 = ser
-        s2.reset_index(drop=True, inplace=True)
+        return_value = s2.reset_index(drop=True, inplace=True)
+        assert return_value is None
         tm.assert_series_equal(s, s2)
 
         # level

pandas/tests/series/methods/test_sort_values.py

@@ -65,7 +65,8 @@ def test_sort_values(self, datetime_series):
 
         # inplace=True
         ts = datetime_series.copy()
-        ts.sort_values(ascending=False, inplace=True)
+        return_value = ts.sort_values(ascending=False, inplace=True)
+        assert return_value is None
         tm.assert_series_equal(ts, datetime_series.sort_values(ascending=False))
         tm.assert_index_equal(
             ts.index, datetime_series.sort_values(ascending=False).index
@@ -81,7 +82,8 @@ def test_sort_values(self, datetime_series):
             "you must create a copy"
         )
         with pytest.raises(ValueError, match=msg):
-            s.sort_values(inplace=True)
+            return_value = s.sort_values(inplace=True)
+            assert return_value is None
 
     def test_sort_values_categorical(self):
 

pandas/tests/series/methods/test_truncate.py

@@ -136,7 +136,8 @@ def test_truncate_multiindex(self):
         df = pd.DataFrame.from_dict(
             {"L1": [2, 2, 3, 3], "L2": ["A", "B", "A", "B"], "col": [2, 3, 4, 5]}
         )
-        df.set_index(["L1", "L2"], inplace=True)
+        return_value = df.set_index(["L1", "L2"], inplace=True)
+        assert return_value is None
         expected = df.col
 
         tm.assert_series_equal(result, expected)

pandas/tests/series/test_api.py

@@ -179,7 +179,8 @@ def test_constructor_dict_timedelta_index(self):
 
     def test_sparse_accessor_updates_on_inplace(self):
         s = pd.Series([1, 1, 2, 3], dtype="Sparse[int]")
-        s.drop([0, 1], inplace=True)
+        return_value = s.drop([0, 1], inplace=True)
+        assert return_value is None
         assert s.sparse.density == 1.0
 
     def test_tab_completion(self):
@@ -459,7 +460,8 @@ def f(x):
 
     def test_str_accessor_updates_on_inplace(self):
         s = pd.Series(list("abc"))
-        s.drop([0], inplace=True)
+        return_value = s.drop([0], inplace=True)
+        assert return_value is None
         assert len(s.str.lower()) == 2
 
     def test_str_attribute(self):
@@ -548,7 +550,8 @@ def test_cat_accessor(self):
         assert not s.cat.ordered, False
 
         exp = Categorical(["a", "b", np.nan, "a"], categories=["b", "a"])
-        s.cat.set_categories(["b", "a"], inplace=True)
+        return_value = s.cat.set_categories(["b", "a"], inplace=True)
+        assert return_value is None
         tm.assert_categorical_equal(s.values, exp)
 
         res = s.cat.set_categories(["b", "a"])
@@ -579,8 +582,10 @@ def test_cat_accessor_no_new_attributes(self):
 
     def test_cat_accessor_updates_on_inplace(self):
         s = Series(list("abc")).astype("category")
-        s.drop(0, inplace=True)
-        s.cat.remove_unused_categories(inplace=True)
+        return_value = s.drop(0, inplace=True)
+        assert return_value is None
+        return_value = s.cat.remove_unused_categories(inplace=True)
+        assert return_value is None
         assert len(s.cat.categories) == 2
 
     def test_categorical_delegations(self):
@@ -614,7 +619,8 @@ def test_categorical_delegations(self):
         assert s.cat.ordered
         s = s.cat.as_unordered()
         assert not s.cat.ordered
-        s.cat.as_ordered(inplace=True)
+        return_value = s.cat.as_ordered(inplace=True)
+        assert return_value is None
         assert s.cat.ordered
 
         # reorder

pandas/tests/series/test_datetime_values.py

@@ -625,7 +625,8 @@ def test_dt_accessor_invalid(self, ser):
     def test_dt_accessor_updates_on_inplace(self):
         s = Series(pd.date_range("2018-01-01", periods=10))
         s[2] = None
-        s.fillna(pd.Timestamp("2018-01-01"), inplace=True)
+        return_value = s.fillna(pd.Timestamp("2018-01-01"), inplace=True)
+        assert return_value is None
         result = s.dt.date
         assert result[0] == result[2]
 

pandas/tests/series/test_missing.py

@@ -453,7 +453,8 @@ def test_fillna_downcast(self):
 
     def test_fillna_int(self):
         s = Series(np.random.randint(-100, 100, 50))
-        s.fillna(method="ffill", inplace=True)
+        return_value = s.fillna(method="ffill", inplace=True)
+        assert return_value is None
         tm.assert_series_equal(s.fillna(method="ffill", inplace=False), s)
 
     def test_categorical_nan_equality(self):
@@ -680,7 +681,8 @@ def test_dropna_empty(self):
         s = Series([], dtype=object)
 
         assert len(s.dropna()) == 0
-        s.dropna(inplace=True)
+        return_value = s.dropna(inplace=True)
+        assert return_value is None
         assert len(s) == 0
 
         # invalid axis
@@ -729,7 +731,8 @@ def test_dropna_no_nan(self):
             assert result is not s
 
             s2 = s.copy()
-            s2.dropna(inplace=True)
+            return_value = s2.dropna(inplace=True)
+            assert return_value is None
             tm.assert_series_equal(s2, s)
 
     def test_dropna_intervals(self):
@@ -775,7 +778,8 @@ def test_pad_nan(self):
             [np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"], dtype=float
         )
 
-        x.fillna(method="pad", inplace=True)
+        return_value = x.fillna(method="pad", inplace=True)
+        assert return_value is None
 
         expected = Series(
             [np.nan, 1.0, 1.0, 3.0, 3.0], ["z", "a", "b", "c", "d"], dtype=float
@@ -799,7 +803,8 @@ def test_dropna_preserve_name(self, datetime_series):
         assert result.name == datetime_series.name
         name = datetime_series.name
         ts = datetime_series.copy()
-        ts.dropna(inplace=True)
+        return_value = ts.dropna(inplace=True)
+        assert return_value is None
         assert ts.name == name
 
     def test_series_fillna_limit(self):