From d90bfbbe1282e29cf3e606cb9617d603a045f061 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Sat, 30 Mar 2024 14:51:57 -0700
Subject: [PATCH 1/3] DEPR: Series setitem/getitem treating ints as positional

---
 doc/source/whatsnew/v3.0.0.rst                |  1 +
 pandas/core/series.py                         | 89 ++-----------------
 pandas/tests/copy_view/test_indexing.py       | 11 +--
 pandas/tests/extension/base/getitem.py        |  9 +-
 pandas/tests/indexing/test_coercion.py        | 12 +--
 pandas/tests/indexing/test_floats.py          | 15 ++--
 pandas/tests/series/indexing/test_datetime.py |  7 --
 pandas/tests/series/indexing/test_get.py      | 26 ++----
 pandas/tests/series/indexing/test_getitem.py  | 71 ++++++---------
 pandas/tests/series/indexing/test_indexing.py | 23 ++---
 pandas/tests/series/indexing/test_setitem.py  | 30 +++----
 11 files changed, 76 insertions(+), 218 deletions(-)

diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 2ebd6fb62b424..9a6866d734402 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -206,6 +206,7 @@ Removal of prior version deprecations/changes
 - :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
 - All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
 - All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Changed behavior of :meth:`Series.__getitem__` and :meth:`Series.__setitem__` to always treat integer keys as labels, never as positional, consistent with :class:`DataFrame` behavior (:issue:`50617`)
 - Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
 - Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
 - Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b0dc05fce7913..b275addfb27b5 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -899,19 +899,9 @@ def __getitem__(self, key):
         if isinstance(key, (list, tuple)):
             key = unpack_1tuple(key)
 
