wip

Author: MarcoGorelli

pandas/tests/indexing/test_at.py

@@ -1,8 +1,3 @@
-from datetime import (
-    datetime,
-    timezone,
-)
-
 import numpy as np
 import pytest
 
@@ -21,17 +16,6 @@
 import pandas._testing as tm
 
 
-def test_at_timezone():
-    # https://github.com/pandas-dev/pandas/issues/33544
-    result = DataFrame({"foo": [datetime(2000, 1, 1)]})
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-        result.at[0, "foo"] = datetime(2000, 1, 2, tzinfo=timezone.utc)
-    expected = DataFrame(
-        {"foo": [datetime(2000, 1, 2, tzinfo=timezone.utc)]}, dtype=object
-    )
-    tm.assert_frame_equal(result, expected)
-
-
 def test_selection_methods_of_assigned_col():
     # GH 29282
     df = DataFrame(data={"a": [1, 2, 3], "b": [4, 5, 6]})

pandas/tests/indexing/test_iloc.py

@@ -9,7 +9,6 @@
 from pandas.errors import IndexingError
 
 from pandas import (
-    NA,
     Categorical,
     CategoricalDtype,
     DataFrame,
@@ -527,12 +526,6 @@ def test_iloc_setitem_frame_duplicate_columns_multiple_blocks(self):
         df.iloc[:, 0] = df.iloc[:, 0].astype("f8")
         assert len(df._mgr.blocks) == 1
 
-        # if the assigned values cannot be held by existing integer arrays,
-        #  we cast
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.iloc[:, 0] = df.iloc[:, 0] + 0.5
-        assert len(df._mgr.blocks) == 2
-
         expected = df.copy()
 
         # assign back to self
@@ -1441,11 +1434,3 @@ def test_iloc_setitem_pure_position_based(self):
         ser1.iloc[1:3] = ser2.iloc[1:3]
         expected = Series([1, 5, 6])
         tm.assert_series_equal(ser1, expected)
-
-    def test_iloc_nullable_int64_size_1_nan(self):
-        # GH 31861
-        result = DataFrame({"a": ["test"], "b": [np.nan]})
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            result.loc[:, "b"] = result.loc[:, "b"].astype("Int64")
-        expected = DataFrame({"a": ["test"], "b": array([NA], dtype="Int64")})
-        tm.assert_frame_equal(result, expected)

pandas/tests/indexing/test_loc.py

@@ -2,7 +2,6 @@
 
 from collections import namedtuple
 from datetime import (
-    date,
     datetime,
     time,
     timedelta,
@@ -16,7 +15,6 @@
 from pandas._config import using_pyarrow_string_dtype
 
 from pandas._libs import index as libindex
-from pandas.compat.numpy import np_version_gt2
 from pandas.errors import IndexingError
 
 import pandas as pd
@@ -379,17 +377,6 @@ def test_loc_setitem_slice(self):
         )
         tm.assert_frame_equal(df1, expected)
 
-        # assigning a new type should get the inferred type
-        df2 = DataFrame({"a": [0, 1, 1], "b": [100, 200, 300]}, dtype="uint64")
-        ix = df1["a"] == 1
-        newb2 = df2.loc[ix, "b"]
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
-            df1.loc[ix, "b"] = newb2
-        expected = DataFrame({"a": [0, 1, 1], "b": [100, 200, 300]}, dtype="uint64")
-        tm.assert_frame_equal(df2, expected)
-
     def test_loc_setitem_dtype(self):
         # GH31340
         df = DataFrame({"id": ["A"], "a": [1.2], "b": [0.0], "c": [-2.5]})
@@ -565,62 +552,6 @@ def frame_for_consistency(self):
             }
         )
 
-    @pytest.mark.parametrize(
-        "val",
-        [0, np.array(0, dtype=np.int64), np.array([0, 0, 0, 0, 0], dtype=np.int64)],
-    )
-    def test_loc_setitem_consistency(self, frame_for_consistency, val):
-        # GH 6149
-        # coerce similarly for setitem and loc when rows have a null-slice
-        expected = DataFrame(
-            {
-                "date": Series(0, index=range(5), dtype=np.int64),
-                "val": Series(range(5), dtype=np.int64),
-            }
-        )
-        df = frame_for_consistency.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[:, "date"] = val
-        tm.assert_frame_equal(df, expected)
-
-    def test_loc_setitem_consistency_dt64_to_str(self, frame_for_consistency):
-        # GH 6149
-        # coerce similarly for setitem and loc when rows have a null-slice
-
-        expected = DataFrame(
-            {
-                "date": Series("foo", index=range(5)),
-                "val": Series(range(5), dtype=np.int64),
-            }
-        )
-        df = frame_for_consistency.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[:, "date"] = "foo"
-        tm.assert_frame_equal(df, expected)
-
-    def test_loc_setitem_consistency_dt64_to_float(self, frame_for_consistency):
-        # GH 6149
-        # coerce similarly for setitem and loc when rows have a null-slice
-        expected = DataFrame(
-            {
-                "date": Series(1.0, index=range(5)),
-                "val": Series(range(5), dtype=np.int64),
-            }
-        )
-        df = frame_for_consistency.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[:, "date"] = 1.0
-        tm.assert_frame_equal(df, expected)
-
-    def test_loc_setitem_consistency_single_row(self):
-        # GH 15494
-        # setting on frame with single row
-        df = DataFrame({"date": Series([Timestamp("20180101")])})
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[:, "date"] = "string"
-        expected = DataFrame({"date": Series(["string"])})
-        tm.assert_frame_equal(df, expected)
-
     def test_loc_setitem_consistency_empty(self):
         # empty (essentially noops)
         # before the enforcement of #45333 in 2.0, the loc.setitem here would