-        if is_integer(key) and self.index._should_fallback_to_positional:
-            warnings.warn(
-                # GH#50617
-                "Series.__getitem__ treating keys as positions is deprecated. "
-                "In a future version, integer keys will always be treated "
-                "as labels (consistent with DataFrame behavior). To access "
-                "a value by position, use `ser.iloc[pos]`",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-            return self._values[key]
-
         elif key_is_scalar:
+            # Note: GH#50617 in 3.0 we changed int key to always be treated as
+            #  a label, matching DataFrame behavior.
             return self._get_value(key)
 
         # Convert generator to list before going through hashable part
@@ -956,35 +946,6 @@ def _get_with(self, key):
         elif isinstance(key, tuple):
             return self._get_values_tuple(key)
 
-        elif not is_list_like(key):
-            # e.g. scalars that aren't recognized by lib.is_scalar, GH#32684
-            return self.loc[key]
-
-        if not isinstance(key, (list, np.ndarray, ExtensionArray, Series, Index)):
-            key = list(key)
-
-        key_type = lib.infer_dtype(key, skipna=False)
-
-        # Note: The key_type == "boolean" case should be caught by the
-        #  com.is_bool_indexer check in __getitem__
-        if key_type == "integer":
-            # We need to decide whether to treat this as a positional indexer
-            #  (i.e. self.iloc) or label-based (i.e. self.loc)
-            if not self.index._should_fallback_to_positional:
-                return self.loc[key]
-            else:
-                warnings.warn(
-                    # GH#50617
-                    "Series.__getitem__ treating keys as positions is deprecated. "
-                    "In a future version, integer keys will always be treated "
-                    "as labels (consistent with DataFrame behavior). To access "
-                    "a value by position, use `ser.iloc[pos]`",
-                    FutureWarning,
-                    stacklevel=find_stack_level(),
-                )
-                return self.iloc[key]
-
-        # handle the dup indexing case GH#4246
         return self.loc[key]
 
     def _get_values_tuple(self, key: tuple):
@@ -1074,27 +1035,8 @@ def __setitem__(self, key, value) -> None:
         except KeyError:
             # We have a scalar (or for MultiIndex or object-dtype, scalar-like)
             #  key that is not present in self.index.
-            if is_integer(key):
-                if not self.index._should_fallback_to_positional:
-                    # GH#33469
-                    self.loc[key] = value
-                else:
-                    # positional setter
-                    # can't use _mgr.setitem_inplace yet bc could have *both*
-                    #  KeyError and then ValueError, xref GH#45070
-                    warnings.warn(
-                        # GH#50617
-                        "Series.__setitem__ treating keys as positions is deprecated. "
-                        "In a future version, integer keys will always be treated "
-                        "as labels (consistent with DataFrame behavior). To set "
-                        "a value by position, use `ser.iloc[pos] = value`",
-                        FutureWarning,
-                        stacklevel=find_stack_level(),
-                    )
-                    self._set_values(key, value)
-            else:
-                # GH#12862 adding a new key to the Series
-                self.loc[key] = value
+            # GH#12862 adding a new key to the Series
+            self.loc[key] = value
 
         except (TypeError, ValueError, LossySetitemError):
             # The key was OK, but we cannot set the value losslessly
@@ -1153,28 +1095,7 @@ def _set_with(self, key, value) -> None:
             # Without this, the call to infer_dtype will consume the generator
             key = list(key)
 
-        if not self.index._should_fallback_to_positional:
-            # Regardless of the key type, we're treating it as labels
-            self._set_labels(key, value)
-
-        else:
-            # Note: key_type == "boolean" should not occur because that
-            #  should be caught by the is_bool_indexer check in __setitem__
-            key_type = lib.infer_dtype(key, skipna=False)
-
-            if key_type == "integer":
-                warnings.warn(
-                    # GH#50617
-                    "Series.__setitem__ treating keys as positions is deprecated. "
-                    "In a future version, integer keys will always be treated "
-                    "as labels (consistent with DataFrame behavior). To set "
-                    "a value by position, use `ser.iloc[pos] = value`",
-                    FutureWarning,
-                    stacklevel=find_stack_level(),
-                )
-                self._set_values(key, value)
-            else:
-                self._set_labels(key, value)
+        self._set_labels(key, value)
 
     def _set_labels(self, key, value) -> None:
         key = com.asarray_tuplesafe(key)
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
index 09d13677eef62..b10141b0d63f4 100644
--- a/pandas/tests/copy_view/test_indexing.py
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -622,16 +622,17 @@ def test_series_subset_set_with_indexer(backend, indexer_si, indexer):
     s_orig = s.copy()
     subset = s[:]
 
-    warn = None
-    msg = "Series.__setitem__ treating keys as positions is deprecated"
     if (
         indexer_si is tm.setitem
         and isinstance(indexer, np.ndarray)
         and indexer.dtype.kind == "i"
     ):
-        warn = FutureWarning
-    with tm.assert_produces_warning(warn, match=msg):
-        indexer_si(subset)[indexer] = 0
+        # In 3.0 we treat integers as always-labels
+        with pytest.raises(KeyError):
+            indexer_si(subset)[indexer] = 0
+        return
+
+    indexer_si(subset)[indexer] = 0
     expected = Series([0, 0, 3], index=["a", "b", "c"])
     tm.assert_series_equal(subset, expected)
 
diff --git a/pandas/tests/extension/base/getitem.py b/pandas/tests/extension/base/getitem.py
index 1f89c7ad9d4e4..935edce32a0ab 100644
--- a/pandas/tests/extension/base/getitem.py
+++ b/pandas/tests/extension/base/getitem.py
@@ -329,11 +329,10 @@ def test_get(self, data):
         result = s.get("Z")
         assert result is None
 
-        msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            assert s.get(4) == s.iloc[4]
-            assert s.get(-1) == s.iloc[-1]
-            assert s.get(len(s)) is None
+        # As of 3.0, getitem with int keys treats them as labels
+        assert s.get(4) is None
+        assert s.get(-1) is None
+        assert s.get(len(s)) is None
 
         # GH 21257
         s = pd.Series(data)
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index d51a986a22f1e..d4bc0341e732e 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -117,16 +117,8 @@ def test_setitem_index_object(self, val, exp_dtype):
         obj = pd.Series([1, 2, 3, 4], index=pd.Index(list("abcd"), dtype=object))
         assert obj.index.dtype == object
 
-        if exp_dtype is IndexError:
-            temp = obj.copy()
-            warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
-            msg = "index 5 is out of bounds for axis 0 with size 4"
-            with pytest.raises(exp_dtype, match=msg):
-                with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-                    temp[5] = 5
-        else:
-            exp_index = pd.Index(list("abcd") + [val], dtype=object)
-            self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype)
+        exp_index = pd.Index(list("abcd") + [val], dtype=object)
+        self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype)
 
     @pytest.mark.parametrize(
         "val,exp_dtype", [(5, np.int64), (1.1, np.float64), ("x", object)]
diff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py
index 1fe431e12f2a1..8597ee1198ff0 100644
--- a/pandas/tests/indexing/test_floats.py
+++ b/pandas/tests/indexing/test_floats.py
@@ -87,11 +87,11 @@ def test_scalar_non_numeric(self, index, frame_or_series, indexer_sl):
         ],
     )
     def test_scalar_non_numeric_series_fallback(self, index):