@@ -675,16 +606,16 @@ def test_loc_setitem_consistency_slice_column_len(self):
             - df.loc[:, ("Respondent", "StartDate")]
         )
 
-        # timedelta64[m] -> float, so this cannot be done inplace, so
-        #  no warning
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[:, ("Respondent", "Duration")] = df.loc[
-                :, ("Respondent", "Duration")
-            ] / Timedelta(60_000_000_000)
-
         expected = Series(
-            [23.0, 12.0, 14.0, 36.0], index=df.index, name=("Respondent", "Duration")
-        )
+            [
+                timedelta(minutes=23),
+                timedelta(minutes=12),
+                timedelta(minutes=14),
+                timedelta(minutes=36),
+            ],
+            index=df.index,
+            name=("Respondent", "Duration"),
+        ).astype("timedelta64[s]")
         tm.assert_series_equal(df[("Respondent", "Duration")], expected)
 
     @pytest.mark.parametrize("unit", ["Y", "M", "D", "h", "m", "s", "ms", "us"])
@@ -1409,18 +1340,6 @@ def test_loc_setitem_listlike_with_timedelta64index(self, indexer, expected):
 
         tm.assert_frame_equal(expected, df)
 
-    def test_loc_setitem_categorical_values_partial_column_slice(self):
-        # Assigning a Category to parts of a int/... column uses the values of
-        # the Categorical
-        df = DataFrame({"a": [1, 1, 1, 1, 1], "b": list("aaaaa")})
-        exp = DataFrame({"a": [1, "b", "b", 1, 1], "b": list("aabba")})
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
-            df.loc[1:2, "a"] = Categorical(["b", "b"], categories=["a", "b"])
-            df.loc[2:3, "b"] = Categorical(["b", "b"], categories=["a", "b"])
-        tm.assert_frame_equal(df, exp)
-
     def test_loc_setitem_single_row_categorical(self, using_infer_string):
         # GH#25495
         df = DataFrame({"Alpha": ["a"], "Numeric": [0]})
@@ -1440,16 +1359,6 @@ def test_loc_setitem_single_row_categorical(self, using_infer_string):
         df["Alpha"] = categories
         tm.assert_series_equal(df["Alpha"], Series(categories, name="Alpha"))
 
-    def test_loc_setitem_datetime_coercion(self):
-        # GH#1048
-        df = DataFrame({"c": [Timestamp("2010-10-01")] * 3})
-        df.loc[0:1, "c"] = np.datetime64("2008-08-08")
-        assert Timestamp("2008-08-08") == df.loc[0, "c"]
-        assert Timestamp("2008-08-08") == df.loc[1, "c"]
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df.loc[2, "c"] = date(2005, 5, 5)
-        assert Timestamp("2005-05-05").date() == df.loc[2, "c"]
-
     @pytest.mark.parametrize("idxer", ["var", ["var"]])
     def test_loc_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
         # GH#11365
@@ -1459,11 +1368,8 @@ def test_loc_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
         # if result started off with object dtype, then the .loc.__setitem__
         #  below would retain object dtype
         result = DataFrame(index=idx, columns=["var"], dtype=np.float64)
-        with tm.assert_produces_warning(
-            FutureWarning if idxer == "var" else None, match="incompatible dtype"
-        ):
-            # See https://github.com/pandas-dev/pandas/issues/56223
-            result.loc[:, idxer] = expected
+        # See https://github.com/pandas-dev/pandas/issues/56223
+        result.loc[:, ["var"]] = expected
         tm.assert_frame_equal(result, expected)
 
     def test_loc_setitem_time_key(self):
@@ -1605,22 +1511,6 @@ def test_loc_setitem_single_column_mixed(self, using_infer_string):
         ).values
         tm.assert_almost_equal(df["str"].values, expected)
 
-    def test_loc_setitem_cast2(self):
-        # GH#7704
-        # dtype conversion on setting
-        df = DataFrame(np.random.default_rng(2).random((30, 3)), columns=tuple("ABC"))
-        df["event"] = np.nan
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
-            df.loc[10, "event"] = "foo"
-        result = df.dtypes
-        expected = Series(
-            [np.dtype("float64")] * 3 + [np.dtype("object")],
-            index=["A", "B", "C", "event"],
-        )
-        tm.assert_series_equal(result, expected)
-
     def test_loc_setitem_cast3(self):
         # Test that data type is preserved . GH#5782
         df = DataFrame({"one": np.arange(6, dtype=np.int8)})
@@ -2969,26 +2859,6 @@ def test_loc_getitem_nullable_index_with_duplicates():
     tm.assert_series_equal(res, expected)
 
 
-@pytest.mark.parametrize("value", [300, np.uint16(300), np.int16(300)])
-def test_loc_setitem_uint8_upcast(value):
-    # GH#26049
-
-    df = DataFrame([1, 2, 3, 4], columns=["col1"], dtype="uint8")
-    with tm.assert_produces_warning(FutureWarning, match="item of incompatible dtype"):
-        df.loc[2, "col1"] = value  # value that can't be held in uint8
-
-    if np_version_gt2 and isinstance(value, np.int16):
-        # Note, result type of uint8 + int16 is int16
-        # in numpy < 2, though, numpy would inspect the
-        # value and see that it could fit in an uint16, resulting in a uint16
-        dtype = "int16"
-    else:
-        dtype = "uint16"
-
-    expected = DataFrame([1, 2, 300, 4], columns=["col1"], dtype=dtype)
-    tm.assert_frame_equal(df, expected)
-
-
 @pytest.mark.parametrize(
     "fill_val,exp_dtype",
     [