-        # fallsback to position selection, series only
+        # starting in 3.0, integer keys are always treated as labels, no longer
+        #  fall back to positional.
         s = Series(np.arange(len(index)), index=index)
 
-        msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
+        with pytest.raises(KeyError, match="3"):
             s[3]
         with pytest.raises(KeyError, match="^3.0$"):
             s[3.0]
@@ -118,12 +118,9 @@ def test_scalar_with_mixed(self, indexer_sl):
             indexer_sl(s3)[1.0]
 
         if indexer_sl is not tm.loc:
-            # __getitem__ falls back to positional
-            msg = "Series.__getitem__ treating keys as positions is deprecated"
-            with tm.assert_produces_warning(FutureWarning, match=msg):
-                result = s3[1]
-            expected = 2
-            assert result == expected
+            # as of 3.0, __getitem__ no longer falls back to positional
+            with pytest.raises(KeyError, match="^1$"):
+                s3[1]
 
         with pytest.raises(KeyError, match=r"^1\.0$"):
             indexer_sl(s3)[1.0]
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index e0ca4bf64ea91..3b41c8ee463d8 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -36,9 +36,6 @@ def test_fancy_getitem():
 
     s = Series(np.arange(len(dti)), index=dti)
 
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert s[48] == 48
     assert s["1/2/2009"] == 48
     assert s["2009-1-2"] == 48
     assert s[datetime(2009, 1, 2)] == 48
@@ -57,10 +54,6 @@ def test_fancy_setitem():
 
     s = Series(np.arange(len(dti)), index=dti)
 
-    msg = "Series.__setitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        s[48] = -1
-    assert s.iloc[48] == -1
     s["1/2/2009"] = -2
     assert s.iloc[48] == -2
     s["1/2/2009":"2009-06-05"] = -3
diff --git a/pandas/tests/series/indexing/test_get.py b/pandas/tests/series/indexing/test_get.py
index 1f3711ad91903..5ff92ca89efba 100644
--- a/pandas/tests/series/indexing/test_get.py
+++ b/pandas/tests/series/indexing/test_get.py
@@ -157,13 +157,8 @@ def test_get_with_default():
             assert s.get("e", "z") == "z"
             assert s.get("e", "e") == "e"
 
-            msg = "Series.__getitem__ treating keys as positions is deprecated"
-            warn = None
-            if index is d0:
-                warn = FutureWarning
-            with tm.assert_produces_warning(warn, match=msg):
-                assert s.get(10, "z") == "z"
-                assert s.get(10, 10) == 10
+            assert s.get(10, "z") == "z"
+            assert s.get(10, 10) == 10
 
 
 @pytest.mark.parametrize(
@@ -201,13 +196,10 @@ def test_get_with_ea(arr):
     result = ser.get("Z")
     assert result is None
 
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert ser.get(4) == ser.iloc[4]
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert ser.get(-1) == ser.iloc[-1]
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert ser.get(len(ser)) is None
+    # As of 3.0, ints are treated as labels
+    assert ser.get(4) is None
+    assert ser.get(-1) is None
+    assert ser.get(len(ser)) is None
 
     # GH#21257
     ser = Series(arr)
@@ -216,16 +208,14 @@ def test_get_with_ea(arr):
 
 
 def test_getitem_get(string_series, object_series):
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-
     for obj in [string_series, object_series]:
         idx = obj.index[5]
 
         assert obj[idx] == obj.get(idx)
         assert obj[idx] == obj.iloc[5]
 
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert string_series.get(-1) == string_series.get(string_series.index[-1])
+    # As of 3.0, ints are treated as labels
+    assert string_series.get(-1) is None
     assert string_series.iloc[5] == string_series.get(string_series.index[5])
 
 
diff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py
index fac543ac450a5..c7656cec1418b 100644
--- a/pandas/tests/series/indexing/test_getitem.py
+++ b/pandas/tests/series/indexing/test_getitem.py
@@ -7,6 +7,7 @@
     datetime,
     time,
 )
+import re
 
 import numpy as np
 import pytest
@@ -72,19 +73,14 @@ def test_getitem_unrecognized_scalar(self):
     def test_getitem_negative_out_of_bounds(self):
         ser = Series(["a"] * 10, index=["a"] * 10)
 
-        msg = "index -11 is out of bounds for axis 0 with size 10|index out of bounds"
-        warn_msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with pytest.raises(IndexError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-                ser[-11]
+        with pytest.raises(KeyError, match="^-11$"):
+            ser[-11]
 
     def test_getitem_out_of_bounds_indexerror(self, datetime_series):
         # don't segfault, GH#495
-        msg = r"index \d+ is out of bounds for axis 0 with size \d+"
-        warn_msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with pytest.raises(IndexError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-                datetime_series[len(datetime_series)]
+        N = len(datetime_series)
+        with pytest.raises(KeyError, match=str(N)):
+            datetime_series[N]
 
     def test_getitem_out_of_bounds_empty_rangeindex_keyerror(self):
         # GH#917
@@ -119,10 +115,8 @@ def test_getitem_keyerror_with_integer_index(self, any_int_numpy_dtype):
 
     def test_getitem_int64(self, datetime_series):
         idx = np.int64(5)
-        msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            res = datetime_series[idx]
-        assert res == datetime_series.iloc[5]
+        with pytest.raises(KeyError, match="^5$"):
+            datetime_series[idx]
 
     def test_getitem_full_range(self):
         # github.com/pandas-dev/pandas/commit/4f433773141d2eb384325714a2776bcc5b2e20f7
@@ -218,10 +212,8 @@ def test_getitem_str_with_timedeltaindex(self):
     def test_getitem_bool_index_positional(self):
         # GH#48653
         ser = Series({True: 1, False: 0})
-        msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            result = ser[0]
-        assert result == 1
+        with pytest.raises(KeyError, match="^0$"):
+            ser[0]
 
 
 class TestSeriesGetitemSlices:
@@ -384,17 +376,16 @@ def test_getitem_intlist_intindex_periodvalues(self):
 
     @pytest.mark.parametrize("box", [list, np.array, Index])
     def test_getitem_intlist_intervalindex_non_int(self, box):
-        # GH#33404 fall back to positional since ints are unambiguous
+        # GH#33404 fall back to positional since ints are unambiguous;
+        #  changed in 3.0 to never fallback
         dti = date_range("2000-01-03", periods=3)._with_freq(None)
         ii = pd.IntervalIndex.from_breaks(dti)
         ser = Series(range(len(ii)), index=ii)
 
-        expected = ser.iloc[:1]
         key = box([0])
-        msg = "Series.__getitem__ treating keys as positions is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            result = ser[key]
-        tm.assert_series_equal(result, expected)
+        msg = "None of [Index([0], dtype='int64')] are in the [index]"
+        with pytest.raises(KeyError, match=re.escape(msg)):
+            ser[key]
 
     @pytest.mark.parametrize("box", [list, np.array, Index])
     @pytest.mark.parametrize("dtype", [np.int64, np.float64, np.uint64])
@@ -635,11 +626,6 @@ def test_getitem_preserve_name(datetime_series):
     result = datetime_series[datetime_series > 0]
     assert result.name == datetime_series.name
 
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        result = datetime_series[[0, 2, 4]]
-    assert result.name == datetime_series.name
-
     result = datetime_series[5:10]
     assert result.name == datetime_series.name
 
@@ -667,21 +653,16 @@ def test_getitem_missing(datetime_series):
 
 
 def test_getitem_fancy(string_series, object_series):
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        slice1 = string_series[[1, 2, 3]]
-        slice2 = object_series[[1, 2, 3]]
-    assert string_series.index[2] == slice1.index[1]
-    assert object_series.index[2] == slice2.index[1]
-    assert string_series.iloc[2] == slice1.iloc[1]
-    assert object_series.iloc[2] == slice2.iloc[1]
+    msg = "None of [Index([1, 2, 3], dtype='int64')] are in the [index]"
+    with pytest.raises(KeyError, match=re.escape(msg)):
+        string_series[[1, 2, 3]]
+    with pytest.raises(KeyError, match=re.escape(msg)):
+        object_series[[1, 2, 3]]
 
 
 def test_getitem_box_float64(datetime_series):
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        value = datetime_series[5]
-    assert isinstance(value, np.float64)
+    with pytest.raises(KeyError, match="^5$"):
+        datetime_series[5]
 
 
 def test_getitem_unordered_dup():
@@ -712,13 +693,11 @@ def test_slice_can_reorder_not_uniquely_indexed():
 
 @pytest.mark.parametrize("index_vals", ["aabcd", "aadcb"])
 def test_duplicated_index_getitem_positional_indexer(index_vals):
-    # GH 11747
+    # GH 11747; changed in 3.0 integers are treated as always-labels
     s = Series(range(5), index=list(index_vals))
 
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        result = s[3]
-    assert result == 3
+    with pytest.raises(KeyError, match="^3$"):
+        s[3]
 
 
 class TestGetitemDeprecatedIndexers:
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index a629d18131306..5002b6d20da09 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -32,27 +32,16 @@ def test_basic_indexing():
         np.random.default_rng(2).standard_normal(5), index=["a", "b", "a", "a", "b"]
     )
 
-    warn_msg = "Series.__[sg]etitem__ treating keys as positions is deprecated"
-    msg = "index 5 is out of bounds for axis 0 with size 5"
-    with pytest.raises(IndexError, match=msg):
-        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-            s[5]
-    with pytest.raises(IndexError, match=msg):
-        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-            s[5] = 0
+    with pytest.raises(KeyError, match="^5$"):
+        s[5]
 
     with pytest.raises(KeyError, match=r"^'c'$"):
         s["c"]
 
     s = s.sort_index()
 
-    with pytest.raises(IndexError, match=msg):
-        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-            s[5]
-    msg = r"index 5 is out of bounds for axis (0|1) with size 5|^5$"
-    with pytest.raises(IndexError, match=msg):
-        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-            s[5] = 0
+    with pytest.raises(KeyError, match="^5$"):
+        s[5]
 
 
 def test_getitem_numeric_should_not_fallback_to_positional(any_numeric_dtype):
@@ -153,9 +142,7 @@ def test_series_box_timestamp():
     assert isinstance(ser.iloc[4], Timestamp)
 
     ser = Series(rng, index=rng)
-    msg = "Series.__getitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        assert isinstance(ser[0], Timestamp)
+    assert isinstance(ser[rng[0]], Timestamp)
     assert isinstance(ser.at[rng[1]], Timestamp)
     assert isinstance(ser.iat[2], Timestamp)
     assert isinstance(ser.loc[rng[3]], Timestamp)
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 6be325073bb67..43c2a7eb22731 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -181,14 +181,12 @@ def test_object_series_setitem_dt64array_exact_match(self):
 
 class TestSetitemScalarIndexer:
     def test_setitem_negative_out_of_bounds(self):
+        # As of 3.0, int keys are treated as labels, so this becomes
+        #  setitem-with-expansion
         ser = Series(["a"] * 10, index=["a"] * 10)
-
-        # string index falls back to positional
-        msg = "index -11|-1 is out of bounds for axis 0 with size 10"
-        warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
-        with pytest.raises(IndexError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-                ser[-11] = "foo"
+        ser[-11] = "foo"
+        exp = Series(["a"] * 10 + ["foo"], index=["a"] * 10 + [-11])
+        tm.assert_series_equal(ser, exp)
 
     @pytest.mark.parametrize("indexer", [tm.loc, tm.at])
     @pytest.mark.parametrize("ser_index", [0, 1])
@@ -1716,24 +1714,24 @@ def test_setitem_bool_int_float_consistency(indexer_sli):
 def test_setitem_positional_with_casting():
     # GH#45070 case where in __setitem__ we get a KeyError, then when
     #  we fallback we *also* get a ValueError if we try to set inplace.
+    # As of 3.0 we always treat int keys as labels, so this becomes
+    #  setitem-with-expansion
     ser = Series([1, 2, 3], index=["a", "b", "c"])
 
-    warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-        ser[0] = "X"
-    expected = Series(["X", 2, 3], index=["a", "b", "c"], dtype=object)
+    ser[0] = "X"
+    expected = Series([1, 2, 3, "X"], index=["a", "b", "c", 0], dtype=object)
     tm.assert_series_equal(ser, expected)
 
 
 def test_setitem_positional_float_into_int_coerces():
     # Case where we hit a KeyError and then trying to set in-place incorrectly
-    #  casts a float to an int
+    #  casts a float to an int;
+    # As of 3.0 we always treat int keys as labels, so this becomes
+    #  setitem-with-expansion
     ser = Series([1, 2, 3], index=["a", "b", "c"])
 
-    warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
-        ser[0] = 1.5
-    expected = Series([1.5, 2, 3], index=["a", "b", "c"])
+    ser[0] = 1.5
+    expected = Series([1, 2, 3, 1.5], index=["a", "b", "c", 0])
     tm.assert_series_equal(ser, expected)
 
 

From 33544f4dc8356d5d92c12cc0fd0f05a366f499b8 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Mon, 1 Apr 2024 13:41:33 -0700
Subject: [PATCH 2/3] 32bit build compat

---
 pandas/tests/series/indexing/test_getitem.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py
index c7656cec1418b..974c1cc23b065 100644
--- a/pandas/tests/series/indexing/test_getitem.py
+++ b/pandas/tests/series/indexing/test_getitem.py
@@ -7,7 +7,6 @@
     datetime,
     time,
 )
-import re
 
 import numpy as np
 import pytest
@@ -383,8 +382,8 @@ def test_getitem_intlist_intervalindex_non_int(self, box):
         ser = Series(range(len(ii)), index=ii)
 
         key = box([0])
-        msg = "None of [Index([0], dtype='int64')] are in the [index]"
-        with pytest.raises(KeyError, match=re.escape(msg)):
+        msg = r"None of \[Index\(\[0\], dtype='int(32|64)'\)\] are in the \[index\]"
+        with pytest.raises(KeyError, match=msg):
             ser[key]
 
     @pytest.mark.parametrize("box", [list, np.array, Index])
@@ -653,10 +652,10 @@ def test_getitem_missing(datetime_series):
 
 
 def test_getitem_fancy(string_series, object_series):
-    msg = "None of [Index([1, 2, 3], dtype='int64')] are in the [index]"
-    with pytest.raises(KeyError, match=re.escape(msg)):
+    msg = r"None of \[Index\(\[1, 2, 3\], dtype='int(32|64)'\)\] are in the \[index\]"
+    with pytest.raises(KeyError, match=msg):
         string_series[[1, 2, 3]]
-    with pytest.raises(KeyError, match=re.escape(msg)):
+    with pytest.raises(KeyError, match=msg):
         object_series[[1, 2, 3]]
 
 

From 9b977f6cffdd696055dd097a97461536cffe26c3 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Mon, 29 Apr 2024 12:11:16 -0700
Subject: [PATCH 3/3] update exception message for numpy 2

---
 pandas/tests/series/indexing/test_getitem.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py
index 974c1cc23b065..ede39ba61dfeb 100644
--- a/pandas/tests/series/indexing/test_getitem.py
+++ b/pandas/tests/series/indexing/test_getitem.py
@@ -15,6 +15,7 @@
     conversion,
     timezones,
 )
+from pandas.compat.numpy import np_version_gt2
 
 from pandas.core.dtypes.common import is_scalar
 
@@ -113,8 +114,12 @@ def test_getitem_keyerror_with_integer_index(self, any_int_numpy_dtype):
             ser["c"]
 
     def test_getitem_int64(self, datetime_series):
+        if np_version_gt2:
+            msg = r"^np.int64\(5\)$"
+        else:
+            msg = "^5$"
         idx = np.int64(5)
-        with pytest.raises(KeyError, match="^5$"):
+        with pytest.raises(KeyError, match=msg):
             datetime_series[idx]
 
     def test_getitem_full_range(self):