Upload folder using huggingface_hub (part 14)

.venv/lib/python3.13/site-packages/pandas/tests/scalar/period/test_asfreq.py

@@ -0,0 +1,815 @@
+import pytest
+
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+
+from pandas import (
+    Period,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+
+bday_msg = "Period with BDay freq is deprecated"
+
+
+class TestFreqConversion:
+    """Test frequency conversion of date objects"""
+
+    @pytest.mark.filterwarnings("ignore:Period with BDay:FutureWarning")
+    @pytest.mark.parametrize("freq", ["Y", "Q", "M", "W", "B", "D"])
+    def test_asfreq_near_zero(self, freq):
+        # GH#19643, GH#19650
+        per = Period("0001-01-01", freq=freq)
+        tup1 = (per.year, per.hour, per.day)
+
+        prev = per - 1
+        assert prev.ordinal == per.ordinal - 1
+        tup2 = (prev.year, prev.month, prev.day)
+        assert tup2 < tup1
+
+    def test_asfreq_near_zero_weekly(self):
+        # GH#19834
+        per1 = Period("0001-01-01", "D") + 6
+        per2 = Period("0001-01-01", "D") - 6
+        week1 = per1.asfreq("W")
+        week2 = per2.asfreq("W")
+        assert week1 != week2
+        assert week1.asfreq("D", "E") >= per1
+        assert week2.asfreq("D", "S") <= per2
+
+    def test_to_timestamp_out_of_bounds(self):
+        # GH#19643, used to incorrectly give Timestamp in 1754
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per = Period("0001-01-01", freq="B")
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per.to_timestamp()
+
+    def test_asfreq_corner(self):
+        val = Period(freq="Y", year=2007)
+        result1 = val.asfreq("5min")
+        result2 = val.asfreq("min")
+        expected = Period("2007-12-31 23:59", freq="min")
+        assert result1.ordinal == expected.ordinal
+        assert result1.freqstr == "5min"
+        assert result2.ordinal == expected.ordinal
+        assert result2.freqstr == "min"
+
+    def test_conv_annual(self):
+        # frequency conversion tests: from Annual Frequency
+        msg = INVALID_FREQ_ERR_MSG
+
+        ival_A = Period(freq="Y", year=2007)
+
+        ival_AJAN = Period(freq="Y-JAN", year=2007)
+        ival_AJUN = Period(freq="Y-JUN", year=2007)
+        ival_ANOV = Period(freq="Y-NOV", year=2007)
+
+        ival_A_to_Q_start = Period(freq="Q", year=2007, quarter=1)
+        ival_A_to_Q_end = Period(freq="Q", year=2007, quarter=4)
+        ival_A_to_M_start = Period(freq="M", year=2007, month=1)
+        ival_A_to_M_end = Period(freq="M", year=2007, month=12)
+        ival_A_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_A_to_W_end = Period(freq="W", year=2007, month=12, day=31)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_A_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+            ival_A_to_B_end = Period(freq="B", year=2007, month=12, day=31)
+        ival_A_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_A_to_D_end = Period(freq="D", year=2007, month=12, day=31)
+        ival_A_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_A_to_H_end = Period(freq="h", year=2007, month=12, day=31, hour=23)
+        ival_A_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_A_to_T_end = Period(
+            freq="Min", year=2007, month=12, day=31, hour=23, minute=59
+        )
+        ival_A_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_A_to_S_end = Period(
+            freq="s", year=2007, month=12, day=31, hour=23, minute=59, second=59
+        )
+
+        ival_AJAN_to_D_end = Period(freq="D", year=2007, month=1, day=31)
+        ival_AJAN_to_D_start = Period(freq="D", year=2006, month=2, day=1)
+        ival_AJUN_to_D_end = Period(freq="D", year=2007, month=6, day=30)
+        ival_AJUN_to_D_start = Period(freq="D", year=2006, month=7, day=1)
+        ival_ANOV_to_D_end = Period(freq="D", year=2007, month=11, day=30)
+        ival_ANOV_to_D_start = Period(freq="D", year=2006, month=12, day=1)
+
+        assert ival_A.asfreq("Q", "s") == ival_A_to_Q_start
+        assert ival_A.asfreq("Q", "e") == ival_A_to_Q_end
+        assert ival_A.asfreq("M", "s") == ival_A_to_M_start
+        assert ival_A.asfreq("M", "E") == ival_A_to_M_end
+        assert ival_A.asfreq("W", "s") == ival_A_to_W_start
+        assert ival_A.asfreq("W", "E") == ival_A_to_W_end
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_A.asfreq("B", "s") == ival_A_to_B_start
+            assert ival_A.asfreq("B", "E") == ival_A_to_B_end
+        assert ival_A.asfreq("D", "s") == ival_A_to_D_start
+        assert ival_A.asfreq("D", "E") == ival_A_to_D_end
+        with pytest.raises(ValueError, match=msg):
+            assert ival_A.asfreq("H", "s") == ival_A_to_H_start
+            assert ival_A.asfreq("H", "E") == ival_A_to_H_end
+        assert ival_A.asfreq("min", "s") == ival_A_to_T_start
+        assert ival_A.asfreq("min", "E") == ival_A_to_T_end
+        with pytest.raises(ValueError, match=msg):
+            assert ival_A.asfreq("T", "s") == ival_A_to_T_start
+            assert ival_A.asfreq("T", "E") == ival_A_to_T_end
+            assert ival_A.asfreq("S", "S") == ival_A_to_S_start
+            assert ival_A.asfreq("S", "E") == ival_A_to_S_end
+
+        assert ival_AJAN.asfreq("D", "s") == ival_AJAN_to_D_start
+        assert ival_AJAN.asfreq("D", "E") == ival_AJAN_to_D_end
+
+        assert ival_AJUN.asfreq("D", "s") == ival_AJUN_to_D_start
+        assert ival_AJUN.asfreq("D", "E") == ival_AJUN_to_D_end
+
+        assert ival_ANOV.asfreq("D", "s") == ival_ANOV_to_D_start
+        assert ival_ANOV.asfreq("D", "E") == ival_ANOV_to_D_end
+
+        assert ival_A.asfreq("Y") == ival_A
+
+    def test_conv_quarterly(self):
+        # frequency conversion tests: from Quarterly Frequency
+
+        ival_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_Q_end_of_year = Period(freq="Q", year=2007, quarter=4)
+
+        ival_QEJAN = Period(freq="Q-JAN", year=2007, quarter=1)
+        ival_QEJUN = Period(freq="Q-JUN", year=2007, quarter=1)
+
+        ival_Q_to_A = Period(freq="Y", year=2007)
+        ival_Q_to_M_start = Period(freq="M", year=2007, month=1)
+        ival_Q_to_M_end = Period(freq="M", year=2007, month=3)
+        ival_Q_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_Q_to_W_end = Period(freq="W", year=2007, month=3, day=31)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_Q_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+            ival_Q_to_B_end = Period(freq="B", year=2007, month=3, day=30)
+        ival_Q_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_Q_to_D_end = Period(freq="D", year=2007, month=3, day=31)
+        ival_Q_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_Q_to_H_end = Period(freq="h", year=2007, month=3, day=31, hour=23)
+        ival_Q_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_Q_to_T_end = Period(
+            freq="Min", year=2007, month=3, day=31, hour=23, minute=59
+        )
+        ival_Q_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_Q_to_S_end = Period(
+            freq="s", year=2007, month=3, day=31, hour=23, minute=59, second=59
+        )
+
+        ival_QEJAN_to_D_start = Period(freq="D", year=2006, month=2, day=1)
+        ival_QEJAN_to_D_end = Period(freq="D", year=2006, month=4, day=30)
+
+        ival_QEJUN_to_D_start = Period(freq="D", year=2006, month=7, day=1)
+        ival_QEJUN_to_D_end = Period(freq="D", year=2006, month=9, day=30)
+
+        assert ival_Q.asfreq("Y") == ival_Q_to_A
+        assert ival_Q_end_of_year.asfreq("Y") == ival_Q_to_A
+
+        assert ival_Q.asfreq("M", "s") == ival_Q_to_M_start
+        assert ival_Q.asfreq("M", "E") == ival_Q_to_M_end
+        assert ival_Q.asfreq("W", "s") == ival_Q_to_W_start
+        assert ival_Q.asfreq("W", "E") == ival_Q_to_W_end
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_Q.asfreq("B", "s") == ival_Q_to_B_start
+            assert ival_Q.asfreq("B", "E") == ival_Q_to_B_end
+        assert ival_Q.asfreq("D", "s") == ival_Q_to_D_start
+        assert ival_Q.asfreq("D", "E") == ival_Q_to_D_end
+        assert ival_Q.asfreq("h", "s") == ival_Q_to_H_start
+        assert ival_Q.asfreq("h", "E") == ival_Q_to_H_end
+        assert ival_Q.asfreq("Min", "s") == ival_Q_to_T_start
+        assert ival_Q.asfreq("Min", "E") == ival_Q_to_T_end
+        assert ival_Q.asfreq("s", "s") == ival_Q_to_S_start
+        assert ival_Q.asfreq("s", "E") == ival_Q_to_S_end
+
+        assert ival_QEJAN.asfreq("D", "s") == ival_QEJAN_to_D_start
+        assert ival_QEJAN.asfreq("D", "E") == ival_QEJAN_to_D_end
+        assert ival_QEJUN.asfreq("D", "s") == ival_QEJUN_to_D_start
+        assert ival_QEJUN.asfreq("D", "E") == ival_QEJUN_to_D_end
+
+        assert ival_Q.asfreq("Q") == ival_Q
+
+    def test_conv_monthly(self):
+        # frequency conversion tests: from Monthly Frequency
+
+        ival_M = Period(freq="M", year=2007, month=1)
+        ival_M_end_of_year = Period(freq="M", year=2007, month=12)
+        ival_M_end_of_quarter = Period(freq="M", year=2007, month=3)
+        ival_M_to_A = Period(freq="Y", year=2007)
+        ival_M_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_M_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_M_to_W_end = Period(freq="W", year=2007, month=1, day=31)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_M_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+            ival_M_to_B_end = Period(freq="B", year=2007, month=1, day=31)
+        ival_M_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_M_to_D_end = Period(freq="D", year=2007, month=1, day=31)
+        ival_M_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_M_to_H_end = Period(freq="h", year=2007, month=1, day=31, hour=23)
+        ival_M_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_M_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=31, hour=23, minute=59
+        )
+        ival_M_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_M_to_S_end = Period(
+            freq="s", year=2007, month=1, day=31, hour=23, minute=59, second=59
+        )
+
+        assert ival_M.asfreq("Y") == ival_M_to_A
+        assert ival_M_end_of_year.asfreq("Y") == ival_M_to_A
+        assert ival_M.asfreq("Q") == ival_M_to_Q
+        assert ival_M_end_of_quarter.asfreq("Q") == ival_M_to_Q
+
+        assert ival_M.asfreq("W", "s") == ival_M_to_W_start
+        assert ival_M.asfreq("W", "E") == ival_M_to_W_end
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_M.asfreq("B", "s") == ival_M_to_B_start
+            assert ival_M.asfreq("B", "E") == ival_M_to_B_end
+        assert ival_M.asfreq("D", "s") == ival_M_to_D_start
+        assert ival_M.asfreq("D", "E") == ival_M_to_D_end
+        assert ival_M.asfreq("h", "s") == ival_M_to_H_start
+        assert ival_M.asfreq("h", "E") == ival_M_to_H_end
+        assert ival_M.asfreq("Min", "s") == ival_M_to_T_start
+        assert ival_M.asfreq("Min", "E") == ival_M_to_T_end
+        assert ival_M.asfreq("s", "s") == ival_M_to_S_start
+        assert ival_M.asfreq("s", "E") == ival_M_to_S_end
+
+        assert ival_M.asfreq("M") == ival_M
+
+    def test_conv_weekly(self):
+        # frequency conversion tests: from Weekly Frequency
+        ival_W = Period(freq="W", year=2007, month=1, day=1)
+
+        ival_WSUN = Period(freq="W", year=2007, month=1, day=7)
+        ival_WSAT = Period(freq="W-SAT", year=2007, month=1, day=6)
+        ival_WFRI = Period(freq="W-FRI", year=2007, month=1, day=5)
+        ival_WTHU = Period(freq="W-THU", year=2007, month=1, day=4)
+        ival_WWED = Period(freq="W-WED", year=2007, month=1, day=3)
+        ival_WTUE = Period(freq="W-TUE", year=2007, month=1, day=2)
+        ival_WMON = Period(freq="W-MON", year=2007, month=1, day=1)
+
+        ival_WSUN_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_WSUN_to_D_end = Period(freq="D", year=2007, month=1, day=7)
+        ival_WSAT_to_D_start = Period(freq="D", year=2006, month=12, day=31)
+        ival_WSAT_to_D_end = Period(freq="D", year=2007, month=1, day=6)
+        ival_WFRI_to_D_start = Period(freq="D", year=2006, month=12, day=30)
+        ival_WFRI_to_D_end = Period(freq="D", year=2007, month=1, day=5)
+        ival_WTHU_to_D_start = Period(freq="D", year=2006, month=12, day=29)
+        ival_WTHU_to_D_end = Period(freq="D", year=2007, month=1, day=4)
+        ival_WWED_to_D_start = Period(freq="D", year=2006, month=12, day=28)
+        ival_WWED_to_D_end = Period(freq="D", year=2007, month=1, day=3)
+        ival_WTUE_to_D_start = Period(freq="D", year=2006, month=12, day=27)
+        ival_WTUE_to_D_end = Period(freq="D", year=2007, month=1, day=2)
+        ival_WMON_to_D_start = Period(freq="D", year=2006, month=12, day=26)
+        ival_WMON_to_D_end = Period(freq="D", year=2007, month=1, day=1)
+
+        ival_W_end_of_year = Period(freq="W", year=2007, month=12, day=31)
+        ival_W_end_of_quarter = Period(freq="W", year=2007, month=3, day=31)
+        ival_W_end_of_month = Period(freq="W", year=2007, month=1, day=31)
+        ival_W_to_A = Period(freq="Y", year=2007)
+        ival_W_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_W_to_M = Period(freq="M", year=2007, month=1)
+
+        if Period(freq="D", year=2007, month=12, day=31).weekday == 6:
+            ival_W_to_A_end_of_year = Period(freq="Y", year=2007)
+        else:
+            ival_W_to_A_end_of_year = Period(freq="Y", year=2008)
+
+        if Period(freq="D", year=2007, month=3, day=31).weekday == 6:
+            ival_W_to_Q_end_of_quarter = Period(freq="Q", year=2007, quarter=1)
+        else:
+            ival_W_to_Q_end_of_quarter = Period(freq="Q", year=2007, quarter=2)
+
+        if Period(freq="D", year=2007, month=1, day=31).weekday == 6:
+            ival_W_to_M_end_of_month = Period(freq="M", year=2007, month=1)
+        else:
+            ival_W_to_M_end_of_month = Period(freq="M", year=2007, month=2)
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_W_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+            ival_W_to_B_end = Period(freq="B", year=2007, month=1, day=5)
+        ival_W_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_W_to_D_end = Period(freq="D", year=2007, month=1, day=7)
+        ival_W_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_W_to_H_end = Period(freq="h", year=2007, month=1, day=7, hour=23)
+        ival_W_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_W_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=7, hour=23, minute=59
+        )
+        ival_W_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_W_to_S_end = Period(
+            freq="s", year=2007, month=1, day=7, hour=23, minute=59, second=59
+        )
+
+        assert ival_W.asfreq("Y") == ival_W_to_A
+        assert ival_W_end_of_year.asfreq("Y") == ival_W_to_A_end_of_year
+
+        assert ival_W.asfreq("Q") == ival_W_to_Q
+        assert ival_W_end_of_quarter.asfreq("Q") == ival_W_to_Q_end_of_quarter
+
+        assert ival_W.asfreq("M") == ival_W_to_M
+        assert ival_W_end_of_month.asfreq("M") == ival_W_to_M_end_of_month
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_W.asfreq("B", "s") == ival_W_to_B_start
+            assert ival_W.asfreq("B", "E") == ival_W_to_B_end
+
+        assert ival_W.asfreq("D", "s") == ival_W_to_D_start
+        assert ival_W.asfreq("D", "E") == ival_W_to_D_end
+
+        assert ival_WSUN.asfreq("D", "s") == ival_WSUN_to_D_start
+        assert ival_WSUN.asfreq("D", "E") == ival_WSUN_to_D_end
+        assert ival_WSAT.asfreq("D", "s") == ival_WSAT_to_D_start
+        assert ival_WSAT.asfreq("D", "E") == ival_WSAT_to_D_end
+        assert ival_WFRI.asfreq("D", "s") == ival_WFRI_to_D_start
+        assert ival_WFRI.asfreq("D", "E") == ival_WFRI_to_D_end
+        assert ival_WTHU.asfreq("D", "s") == ival_WTHU_to_D_start
+        assert ival_WTHU.asfreq("D", "E") == ival_WTHU_to_D_end
+        assert ival_WWED.asfreq("D", "s") == ival_WWED_to_D_start
+        assert ival_WWED.asfreq("D", "E") == ival_WWED_to_D_end
+        assert ival_WTUE.asfreq("D", "s") == ival_WTUE_to_D_start
+        assert ival_WTUE.asfreq("D", "E") == ival_WTUE_to_D_end
+        assert ival_WMON.asfreq("D", "s") == ival_WMON_to_D_start
+        assert ival_WMON.asfreq("D", "E") == ival_WMON_to_D_end
+
+        assert ival_W.asfreq("h", "s") == ival_W_to_H_start
+        assert ival_W.asfreq("h", "E") == ival_W_to_H_end
+        assert ival_W.asfreq("Min", "s") == ival_W_to_T_start
+        assert ival_W.asfreq("Min", "E") == ival_W_to_T_end
+        assert ival_W.asfreq("s", "s") == ival_W_to_S_start
+        assert ival_W.asfreq("s", "E") == ival_W_to_S_end
+
+        assert ival_W.asfreq("W") == ival_W
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            ival_W.asfreq("WK")
+
+    def test_conv_weekly_legacy(self):
+        # frequency conversion tests: from Weekly Frequency
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK", year=2007, month=1, day=1)
+
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-SAT", year=2007, month=1, day=6)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-FRI", year=2007, month=1, day=5)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-THU", year=2007, month=1, day=4)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-WED", year=2007, month=1, day=3)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-TUE", year=2007, month=1, day=2)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-MON", year=2007, month=1, day=1)
+
+    def test_conv_business(self):
+        # frequency conversion tests: from Business Frequency"
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_B = Period(freq="B", year=2007, month=1, day=1)
+            ival_B_end_of_year = Period(freq="B", year=2007, month=12, day=31)
+            ival_B_end_of_quarter = Period(freq="B", year=2007, month=3, day=30)
+            ival_B_end_of_month = Period(freq="B", year=2007, month=1, day=31)
+            ival_B_end_of_week = Period(freq="B", year=2007, month=1, day=5)
+
+        ival_B_to_A = Period(freq="Y", year=2007)
+        ival_B_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_B_to_M = Period(freq="M", year=2007, month=1)
+        ival_B_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_B_to_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_B_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_B_to_H_end = Period(freq="h", year=2007, month=1, day=1, hour=23)
+        ival_B_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_B_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_B_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_B_to_S_end = Period(
+            freq="s", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+
+        assert ival_B.asfreq("Y") == ival_B_to_A
+        assert ival_B_end_of_year.asfreq("Y") == ival_B_to_A
+        assert ival_B.asfreq("Q") == ival_B_to_Q
+        assert ival_B_end_of_quarter.asfreq("Q") == ival_B_to_Q
+        assert ival_B.asfreq("M") == ival_B_to_M
+        assert ival_B_end_of_month.asfreq("M") == ival_B_to_M
+        assert ival_B.asfreq("W") == ival_B_to_W
+        assert ival_B_end_of_week.asfreq("W") == ival_B_to_W
+
+        assert ival_B.asfreq("D") == ival_B_to_D
+
+        assert ival_B.asfreq("h", "s") == ival_B_to_H_start
+        assert ival_B.asfreq("h", "E") == ival_B_to_H_end
+        assert ival_B.asfreq("Min", "s") == ival_B_to_T_start
+        assert ival_B.asfreq("Min", "E") == ival_B_to_T_end
+        assert ival_B.asfreq("s", "s") == ival_B_to_S_start
+        assert ival_B.asfreq("s", "E") == ival_B_to_S_end
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_B.asfreq("B") == ival_B
+
+    def test_conv_daily(self):
+        # frequency conversion tests: from Business Frequency"
+
+        ival_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_D_end_of_year = Period(freq="D", year=2007, month=12, day=31)
+        ival_D_end_of_quarter = Period(freq="D", year=2007, month=3, day=31)
+        ival_D_end_of_month = Period(freq="D", year=2007, month=1, day=31)
+        ival_D_end_of_week = Period(freq="D", year=2007, month=1, day=7)
+
+        ival_D_friday = Period(freq="D", year=2007, month=1, day=5)
+        ival_D_saturday = Period(freq="D", year=2007, month=1, day=6)
+        ival_D_sunday = Period(freq="D", year=2007, month=1, day=7)
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_B_friday = Period(freq="B", year=2007, month=1, day=5)
+            ival_B_monday = Period(freq="B", year=2007, month=1, day=8)
+
+        ival_D_to_A = Period(freq="Y", year=2007)
+
+        ival_Deoq_to_AJAN = Period(freq="Y-JAN", year=2008)
+        ival_Deoq_to_AJUN = Period(freq="Y-JUN", year=2007)
+        ival_Deoq_to_ADEC = Period(freq="Y-DEC", year=2007)
+
+        ival_D_to_QEJAN = Period(freq="Q-JAN", year=2007, quarter=4)
+        ival_D_to_QEJUN = Period(freq="Q-JUN", year=2007, quarter=3)
+        ival_D_to_QEDEC = Period(freq="Q-DEC", year=2007, quarter=1)
+
+        ival_D_to_M = Period(freq="M", year=2007, month=1)
+        ival_D_to_W = Period(freq="W", year=2007, month=1, day=7)
+
+        ival_D_to_H_start = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_D_to_H_end = Period(freq="h", year=2007, month=1, day=1, hour=23)
+        ival_D_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_D_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_D_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_D_to_S_end = Period(
+            freq="s", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+
+        assert ival_D.asfreq("Y") == ival_D_to_A
+
+        assert ival_D_end_of_quarter.asfreq("Y-JAN") == ival_Deoq_to_AJAN
+        assert ival_D_end_of_quarter.asfreq("Y-JUN") == ival_Deoq_to_AJUN
+        assert ival_D_end_of_quarter.asfreq("Y-DEC") == ival_Deoq_to_ADEC
+
+        assert ival_D_end_of_year.asfreq("Y") == ival_D_to_A
+        assert ival_D_end_of_quarter.asfreq("Q") == ival_D_to_QEDEC
+        assert ival_D.asfreq("Q-JAN") == ival_D_to_QEJAN
+        assert ival_D.asfreq("Q-JUN") == ival_D_to_QEJUN
+        assert ival_D.asfreq("Q-DEC") == ival_D_to_QEDEC
+        assert ival_D.asfreq("M") == ival_D_to_M
+        assert ival_D_end_of_month.asfreq("M") == ival_D_to_M
+        assert ival_D.asfreq("W") == ival_D_to_W
+        assert ival_D_end_of_week.asfreq("W") == ival_D_to_W
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_D_friday.asfreq("B") == ival_B_friday
+            assert ival_D_saturday.asfreq("B", "s") == ival_B_friday
+            assert ival_D_saturday.asfreq("B", "E") == ival_B_monday
+            assert ival_D_sunday.asfreq("B", "s") == ival_B_friday
+            assert ival_D_sunday.asfreq("B", "E") == ival_B_monday
+
+        assert ival_D.asfreq("h", "s") == ival_D_to_H_start
+        assert ival_D.asfreq("h", "E") == ival_D_to_H_end
+        assert ival_D.asfreq("Min", "s") == ival_D_to_T_start
+        assert ival_D.asfreq("Min", "E") == ival_D_to_T_end
+        assert ival_D.asfreq("s", "s") == ival_D_to_S_start
+        assert ival_D.asfreq("s", "E") == ival_D_to_S_end
+
+        assert ival_D.asfreq("D") == ival_D
+
+    def test_conv_hourly(self):
+        # frequency conversion tests: from Hourly Frequency"
+
+        ival_H = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_H_end_of_year = Period(freq="h", year=2007, month=12, day=31, hour=23)
+        ival_H_end_of_quarter = Period(freq="h", year=2007, month=3, day=31, hour=23)
+        ival_H_end_of_month = Period(freq="h", year=2007, month=1, day=31, hour=23)
+        ival_H_end_of_week = Period(freq="h", year=2007, month=1, day=7, hour=23)
+        ival_H_end_of_day = Period(freq="h", year=2007, month=1, day=1, hour=23)
+        ival_H_end_of_bus = Period(freq="h", year=2007, month=1, day=1, hour=23)
+
+        ival_H_to_A = Period(freq="Y", year=2007)
+        ival_H_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_H_to_M = Period(freq="M", year=2007, month=1)
+        ival_H_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_H_to_D = Period(freq="D", year=2007, month=1, day=1)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_H_to_B = Period(freq="B", year=2007, month=1, day=1)
+
+        ival_H_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_H_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=59
+        )
+        ival_H_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_H_to_S_end = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=59, second=59
+        )
+
+        assert ival_H.asfreq("Y") == ival_H_to_A
+        assert ival_H_end_of_year.asfreq("Y") == ival_H_to_A
+        assert ival_H.asfreq("Q") == ival_H_to_Q
+        assert ival_H_end_of_quarter.asfreq("Q") == ival_H_to_Q
+        assert ival_H.asfreq("M") == ival_H_to_M
+        assert ival_H_end_of_month.asfreq("M") == ival_H_to_M
+        assert ival_H.asfreq("W") == ival_H_to_W
+        assert ival_H_end_of_week.asfreq("W") == ival_H_to_W
+        assert ival_H.asfreq("D") == ival_H_to_D
+        assert ival_H_end_of_day.asfreq("D") == ival_H_to_D
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_H.asfreq("B") == ival_H_to_B
+            assert ival_H_end_of_bus.asfreq("B") == ival_H_to_B
+
+        assert ival_H.asfreq("Min", "s") == ival_H_to_T_start
+        assert ival_H.asfreq("Min", "E") == ival_H_to_T_end
+        assert ival_H.asfreq("s", "s") == ival_H_to_S_start
+        assert ival_H.asfreq("s", "E") == ival_H_to_S_end
+
+        assert ival_H.asfreq("h") == ival_H
+
+    def test_conv_minutely(self):
+        # frequency conversion tests: from Minutely Frequency"
+
+        ival_T = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+        ival_T_end_of_year = Period(
+            freq="Min", year=2007, month=12, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_quarter = Period(
+            freq="Min", year=2007, month=3, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_month = Period(
+            freq="Min", year=2007, month=1, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_week = Period(
+            freq="Min", year=2007, month=1, day=7, hour=23, minute=59
+        )
+        ival_T_end_of_day = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_T_end_of_bus = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_T_end_of_hour = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=59
+        )
+
+        ival_T_to_A = Period(freq="Y", year=2007)
+        ival_T_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_T_to_M = Period(freq="M", year=2007, month=1)
+        ival_T_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_T_to_D = Period(freq="D", year=2007, month=1, day=1)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_T_to_B = Period(freq="B", year=2007, month=1, day=1)
+        ival_T_to_H = Period(freq="h", year=2007, month=1, day=1, hour=0)
+
+        ival_T_to_S_start = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_T_to_S_end = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=59
+        )
+
+        assert ival_T.asfreq("Y") == ival_T_to_A
+        assert ival_T_end_of_year.asfreq("Y") == ival_T_to_A
+        assert ival_T.asfreq("Q") == ival_T_to_Q
+        assert ival_T_end_of_quarter.asfreq("Q") == ival_T_to_Q
+        assert ival_T.asfreq("M") == ival_T_to_M
+        assert ival_T_end_of_month.asfreq("M") == ival_T_to_M
+        assert ival_T.asfreq("W") == ival_T_to_W
+        assert ival_T_end_of_week.asfreq("W") == ival_T_to_W
+        assert ival_T.asfreq("D") == ival_T_to_D
+        assert ival_T_end_of_day.asfreq("D") == ival_T_to_D
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_T.asfreq("B") == ival_T_to_B
+            assert ival_T_end_of_bus.asfreq("B") == ival_T_to_B
+        assert ival_T.asfreq("h") == ival_T_to_H
+        assert ival_T_end_of_hour.asfreq("h") == ival_T_to_H
+
+        assert ival_T.asfreq("s", "s") == ival_T_to_S_start
+        assert ival_T.asfreq("s", "E") == ival_T_to_S_end
+
+        assert ival_T.asfreq("Min") == ival_T
+
+    def test_conv_secondly(self):
+        # frequency conversion tests: from Secondly Frequency"
+
+        ival_S = Period(freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=0)
+        ival_S_end_of_year = Period(
+            freq="s", year=2007, month=12, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_quarter = Period(
+            freq="s", year=2007, month=3, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_month = Period(
+            freq="s", year=2007, month=1, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_week = Period(
+            freq="s", year=2007, month=1, day=7, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_day = Period(
+            freq="s", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_bus = Period(
+            freq="s", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_hour = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=59, second=59
+        )
+        ival_S_end_of_minute = Period(
+            freq="s", year=2007, month=1, day=1, hour=0, minute=0, second=59
+        )
+
+        ival_S_to_A = Period(freq="Y", year=2007)
+        ival_S_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_S_to_M = Period(freq="M", year=2007, month=1)
+        ival_S_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_S_to_D = Period(freq="D", year=2007, month=1, day=1)
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            ival_S_to_B = Period(freq="B", year=2007, month=1, day=1)
+        ival_S_to_H = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        ival_S_to_T = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+
+        assert ival_S.asfreq("Y") == ival_S_to_A
+        assert ival_S_end_of_year.asfreq("Y") == ival_S_to_A
+        assert ival_S.asfreq("Q") == ival_S_to_Q
+        assert ival_S_end_of_quarter.asfreq("Q") == ival_S_to_Q
+        assert ival_S.asfreq("M") == ival_S_to_M
+        assert ival_S_end_of_month.asfreq("M") == ival_S_to_M
+        assert ival_S.asfreq("W") == ival_S_to_W
+        assert ival_S_end_of_week.asfreq("W") == ival_S_to_W
+        assert ival_S.asfreq("D") == ival_S_to_D
+        assert ival_S_end_of_day.asfreq("D") == ival_S_to_D
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert ival_S.asfreq("B") == ival_S_to_B
+            assert ival_S_end_of_bus.asfreq("B") == ival_S_to_B
+        assert ival_S.asfreq("h") == ival_S_to_H
+        assert ival_S_end_of_hour.asfreq("h") == ival_S_to_H
+        assert ival_S.asfreq("Min") == ival_S_to_T
+        assert ival_S_end_of_minute.asfreq("Min") == ival_S_to_T
+
+        assert ival_S.asfreq("s") == ival_S
+
+    def test_conv_microsecond(self):
+        # GH#31475 Avoid floating point errors dropping the start_time to
+        #  before the beginning of the Period
+        per = Period("2020-01-30 15:57:27.576166", freq="us")
+        assert per.ordinal == 1580399847576166
+
+        start = per.start_time
+        expected = Timestamp("2020-01-30 15:57:27.576166")
+        assert start == expected
+        assert start._value == per.ordinal
+
+    def test_asfreq_mult(self):
+        # normal freq to mult freq
+        p = Period(freq="Y", year=2007)
+        # ordinal will not change
+        for freq in ["3Y", offsets.YearEnd(3)]:
+            result = p.asfreq(freq)
+            expected = Period("2007", freq="3Y")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        # ordinal will not change
+        for freq in ["3Y", offsets.YearEnd(3)]:
+            result = p.asfreq(freq, how="S")
+            expected = Period("2007", freq="3Y")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        # mult freq to normal freq
+        p = Period(freq="3Y", year=2007)
+        # ordinal will change because how=E is the default
+        for freq in ["Y", offsets.YearEnd()]:
+            result = p.asfreq(freq)
+            expected = Period("2009", freq="Y")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        # ordinal will not change
+        for freq in ["Y", offsets.YearEnd()]:
+            result = p.asfreq(freq, how="s")
+            expected = Period("2007", freq="Y")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        p = Period(freq="Y", year=2007)
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq)
+            expected = Period("2007-12", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq, how="s")
+            expected = Period("2007-01", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        p = Period(freq="3Y", year=2007)
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq)
+            expected = Period("2009-12", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq, how="s")
+            expected = Period("2007-01", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+    def test_asfreq_combined(self):
+        # normal freq to combined freq
+        p = Period("2007", freq="h")
+
+        # ordinal will not change
+        expected = Period("2007", freq="25h")
+        for freq, how in zip(["1D1h", "1h1D"], ["E", "S"]):
+            result = p.asfreq(freq, how=how)
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        # combined freq to normal freq
+        p1 = Period(freq="1D1h", year=2007)
+        p2 = Period(freq="1h1D", year=2007)
+
+        # ordinal will change because how=E is the default
+        result1 = p1.asfreq("h")
+        result2 = p2.asfreq("h")
+        expected = Period("2007-01-02", freq="h")
+        assert result1 == expected
+        assert result1.ordinal == expected.ordinal
+        assert result1.freq == expected.freq
+        assert result2 == expected
+        assert result2.ordinal == expected.ordinal
+        assert result2.freq == expected.freq
+
+        # ordinal will not change
+        result1 = p1.asfreq("h", how="S")
+        result2 = p2.asfreq("h", how="S")
+        expected = Period("2007-01-01", freq="h")
+        assert result1 == expected
+        assert result1.ordinal == expected.ordinal
+        assert result1.freq == expected.freq
+        assert result2 == expected
+        assert result2.ordinal == expected.ordinal
+        assert result2.freq == expected.freq
+
+    def test_asfreq_MS(self):
+        initial = Period("2013")
+
+        assert initial.asfreq(freq="M", how="S") == Period("2013-01", "M")
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            initial.asfreq(freq="MS", how="S")
+
+        with pytest.raises(ValueError, match=msg):
+            Period("2013-01", "MS")

.venv/lib/python3.13/site-packages/pandas/tests/scalar/period/test_period.py

@@ -0,0 +1,1208 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    iNaT,
+    to_offset,
+)
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTHS,
+)
+from pandas._libs.tslibs.parsing import DateParseError
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+from pandas.compat import PY314
+from pandas.errors import (
+    OutOfBoundsDatetime,
+    Pandas4Warning,
+)
+
+from pandas import (
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+
+bday_msg = "Period with BDay freq is deprecated"
+
+
+class TestPeriodDisallowedFreqs:
+    @pytest.mark.parametrize(
+        "freq, freq_msg",
+        [
+            (offsets.BYearBegin(), "BYearBegin"),
+            (offsets.YearBegin(2), "YearBegin"),
+            (offsets.QuarterBegin(startingMonth=12), "QuarterBegin"),
+            (offsets.BusinessMonthEnd(2), "BusinessMonthEnd"),
+        ],
+    )
+    def test_offsets_not_supported(self, freq, freq_msg):
+        # GH#55785
+        msg = re.escape(f"{freq} is not supported as period frequency")
+        with pytest.raises(ValueError, match=msg):
+            Period(year=2014, freq=freq)
+
+    def test_custom_business_day_freq_raises(self):
+        # GH#52534
+        msg = "C is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2023-04-10", freq="C")
+        msg = f"{offsets.CustomBusinessDay().base} is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2023-04-10", freq=offsets.CustomBusinessDay())
+
+    def test_invalid_frequency_error_message(self):
+        msg = "WOM-1MON is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2012-01-02", freq="WOM-1MON")
+
+    def test_invalid_frequency_period_error_message(self):
+        msg = "Invalid frequency: ME"
+        with pytest.raises(ValueError, match=msg):
+            Period("2012-01-02", freq="ME")
+
+
+class TestPeriodConstruction:
+    def test_from_td64nat_raises(self):
+        # GH#44507
+        td = NaT.to_numpy("m8[ns]")
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(td)
+
+        with pytest.raises(ValueError, match=msg):
+            Period(td, freq="D")
+
+    def test_construction(self):
+        i1 = Period("1/1/2005", freq="M")
+        i2 = Period("Jan 2005")
+
+        assert i1 == i2
+
+        # GH#54105 - Period can be confusingly instantiated with lowercase freq
+        # TODO: raise in the future an error when passing lowercase freq
+        i1 = Period("2005", freq="Y")
+        i2 = Period("2005")
+
+        assert i1 == i2
+
+        i4 = Period("2005", freq="M")
+        assert i1 != i4
+
+        i1 = Period.now(freq="Q")
+        i2 = Period(datetime.now(), freq="Q")
+
+        assert i1 == i2
+
+        # Pass in freq as a keyword argument sometimes as a test for
+        # https://github.com/pandas-dev/pandas/issues/53369
+        i1 = Period.now(freq="D")
+        i2 = Period(datetime.now(), freq="D")
+        i3 = Period.now(offsets.Day())
+
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("1982", freq="min")
+        msg = "'MIN' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            i2 = Period("1982", freq="MIN")
+        assert i1 == i2
+
+        i1 = Period(year=2005, month=3, day=1, freq="D")
+        i2 = Period("3/1/2005", freq="D")
+        assert i1 == i2
+
+        msg = "'d' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            i3 = Period(year=2005, month=3, day=1, freq="d")
+        assert i1 == i3
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
+        assert i1 == expected
+
+        msg = "Must supply freq for ordinal value"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=200701)
+
+        msg = "Invalid frequency: X"
+        with pytest.raises(ValueError, match=msg):
+            Period("2007-1-1", freq="X")
+
+    def test_tuple_freq_disallowed(self):
+        # GH#34703 tuple freq disallowed
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("1982", freq=("Min", 1))
+
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("2006-12-31", ("w", 1))
+
+    def test_construction_from_timestamp_nanos(self):
+        # GH#46811 don't drop nanos from Timestamp
+        ts = Timestamp("2022-04-20 09:23:24.123456789")
+        per = Period(ts, freq="ns")
+
+        # should losslessly round-trip, not lose the 789
+        rt = per.to_timestamp()
+        assert rt == ts
+
+        # same thing but from a datetime64 object
+        dt64 = ts.asm8
+        per2 = Period(dt64, freq="ns")
+        rt2 = per2.to_timestamp()
+        assert rt2.asm8 == dt64
+
+    @pytest.mark.parametrize("freq", ["ms", "us", "ns"])
+    def test_construction_from_min_timestamp(self, freq):
+        # GH-63278
+        ts = Timestamp(Timestamp.min.value, unit=freq)
+        per = Period(ts, freq=freq)
+
+        # pandas.errors.OutOfBoundsDatetime: Out of bounds nanosecond timestamp:
+        # -290308-12-21 19:59:05
+        # rt = per.to_timestamp()
+
+        assert per.year == ts.year
+        assert per.month == ts.month
+        assert per.day == ts.day
+        assert per.hour == ts.hour
+        assert per.minute == ts.minute
+        assert per.second == ts.second
+
+    def test_construction_bday(self):
+        # Biz day construction, roll forward if non-weekday
+        with tm.assert_produces_warning(
+            Pandas4Warning, match="'b' is deprecated", raise_on_extra_warnings=False
+        ):
+            i1 = Period("3/10/12", freq="B")
+            i2 = Period("3/10/12", freq="D")
+            assert i1 == i2.asfreq("B")
+            i2 = Period("3/11/12", freq="D")
+            assert i1 == i2.asfreq("B")
+            i2 = Period("3/12/12", freq="D")
+            assert i1 == i2.asfreq("B")
+
+            i3 = Period("3/10/12", freq="b")
+            assert i1 == i3
+
+            i1 = Period(year=2012, month=3, day=10, freq="B")
+            i2 = Period("3/12/12", freq="B")
+            assert i1 == i2
+
+    def test_construction_quarter(self):
+        i1 = Period(year=2005, quarter=1, freq="Q")
+        i2 = Period("1/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period(year=2005, quarter=3, freq="Q")
+        i2 = Period("9/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period("2005Q1")
+        i2 = Period(year=2005, quarter=1, freq="Q")
+        i3 = Period("2005q1")
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("05Q1")
+        assert i1 == i2
+        lower = Period("05q1")
+        assert i1 == lower
+
+        i1 = Period("1Q2005")
+        assert i1 == i2
+        lower = Period("1q2005")
+        assert i1 == lower
+
+        i1 = Period("1Q05")
+        assert i1 == i2
+        lower = Period("1q05")
+        assert i1 == lower
+
+        i1 = Period("4Q1984")
+        assert i1.year == 1984
+        lower = Period("4q1984")
+        assert i1 == lower
+
+    def test_construction_month(self):
+        expected = Period("2007-01", freq="M")
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period(200701, freq="M")
+        assert i1 == expected
+
+        i1 = Period(ordinal=200701, freq="M")
+        assert i1.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+    def test_period_constructor_offsets(self):
+        assert Period("1/1/2005", freq=offsets.MonthEnd()) == Period(
+            "1/1/2005", freq="M"
+        )
+        assert Period("2005", freq=offsets.YearEnd()) == Period("2005", freq="Y")
+        assert Period("2005", freq=offsets.MonthEnd()) == Period("2005", freq="M")
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period("3/10/12", freq=offsets.BusinessDay()) == Period(
+                "3/10/12", freq="B"
+            )
+        assert Period("3/10/12", freq=offsets.Day()) == Period("3/10/12", freq="D")
+
+        assert Period(
+            year=2005, quarter=1, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=1, freq="Q")
+        assert Period(
+            year=2005, quarter=2, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=2, freq="Q")
+
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day()) == Period(
+            year=2005, month=3, day=1, freq="D"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(year=2012, month=3, day=10, freq=offsets.BDay()) == Period(
+                year=2012, month=3, day=10, freq="B"
+            )
+
+        expected = Period("2005-03-01", freq="3D")
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day(3)) == expected
+        assert Period(year=2005, month=3, day=1, freq="3D") == expected
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(year=2012, month=3, day=10, freq=offsets.BDay(3)) == Period(
+                year=2012, month=3, day=10, freq="3B"
+            )
+
+        assert Period(200701, freq=offsets.MonthEnd()) == Period(200701, freq="M")
+
+        i1 = Period(ordinal=200701, freq=offsets.MonthEnd())
+        i2 = Period(ordinal=200701, freq="M")
+        assert i1 == i2
+        assert i1.year == 18695
+        assert i2.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
+        assert i1 == expected
+
+    def test_invalid_arguments(self):
+        msg = "Must supply freq for datetime value"
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now())
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now().date())
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(1.6, freq="D")
+        msg = "Ordinal must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1.6, freq="D")
+        msg = "Only value or ordinal but not both should be given but not both"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=2, value=1, freq="D")
+
+        msg = "If value is None, freq cannot be None"
+        with pytest.raises(ValueError, match=msg):
+            Period(month=1)
+
+        msg = '^Given date string "-2000" not likely a datetime$'
+        with pytest.raises(ValueError, match=msg):
+            Period("-2000", "Y")
+        if PY314:
+            msg = "day 0 must be in range 1..31 for month 1 in year 1: 0"
+        else:
+            msg = "day is out of range for month"
+        with pytest.raises(DateParseError, match=msg):
+            Period("0", "Y")
+        msg = "Unknown datetime string format, unable to parse"
+        with pytest.raises(DateParseError, match=msg):
+            Period("1/1/-2000", "Y")
+
+    def test_constructor_corner(self):
+        expected = Period("2007-01", freq="2M")
+        assert Period(year=2007, month=1, freq="2M") == expected
+
+        assert Period(None) is NaT
+
+        p = Period("2007-01-01", freq="D")
+
+        result = Period(p, freq="Y")
+        exp = Period("2007", freq="Y")
+        assert result == exp
+
+    def test_constructor_infer_freq(self):
+        p = Period("2007-01-01")
+        assert p.freq == "D"
+
+        p = Period("2007-01-01 07")
+        assert p.freq == "h"
+
+        p = Period("2007-01-01 07:10")
+        assert p.freq == "min"
+
+        p = Period("2007-01-01 07:10:15")
+        assert p.freq == "s"
+
+        p = Period("2007-01-01 07:10:15.123")
+        assert p.freq == "ms"
+
+        # We see that there are 6 digits after the decimal, so get microsecond
+        #  even though they are all zeros.
+        p = Period("2007-01-01 07:10:15.123000")
+        assert p.freq == "us"
+
+        p = Period("2007-01-01 07:10:15.123400")
+        assert p.freq == "us"
+
+    def test_multiples(self):
+        result1 = Period("1989", freq="2Y")
+        result2 = Period("1989", freq="Y")
+        assert result1.ordinal == result2.ordinal
+        assert result1.freqstr == "2Y-DEC"
+        assert result2.freqstr == "Y-DEC"
+        assert result1.freq == offsets.YearEnd(2)
+        assert result2.freq == offsets.YearEnd()
+
+        assert (result1 + 1).ordinal == result1.ordinal + 2
+        assert (1 + result1).ordinal == result1.ordinal + 2
+        assert (result1 - 1).ordinal == result2.ordinal - 2
+        assert (-1 + result1).ordinal == result2.ordinal - 2
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_quarterly(self, month):
+        # bugs in scikits.timeseries
+        freq = f"Q-{month}"
+        exp = Period("1989Q3", freq=freq)
+        assert "1989Q3" in str(exp)
+        stamp = exp.to_timestamp("D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+        stamp = exp.to_timestamp("3D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_annual(self, month):
+        # bugs in scikits.timeseries
+        freq = f"Y-{month}"
+        exp = Period("1989", freq=freq)
+        stamp = exp.to_timestamp("D", how="end") + timedelta(days=30)
+        p = Period(stamp, freq=freq)
+
+        assert p == exp + 1
+        assert isinstance(p, Period)
+
+    @pytest.mark.parametrize("day", DAYS)
+    @pytest.mark.parametrize("num", range(10, 17))
+    def test_period_cons_weekly(self, num, day):
+        daystr = f"2011-02-{num}"
+        freq = f"W-{day}"
+
+        result = Period(daystr, freq=freq)
+        expected = Period(daystr, freq="D").asfreq(freq)
+        assert result == expected
+        assert isinstance(result, Period)
+
+    def test_parse_week_str_roundstrip(self):
+        # GH#50803
+        per = Period("2017-01-23/2017-01-29")
+        assert per.freq.freqstr == "W-SUN"
+
+        per = Period("2017-01-24/2017-01-30")
+        assert per.freq.freqstr == "W-MON"
+
+        msg = "Could not parse as weekly-freq Period"
+        with pytest.raises(ValueError, match=msg):
+            # not 6 days apart
+            Period("2016-01-23/2017-01-29")
+
+    def test_period_from_ordinal(self):
+        p = Period("2011-01", freq="M")
+        res = Period._from_ordinal(p.ordinal, freq=p.freq)
+        assert p == res
+        assert isinstance(res, Period)
+
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "h"])
+    def test_construct_from_nat_string_and_freq(self, freq):
+        per = Period("NaT", freq=freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="2" + freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="3" + freq)
+        assert per is NaT
+
+    def test_period_cons_nat(self):
+        p = Period("nat", freq="W-SUN")
+        assert p is NaT
+
+        p = Period(iNaT, freq="D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="3D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="1D1h")
+        assert p is NaT
+
+        p = Period("NaT")
+        assert p is NaT
+
+        p = Period(iNaT)
+        assert p is NaT
+
+    def test_period_cons_mult(self):
+        p1 = Period("2011-01", freq="3M")
+        p2 = Period("2011-01", freq="M")
+        assert p1.ordinal == p2.ordinal
+
+        assert p1.freq == offsets.MonthEnd(3)
+        assert p1.freqstr == "3M"
+
+        assert p2.freq == offsets.MonthEnd()
+        assert p2.freqstr == "M"
+
+        result = p1 + 1
+        assert result.ordinal == (p2 + 3).ordinal
+
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        result = p1 - 1
+        assert result.ordinal == (p2 - 3).ordinal
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        msg = "Frequency must be positive, because it represents span: -3M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-3M")
+
+        msg = "Frequency must be positive, because it represents span: 0M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0M")
+
+    def test_period_cons_combined(self):
+        p = [
+            (
+                Period("2011-01", freq="1D1h"),
+                Period("2011-01", freq="1h1D"),
+                Period("2011-01", freq="h"),
+            ),
+            (
+                Period(ordinal=1, freq="1D1h"),
+                Period(ordinal=1, freq="1h1D"),
+                Period(ordinal=1, freq="h"),
+            ),
+        ]
+
+        for p1, p2, p3 in p:
+            assert p1.ordinal == p3.ordinal
+            assert p2.ordinal == p3.ordinal
+
+            assert p1.freq == offsets.Hour(25)
+            assert p1.freqstr == "25h"
+
+            assert p2.freq == offsets.Hour(25)
+            assert p2.freqstr == "25h"
+
+            assert p3.freq == offsets.Hour()
+            assert p3.freqstr == "h"
+
+            result = p1 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25h"
+
+            result = p2 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25h"
+
+            result = p1 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25h"
+
+            result = p2 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25h"
+
+        msg = "Frequency must be positive, because it represents span: -25h"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1D1h")
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1h1D")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1D1h")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1h1D")
+
+        msg = "Frequency must be positive, because it represents span: 0D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0D0h")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="0D0h")
+
+        # You can only combine together day and intraday offsets
+        msg = "Invalid frequency: 1W1D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1W1D")
+        msg = "Invalid frequency: 1D1W"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1D1W")
+
+    @pytest.mark.parametrize("day", ["1970/01/01 ", "2020-12-31 ", "1981/09/13 "])
+    @pytest.mark.parametrize("hour", ["00:00:00", "00:00:01", "23:59:59", "12:00:59"])
+    @pytest.mark.parametrize(
+        "sec_float, expected",
+        [
+            (".000000001", 1),
+            (".000000999", 999),
+            (".123456789", 789),
+            (".999999999", 999),
+            (".999999000", 0),
+            # Test femtoseconds, attoseconds, picoseconds are dropped like Timestamp
+            (".999999001123", 1),
+            (".999999001123456", 1),
+            (".999999001123456789", 1),
+        ],
+    )
+    def test_period_constructor_nanosecond(self, day, hour, sec_float, expected):
+        # GH 34621
+
+        assert Period(day + hour + sec_float).start_time.nanosecond == expected
+
+    @pytest.mark.parametrize("hour", range(24))
+    def test_period_large_ordinal(self, hour):
+        # Issue #36430
+        # Integer overflow for Period over the maximum timestamp
+        p = Period(ordinal=2562048 + hour, freq="1h")
+        assert p.hour == hour
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    @pytest.mark.parametrize(
+        "freq,freq_depr",
+        [("2W", "2w"), ("2W-FRI", "2w-fri"), ("2D", "2d"), ("2B", "2b")],
+    )
+    def test_period_deprecated_lowercase_freq(self, freq, freq_depr):
+        # GH#58998
+        msg = (
+            f"'{freq_depr[1:]}' is deprecated and will be removed in a future version."
+        )
+
+        with tm.assert_produces_warning(
+            Pandas4Warning, match=msg, raise_on_extra_warnings=False
+        ):
+            result = Period("2016-03-01 09:00", freq=freq_depr)
+
+        expected = Period("2016-03-01 09:00", freq=freq)
+        assert result == expected
+
+
+class TestPeriodMethods:
+    def test_round_trip(self, temp_file):
+        p = Period("2000Q1")
+        new_p = tm.round_trip_pickle(p, temp_file)
+        assert new_p == p
+
+    def test_hash(self):
+        assert hash(Period("2011-01", freq="M")) == hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01-01", freq="D")) != hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01", freq="3M")) != hash(Period("2011-01", freq="2M"))
+
+        assert hash(Period("2011-01", freq="M")) != hash(Period("2011-02", freq="M"))
+
+    # --------------------------------------------------------------
+    # to_timestamp
+
+    def test_to_timestamp_mult(self):
+        p = Period("2011-01", freq="M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-02-01") - Timedelta(1, unit="us")
+        assert p.to_timestamp(how="E") == expected
+
+        p = Period("2011-01", freq="3M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-04-01") - Timedelta(1, unit="us")
+        assert p.to_timestamp(how="E") == expected
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_to_timestamp(self):
+        p = Period("1982", freq="Y")
+        start_ts = p.to_timestamp(how="S")
+        aliases = ["s", "StarT", "BEGIn"]
+        for a in aliases:
+            assert start_ts == p.to_timestamp("D", how=a)
+            # freq with mult should not affect to the result
+            assert start_ts == p.to_timestamp("3D", how=a)
+
+        end_ts = p.to_timestamp(how="E")
+        aliases = ["e", "end", "FINIsH"]
+        for a in aliases:
+            assert end_ts == p.to_timestamp("D", how=a)
+            assert end_ts == p.to_timestamp("3D", how=a)
+
+        from_lst = ["Y", "Q", "M", "W", "B", "D", "h", "Min", "s"]
+
+        def _ex(p):
+            if p.freq == "B":
+                return p.start_time + Timedelta(days=1) - Timedelta(microseconds=1)
+            return Timestamp((p + p.freq).start_time._value - 1, unit="us")
+
+        for fcode in from_lst:
+            p = Period("1982", freq=fcode)
+            result = p.to_timestamp().to_period(fcode)
+            assert result == p
+
+            assert p.start_time == p.to_timestamp(how="S")
+
+            assert p.end_time == _ex(p)
+
+        # Frequency other than daily
+
+        p = Period("1985", freq="Y")
+
+        result = p.to_timestamp("h", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, unit="us")
+        assert result == expected
+        result = p.to_timestamp("3h", how="end")
+        assert result == expected
+
+        result = p.to_timestamp("min", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, unit="us")
+        assert result == expected
+        result = p.to_timestamp("2min", how="end")
+        assert result == expected
+
+        result = p.to_timestamp(how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, unit="us")
+        assert result == expected
+
+        expected = datetime(1985, 1, 1)
+        result = p.to_timestamp("h", how="start")
+        assert result == expected
+        result = p.to_timestamp("min", how="start")
+        assert result == expected
+        result = p.to_timestamp("s", how="start")
+        assert result == expected
+        result = p.to_timestamp("3h", how="start")
+        assert result == expected
+        result = p.to_timestamp("5s", how="start")
+        assert result == expected
+
+    def test_to_timestamp_business_end(self):
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per = Period("1990-01-05", "B")  # Friday
+            result = per.to_timestamp("B", how="E")
+
+        expected = Timestamp("1990-01-06") - Timedelta(1, unit="us")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "ts, expected",
+        [
+            ("1970-01-01 00:00:00", 0),
+            ("1970-01-01 00:00:00.000001", 1),
+            ("1970-01-01 00:00:00.00001", 10),
+            ("1970-01-01 00:00:00.499", 499000),
+            ("1999-12-31 23:59:59.999", 999000),
+            ("1999-12-31 23:59:59.999999", 999999),
+            ("2050-12-31 23:59:59.5", 500000),
+            ("2050-12-31 23:59:59.500001", 500001),
+            ("2050-12-31 23:59:59.123456", 123456),
+        ],
+    )
+    @pytest.mark.parametrize("freq", [None, "us", "ns"])
+    def test_to_timestamp_microsecond(self, ts, expected, freq):
+        # GH 24444
+        result = Period(ts).to_timestamp(freq=freq).microsecond
+        assert result == expected
+
+    # --------------------------------------------------------------
+    # Rendering: __repr__, strftime, etc
+
+    @pytest.mark.parametrize(
+        "str_ts,freq,str_res,str_freq",
+        (
+            ("Jan-2000", None, "2000-01", "M"),
+            ("2000-12-15", None, "2000-12-15", "D"),
+            (
+                "2000-12-15 13:45:26.123456789",
+                "ns",
+                "2000-12-15 13:45:26.123456789",
+                "ns",
+            ),
+            ("2000-12-15 13:45:26.123456789", "us", "2000-12-15 13:45:26.123456", "us"),
+            ("2000-12-15 13:45:26.123456", None, "2000-12-15 13:45:26.123456", "us"),
+            ("2000-12-15 13:45:26.123456789", "ms", "2000-12-15 13:45:26.123", "ms"),
+            ("2000-12-15 13:45:26.123", None, "2000-12-15 13:45:26.123", "ms"),
+            ("2000-12-15 13:45:26", "s", "2000-12-15 13:45:26", "s"),
+            ("2000-12-15 13:45:26", "min", "2000-12-15 13:45", "min"),
+            ("2000-12-15 13:45:26", "h", "2000-12-15 13:00", "h"),
+            ("2000-12-15", "Y", "2000", "Y-DEC"),
+            ("2000-12-15", "Q", "2000Q4", "Q-DEC"),
+            ("2000-12-15", "M", "2000-12", "M"),
+            ("2000-12-15", "W", "2000-12-11/2000-12-17", "W-SUN"),
+            ("2000-12-15", "D", "2000-12-15", "D"),
+            ("2000-12-15", "B", "2000-12-15", "B"),
+        ),
+    )
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_repr(self, str_ts, freq, str_res, str_freq):
+        p = Period(str_ts, freq=freq)
+        assert str(p) == str_res
+        assert repr(p) == f"Period('{str_res}', '{str_freq}')"
+
+    def test_repr_nat(self):
+        p = Period("nat", freq="M")
+        assert repr(NaT) in repr(p)
+
+    def test_strftime(self):
+        # GH#3363
+        p = Period("2000-1-1 12:34:12", freq="s")
+        res = p.strftime("%Y-%m-%d %H:%M:%S")
+        assert res == "2000-01-01 12:34:12"
+        assert isinstance(res, str)
+
+
+class TestPeriodProperties:
+    """Test properties such as year, month, weekday, etc...."""
+
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "h"])
+    def test_is_leap_year(self, freq):
+        # GH 13727
+        p = Period("2000-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+        assert isinstance(p.is_leap_year, bool)
+
+        p = Period("1999-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+        p = Period("2004-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+
+        p = Period("2100-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+    def test_quarterly_negative_ordinals(self):
+        p = Period(ordinal=-1, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 4
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 3
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="M")
+        assert p.year == 1969
+        assert p.month == 11
+        assert isinstance(p, Period)
+
+    def test_freq_str(self):
+        i1 = Period("1982", freq="Min")
+        assert i1.freq == offsets.Minute()
+        assert i1.freqstr == "min"
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_period_deprecated_freq(self):
+        cases = {
+            "M": ["MTH", "MONTH", "MONTHLY", "Mth", "month", "monthly"],
+            "B": ["BUS", "BUSINESS", "BUSINESSLY", "WEEKDAY", "bus"],
+            "D": ["DAY", "DLY", "DAILY", "Day", "Dly", "Daily"],
+            "h": ["HR", "HOUR", "HRLY", "HOURLY", "hr", "Hour", "HRly"],
+            "min": ["minute", "MINUTE", "MINUTELY", "minutely"],
+            "s": ["sec", "SEC", "SECOND", "SECONDLY", "second"],
+            "ms": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
+            "us": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
+            "ns": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
+        }
+
+        msg = INVALID_FREQ_ERR_MSG
+        for exp, freqs in cases.items():
+            for freq in freqs:
+                with pytest.raises(ValueError, match=msg):
+                    Period("2016-03-01 09:00", freq=freq)
+                with pytest.raises(ValueError, match=msg):
+                    Period(ordinal=1, freq=freq)
+
+            # check supported freq-aliases still works
+            p1 = Period("2016-03-01 09:00", freq=exp)
+            p2 = Period(ordinal=1, freq=exp)
+            assert isinstance(p1, Period)
+            assert isinstance(p2, Period)
+
+    @staticmethod
+    def _period_constructor(bound, offset):
+        return Period(
+            year=bound.year,
+            month=bound.month,
+            day=bound.day,
+            hour=bound.hour,
+            minute=bound.minute,
+            second=bound.second + offset,
+            freq="us",
+        )
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_outer_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, offset)
+        # post-GH#63760 this no longer raises OutOfBoundsDatetime
+        getattr(period, period_property)
+
+        per = Period._from_ordinal(bound.value, freq=to_offset("ms"))
+
+        if period_property == "end_time" and offset == 1:
+            err = OverflowError
+            msg = "value too large"
+        else:
+            err = OutOfBoundsDatetime
+            msg = "Out of bounds microsecond"
+        # But if we do the same thing with a much-more-remote date, we still
+        #  raise OutOfBoundsDatetime (as opposed to silently giving a wrong result)
+        with pytest.raises(err, match=msg):
+            getattr(per, period_property)
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_inner_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, -offset)
+        expected = period.to_timestamp().round(freq="s")
+        assert getattr(period, period_property).round(freq="s") == expected
+        expected = (bound - offset * Timedelta(1, unit="s")).floor("s")
+        assert getattr(period, period_property).floor("s") == expected
+
+    def test_start_time(self):
+        freq_lst = ["Y", "Q", "M", "D", "h", "min", "s"]
+        xp = datetime(2012, 1, 1)
+        for f in freq_lst:
+            p = Period("2012", freq=f)
+            assert p.start_time == xp
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period("2012", freq="B").start_time == datetime(2012, 1, 2)
+        assert Period("2012", freq="W").start_time == datetime(2011, 12, 26)
+
+    def test_end_time(self):
+        p = Period("2012", freq="Y")
+
+        exp = Timestamp(2012, 12, 31, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="Q")
+        exp = Timestamp(2012, 3, 31, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="M")
+        exp = Timestamp(2012, 1, 31, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="D")
+        exp = Timestamp(2012, 1, 1, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="h")
+        exp = Timestamp(2012, 1, 1, 0, 59, 59, 999999)
+        assert p.end_time == exp
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            p = Period("2012", freq="B")
+            exp = Timestamp(2012, 1, 2, 23, 59, 59, 999999)
+            assert p.end_time == exp
+
+        p = Period("2012", freq="W")
+        exp = Timestamp(2012, 1, 1, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        # Test for GH 11738
+        p = Period("2012", freq="15D")
+        exp = Timestamp(2012, 1, 15, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="1D1h")
+        exp = Timestamp(2012, 1, 2, 0, 59, 59, 999999)
+        assert p.end_time == exp
+
+        p = Period("2012", freq="1h1D")
+        exp = Timestamp(2012, 1, 2, 0, 59, 59, 999999)
+        assert p.end_time == exp
+
+    def test_end_time_business_friday(self):
+        # GH#34449
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per = Period("1990-01-05", "B")
+            result = per.end_time
+
+        expected = Timestamp("1990-01-06") - Timedelta(1, unit="us")
+        assert result == expected
+
+    def test_anchor_week_end_time(self):
+        p = Period("2013-1-1", "W-SAT")
+        exp = Timestamp(2013, 1, 5, 23, 59, 59, 999999)
+        assert p.end_time == exp
+
+    def test_properties_annually(self):
+        # Test properties on Periods with annually frequency.
+        a_date = Period(freq="Y", year=2007)
+        assert a_date.year == 2007
+
+    def test_properties_quarterly(self):
+        # Test properties on Periods with daily frequency.
+        qedec_date = Period(freq="Q-DEC", year=2007, quarter=1)
+        qejan_date = Period(freq="Q-JAN", year=2007, quarter=1)
+        qejun_date = Period(freq="Q-JUN", year=2007, quarter=1)
+        for x in range(3):
+            for qd in (qedec_date, qejan_date, qejun_date):
+                assert (qd + x).qyear == 2007
+                assert (qd + x).quarter == x + 1
+
+    def test_properties_monthly(self):
+        # Test properties on Periods with daily frequency.
+        m_date = Period(freq="M", year=2007, month=1)
+        for x in range(11):
+            m_ival_x = m_date + x
+            assert m_ival_x.year == 2007
+            if 1 <= x + 1 <= 3:
+                assert m_ival_x.quarter == 1
+            elif 4 <= x + 1 <= 6:
+                assert m_ival_x.quarter == 2
+            elif 7 <= x + 1 <= 9:
+                assert m_ival_x.quarter == 3
+            elif 10 <= x + 1 <= 12:
+                assert m_ival_x.quarter == 4
+            assert m_ival_x.month == x + 1
+
+    def test_properties_weekly(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+        assert Period(freq="W", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_weekly_legacy(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+
+        exp = Period(freq="W", year=2012, month=2, day=1)
+        assert exp.days_in_month == 29
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK", year=2007, month=1, day=7)
+
+    def test_properties_daily(self):
+        # Test properties on Periods with daily frequency.
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            b_date = Period(freq="B", year=2007, month=1, day=1)
+        assert b_date.year == 2007
+        assert b_date.quarter == 1
+        assert b_date.month == 1
+        assert b_date.day == 1
+        assert b_date.weekday == 0
+        assert b_date.dayofyear == 1
+        assert b_date.days_in_month == 31
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(freq="B", year=2012, month=2, day=1).days_in_month == 29
+
+        d_date = Period(freq="D", year=2007, month=1, day=1)
+
+        assert d_date.year == 2007
+        assert d_date.quarter == 1
+        assert d_date.month == 1
+        assert d_date.day == 1
+        assert d_date.weekday == 0
+        assert d_date.dayofyear == 1
+        assert d_date.days_in_month == 31
+        assert Period(freq="D", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_hourly(self):
+        # Test properties on Periods with hourly frequency.
+        h_date1 = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        h_date2 = Period(freq="2h", year=2007, month=1, day=1, hour=0)
+
+        for h_date in [h_date1, h_date2]:
+            assert h_date.year == 2007
+            assert h_date.quarter == 1
+            assert h_date.month == 1
+            assert h_date.day == 1
+            assert h_date.weekday == 0
+            assert h_date.dayofyear == 1
+            assert h_date.hour == 0
+            assert h_date.days_in_month == 31
+            assert (
+                Period(freq="h", year=2012, month=2, day=1, hour=0).days_in_month == 29
+            )
+
+    def test_properties_minutely(self):
+        # Test properties on Periods with minutely frequency.
+        t_date = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+        assert t_date.quarter == 1
+        assert t_date.month == 1
+        assert t_date.day == 1
+        assert t_date.weekday == 0
+        assert t_date.dayofyear == 1
+        assert t_date.hour == 0
+        assert t_date.minute == 0
+        assert t_date.days_in_month == 31
+        assert (
+            Period(freq="D", year=2012, month=2, day=1, hour=0, minute=0).days_in_month
+            == 29
+        )
+
+    def test_properties_secondly(self):
+        # Test properties on Periods with secondly frequency.
+        s_date = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        assert s_date.year == 2007
+        assert s_date.quarter == 1
+        assert s_date.month == 1
+        assert s_date.day == 1
+        assert s_date.weekday == 0
+        assert s_date.dayofyear == 1
+        assert s_date.hour == 0
+        assert s_date.minute == 0
+        assert s_date.second == 0
+        assert s_date.days_in_month == 31
+        assert (
+            Period(
+                freq="Min", year=2012, month=2, day=1, hour=0, minute=0, second=0
+            ).days_in_month
+            == 29
+        )
+
+
+class TestPeriodComparisons:
+    def test_sort_periods(self):
+        jan = Period("2000-01", "M")
+        feb = Period("2000-02", "M")
+        mar = Period("2000-03", "M")
+        periods = [mar, jan, feb]
+        correctPeriods = [jan, feb, mar]
+        assert sorted(periods) == correctPeriods
+
+
+def test_period_immutable():
+    # see gh-17116
+    msg = "not writable"
+
+    per = Period("2014Q1")
+    with pytest.raises(AttributeError, match=msg):
+        per.ordinal = 14
+
+    freq = per.freq
+    with pytest.raises(AttributeError, match=msg):
+        per.freq = 2 * freq
+
+
+def test_small_year_parsing():
+    per1 = Period("0001-01-07", "D")
+    assert per1.year == 1
+    assert per1.day == 7
+
+
+def test_negone_ordinals():
+    freqs = ["Y", "M", "Q", "D", "h", "min", "s"]
+
+    period = Period(ordinal=-1, freq="D")
+    for freq in freqs:
+        repr(period.asfreq(freq))
+
+    for freq in freqs:
+        period = Period(ordinal=-1, freq=freq)
+        repr(period)
+        assert period.year == 1969
+
+    with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+        period = Period(ordinal=-1, freq="B")
+    repr(period)
+    period = Period(ordinal=-1, freq="W")
+    repr(period)

.venv/lib/python3.13/site-packages/pandas/tests/scalar/test_na_scalar.py

@@ -0,0 +1,334 @@
+from datetime import (
+    date,
+    time,
+    timedelta,
+)
+import pickle
+
+import numpy as np
+import pytest
+
+from pandas._libs.missing import NA
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_singleton():
+    assert NA is NA
+    new_NA = type(NA)()
+    assert new_NA is NA
+
+
+def test_repr():
+    assert repr(NA) == "<NA>"
+    assert str(NA) == "<NA>"
+
+
+def test_format():
+    # GH-34740
+    assert format(NA) == "<NA>"
+    assert format(NA, ">10") == "      <NA>"
+    assert format(NA, "xxx") == "<NA>"  # NA is flexible, accept any format spec
+
+    assert f"{NA}" == "<NA>"
+    assert f"{NA:>10}" == "      <NA>"
+    assert f"{NA:xxx}" == "<NA>"
+
+
+def test_truthiness():
+    msg = "boolean value of NA is ambiguous"
+
+    with pytest.raises(TypeError, match=msg):
+        bool(NA)
+
+    with pytest.raises(TypeError, match=msg):
+        not NA
+
+
+def test_hashable():
+    assert hash(NA) == hash(NA)
+    d = {NA: "test"}
+    assert d[NA] == "test"
+
+
+@pytest.mark.parametrize(
+    "other", [NA, 1, 1.0, "a", b"a", np.int64(1), np.nan], ids=repr
+)
+def test_arithmetic_ops(all_arithmetic_functions, other):
+    op = all_arithmetic_functions
+
+    if op.__name__ in ("pow", "rpow", "rmod") and isinstance(other, (str, bytes)):
+        pytest.skip(reason=f"{op.__name__} with NA and {other} not defined.")
+    if op.__name__ in ("divmod", "rdivmod"):
+        assert op(NA, other) is (NA, NA)
+    else:
+        if op.__name__ == "rpow":
+            # avoid special case
+            other += 1
+        assert op(NA, other) is NA
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        NA,
+        1,
+        1.0,
+        "a",
+        b"a",
+        np.int64(1),
+        np.nan,
+        np.bool_(True),
+        time(0),
+        date(1, 2, 3),
+        timedelta(1),
+        pd.NaT,
+    ],
+)
+def test_comparison_ops(comparison_op, other):
+    assert comparison_op(NA, other) is NA
+    assert comparison_op(other, NA) is NA
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        0,
+        0.0,
+        -0,
+        -0.0,
+        False,
+        np.bool_(False),
+        np.int_(0),
+        np.float64(0),
+        np.int_(-0),
+        np.float64(-0),
+    ],
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_pow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = NA**value
+
+    if asarray:
+        result = result[0]
+    else:
+        # this assertion isn't possible for ndarray.
+        assert isinstance(result, type(value))
+    assert result == 1
+
+
+@pytest.mark.parametrize(
+    "value", [1, 1.0, True, np.bool_(True), np.int_(1), np.float64(1)]
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value**NA
+
+    if asarray:
+        result = result[0]
+    elif not isinstance(value, (np.float64, np.bool_, np.int_)):
+        # this assertion isn't possible with asarray=True
+        assert isinstance(result, type(value))
+
+    assert result == value
+
+
+@pytest.mark.parametrize("value", [-1, -1.0, np.int_(-1), np.float64(-1)])
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_minus_one(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value**NA
+
+    if asarray:
+        result = result[0]
+
+    assert pd.isna(result)
+
+
+def test_unary_ops():
+    assert +NA is NA
+    assert -NA is NA
+    assert abs(NA) is NA
+    assert ~NA is NA
+
+
+def test_logical_and():
+    assert NA & True is NA
+    assert True & NA is NA
+    assert NA & False is False
+    assert False & NA is False
+    assert NA & NA is NA
+
+    # GH#58427
+    assert NA & np.bool_(True) is NA
+    assert np.bool_(True) & NA is NA
+    assert NA & np.bool_(False) is False
+    assert np.bool_(False) & NA is False
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA & 5
+
+
+def test_logical_or():
+    assert NA | True is True
+    assert True | NA is True
+    assert NA | False is NA
+    assert False | NA is NA
+    assert NA | NA is NA
+
+    # GH#58427
+    assert NA | np.bool_(True) is True
+    assert np.bool_(True) | NA is True
+    assert NA | np.bool_(False) is NA
+    assert np.bool_(False) | NA is NA
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA | 5
+
+
+def test_logical_xor():
+    assert NA ^ True is NA
+    assert True ^ NA is NA
+    assert NA ^ False is NA
+    assert False ^ NA is NA
+    assert NA ^ NA is NA
+
+    # GH#58427
+    assert NA ^ np.bool_(True) is NA
+    assert np.bool_(True) ^ NA is NA
+    assert NA ^ np.bool_(False) is NA
+    assert np.bool_(False) ^ NA is NA
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA ^ 5
+
+
+def test_logical_not():
+    assert ~NA is NA
+
+
+@pytest.mark.parametrize("shape", [(3,), (3, 3), (1, 2, 3)])
+def test_arithmetic_ndarray(shape, all_arithmetic_functions):
+    op = all_arithmetic_functions
+    a = np.zeros(shape)
+    if op.__name__ == "pow":
+        a += 5
+    result = op(NA, a)
+    expected = np.full(a.shape, NA, dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_is_scalar():
+    assert is_scalar(NA) is True
+
+
+def test_isna():
+    assert pd.isna(NA) is True
+    assert pd.notna(NA) is False
+
+
+def test_series_isna():
+    s = pd.Series([1, NA], dtype=object)
+    expected = pd.Series([False, True])
+    tm.assert_series_equal(s.isna(), expected)
+
+
+def test_ufunc():
+    assert np.log(NA) is NA
+    assert np.add(NA, 1) is NA
+    result = np.divmod(NA, 1)
+    assert result[0] is NA and result[1] is NA
+
+    result = np.frexp(NA)
+    assert result[0] is NA and result[1] is NA
+
+
+def test_ufunc_raises():
+    msg = "ufunc method 'at'"
+    with pytest.raises(ValueError, match=msg):
+        np.log.at(NA, 0)
+
+
+def test_binary_input_not_dunder():
+    a = np.array([1, 2, 3])
+    expected = np.array([NA, NA, NA], dtype=object)
+    result = np.logaddexp(a, NA)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.logaddexp(NA, a)
+    tm.assert_numpy_array_equal(result, expected)
+
+    # all NA, multiple inputs
+    assert np.logaddexp(NA, NA) is NA
+
+    result = np.modf(NA, NA)
+    assert len(result) == 2
+    assert all(x is NA for x in result)
+
+
+def test_divmod_ufunc():
+    # binary in, binary out.
+    a = np.array([1, 2, 3])
+    expected = np.array([NA, NA, NA], dtype=object)
+
+    result = np.divmod(a, NA)
+    assert isinstance(result, tuple)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+    result = np.divmod(NA, a)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+
+def test_integer_hash_collision_dict():
+    # GH 30013
+    result = {NA: "foo", hash(NA): "bar"}
+
+    assert result[NA] == "foo"
+    assert result[hash(NA)] == "bar"
+
+
+def test_integer_hash_collision_set():
+    # GH 30013
+    result = {NA, hash(NA)}
+
+    assert len(result) == 2
+    assert NA in result
+    assert hash(NA) in result
+
+
+def test_pickle_roundtrip():
+    # https://github.com/pandas-dev/pandas/issues/31847
+    result = pickle.loads(pickle.dumps(NA))
+    assert result is NA
+
+
+def test_pickle_roundtrip_pandas(temp_file):
+    result = tm.round_trip_pickle(NA, temp_file)
+    assert result is NA
+
+
+@pytest.mark.parametrize(
+    "values, dtype", [([1, 2, NA], "Int64"), (["A", "B", NA], "string")]
+)
+@pytest.mark.parametrize("as_frame", [True, False])
+def test_pickle_roundtrip_containers(as_frame, values, dtype, temp_file):
+    s = pd.Series(pd.array(values, dtype=dtype))
+    if as_frame:
+        s = s.to_frame(name="A")
+    result = tm.round_trip_pickle(s, temp_file)
+    tm.assert_equal(result, s)

.venv/lib/python3.13/site-packages/pandas/tests/scalar/test_nat.py

@@ -0,0 +1,684 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+import zoneinfo
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+
+from pandas import (
+    DatetimeIndex,
+    DatetimeTZDtype,
+    Index,
+    NaT,
+    Period,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    Timestamp,
+    isna,
+    offsets,
+)
+import pandas._testing as tm
+from pandas.core import roperator
+from pandas.core.arrays import (
+    DatetimeArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+
+
+class TestNaTFormatting:
+    def test_repr(self):
+        assert repr(NaT) == "NaT"
+
+    def test_str(self):
+        assert str(NaT) == "NaT"
+
+    def test_isoformat(self):
+        assert NaT.isoformat() == "NaT"
+
+
+@pytest.mark.parametrize(
+    "nat,idx",
+    [
+        (Timestamp("NaT"), DatetimeArray),
+        (Timedelta("NaT"), TimedeltaArray),
+        (Period("NaT", freq="M"), PeriodArray),
+    ],
+)
+def test_nat_fields(nat, idx):
+    for field in idx._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(NaT, field)
+        assert np.isnan(result)
+
+        result = getattr(nat, field)
+        assert np.isnan(result)
+
+    for field in idx._bool_ops:
+        result = getattr(NaT, field)
+        assert result is False
+
+        result = getattr(nat, field)
+        assert result is False
+
+
+def test_nat_vector_field_access():
+    idx = DatetimeIndex(["1/1/2000", None, None, "1/4/2000"])
+
+    for field in DatetimeArray._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(idx, field)
+        expected = Index([getattr(x, field) for x in idx])
+        tm.assert_index_equal(result, expected)
+
+    ser = Series(idx)
+
+    for field in DatetimeArray._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(ser.dt, field)
+        expected = [getattr(x, field) for x in idx]
+        tm.assert_series_equal(result, Series(expected))
+
+    for field in DatetimeArray._bool_ops:
+        result = getattr(ser.dt, field)
+        expected = [getattr(x, field) for x in idx]
+        tm.assert_series_equal(result, Series(expected))
+
+
+@pytest.mark.parametrize("klass", [Timestamp, Timedelta, Period])
+@pytest.mark.parametrize(
+    "value", [None, np.nan, iNaT, float("nan"), NaT, "NaT", "nat", "", "NAT"]
+)
+def test_identity(klass, value):
+    assert klass(value) is NaT
+
+
+@pytest.mark.parametrize("klass", [Timestamp, Timedelta])
+@pytest.mark.parametrize("method", ["round", "floor", "ceil"])
+@pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
+def test_round_nat(klass, method, freq):
+    # see gh-14940
+    ts = klass("nat")
+
+    round_method = getattr(ts, method)
+    assert round_method(freq) is ts
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        "astimezone",
+        "combine",
+        "ctime",
+        "dst",
+        "fromordinal",
+        "fromtimestamp",
+        "fromisocalendar",
+        "isocalendar",
+        "strftime",
+        "strptime",
+        "time",
+        "timestamp",
+        "timetuple",
+        "timetz",
+        "toordinal",
+        "tzname",
+        "utcfromtimestamp",
+        "utcnow",
+        "utcoffset",
+        "utctimetuple",
+    ],
+)
+def test_nat_methods_raise(method):
+    # see gh-9513, gh-17329
+    msg = f"NaTType does not support {method}"
+
+    with pytest.raises(ValueError, match=msg):
+        getattr(NaT, method)()
+
+
+@pytest.mark.parametrize("method", ["weekday", "isoweekday"])
+def test_nat_methods_nan(method):
+    # see gh-9513, gh-17329
+    assert np.isnan(getattr(NaT, method)())
+
+
+@pytest.mark.parametrize(
+    "method", ["date", "now", "replace", "today", "tz_convert", "tz_localize"]
+)
+def test_nat_methods_nat(method):
+    # see gh-8254, gh-9513, gh-17329
+    assert getattr(NaT, method)() is NaT
+
+
+@pytest.mark.parametrize(
+    "get_nat", [lambda x: NaT, lambda x: Timedelta(x), lambda x: Timestamp(x)]
+)
+def test_nat_iso_format(get_nat):
+    # see gh-12300
+    assert get_nat("NaT").isoformat() == "NaT"
+    assert get_nat("NaT").isoformat(timespec="nanoseconds") == "NaT"
+
+
+@pytest.mark.parametrize(
+    "klass,expected",
+    [
+        (Timestamp, ["normalize", "to_julian_date", "to_period", "unit"]),
+        (
+            Timedelta,
+            [
+                "components",
+                "resolution_string",
+                "to_pytimedelta",
+                "to_timedelta64",
+                "unit",
+                "view",
+            ],
+        ),
+    ],
+)
+def test_missing_public_nat_methods(klass, expected):
+    # see gh-17327
+    #
+    # NaT should have *most* of the Timestamp and Timedelta methods.
+    # Here, we check which public methods NaT does not have. We
+    # ignore any missing private methods.
+    nat_names = dir(NaT)
+    klass_names = dir(klass)
+
+    missing = [x for x in klass_names if x not in nat_names and not x.startswith("_")]
+    missing.sort()
+
+    assert missing == expected
+
+
+def _get_overlap_public_nat_methods(klass, as_tuple=False):
+    """
+    Get overlapping public methods between NaT and another class.
+
+    Parameters
+    ----------
+    klass : type
+        The class to compare with NaT
+    as_tuple : bool, default False
+        Whether to return a list of tuples of the form (klass, method).
+
+    Returns
+    -------
+    overlap : list
+    """
+    nat_names = dir(NaT)
+    klass_names = dir(klass)
+
+    overlap = [
+        x
+        for x in nat_names
+        if x in klass_names and not x.startswith("_") and callable(getattr(klass, x))
+    ]
+
+    # Timestamp takes precedence over Timedelta in terms of overlap.
+    if klass is Timedelta:
+        ts_names = dir(Timestamp)
+        overlap = [x for x in overlap if x not in ts_names]
+
+    if as_tuple:
+        overlap = [(klass, method) for method in overlap]
+
+    overlap.sort()
+    return overlap
+
+
+@pytest.mark.parametrize(
+    "klass,expected",
+    [
+        (
+            Timestamp,
+            [
+                "as_unit",
+                "astimezone",
+                "ceil",
+                "combine",
+                "ctime",
+                "date",
+                "day_name",
+                "dst",
+                "floor",
+                "fromisocalendar",
+                "fromisoformat",
+                "fromordinal",
+                "fromtimestamp",
+                "isocalendar",
+                "isoformat",
+                "isoweekday",
+                "month_name",
+                "now",
+                "replace",
+                "round",
+                "strftime",
+                "strptime",
+                "time",
+                "timestamp",
+                "timetuple",
+                "timetz",
+                "to_datetime64",
+                "to_numpy",
+                "to_pydatetime",
+                "today",
+                "toordinal",
+                "tz_convert",
+                "tz_localize",
+                "tzname",
+                "utcfromtimestamp",
+                "utcnow",
+                "utcoffset",
+                "utctimetuple",
+                "weekday",
+            ],
+        ),
+        (Timedelta, ["total_seconds"]),
+    ],
+)
+def test_overlap_public_nat_methods(klass, expected):
+    # see gh-17327
+    #
+    # NaT should have *most* of the Timestamp and Timedelta methods.
+    # In case when Timestamp, Timedelta, and NaT are overlap, the overlap
+    # is considered to be with Timestamp and NaT, not Timedelta.
+    assert _get_overlap_public_nat_methods(klass) == expected
+
+
+@pytest.mark.parametrize(
+    "compare",
+    (
+        _get_overlap_public_nat_methods(Timestamp, True)
+        + _get_overlap_public_nat_methods(Timedelta, True)
+    ),
+    ids=lambda x: f"{x[0].__name__}.{x[1]}",
+)
+def test_nat_doc_strings(compare):
+    # see gh-17327
+    #
+    # The docstrings for overlapping methods should match.
+    klass, method = compare
+    klass_doc = getattr(klass, method).__doc__
+
+    if klass == Timestamp and method == "isoformat":
+        pytest.skip(
+            "Ignore differences with Timestamp.isoformat() as they're intentional"
+        )
+
+    if method == "to_numpy":
+        # GH#44460 can return either dt64 or td64 depending on dtype,
+        #  different docstring is intentional
+        pytest.skip(f"different docstring for {method} is intentional")
+
+    nat_doc = getattr(NaT, method).__doc__
+    assert klass_doc == nat_doc
+
+
+_ops = {
+    "left_plus_right": lambda a, b: a + b,
+    "right_plus_left": lambda a, b: b + a,
+    "left_minus_right": lambda a, b: a - b,
+    "right_minus_left": lambda a, b: b - a,
+    "left_times_right": lambda a, b: a * b,
+    "right_times_left": lambda a, b: b * a,
+    "left_div_right": lambda a, b: a / b,
+    "right_div_left": lambda a, b: b / a,
+}
+
+
+@pytest.mark.parametrize("op_name", list(_ops.keys()))
+@pytest.mark.parametrize(
+    "value,val_type",
+    [
+        (2, "scalar"),
+        (1.5, "floating"),
+        (np.nan, "floating"),
+        ("foo", "str"),
+        (timedelta(3600), "timedelta"),
+        (Timedelta("5s"), "timedelta"),
+        (datetime(2014, 1, 1), "timestamp"),
+        (Timestamp("2014-01-01"), "timestamp"),
+        (Timestamp("2014-01-01", tz="UTC"), "timestamp"),
+        (Timestamp("2014-01-01", tz="US/Eastern"), "timestamp"),
+        (datetime(2014, 1, 1).astimezone(zoneinfo.ZoneInfo("Asia/Tokyo")), "timestamp"),
+    ],
+)
+def test_nat_arithmetic_scalar(op_name, value, val_type):
+    # see gh-6873
+    invalid_ops = {
+        "scalar": {"right_div_left"},
+        "floating": {
+            "right_div_left",
+            "left_minus_right",
+            "right_minus_left",
+            "left_plus_right",
+            "right_plus_left",
+        },
+        "str": set(_ops.keys()),
+        "timedelta": {"left_times_right", "right_times_left"},
+        "timestamp": {
+            "left_times_right",
+            "right_times_left",
+            "left_div_right",
+            "right_div_left",
+        },
+    }
+
+    op = _ops[op_name]
+
+    if op_name in invalid_ops.get(val_type, set()):
+        if (
+            val_type == "timedelta"
+            and "times" in op_name
+            and isinstance(value, Timedelta)
+        ):
+            typs = "(Timedelta|NaTType)"
+            msg = rf"unsupported operand type\(s\) for \*: '{typs}' and '{typs}'"
+        elif val_type == "str":
+            # un-specific check here because the message comes from str
+            #  and varies by method
+            msg = "|".join(
+                [
+                    "can only concatenate str",
+                    "unsupported operand type",
+                    "can't multiply sequence",
+                    "Can't convert 'NaTType'",
+                    "must be str, not NaTType",
+                ]
+            )
+        else:
+            msg = "unsupported operand type"
+
+        with pytest.raises(TypeError, match=msg):
+            op(NaT, value)
+    else:
+        if val_type == "timedelta" and "div" in op_name:
+            expected = np.nan
+        else:
+            expected = NaT
+
+        assert op(NaT, value) is expected
+
+
+@pytest.mark.parametrize(
+    "val,expected",
+    [(np.nan, NaT), (NaT, np.nan), (np.timedelta64("NaT", "ns"), np.nan)],
+)
+def test_nat_rfloordiv_timedelta(val, expected):
+    # see gh-#18846
+    #
+    # See also test_timedelta.TestTimedeltaArithmetic.test_floordiv
+    td = Timedelta(hours=3, minutes=4)
+    assert td // val is expected
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    ["left_plus_right", "right_plus_left", "left_minus_right", "right_minus_left"],
+)
+@pytest.mark.parametrize(
+    "value",
+    [
+        DatetimeIndex(["2011-01-01", "2011-01-02"], dtype="M8[ns]", name="x"),
+        DatetimeIndex(
+            ["2011-01-01", "2011-01-02"], dtype="M8[ns, US/Eastern]", name="x"
+        ),
+        DatetimeArray._from_sequence(["2011-01-01", "2011-01-02"], dtype="M8[ns]"),
+        DatetimeArray._from_sequence(
+            ["2011-01-01", "2011-01-02"], dtype=DatetimeTZDtype(tz="US/Pacific")
+        ),
+        TimedeltaIndex(["1 day", "2 day"], name="x"),
+    ],
+)
+def test_nat_arithmetic_index(op_name, value):
+    # see gh-11718
+    exp_name = "x"
+    exp_data = [NaT] * 2
+
+    if value.dtype.kind == "M" and "plus" in op_name:
+        expected = DatetimeIndex(exp_data, tz=value.tz, name=exp_name)
+    else:
+        expected = TimedeltaIndex(exp_data, name=exp_name)
+    expected = expected.as_unit(value.unit)
+
+    if not isinstance(value, Index):
+        expected = expected.array
+
+    op = _ops[op_name]
+    result = op(NaT, value)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    ["left_plus_right", "right_plus_left", "left_minus_right", "right_minus_left"],
+)
+@pytest.mark.parametrize("box", [TimedeltaIndex, Series, TimedeltaArray._from_sequence])
+def test_nat_arithmetic_td64_vector(op_name, box):
+    # see gh-19124
+    vec = box(["1 day", "2 day"], dtype="timedelta64[ns]")
+    box_nat = box([NaT, NaT], dtype="timedelta64[ns]")
+    tm.assert_equal(_ops[op_name](vec, NaT), box_nat)
+
+
+@pytest.mark.parametrize(
+    "dtype,op,out_dtype",
+    [
+        ("datetime64[ns]", operator.add, "datetime64[ns]"),
+        ("datetime64[ns]", roperator.radd, "datetime64[ns]"),
+        ("datetime64[ns]", operator.sub, "timedelta64[ns]"),
+        ("datetime64[ns]", roperator.rsub, "timedelta64[ns]"),
+        ("timedelta64[ns]", operator.add, "datetime64[ns]"),
+        ("timedelta64[ns]", roperator.radd, "datetime64[ns]"),
+        ("timedelta64[ns]", operator.sub, "datetime64[ns]"),
+        ("timedelta64[ns]", roperator.rsub, "timedelta64[ns]"),
+    ],
+)
+def test_nat_arithmetic_ndarray(dtype, op, out_dtype):
+    other = np.arange(10).astype(dtype)
+    result = op(NaT, other)
+
+    expected = np.empty(other.shape, dtype=out_dtype)
+    expected.fill("NaT")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_nat_pinned_docstrings():
+    # see gh-17327
+    assert NaT.ctime.__doc__ == Timestamp.ctime.__doc__
+
+
+def test_to_numpy_alias():
+    # GH 24653: alias .to_numpy() for scalars
+    expected = NaT.to_datetime64()
+    result = NaT.to_numpy()
+
+    assert isna(expected) and isna(result)
+
+    # GH#44460
+    result = NaT.to_numpy("M8[s]")
+    assert isinstance(result, np.datetime64)
+    assert result.dtype == "M8[s]"
+
+    result = NaT.to_numpy("m8[ns]")
+    assert isinstance(result, np.timedelta64)
+    assert result.dtype == "m8[ns]"
+
+    result = NaT.to_numpy("m8[s]")
+    assert isinstance(result, np.timedelta64)
+    assert result.dtype == "m8[s]"
+
+    with pytest.raises(ValueError, match="NaT.to_numpy dtype must be a "):
+        NaT.to_numpy(np.int64)
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        Timedelta(0),
+        Timedelta(0).to_pytimedelta(),
+        Timedelta(0).to_timedelta64(),
+        Timestamp(0),
+        Timestamp(0).to_pydatetime(),
+        Timestamp(0).to_datetime64(),
+        Timestamp(0).tz_localize("UTC"),
+        NaT,
+    ],
+)
+def test_nat_comparisons(compare_operators_no_eq_ne, other):
+    # GH 26039
+    opname = compare_operators_no_eq_ne
+
+    assert getattr(NaT, opname)(other) is False
+
+    op = getattr(operator, opname.strip("_"))
+    assert op(NaT, other) is False
+    assert op(other, NaT) is False
+
+
+@pytest.mark.parametrize("other_and_type", [("foo", "str"), (2, "int"), (2.0, "float")])
+@pytest.mark.parametrize(
+    "symbol_and_op",
+    [("<=", operator.le), ("<", operator.lt), (">=", operator.ge), (">", operator.gt)],
+)
+def test_nat_comparisons_invalid(other_and_type, symbol_and_op):
+    # GH#35585
+    other, other_type = other_and_type
+    symbol, op = symbol_and_op
+
+    assert not NaT == other
+    assert not other == NaT
+
+    assert NaT != other
+    assert other != NaT
+
+    msg = f"'{symbol}' not supported between instances of 'NaTType' and '{other_type}'"
+    with pytest.raises(TypeError, match=msg):
+        op(NaT, other)
+
+    msg = f"'{symbol}' not supported between instances of '{other_type}' and 'NaTType'"
+    with pytest.raises(TypeError, match=msg):
+        op(other, NaT)
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        np.array(["foo"] * 2, dtype=object),
+        np.array([2, 3], dtype="int64"),
+        np.array([2.0, 3.5], dtype="float64"),
+    ],
+    ids=["str", "int", "float"],
+)
+def test_nat_comparisons_invalid_ndarray(other):
+    # GH#40722
+    expected = np.array([False, False])
+    result = NaT == other
+    tm.assert_numpy_array_equal(result, expected)
+    result = other == NaT
+    tm.assert_numpy_array_equal(result, expected)
+
+    expected = np.array([True, True])
+    result = NaT != other
+    tm.assert_numpy_array_equal(result, expected)
+    result = other != NaT
+    tm.assert_numpy_array_equal(result, expected)
+
+    for symbol, op in [
+        ("<=", operator.le),
+        ("<", operator.lt),
+        (">=", operator.ge),
+        (">", operator.gt),
+    ]:
+        msg = f"'{symbol}' not supported between"
+
+        with pytest.raises(TypeError, match=msg):
+            op(NaT, other)
+
+        if other.dtype == np.dtype("object"):
+            # uses the reverse operator, so symbol changes
+            msg = None
+        with pytest.raises(TypeError, match=msg):
+            op(other, NaT)
+
+
+def test_compare_date(fixed_now_ts):
+    # GH#39151 comparing NaT with date object is deprecated
+    # See also: tests.scalar.timestamps.test_comparisons::test_compare_date
+
+    dt = fixed_now_ts.to_pydatetime().date()
+
+    msg = "Cannot compare NaT with datetime.date object"
+    for left, right in [(NaT, dt), (dt, NaT)]:
+        assert not left == right
+        assert left != right
+
+        with pytest.raises(TypeError, match=msg):
+            left < right
+        with pytest.raises(TypeError, match=msg):
+            left <= right
+        with pytest.raises(TypeError, match=msg):
+            left > right
+        with pytest.raises(TypeError, match=msg):
+            left >= right
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        offsets.YearEnd(2),
+        offsets.YearBegin(2),
+        offsets.MonthBegin(1),
+        offsets.MonthEnd(2),
+        offsets.MonthEnd(12),
+        offsets.Day(2),
+        offsets.Day(5),
+        offsets.Hour(24),
+        offsets.Hour(3),
+        offsets.Minute(),
+        np.timedelta64(3, "h"),
+        np.timedelta64(4, "h"),
+        np.timedelta64(3200, "s"),
+        np.timedelta64(3600, "s"),
+        np.timedelta64(3600 * 24, "s"),
+        np.timedelta64(2, "D"),
+        np.timedelta64(365, "D"),
+        timedelta(-2),
+        timedelta(365),
+        timedelta(minutes=120),
+        timedelta(days=4, minutes=180),
+        timedelta(hours=23),
+        timedelta(hours=23, minutes=30),
+        timedelta(hours=48),
+    ],
+)
+def test_nat_addsub_tdlike_scalar(obj):
+    assert NaT + obj is NaT
+    assert obj + NaT is NaT
+    assert NaT - obj is NaT
+
+
+def test_pickle(temp_file):
+    # GH#4606
+    p = tm.round_trip_pickle(NaT, temp_file)
+    assert p is NaT

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/methods/test_as_unit.py

@@ -0,0 +1,80 @@
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsTimedelta
+
+from pandas import Timedelta
+
+
+class TestAsUnit:
+    def test_as_unit(self):
+        td = Timedelta(days=1)
+
+        assert td.as_unit("us") is td
+
+        res = td.as_unit("ns")
+        assert res._value == td._value * 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+        rt = res.as_unit("us")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+        res = td.as_unit("ms")
+        assert res._value == td._value // 1_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+        rt = res.as_unit("us")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+        res = td.as_unit("s")
+        assert res._value == td._value // 1_000_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+        rt = res.as_unit("us")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+    def test_as_unit_overflows(self):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        td = Timedelta._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value)
+
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td.as_unit("ns")
+
+        res = td.as_unit("ms")
+        assert res._value == us // 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    def test_as_unit_rounding(self):
+        td = Timedelta(microseconds=1500)
+        res = td.as_unit("ms")
+
+        expected = Timedelta(milliseconds=1)
+        assert res == expected
+
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res._value == 1
+
+        with pytest.raises(ValueError, match="Cannot losslessly convert units"):
+            td.as_unit("ms", round_ok=False)
+
+    def test_as_unit_non_nano(self):
+        # case where we are going neither to nor from nano
+        td = Timedelta(days=1).as_unit("ms")
+        assert td.days == 1
+        assert td._value == 86_400_000
+        assert td.components.days == 1
+        assert td._d == 1
+        assert td.total_seconds() == 86400
+
+        res = td.as_unit("us")
+        assert res._value == 86_400_000_000
+        assert res.components.days == 1
+        assert res.components.hours == 0
+        assert res._d == 1
+        assert res._h == 0
+        assert res.total_seconds() == 86400

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/methods/test_round.py

@@ -0,0 +1,195 @@
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+from pandas._libs.tslibs import iNaT
+from pandas.errors import OutOfBoundsTimedelta
+
+from pandas import Timedelta
+
+
+class TestTimedeltaRound:
+    @pytest.mark.parametrize(
+        "freq,s1,s2",
+        [
+            # This first case has s1, s2 being the same as t1,t2 below
+            (
+                "ns",
+                "1 days 02:34:56.789123456",
+                "-1 days 02:34:56.789123456",
+            ),
+            (
+                "us",
+                "1 days 02:34:56.789123000",
+                "-1 days 02:34:56.789123000",
+            ),
+            (
+                "ms",
+                "1 days 02:34:56.789000000",
+                "-1 days 02:34:56.789000000",
+            ),
+            ("s", "1 days 02:34:57", "-1 days 02:34:57"),
+            ("2s", "1 days 02:34:56", "-1 days 02:34:56"),
+            ("5s", "1 days 02:34:55", "-1 days 02:34:55"),
+            ("min", "1 days 02:35:00", "-1 days 02:35:00"),
+            ("12min", "1 days 02:36:00", "-1 days 02:36:00"),
+            ("h", "1 days 03:00:00", "-1 days 03:00:00"),
+            ("D", "1 days", "-1 days"),
+        ],
+    )
+    def test_round(self, freq, s1, s2):
+        s1 = Timedelta(s1)
+        s2 = Timedelta(s2)
+        t1 = Timedelta("1 days 02:34:56.789123456")
+        t2 = Timedelta("-1 days 02:34:56.789123456")
+
+        r1 = t1.round(freq)
+        assert r1 == s1
+        r2 = t2.round(freq)
+        assert r2 == s2
+
+    def test_round_invalid(self):
+        t1 = Timedelta("1 days 02:34:56.789123456")
+
+        for freq, msg in [
+            ("YE", "<YearEnd: month=12> is a non-fixed frequency"),
+            ("ME", "<MonthEnd> is a non-fixed frequency"),
+            ("foobar", "Invalid frequency: foobar"),
+        ]:
+            with pytest.raises(ValueError, match=msg):
+                t1.round(freq)
+
+    def test_round_implementation_bounds(self):
+        # See also: analogous test for Timestamp
+        # GH#38964
+        result = Timedelta.min.ceil("s")
+        expected = Timedelta.min + Timedelta(seconds=1) - Timedelta(145224193)
+        assert result == expected
+
+        result = Timedelta.max.floor("s")
+        expected = Timedelta.max - Timedelta(854775807)
+        assert result == expected
+
+        msg = (
+            r"Cannot round -106752 days \+00:12:43.145224193 to freq=s without overflow"
+        )
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta.min.floor("s")
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta.min.round("s")
+
+        msg = "Cannot round 106751 days 23:47:16.854775807 to freq=s without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta.max.ceil("s")
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta.max.round("s")
+
+    @pytest.mark.slow
+    @given(val=st.integers(min_value=iNaT + 1, max_value=lib.i8max))
+    @pytest.mark.parametrize(
+        "method", [Timedelta.round, Timedelta.floor, Timedelta.ceil]
+    )
+    def test_round_sanity(self, val, method):
+        cls = Timedelta
+        err_cls = OutOfBoundsTimedelta
+
+        val = np.int64(val)
+        td = cls(val)
+
+        def checker(ts, nanos, unit):
+            # First check that we do raise in cases where we should
+            if nanos == 1:
+                pass
+            else:
+                div, mod = divmod(ts._value, nanos)
+                diff = int(nanos - mod)
+                lb = ts._value - mod
+                assert lb <= ts._value  # i.e. no overflows with python ints
+                ub = ts._value + diff
+                assert ub > ts._value  # i.e. no overflows with python ints
+
+                msg = "without overflow"
+                if mod == 0:
+                    # We should never be raising in this
+                    pass
+                elif method is cls.ceil:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif method is cls.floor:
+                    if lb < cls.min._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif mod >= diff:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif lb < cls.min._value:
+                    with pytest.raises(err_cls, match=msg):
+                        method(ts, unit)
+                    return
+
+            res = method(ts, unit)
+
+            td = res - ts
+            diff = abs(td._value)
+            assert diff < nanos
+            assert res._value % nanos == 0
+
+            if method is cls.round:
+                assert diff <= nanos / 2
+            elif method is cls.floor:
+                assert res <= ts
+            elif method is cls.ceil:
+                assert res >= ts
+
+        nanos = 1
+        checker(td, nanos, "ns")
+
+        nanos = 1000
+        checker(td, nanos, "us")
+
+        nanos = 1_000_000
+        checker(td, nanos, "ms")
+
+        nanos = 1_000_000_000
+        checker(td, nanos, "s")
+
+        nanos = 60 * 1_000_000_000
+        checker(td, nanos, "min")
+
+        nanos = 60 * 60 * 1_000_000_000
+        checker(td, nanos, "h")
+
+        nanos = 24 * 60 * 60 * 1_000_000_000
+        checker(td, nanos, "D")
+
+    def test_round_non_nano(self, unit):
+        td = Timedelta("1 days 02:34:57").as_unit(unit)
+
+        res = td.round("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._creso == td._creso
+
+        res = td.floor("min")
+        assert res == Timedelta("1 days 02:34:00")
+        assert res._creso == td._creso
+
+        res = td.ceil("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._creso == td._creso
+
+    def test_round_freq_finer_than_resolution(self):
+        # GH#64828
+        td = Timedelta(1.0, unit="days").as_unit("s")
+        assert td.unit == "s"
+        assert td.round("100ms") == Timedelta("1 days 00:00:00")
+        assert td.floor("100ms") == Timedelta("1 days 00:00:00")
+        assert td.ceil("100ms") == Timedelta("1 days 00:00:00")

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -0,0 +1,1251 @@
+"""
+Tests for scalar Timedelta arithmetic ops
+"""
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    OutOfBoundsTimedelta,
+    Pandas4Warning,
+)
+
+import pandas as pd
+from pandas import (
+    NaT,
+    Timedelta,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+from pandas.core import ops
+
+
+class TestTimedeltaAdditionSubtraction:
+    """
+    Tests for Timedelta methods:
+
+        __add__, __radd__,
+        __sub__, __rsub__
+    """
+
+    def test_td_add_sub_pydatetime(self, unit):
+        # GH#53643
+        td = Timedelta(hours=23).as_unit(unit)
+        dt = datetime(2016, 1, 1)
+
+        expected = datetime(2016, 1, 1, 23)
+        result = dt + td
+        assert result == expected
+        result = td + dt
+        assert result == expected
+
+        expected = datetime(2015, 12, 31, 1)
+        result = dt - td
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "ten_seconds",
+        [
+            Timedelta(10, unit="s"),
+            timedelta(seconds=10),
+            np.timedelta64(10, "s"),
+            np.timedelta64(10000000000, "ns"),
+            offsets.Second(10),
+        ],
+    )
+    def test_td_add_sub_ten_seconds(self, ten_seconds):
+        # GH#6808
+        base = Timestamp("20130101 09:01:12.123456")
+        expected_add = Timestamp("20130101 09:01:22.123456")
+        expected_sub = Timestamp("20130101 09:01:02.123456")
+
+        result = base + ten_seconds
+        assert result == expected_add
+
+        result = base - ten_seconds
+        assert result == expected_sub
+
+    @pytest.mark.parametrize(
+        "one_day_ten_secs",
+        [
+            Timedelta("1 day, 00:00:10"),
+            Timedelta("1 days, 00:00:10"),
+            timedelta(days=1, seconds=10),
+            np.timedelta64(1, "D") + np.timedelta64(10, "s"),
+            offsets.Day() + offsets.Second(10),
+        ],
+    )
+    def test_td_add_sub_one_day_ten_seconds(self, one_day_ten_secs):
+        # GH#6808
+        base = Timestamp("20130102 09:01:12.123456")
+        expected_add = Timestamp("20130103 09:01:22.123456")
+        expected_sub = Timestamp("20130101 09:01:02.123456")
+
+        result = base + one_day_ten_secs
+        assert result == expected_add
+
+        result = base - one_day_ten_secs
+        assert result == expected_sub
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_datetimelike_scalar(self, op):
+        # GH#19738
+        td = Timedelta(10, unit="D")
+
+        result = op(td, datetime(2016, 1, 1))
+        if op is operator.add:
+            # datetime + Timedelta does _not_ call Timedelta.__radd__,
+            # so we get a datetime back instead of a Timestamp
+            assert isinstance(result, Timestamp)
+        assert result == Timestamp(2016, 1, 11)
+
+        result = op(td, Timestamp("2018-01-12 18:09"))
+        assert isinstance(result, Timestamp)
+        assert result == Timestamp("2018-01-22 18:09")
+
+        result = op(td, np.datetime64("2018-01-12"))
+        assert isinstance(result, Timestamp)
+        assert result == Timestamp("2018-01-22")
+
+        result = op(td, NaT)
+        assert result is NaT
+
+    def test_td_add_timestamp_overflow(self):
+        ts = Timestamp("1700-01-01").as_unit("ns")
+        msg = "Cannot cast 259987 days 00:00:00 to unit='ns' without overflow."
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            ts + Timedelta(13 * 19999, unit="D")
+
+        msg = "Cannot cast 259987 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            ts + timedelta(days=13 * 19999)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_td(self, op):
+        td = Timedelta(10, unit="D")
+
+        result = op(td, Timedelta(days=10))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=20)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_pytimedelta(self, op):
+        td = Timedelta(10, unit="D")
+        result = op(td, timedelta(days=9))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=19)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_timedelta64(self, op):
+        td = Timedelta(10, unit="D")
+        result = op(td, np.timedelta64(-4, "D"))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=6)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_offset(self, op):
+        td = Timedelta(10, unit="D")
+
+        result = op(td, offsets.Hour(6))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=10, hours=6)
+
+    def test_td_sub_td(self):
+        td = Timedelta(10, unit="D")
+        expected = Timedelta(0, unit="ns")
+        result = td - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_pytimedelta(self):
+        td = Timedelta(10, unit="D")
+        expected = Timedelta(0, unit="ns")
+
+        result = td - td.to_pytimedelta()
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = td.to_pytimedelta() - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_timedelta64(self):
+        td = Timedelta(10, unit="D")
+        expected = Timedelta(0, unit="ns")
+
+        result = td - td.to_timedelta64()
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = td.to_timedelta64() - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_nat(self):
+        # In this context pd.NaT is treated as timedelta-like
+        td = Timedelta(10, unit="D")
+        result = td - NaT
+        assert result is NaT
+
+    def test_td_sub_td64_nat(self):
+        td = Timedelta(10, unit="D")
+        td_nat = np.timedelta64("NaT", "ns")
+
+        result = td - td_nat
+        assert result is NaT
+
+        result = td_nat - td
+        assert result is NaT
+
+    def test_td_sub_offset(self):
+        td = Timedelta(10, unit="D")
+        result = td - offsets.Hour(1)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(239, unit="h")
+
+    def test_td_add_sub_numeric_raises(self):
+        td = Timedelta(10, unit="D")
+        msg = "unsupported operand type"
+        for other in [2, 2.0, np.int64(2), np.float64(2)]:
+            with pytest.raises(TypeError, match=msg):
+                td + other
+            with pytest.raises(TypeError, match=msg):
+                other + td
+            with pytest.raises(TypeError, match=msg):
+                td - other
+            with pytest.raises(TypeError, match=msg):
+                other - td
+
+    def test_td_add_sub_int_ndarray(self):
+        td = Timedelta("1 day")
+        other = np.array([1])
+
+        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td + np.array([1])
+
+        msg = "|".join(
+            [
+                (
+                    r"unsupported operand type\(s\) for \+: 'numpy.ndarray' "
+                    "and 'Timedelta'"
+                ),
+                # This message goes on to say "Please do not rely on this error;
+                #  it may not be given on all Python implementations"
+                "Concatenation operation is not implemented for NumPy arrays",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            other + td
+        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td - other
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            other - td
+
+    def test_td_rsub_nat(self):
+        td = Timedelta(10, unit="D")
+        result = NaT - td
+        assert result is NaT
+
+        result = np.datetime64("NaT", "ns") - td
+        assert result is NaT
+
+    def test_td_rsub_offset(self):
+        result = offsets.Hour(1) - Timedelta(10, unit="D")
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(-239, unit="h")
+
+    def test_td_sub_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        arr = np.array([Timestamp("20130101 9:01"), Timestamp("20121230 9:02")])
+        exp = np.array([Timestamp("20121231 9:01"), Timestamp("20121229 9:02")])
+        res = arr - Timedelta("1D")
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_sub_mixed_most_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D"), np.timedelta64(2, "h")])
+        exp = np.array(
+            [
+                now - Timedelta("1D"),
+                Timedelta("0D"),
+                np.timedelta64(2, "h") - Timedelta("1D"),
+            ]
+        )
+        res = arr - Timedelta("1D")
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_rsub_mixed_most_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D"), np.timedelta64(2, "h")])
+        msg = r"unsupported operand type\(s\) for \-: 'Timedelta' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            Timedelta("1D") - arr
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_timedeltalike_object_dtype_array(self, op):
+        # GH#21980
+        arr = np.array([Timestamp("20130101 9:01"), Timestamp("20121230 9:02")])
+        exp = np.array([Timestamp("20130102 9:01"), Timestamp("20121231 9:02")])
+        res = op(arr, Timedelta("1D"))
+        tm.assert_numpy_array_equal(res, exp)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_mixed_timedeltalike_object_dtype_array(self, op):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D")])
+        exp = np.array([now + Timedelta("1D"), Timedelta("2D")])
+        res = op(arr, Timedelta("1D"))
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_add_sub_td64_ndarray(self):
+        td = Timedelta("1 day")
+
+        other = np.array([td.to_timedelta64()])
+        expected = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        result = td + other
+        tm.assert_numpy_array_equal(result, expected)
+        result = other + td
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td - other
+        tm.assert_numpy_array_equal(result, expected * 0)
+        result = other - td
+        tm.assert_numpy_array_equal(result, expected * 0)
+
+    def test_td_add_sub_dt64_ndarray(self):
+        td = Timedelta("1 day")
+        other = np.array(["2000-01-01"], dtype="M8[ns]")
+
+        expected = np.array(["2000-01-02"], dtype="M8[ns]")
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+
+        expected = np.array(["1999-12-31"], dtype="M8[ns]")
+        tm.assert_numpy_array_equal(-td + other, expected)
+        tm.assert_numpy_array_equal(other - td, expected)
+
+    def test_td_add_sub_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(td.asm8)
+
+        result = td + other
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other + td
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other - td
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
+        result = td - other
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
+
+class TestTimedeltaMultiplicationDivision:
+    """
+    Tests for Timedelta methods:
+
+        __mul__, __rmul__,
+        __div__, __rdiv__,
+        __truediv__, __rtruediv__,
+        __floordiv__, __rfloordiv__,
+        __mod__, __rmod__,
+        __divmod__, __rdivmod__
+    """
+
+    # ---------------------------------------------------------------
+    # Timedelta.__mul__, __rmul__
+
+    @pytest.mark.parametrize("td_nat", [NaT, np.timedelta64("NaT", "ns")])
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_nat(self, op, td_nat):
+        # GH#19819
+        td = Timedelta(10, unit="D")
+        typs = "|".join(["numpy.timedelta64", "NaTType", "Timedelta"])
+        msg = "|".join(
+            [
+                rf"unsupported operand type\(s\) for \*: '{typs}' and '{typs}'",
+                r"ufunc '?multiply'? cannot use operands with types",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            op(td, td_nat)
+
+    @pytest.mark.parametrize("nan", [np.nan, np.float64("NaN"), float("nan")])
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_nan(self, op, nan):
+        # np.float64('NaN') has a 'dtype' attr, avoid treating as array
+        td = Timedelta(10, unit="D")
+        result = op(td, nan)
+        assert result is NaT
+
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_scalar(self, op):
+        # GH#19738
+        td = Timedelta(minutes=3)
+
+        result = op(td, 2)
+        assert result == Timedelta(minutes=6)
+
+        result = op(td, 1.5)
+        assert result == Timedelta(minutes=4, seconds=30)
+
+        assert op(td, np.nan) is NaT
+
+        assert op(-1, td)._value == -1 * td._value
+        assert op(-1.0, td)._value == -1.0 * td._value
+
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            # timedelta * datetime is gibberish
+            op(td, Timestamp(2016, 1, 2))
+
+        with pytest.raises(TypeError, match=msg):
+            # invalid multiply with another timedelta
+            op(td, td)
+
+    def test_td_mul_numeric_ndarray(self):
+        td = Timedelta("1 day")
+        other = np.array([2])
+        expected = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        result = td * other
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other * td
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_td_mul_numeric_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(2, dtype=np.int64)
+        assert other.ndim == 0
+        expected = Timedelta("2 days")
+
+        res = td * other
+        assert type(res) is Timedelta
+        assert res == expected
+
+        res = other * td
+        assert type(res) is Timedelta
+        assert res == expected
+
+    def test_td_mul_td64_ndarray_invalid(self):
+        td = Timedelta("1 day")
+        other = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        msg = (
+            "ufunc '?multiply'? cannot use operands with types "
+            rf"dtype\('{tm.ENDIAN}m8\[us\]'\) and dtype\('{tm.ENDIAN}m8\[us\]'\)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            td * other
+        with pytest.raises(TypeError, match=msg):
+            other * td
+
+    # ---------------------------------------------------------------
+    # Timedelta.__div__, __truediv__
+
+    def test_td_div_timedeltalike_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="D")
+
+        result = td / offsets.Hour(1)
+        assert result == 240
+
+        assert td / td == 1
+        assert td / np.timedelta64(60, "h") == 4
+
+        assert np.isnan(td / NaT)
+
+    def test_td_div_td64_non_nano(self):
+        # truediv
+        td = Timedelta("1 days 2 hours 3 ns")
+        result = td / np.timedelta64(1, "D")
+        assert result == td._value / (86400 * 10**9)
+        result = td / np.timedelta64(1, "s")
+        assert result == td._value / 10**9
+        result = td / np.timedelta64(1, "ns")
+        assert result == td._value
+
+        # floordiv
+        td = Timedelta("1 days 2 hours 3 ns")
+        result = td // np.timedelta64(1, "D")
+        assert result == 1
+        result = td // np.timedelta64(1, "s")
+        assert result == 93600
+        result = td // np.timedelta64(1, "ns")
+        assert result == td._value
+
+    def test_td_div_numeric_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="D")
+
+        result = td / 2
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=5)
+
+        result = td / 5
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=2)
+
+    @pytest.mark.parametrize(
+        "nan",
+        [
+            np.nan,
+            np.float64("NaN"),
+            float("nan"),
+        ],
+    )
+    def test_td_div_nan(self, nan):
+        # np.float64('NaN') has a 'dtype' attr, avoid treating as array
+        td = Timedelta(10, unit="D")
+        result = td / nan
+        assert result is NaT
+
+        result = td // nan
+        assert result is NaT
+
+    def test_td_div_td64_ndarray(self):
+        td = Timedelta("1 day")
+
+        other = np.array([Timedelta("2 Days").to_timedelta64()])
+        expected = np.array([0.5])
+
+        result = td / other
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other / td
+        tm.assert_numpy_array_equal(result, expected * 4)
+
+    def test_td_div_ndarray_0d(self):
+        td = Timedelta("1 day")
+
+        other = np.array(1)
+        res = td / other
+        assert isinstance(res, Timedelta)
+        assert res == td
+
+    # ---------------------------------------------------------------
+    # Timedelta.__rdiv__
+
+    def test_td_rdiv_timedeltalike_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="D")
+        result = offsets.Hour(1) / td
+        assert result == 1 / 240.0
+
+        assert np.timedelta64(60, "h") / td == 0.25
+
+    def test_td_rdiv_na_scalar(self):
+        # GH#31869 None gets cast to NaT
+        td = Timedelta(10, unit="D")
+
+        result = NaT / td
+        assert np.isnan(result)
+
+        result = None / td
+        assert np.isnan(result)
+
+        result = np.timedelta64("NaT", "ns") / td
+        assert np.isnan(result)
+
+        msg = r"unsupported operand type\(s\) for /: 'numpy.datetime64' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.datetime64("NaT", "ns") / td
+
+        msg = r"unsupported operand type\(s\) for /: 'float' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.nan / td
+
+    def test_td_rdiv_ndarray(self):
+        td = Timedelta(10, unit="D")
+
+        arr = np.array([td], dtype=object)
+        result = arr / td
+        expected = np.array([1], dtype=np.float64)
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = np.array([None])
+        result = arr / td
+        expected = np.array([np.nan])
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = np.array([np.nan], dtype=object)
+        msg = r"unsupported operand type\(s\) for /: 'float' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            arr / td
+
+        arr = np.array([np.nan], dtype=np.float64)
+        msg = "cannot use operands with types dtype"
+        with pytest.raises(TypeError, match=msg):
+            arr / td
+
+    def test_td_rdiv_ndarray_0d(self):
+        td = Timedelta(10, unit="D")
+
+        arr = np.array(td.asm8)
+
+        assert arr / td == 1
+
+    # ---------------------------------------------------------------
+    # Timedelta.__floordiv__
+
+    def test_td_floordiv_timedeltalike_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        scalar = Timedelta(hours=3, minutes=3)
+
+        assert td // scalar == 1
+        assert -td // scalar.to_pytimedelta() == -2
+        assert (2 * td) // scalar.to_timedelta64() == 2
+
+    def test_td_floordiv_null_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        assert td // np.nan is NaT
+        assert np.isnan(td // NaT)
+        assert np.isnan(td // np.timedelta64("NaT", "ns"))
+
+    def test_td_floordiv_offsets(self):
+        # GH#19738
+        td = Timedelta(hours=3, minutes=4)
+        assert td // offsets.Hour(1) == 3
+        assert td // offsets.Minute(2) == 92
+
+    def test_td_floordiv_invalid_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        msg = "|".join(
+            [
+                r"Invalid dtype datetime64\[D\] for __floordiv__",
+                "'dtype' is an invalid keyword argument for this function",
+                "this function got an unexpected keyword argument 'dtype'",
+                r"ufunc '?floor_divide'? cannot use operands with types",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            td // np.datetime64("2016-01-01", dtype="datetime64[us]")
+
+    def test_td_floordiv_numeric_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        expected = Timedelta(hours=1, minutes=32)
+        assert td // 2 == expected
+        assert td // 2.0 == expected
+        assert td // np.float64(2.0) == expected
+        assert td // np.int32(2.0) == expected
+        assert td // np.uint8(2.0) == expected
+
+    def test_td_floordiv_timedeltalike_array(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        scalar = Timedelta(hours=3, minutes=3)
+
+        # Array-like others
+        assert td // np.array(scalar.to_timedelta64()) == 1
+
+        res = (3 * td) // np.array([scalar.to_timedelta64()])
+        expected = np.array([3], dtype=np.int64)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = (10 * td) // np.array(
+            [scalar.to_timedelta64(), np.timedelta64("NaT", "ns")]
+        )
+        expected = np.array([10, np.nan])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_td_floordiv_numeric_series(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        ser = pd.Series([1], dtype=np.int64)
+        res = td // ser
+        assert res.dtype.kind == "m"
+
+    # ---------------------------------------------------------------
+    # Timedelta.__rfloordiv__
+
+    def test_td_rfloordiv_timedeltalike_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        scalar = Timedelta(hours=3, minutes=4)
+
+        # scalar others
+        # x // Timedelta is defined only for timedelta-like x. int-like,
+        # float-like, and date-like, in particular, should all either
+        # a) raise TypeError directly or
+        # b) return NotImplemented, following which the reversed
+        #    operation will raise TypeError.
+        assert td.__rfloordiv__(scalar) == 1
+        assert (-td).__rfloordiv__(scalar.to_pytimedelta()) == -2
+        assert (2 * td).__rfloordiv__(scalar.to_timedelta64()) == 0
+
+    def test_td_rfloordiv_null_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        assert np.isnan(td.__rfloordiv__(NaT))
+        assert np.isnan(td.__rfloordiv__(np.timedelta64("NaT", "ns")))
+
+    def test_td_rfloordiv_offsets(self):
+        # GH#19738
+        assert offsets.Hour(1) // Timedelta(minutes=25) == 2
+
+    def test_td_rfloordiv_invalid_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        dt64 = np.datetime64("2016-01-01", "us")
+
+        assert td.__rfloordiv__(dt64) is NotImplemented
+
+        msg = (
+            r"unsupported operand type\(s\) for //: 'numpy.datetime64' and 'Timedelta'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            dt64 // td
+
+    def test_td_rfloordiv_numeric_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        assert td.__rfloordiv__(np.nan) is NotImplemented
+        assert td.__rfloordiv__(3.5) is NotImplemented
+        assert td.__rfloordiv__(2) is NotImplemented
+        assert td.__rfloordiv__(np.float64(2.0)) is NotImplemented
+        assert td.__rfloordiv__(np.uint8(9)) is NotImplemented
+        assert td.__rfloordiv__(np.int32(2.0)) is NotImplemented
+
+        msg = r"unsupported operand type\(s\) for //: '.*' and 'Timedelta"
+        with pytest.raises(TypeError, match=msg):
+            np.float64(2.0) // td
+        with pytest.raises(TypeError, match=msg):
+            np.uint8(9) // td
+        with pytest.raises(TypeError, match=msg):
+            # deprecated GH#19761, enforced GH#29797
+            np.int32(2.0) // td
+
+    def test_td_rfloordiv_timedeltalike_array(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        scalar = Timedelta(hours=3, minutes=4)
+
+        # Array-like others
+        assert td.__rfloordiv__(np.array(scalar.to_timedelta64())) == 1
+
+        res = td.__rfloordiv__(np.array([(3 * scalar).to_timedelta64()]))
+        expected = np.array([3], dtype=np.int64)
+        tm.assert_numpy_array_equal(res, expected)
+
+        arr = np.array([(10 * scalar).to_timedelta64(), np.timedelta64("NaT", "ns")])
+        res = td.__rfloordiv__(arr)
+        expected = np.array([10, np.nan])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_td_rfloordiv_intarray(self):
+        # deprecated GH#19761, enforced GH#29797
+        ints = np.array([1349654400, 1349740800, 1349827200, 1349913600]) * 10**9
+
+        msg = "Invalid dtype"
+        with pytest.raises(TypeError, match=msg):
+            ints // Timedelta(1, unit="s")
+
+    def test_td_rfloordiv_numeric_series(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        ser = pd.Series([1], dtype=np.int64)
+        res = td.__rfloordiv__(ser)
+        assert res is NotImplemented
+
+        msg = "Invalid dtype"
+        with pytest.raises(TypeError, match=msg):
+            # Deprecated GH#19761, enforced GH#29797
+            ser // td
+
+    # ----------------------------------------------------------------
+    # Timedelta.__mod__, __rmod__
+
+    def test_mod_timedeltalike(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        # Timedelta-like others
+        result = td % Timedelta(hours=6)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+        result = td % timedelta(minutes=60)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % NaT
+        assert result is NaT
+
+    def test_mod_timedelta64_nat(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % np.timedelta64("NaT", "ns")
+        assert result is NaT
+
+    def test_mod_timedelta64(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % np.timedelta64(2, "h")
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+    def test_mod_offset(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % offsets.Hour(5)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=2)
+
+    def test_mod_numeric(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        # Numeric Others
+        result = td % 2
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % 1e9
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+        result = td % int(1e9)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+    def test_mod_invalid(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            td % Timestamp("2018-01-22")
+
+        with pytest.raises(TypeError, match=msg):
+            td % []
+
+    def test_rmod_pytimedelta(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        result = timedelta(minutes=4) % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=1)
+
+    def test_rmod_timedelta64(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+        result = np.timedelta64(5, "m") % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=2)
+
+    def test_rmod_invalid(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        msg = "unsupported operand"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp("2018-01-22") % td
+
+        with pytest.raises(TypeError, match=msg):
+            15 % td
+
+        with pytest.raises(TypeError, match=msg):
+            16.0 % td
+
+        msg = "Invalid dtype int"
+        with pytest.raises(TypeError, match=msg):
+            np.array([22, 24]) % td
+
+    # ----------------------------------------------------------------
+    # Timedelta.__divmod__, __rdivmod__
+
+    def test_divmod_numeric(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, 53 * 3600 * 1e6)
+        assert result[0] == Timedelta(1, unit="us").as_unit("us")
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=1)
+
+        assert result
+        result = divmod(td, np.nan)
+        assert result[0] is NaT
+        assert result[1] is NaT
+
+    def test_divmod(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+        result = divmod(td, 54)
+        assert result[0] == Timedelta(hours=1)
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(0)
+
+        result = divmod(td, NaT)
+        assert np.isnan(result[0])
+        assert result[1] is NaT
+
+    def test_divmod_offset(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, offsets.Hour(-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
+    def test_divmod_invalid(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        msg = r"unsupported operand type\(s\) for //: 'Timedelta' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            divmod(td, Timestamp("2018-01-22"))
+
+    def test_rdivmod_pytimedelta(self):
+        # GH#19365
+        result = divmod(timedelta(days=2, hours=6), Timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+    def test_rdivmod_offset(self):
+        result = divmod(offsets.Hour(54), Timedelta(hours=-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
+    def test_rdivmod_invalid(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+        msg = "unsupported operand type"
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(Timestamp("2018-01-22"), td)
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(15, td)
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(16.0, td)
+
+        msg = "Invalid dtype int"
+        with pytest.raises(TypeError, match=msg):
+            divmod(np.array([22, 24]), td)
+
+    # ----------------------------------------------------------------
+
+    @pytest.mark.parametrize(
+        "op", [operator.mul, ops.rmul, operator.truediv, ops.rdiv, ops.rsub]
+    )
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            [Timestamp("20130101 9:01"), Timestamp("20121230 9:02")],
+            [Timestamp("2021-11-09 09:54:00"), Timedelta("1D")],
+        ],
+    )
+    def test_td_op_timedelta_timedeltalike_array(self, op, arr):
+        arr = np.array(arr)
+        msg = "unsupported operand type|cannot use operands with types"
+        with pytest.raises(TypeError, match=msg):
+            op(arr, Timedelta("1D"))
+
+    def test_mul_bool_invalid(self):
+        # GH#62316
+        msg = "Cannot multiply Timedelta by bool. Explicitly cast to integer"
+        with pytest.raises(TypeError, match=msg):
+            Timedelta("1 day") * True
+
+
+class TestTimedeltaComparison:
+    def test_compare_pytimedelta_bounds(self):
+        # GH#49021 don't overflow on comparison with very large pytimedeltas
+
+        for unit in ["ns", "us"]:
+            tdmax = Timedelta.max.as_unit(unit).max
+            tdmin = Timedelta.min.as_unit(unit).min
+
+            assert tdmax < timedelta.max
+            assert tdmax <= timedelta.max
+            assert not tdmax > timedelta.max
+            assert not tdmax >= timedelta.max
+            assert tdmax != timedelta.max
+            assert not tdmax == timedelta.max
+
+            assert tdmin > timedelta.min
+            assert tdmin >= timedelta.min
+            assert not tdmin < timedelta.min
+            assert not tdmin <= timedelta.min
+            assert tdmin != timedelta.min
+            assert not tdmin == timedelta.min
+
+        # But the "ms" and "s"-reso bounds extend pass pytimedelta
+        for unit in ["ms", "s"]:
+            tdmax = Timedelta.max.as_unit(unit).max
+            tdmin = Timedelta.min.as_unit(unit).min
+
+            assert tdmax > timedelta.max
+            assert tdmax >= timedelta.max
+            assert not tdmax < timedelta.max
+            assert not tdmax <= timedelta.max
+            assert tdmax != timedelta.max
+            assert not tdmax == timedelta.max
+
+            assert tdmin < timedelta.min
+            assert tdmin <= timedelta.min
+            assert not tdmin > timedelta.min
+            assert not tdmin >= timedelta.min
+            assert tdmin != timedelta.min
+            assert not tdmin == timedelta.min
+
+    def test_compare_pytimedelta_bounds2(self):
+        # a pytimedelta outside the microsecond bounds
+        pytd = timedelta(days=999999999, seconds=86399)
+        # NB: np.timedelta64(td, "s"") incorrectly overflows
+        td64 = np.timedelta64(pytd.days, "D") + np.timedelta64(pytd.seconds, "s")
+        td = Timedelta(td64)
+        assert td.days == pytd.days
+        assert td.seconds == pytd.seconds
+
+        assert td == pytd
+        assert not td != pytd
+        assert not td < pytd
+        assert not td > pytd
+        assert td <= pytd
+        assert td >= pytd
+
+        td2 = td - Timedelta(seconds=1).as_unit("s")
+        assert td2 != pytd
+        assert not td2 == pytd
+        assert td2 < pytd
+        assert td2 <= pytd
+        assert not td2 > pytd
+        assert not td2 >= pytd
+
+    def test_compare_tick(self, tick_classes):
+        cls = tick_classes
+
+        off = cls(4)
+        td = off._as_pd_timedelta
+        assert isinstance(td, Timedelta)
+
+        assert td == off
+        assert not td != off
+        assert td <= off
+        assert td >= off
+        assert not td < off
+        assert not td > off
+
+        assert not td == 2 * off
+        assert td != 2 * off
+        assert td <= 2 * off
+        assert td < 2 * off
+        assert not td >= 2 * off
+        assert not td > 2 * off
+
+    def test_comparison_object_array(self):
+        # analogous to GH#15183
+        td = Timedelta("2 days")
+        other = Timedelta("3 hours")
+
+        arr = np.array([other, td], dtype=object)
+        res = arr == td
+        expected = np.array([False, True], dtype=bool)
+        assert (res == expected).all()
+
+        # 2D case
+        arr = np.array([[other, td], [td, other]], dtype=object)
+        res = arr != td
+        expected = np.array([[True, False], [False, True]], dtype=bool)
+        assert res.shape == expected.shape
+        assert (res == expected).all()
+
+    def test_compare_timedelta_ndarray(self):
+        # GH#11835
+        periods = [Timedelta("0 days 01:00:00"), Timedelta("0 days 01:00:00")]
+        arr = np.array(periods)
+        result = arr[0] > arr
+        expected = np.array([False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_td64_ndarray(self):
+        # GG#33441
+        arr = np.arange(5).astype("timedelta64[ns]")
+        td = Timedelta(arr[1])
+
+        expected = np.array([False, True, False, False, False], dtype=bool)
+
+        result = td == arr
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr == td
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td != arr
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = arr != td
+        tm.assert_numpy_array_equal(result, ~expected)
+
+    def test_compare_custom_object(self):
+        """
+        Make sure non supported operations on Timedelta returns NonImplemented
+        and yields to other operand (GH#20829).
+        """
+
+        class CustomClass:
+            def __init__(self, cmp_result=None) -> None:
+                self.cmp_result = cmp_result
+
+            def generic_result(self):
+                if self.cmp_result is None:
+                    return NotImplemented
+                else:
+                    return self.cmp_result
+
+            def __eq__(self, other):
+                return self.generic_result()
+
+            def __gt__(self, other):
+                return self.generic_result()
+
+        t = Timedelta("1s")
+
+        assert t != "string"
+        assert t != 1
+        assert t != CustomClass()
+        assert t != CustomClass(cmp_result=False)
+
+        assert t < CustomClass(cmp_result=True)
+        assert not t < CustomClass(cmp_result=False)
+
+        assert t == CustomClass(cmp_result=True)
+
+    @pytest.mark.parametrize("val", ["string", 1])
+    def test_compare_unknown_type(self, val):
+        # GH#20829
+        t = Timedelta("1s")
+        msg = "not supported between instances of 'Timedelta' and '(int|str)'"
+        with pytest.raises(TypeError, match=msg):
+            t >= val
+        with pytest.raises(TypeError, match=msg):
+            t > val
+        with pytest.raises(TypeError, match=msg):
+            t <= val
+        with pytest.raises(TypeError, match=msg):
+            t < val
+
+
+def test_ops_notimplemented():
+    class Other:
+        pass
+
+    other = Other()
+
+    td = Timedelta("1 day")
+    assert td.__add__(other) is NotImplemented
+    assert td.__sub__(other) is NotImplemented
+    assert td.__truediv__(other) is NotImplemented
+    assert td.__mul__(other) is NotImplemented
+    assert td.__floordiv__(other) is NotImplemented
+
+
+def test_ops_error_str():
+    # GH#13624
+    td = Timedelta("1 day")
+
+    for left, right in [(td, "a"), ("a", td)]:
+        msg = "|".join(
+            [
+                "unsupported operand type",
+                r'can only concatenate str \(not "Timedelta"\) to str',
+                "must be str, not Timedelta",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            left + right
+
+        msg = "not supported between instances of"
+        with pytest.raises(TypeError, match=msg):
+            left > right
+
+        assert not left == right
+        assert left != right
+
+
+@pytest.mark.parametrize("box", [True, False])
+def test_ops_str_deprecated(box):
+    # GH#59653
+    td = Timedelta("1 day")
+    item = "1"
+    if box:
+        item = np.array([item], dtype=object)
+
+    msg = "Scalar operations between Timedelta and string are deprecated"
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        td + item
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        item + td
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        td - item
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        item - td
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        item / td
+    if not box:
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            td / item
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            item // td
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            td // item
+    else:
+        msg = "|".join(
+            [
+                "ufunc 'divide' cannot use operands",
+                "Invalid dtype object for __floordiv__",
+                r"unsupported operand type\(s\) for /: 'int' and 'str'",
+                r"unsupported operand type\(s\) for /: 'datetime.timedelta' and 'str'",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            td / item
+        with pytest.raises(TypeError, match=msg):
+            item // td
+        with pytest.raises(TypeError, match=msg):
+            td // item

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/test_constructors.py

@@ -0,0 +1,795 @@
+from datetime import timedelta
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import OutOfBoundsTimedelta
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.compat.numpy import (
+    is_numpy_dev,
+    np_version_gt2_5,
+)
+from pandas.errors import Pandas4Warning
+
+from pandas import (
+    Index,
+    NaT,
+    Timedelta,
+    TimedeltaIndex,
+    offsets,
+    to_timedelta,
+)
+import pandas._testing as tm
+
+
+class TestTimedeltaConstructorKeywordBased:
+    # Tests for constructing a Timedelta from keywords like the pytimedelta
+    # base class
+    def test_nanosecond_keyword(self):
+        # GH#63216
+        td = Timedelta(nanoseconds=1000)
+        assert td.unit == "ns"
+
+    def test_noninteger_microseconds(self):
+        # GH#63216
+        td = Timedelta(microseconds=1.5)
+        assert td.unit == "ns"
+        assert td == Timedelta(nanoseconds=1500)
+
+
+class TestTimedeltaConstructorUnitKeyword:
+    def test_result_unit(self):
+        # For supported units, we get result.unit == unit
+        for unit in ["s", "ms", "us", "ns"]:
+            td = Timedelta(1, unit=unit)
+            assert td.unit == unit
+
+            td = to_timedelta(1, unit=unit)
+            assert td.unit == unit
+
+        # For non-supported units we get the closest-supported unit
+        for unit in ["W", "D", "h", "m"]:
+            td = Timedelta(1, unit=unit)
+            assert td.unit == "s"
+
+            td = to_timedelta(1, unit=unit)
+            assert td.unit == "s"
+
+    @pytest.mark.parametrize("unit", ["Y", "y", "M"])
+    def test_unit_m_y_raises(self, unit):
+        msg = "Units 'M', 'Y', and 'y' are no longer supported"
+
+        with pytest.raises(ValueError, match=msg):
+            Timedelta(10, unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta(10, unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta([1, 2], unit)
+
+    @pytest.mark.parametrize(
+        "unit,unit_depr",
+        [
+            ("W", "w"),
+            ("D", "d"),
+            ("min", "MIN"),
+            ("s", "S"),
+            ("h", "H"),
+            ("ms", "MS"),
+            ("us", "US"),
+        ],
+    )
+    def test_unit_deprecated(self, unit, unit_depr):
+        # GH#52536
+        msg = f"'{unit_depr}' is deprecated and will be removed in a future version."
+
+        expected = Timedelta(1, unit=unit)
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            result = Timedelta(1, unit=unit_depr)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "unit, np_unit",
+        [("W", "W")]
+        + [(value, "D") for value in ["D", "days", "day", "Days", "Day"]]
+        + [
+            (value, "m")
+            for value in [
+                "m",
+                "minute",
+                "min",
+                "minutes",
+                "Minute",
+                "Min",
+                "Minutes",
+            ]
+        ]
+        + [
+            (value, "s")
+            for value in [
+                "s",
+                "seconds",
+                "sec",
+                "second",
+                "Seconds",
+                "Sec",
+                "Second",
+            ]
+        ]
+        + [
+            (value, "ms")
+            for value in [
+                "ms",
+                "milliseconds",
+                "millisecond",
+                "milli",
+                "millis",
+                "Milliseconds",
+                "Millisecond",
+                "Milli",
+                "Millis",
+            ]
+        ]
+        + [
+            (value, "us")
+            for value in [
+                "us",
+                "microseconds",
+                "microsecond",
+                "micro",
+                "micros",
+                "Microseconds",
+                "Microsecond",
+                "Micro",
+                "Micros",
+            ]
+        ]
+        + [
+            (value, "ns")
+            for value in [
+                "ns",
+                "nanoseconds",
+                "nanosecond",
+                "nano",
+                "nanos",
+                "Nanoseconds",
+                "Nanosecond",
+                "Nano",
+                "Nanos",
+            ]
+        ],
+    )
+    @pytest.mark.parametrize("wrapper", [np.array, list, Index])
+    def test_unit_parser(self, unit, np_unit, wrapper):
+        # validate all units, GH 6855, GH 21762
+        # array-likes
+        exp_unit = np_unit if np_unit not in ["W", "D", "m"] else "s"
+        expected = TimedeltaIndex(
+            [np.timedelta64(i, np_unit) for i in np.arange(5).tolist()],
+            dtype=f"m8[{exp_unit}]",
+        )
+
+        result = to_timedelta(wrapper(range(5)), unit=unit)
+        tm.assert_index_equal(result, expected)
+
+        str_repr = [f"{x}{unit}" for x in np.arange(5)]
+        exp_unit = "us" if np_unit != "ns" else "ns"
+        result = to_timedelta(wrapper(str_repr))
+        tm.assert_index_equal(result, expected.as_unit(exp_unit))
+        result = to_timedelta(wrapper(str_repr))
+        tm.assert_index_equal(result, expected.as_unit(exp_unit))
+
+        # scalar
+        expected = Timedelta(np.timedelta64(2, np_unit)).as_unit(exp_unit)
+        result = to_timedelta(2, unit=unit)
+        assert result == expected
+        result = Timedelta(2, unit=unit)
+        assert result == expected
+
+        result = to_timedelta(f"2{unit}")
+        assert result == expected
+        result = Timedelta(f"2{unit}")
+        assert result == expected
+
+    @pytest.mark.parametrize("unit", ["T", "t", "L", "l", "U", "u", "N", "n"])
+    def test_unit_T_L_N_U_raises(self, unit):
+        msg = f"invalid unit abbreviation: {unit}"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta(1, unit=unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta(10, unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta([1, 2], unit)
+
+    def test_unit_round_float(self):
+        # When the float is round, we give the requested unit
+        #  (or nearest-supported) like we do with integers
+        td = Timedelta(45.0, unit="s")
+        assert td.unit == "s"
+        assert td == Timedelta(45, unit="s")
+
+        td = to_timedelta(45.0, unit="s")
+        assert td.unit == "s"
+        assert td == Timedelta(45, unit="s")
+
+    def test_unit_non_round_float(self):
+        # With non-round floats, we have to give nanosecond
+        td = Timedelta(45.5, unit="s")
+        assert td.unit == "ns"
+        assert td == Timedelta(45_500, unit="ms")
+
+        td = to_timedelta(45.5, unit="s")
+        assert td.unit == "ns"
+        assert td == Timedelta(45_500, unit="ms")
+
+
+def test_construct_from_kwargs_overflow():
+    # GH#55503
+    msg = "seconds=86400000000000000000, milliseconds=0, microseconds=0, nanoseconds=0"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(days=10**6)
+    msg = "seconds=60000000000000000000, milliseconds=0, microseconds=0, nanoseconds=0"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(minutes=10**9)
+
+
+def test_construct_with_weeks_unit_overflow():
+    # GH#47268 don't silently wrap around
+    msg = "1000000000000000000 weeks"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(1000000000000000000, unit="W")
+
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(1000000000000000000.0, unit="W")
+
+
+def test_construct_from_td64_with_unit():
+    # ignore the unit, as it may cause silently overflows leading to incorrect
+    #  results, and in non-overflow cases is irrelevant GH#46827
+    obj = np.timedelta64(123456789000000000, "h")
+
+    msg = "The 'unit' keyword is only used when the Timedelta input is"
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        with tm.assert_produces_warning(UserWarning, match=msg):
+            Timedelta(obj, unit="ps")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        with tm.assert_produces_warning(UserWarning, match=msg):
+            Timedelta(obj, unit="ns")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        Timedelta(obj)
+
+
+def test_from_td64_retain_resolution():
+    # case where we retain millisecond resolution
+    obj = np.timedelta64(12345, "ms")
+
+    td = Timedelta(obj)
+    assert td._value == obj.view("i8")
+    assert td._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    # Case where we cast to nearest-supported reso
+    obj2 = np.timedelta64(1234, "D")
+    td2 = Timedelta(obj2)
+    assert td2._creso == NpyDatetimeUnit.NPY_FR_s.value
+    assert td2 == obj2
+    assert td2.days == 1234
+
+    # Case that _would_ overflow if we didn't support non-nano
+    obj3 = np.timedelta64(1000000000000000000, "us")
+    td3 = Timedelta(obj3)
+    assert td3.total_seconds() == 1000000000000
+    assert td3._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+
+def test_from_pytimedelta_us_reso():
+    # pytimedelta has microsecond resolution, so Timedelta(pytd) inherits that
+    td = timedelta(days=4, minutes=3)
+    result = Timedelta(td)
+    assert result.to_pytimedelta() == td
+    assert result._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+
+def test_from_tick_reso():
+    tick = offsets.Nano()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    tick = offsets.Micro()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+    tick = offsets.Milli()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    tick = offsets.Second()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    # everything above Second gets cast to the closest supported reso: second
+    tick = offsets.Minute()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    tick = offsets.Hour()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    tick = offsets.Day()
+    msg = (
+        "Value must be Timedelta, string, integer, float, timedelta "
+        "or convertible, not Day"
+    )
+    with pytest.raises(ValueError, match=msg):
+        # GH#41943 Day is no longer a Tick
+        Timedelta(tick)
+
+
+def test_construction():
+    expected = np.timedelta64(10, "D").astype("m8[ns]").view("i8")
+    assert Timedelta(10, unit="D")._value == expected // 10**9
+    assert Timedelta(10.0, unit="D")._value == expected // 10**9
+    assert Timedelta("10 days")._value == expected // 1000
+    assert Timedelta(days=10)._value == expected // 1000
+    assert Timedelta(days=10.0)._value == expected // 1000
+
+    expected += np.timedelta64(10, "s").astype("m8[ns]").view("i8")
+    assert Timedelta("10 days 00:00:10")._value == expected // 1000
+    assert Timedelta(days=10, seconds=10)._value == expected // 1000
+    assert Timedelta(days=10, milliseconds=10 * 1000)._value == expected // 1000
+    assert Timedelta(days=10, microseconds=10 * 1000 * 1000)._value == expected // 1000
+
+    # rounding cases
+    assert Timedelta(82739999850000)._value == 82739999850000
+    assert "0 days 22:58:59.999850" in str(Timedelta(82739999850000))
+    assert Timedelta(123072001000000)._value == 123072001000000
+    assert "1 days 10:11:12.001" in str(Timedelta(123072001000000))
+
+    # string conversion with/without leading zero
+    # GH#9570
+    assert Timedelta("0:00:00") == timedelta(hours=0)
+    assert Timedelta("00:00:00") == timedelta(hours=0)
+    assert Timedelta("-1:00:00") == -timedelta(hours=1)
+    assert Timedelta("-01:00:00") == -timedelta(hours=1)
+
+    # more strings & abbrevs
+    # GH#8190
+    assert Timedelta("1 h") == timedelta(hours=1)
+    assert Timedelta("1 hour") == timedelta(hours=1)
+    assert Timedelta("1 hr") == timedelta(hours=1)
+    assert Timedelta("1 hours") == timedelta(hours=1)
+    assert Timedelta("-1 hours") == -timedelta(hours=1)
+    assert Timedelta("1 m") == timedelta(minutes=1)
+    assert Timedelta("1.5 m") == timedelta(seconds=90)
+    assert Timedelta("1 minute") == timedelta(minutes=1)
+    assert Timedelta("1 minutes") == timedelta(minutes=1)
+    assert Timedelta("1 s") == timedelta(seconds=1)
+    assert Timedelta("1 second") == timedelta(seconds=1)
+    assert Timedelta("1 seconds") == timedelta(seconds=1)
+    assert Timedelta("1 ms") == timedelta(milliseconds=1)
+    assert Timedelta("1 milli") == timedelta(milliseconds=1)
+    assert Timedelta("1 millisecond") == timedelta(milliseconds=1)
+    assert Timedelta("1 us") == timedelta(microseconds=1)
+    assert Timedelta("1 µs") == timedelta(microseconds=1)
+    assert Timedelta("1 micros") == timedelta(microseconds=1)
+    assert Timedelta("1 microsecond") == timedelta(microseconds=1)
+    assert Timedelta("1.5 microsecond") == Timedelta("00:00:00.000001500")
+    assert Timedelta("1 ns") == Timedelta("00:00:00.000000001")
+    assert Timedelta("1 nano") == Timedelta("00:00:00.000000001")
+    assert Timedelta("1 nanosecond") == Timedelta("00:00:00.000000001")
+
+    # combos
+    assert Timedelta("10 days 1 hour") == timedelta(days=10, hours=1)
+    assert Timedelta("10 days 1 h") == timedelta(days=10, hours=1)
+    assert Timedelta("10 days 1 h 1m 1s") == timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s 3us") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1, microseconds=3
+    )
+    assert Timedelta("-10 days 1 h 1.5m 1s 3us") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=31, microseconds=3
+    )
+
+    # Currently invalid as it has a - on the hh:mm:dd part
+    # (only allowed on the days)
+    msg = "only leading negative signs are allowed"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("-10 days -1 h 1.5m 1s 3us")
+
+    # only leading neg signs are allowed
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("10 days -1 h 1.5m 1s 3us")
+
+    # no units specified
+    msg = "no units specified"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("3.1415")
+
+    # invalid construction
+    msg = "cannot construct a Timedelta"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta()
+
+    msg = "unit abbreviation w/o a number"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("foo")
+
+    msg = (
+        "cannot construct a Timedelta from the passed arguments, allowed keywords are "
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(day=10)
+
+    # floats
+    expected = np.timedelta64(10, "s").astype("m8[ns]").view("i8") + np.timedelta64(
+        500, "ms"
+    ).astype("m8[ns]").view("i8")
+    assert Timedelta(10.5, unit="s")._value == expected
+
+    # offset
+    assert to_timedelta(offsets.Hour(2)) == Timedelta(hours=2)
+    assert Timedelta(offsets.Hour(2)) == Timedelta(hours=2)
+    assert Timedelta(offsets.Second(2)) == Timedelta(seconds=2)
+
+    # GH#11995: unicode
+    expected = Timedelta("1h")
+    result = Timedelta("1h")
+    assert result == expected
+    assert to_timedelta(offsets.Hour(2)) == Timedelta("0 days, 02:00:00")
+
+    msg = "unit abbreviation w/o a number"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("foo bar")
+
+
+@pytest.mark.parametrize(
+    "item",
+    list(
+        {
+            "days": "D",
+            "seconds": "s",
+            "microseconds": "us",
+            "milliseconds": "ms",
+            "minutes": "m",
+            "hours": "h",
+            "weeks": "W",
+        }.items()
+    ),
+)
+@pytest.mark.parametrize(
+    "npdtype", [np.int64, np.int32, np.int16, np.float64, np.float32, np.float16]
+)
+def test_td_construction_with_np_dtypes(npdtype, item):
+    # GH#8757: test construction with np dtypes
+    pykwarg, npkwarg = item
+    expected = np.timedelta64(1, npkwarg).astype("m8[us]").view("i8")
+    assert Timedelta(**{pykwarg: npdtype(1)})._value == expected
+
+
+@pytest.mark.parametrize(
+    "val",
+    [
+        "1s",
+        "-1s",
+        "1us",
+        "-1us",
+        "1 day",
+        "-1 day",
+        "-23:59:59.999999",
+        "-1 days +23:59:59.999999",
+        "-1ns",
+        "1ns",
+        "-23:59:59.999999999",
+    ],
+)
+def test_td_from_repr_roundtrip(val):
+    # round-trip both for string and value
+    td = Timedelta(val)
+    assert Timedelta(td.value) == td
+
+    assert Timedelta(str(td)) == td
+    assert Timedelta(td._repr_base(format="all")) == td
+    assert Timedelta(td._repr_base()) == td
+
+
+def test_overflow_on_construction():
+    # GH#3374
+    value = Timedelta("1day").as_unit("ns")._value * 20169940
+    msg = "Cannot cast 1742682816000000000000 from ns to 'ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(value)
+
+    # xref GH#17637
+    # used to overflows before we changed output unit to "s"
+    td = Timedelta(7 * 19999, unit="D")
+    assert td.unit == "s"
+
+    # used to overflow before non-ns support
+    td = Timedelta(timedelta(days=13 * 19999))
+    assert td._creso == NpyDatetimeUnit.NPY_FR_us.value
+    assert td.days == 13 * 19999
+
+
+@pytest.mark.parametrize(
+    "val, unit",
+    [
+        (15251, "W"),  # 1
+        (106752, "D"),  # change from previous:
+        (2562048, "h"),  # 0 hours
+        (153722868, "m"),  # 13 minutes
+        (9223372037, "s"),  # 44 seconds
+    ],
+)
+def test_construction_out_of_bounds_td64ns(val, unit):
+    # TODO: parametrize over units just above/below the implementation bounds
+    #  once GH#38964 is resolved
+
+    # Timedelta.max is just under 106752 days
+    td64 = np.timedelta64(val, unit)
+    if is_numpy_dev or np_version_gt2_5:
+        # numpy now raises instead of silently overflowing
+        with pytest.raises(OverflowError, match="Overflow"):
+            td64.astype("m8[ns]")
+    else:
+        assert td64.astype("m8[ns]").view("i8") < 0  # i.e. naive astype will be wrong
+
+    td = Timedelta(td64)
+    if unit != "M":
+        # with unit="M" the conversion to "s" is poorly defined
+        #  (and numpy issues DeprecationWarning)
+        assert td.asm8 == td64
+    assert td.asm8.dtype == "m8[s]"
+    msg = r"Cannot cast 1067\d\d days .* to unit='ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        td.as_unit("ns")
+
+    # But just back in bounds and we are OK
+    one = np.timedelta64(1, unit)
+    assert Timedelta(td64 - one) == td64 - one
+
+    td64 = np.timedelta64(-val, unit)
+    if is_numpy_dev or np_version_gt2_5:
+        with pytest.raises(OverflowError, match="Overflow"):
+            td64.astype("m8[ns]")
+    else:
+        assert td64.astype("m8[ns]").view("i8") > 0  # i.e. naive astype will be wrong
+
+    td2 = Timedelta(td64)
+    msg = r"Cannot cast -1067\d\d days .* to unit='ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        td2.as_unit("ns")
+
+    # But just back in bounds and we are OK
+    assert Timedelta(td64 + one) == td64 + one
+
+
+@pytest.mark.parametrize(
+    "val, unit",
+    [
+        (15251 * 10**9, "W"),
+        (106752 * 10**9, "D"),
+        (2562048 * 10**9, "h"),
+        (153722868 * 10**9, "m"),
+    ],
+)
+def test_construction_out_of_bounds_td64s(val, unit):
+    td64 = np.timedelta64(val, unit)
+    with pytest.raises(OutOfBoundsTimedelta, match=str(td64)):
+        Timedelta(td64)
+
+    # But just back in bounds and we are OK
+    offset = np.timedelta64(10**9, unit)
+    assert Timedelta(td64 - offset) == td64 - offset
+
+
+@pytest.mark.parametrize(
+    "fmt,exp",
+    [
+        (
+            "P6DT0H50M3.010010012S",
+            Timedelta(
+                days=6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+        ),
+        (
+            "P-6DT0H50M3.010010012S",
+            Timedelta(
+                days=-6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+        ),
+        ("P4DT12H30M5S", Timedelta(days=4, hours=12, minutes=30, seconds=5)),
+        ("P0DT0H0M0.000000123S", Timedelta(nanoseconds=123)),
+        ("P0DT0H0M0.00001S", Timedelta(microseconds=10)),
+        ("P0DT0H0M0.001S", Timedelta(milliseconds=1)),
+        ("P0DT0H1M0S", Timedelta(minutes=1)),
+        ("P1DT25H61M61S", Timedelta(days=1, hours=25, minutes=61, seconds=61)),
+        ("PT1S", Timedelta(seconds=1)),
+        ("PT0S", Timedelta(seconds=0)),
+        ("P1WT0S", Timedelta(days=7, seconds=0)),
+        ("P1D", Timedelta(days=1)),
+        ("P1DT1H", Timedelta(days=1, hours=1)),
+        ("P1W", Timedelta(days=7)),
+        ("PT300S", Timedelta(seconds=300)),
+        ("P1DT0H0M00000000000S", Timedelta(days=1)),
+        ("PT-6H3M", Timedelta(hours=-6, minutes=3)),
+        ("-PT6H3M", Timedelta(hours=-6, minutes=-3)),
+        ("-PT-6H+3M", Timedelta(hours=6, minutes=-3)),
+    ],
+)
+def test_iso_constructor(fmt, exp):
+    assert Timedelta(fmt) == exp
+
+
+@pytest.mark.parametrize(
+    "fmt",
+    [
+        "PPPPPPPPPPPP",
+        "PDTHMS",
+        "P0DT999H999M999S",
+        "P1DT0H0M0.0000000000000S",
+        "P1DT0H0M0.S",
+        "P",
+        "-P",
+    ],
+)
+def test_iso_constructor_raises(fmt):
+    msg = f"Invalid ISO 8601 Duration format - {fmt}"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(fmt)
+
+
+@pytest.mark.parametrize(
+    "constructed_td, conversion",
+    [
+        (Timedelta(nanoseconds=100), "100ns"),
+        (
+            Timedelta(
+                days=1,
+                hours=1,
+                minutes=1,
+                weeks=1,
+                seconds=1,
+                milliseconds=1,
+                microseconds=1,
+                nanoseconds=1,
+            ),
+            694861001001001,
+        ),
+        (Timedelta(microseconds=1) + Timedelta(nanoseconds=1), "1us1ns"),
+        (Timedelta(microseconds=1) - Timedelta(nanoseconds=1), "999ns"),
+        (Timedelta(microseconds=1) + 5 * Timedelta(nanoseconds=-2), "990ns"),
+    ],
+)
+def test_td_constructor_on_nanoseconds(constructed_td, conversion):
+    # GH#9273
+    assert constructed_td == Timedelta(conversion)
+
+
+def test_td_constructor_value_error():
+    msg = "Invalid type <class 'str'>. Must be int or float."
+    with pytest.raises(TypeError, match=msg):
+        Timedelta(nanoseconds="abc")
+
+
+def test_timedelta_constructor_identity():
+    # Test for #30543
+    expected = Timedelta(np.timedelta64(1, "s"))
+    result = Timedelta(expected)
+    assert result is expected
+
+
+def test_timedelta_pass_td_and_kwargs_raises():
+    # don't silently ignore the kwargs GH#48898
+    td = Timedelta(days=1)
+    msg = (
+        "Cannot pass both a Timedelta input and timedelta keyword arguments, "
+        r"got \['days'\]"
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(td, days=2)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:The 'unit' keyword is only used when the Timedelta input:UserWarning"
+)
+@pytest.mark.parametrize(
+    "constructor, value, unit",
+    [
+        (Timedelta, "10s", "ms"),
+        (to_timedelta, "10s", "ms"),
+        (to_timedelta, ["1", 2, 3], "s"),
+    ],
+)
+def test_string_with_unit(constructor, value, unit):
+    with pytest.raises(ValueError, match="unit must not be specified"):
+        constructor(value, unit=unit)
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "".join(elements)
+        for repetition in (1, 2)
+        for elements in product("+-, ", repeat=repetition)
+    ],
+)
+def test_string_without_numbers(value):
+    # GH39710 Timedelta input string with only symbols and no digits raises an error
+    msg = (
+        "symbols w/o a number"
+        if value != "--"
+        else "only leading negative signs are allowed"
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(value)
+
+
+def test_timedelta_new_npnat():
+    # GH#48898
+    nat = np.timedelta64("NaT", "h")
+    assert Timedelta(nat) is NaT
+
+
+def test_subclass_respected():
+    # GH#49579
+    class MyCustomTimedelta(Timedelta):
+        pass
+
+    td = MyCustomTimedelta("1 minute")
+    assert isinstance(td, MyCustomTimedelta)
+
+
+def test_non_nano_value():
+    # https://github.com/pandas-dev/pandas/issues/49076
+    result = Timedelta(10, unit="D").as_unit("s").value
+    # `.value` shows nanoseconds, even though unit is 's'
+    assert result == 864000000000000
+
+    # out-of-nanoseconds-bounds `.value` raises informative message
+    msg = (
+        r"Cannot convert Timedelta to nanoseconds without overflow. "
+        r"Use `.asm8.view\('i8'\)` to cast represent Timedelta in its "
+        r"own unit \(here, s\).$"
+    )
+    td = Timedelta(1_000, "D").as_unit("s") * 1_000
+    with pytest.raises(OverflowError, match=msg):
+        td.value
+    # check that the suggested workaround actually works
+    result = td.asm8.view("i8")
+    assert result == 86400000000
+
+
+def test_parsed_unit():
+    td = Timedelta("1 Day")
+    assert td.unit == "us"
+
+    td = Timedelta("1 Day 2 hours 3 minutes 4 ns")
+    assert td.unit == "ns"
+
+    td = Timedelta("1 Day 2:03:04.012345")
+    assert td.unit == "us"
+
+    td = Timedelta("1 Day 2:03:04.012345000")
+    assert td.unit == "ns"
+
+    # 7 digits after the decimal
+    td = Timedelta("1 Day 2:03:04.0123450")
+    assert td.unit == "ns"

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/test_formats.py

@@ -0,0 +1,109 @@
+import pytest
+
+from pandas import Timedelta
+
+
+@pytest.mark.parametrize(
+    "td, expected_repr",
+    [
+        (Timedelta(10, unit="D"), "Timedelta('10 days 00:00:00')"),
+        (Timedelta(10, unit="s"), "Timedelta('0 days 00:00:10')"),
+        (Timedelta(10, unit="ms"), "Timedelta('0 days 00:00:00.010000')"),
+        (Timedelta(-10, unit="ms"), "Timedelta('-1 days +23:59:59.990000')"),
+    ],
+)
+def test_repr(td, expected_repr):
+    assert repr(td) == expected_repr
+
+
+@pytest.mark.parametrize(
+    "td, expected_iso",
+    [
+        (
+            Timedelta(
+                days=6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+            "P6DT0H50M3.010010012S",
+        ),
+        (Timedelta(days=4, hours=12, minutes=30, seconds=5), "P4DT12H30M5S"),
+        (Timedelta(nanoseconds=123), "P0DT0H0M0.000000123S"),
+        # trim nano
+        (Timedelta(microseconds=10), "P0DT0H0M0.00001S"),
+        # trim micro
+        (Timedelta(milliseconds=1), "P0DT0H0M0.001S"),
+        # don't strip every 0
+        (Timedelta(minutes=1), "P0DT0H1M0S"),
+    ],
+)
+def test_isoformat(td, expected_iso):
+    assert td.isoformat() == expected_iso
+
+
+class TestReprBase:
+    def test_none(self):
+        delta_1d = Timedelta(1, unit="D")
+        delta_0d = Timedelta(0, unit="D")
+        delta_1s = Timedelta(1, unit="s")
+        delta_500ms = Timedelta(500, unit="ms")
+
+        drepr = lambda x: x._repr_base()
+        assert drepr(delta_1d) == "1 days"
+        assert drepr(-delta_1d) == "-1 days"
+        assert drepr(delta_0d) == "0 days"
+        assert drepr(delta_1s) == "0 days 00:00:01"
+        assert drepr(delta_500ms) == "0 days 00:00:00.500000"
+        assert drepr(delta_1d + delta_1s) == "1 days 00:00:01"
+        assert drepr(-delta_1d + delta_1s) == "-1 days +00:00:01"
+        assert drepr(delta_1d + delta_500ms) == "1 days 00:00:00.500000"
+        assert drepr(-delta_1d + delta_500ms) == "-1 days +00:00:00.500000"
+
+    def test_sub_day(self):
+        delta_1d = Timedelta(1, unit="D")
+        delta_0d = Timedelta(0, unit="D")
+        delta_1s = Timedelta(1, unit="s")
+        delta_500ms = Timedelta(500, unit="ms")
+
+        drepr = lambda x: x._repr_base(format="sub_day")
+        assert drepr(delta_1d) == "1 days"
+        assert drepr(-delta_1d) == "-1 days"
+        assert drepr(delta_0d) == "00:00:00"
+        assert drepr(delta_1s) == "00:00:01"
+        assert drepr(delta_500ms) == "00:00:00.500000"
+        assert drepr(delta_1d + delta_1s) == "1 days 00:00:01"
+        assert drepr(-delta_1d + delta_1s) == "-1 days +00:00:01"
+        assert drepr(delta_1d + delta_500ms) == "1 days 00:00:00.500000"
+        assert drepr(-delta_1d + delta_500ms) == "-1 days +00:00:00.500000"
+
+    def test_long(self):
+        delta_1d = Timedelta(1, unit="D")
+        delta_0d = Timedelta(0, unit="D")
+        delta_1s = Timedelta(1, unit="s")
+        delta_500ms = Timedelta(500, unit="ms")
+
+        drepr = lambda x: x._repr_base(format="long")
+        assert drepr(delta_1d) == "1 days 00:00:00"
+        assert drepr(-delta_1d) == "-1 days +00:00:00"
+        assert drepr(delta_0d) == "0 days 00:00:00"
+        assert drepr(delta_1s) == "0 days 00:00:01"
+        assert drepr(delta_500ms) == "0 days 00:00:00.500000"
+        assert drepr(delta_1d + delta_1s) == "1 days 00:00:01"
+        assert drepr(-delta_1d + delta_1s) == "-1 days +00:00:01"
+        assert drepr(delta_1d + delta_500ms) == "1 days 00:00:00.500000"
+        assert drepr(-delta_1d + delta_500ms) == "-1 days +00:00:00.500000"
+
+    def test_all(self):
+        delta_1d = Timedelta(1, unit="D")
+        delta_0d = Timedelta(0, unit="D")
+        delta_1ns = Timedelta(1, unit="ns")
+
+        drepr = lambda x: x._repr_base(format="all")
+        assert drepr(delta_1d) == "1 days 00:00:00.000000000"
+        assert drepr(-delta_1d) == "-1 days +00:00:00.000000000"
+        assert drepr(delta_0d) == "0 days 00:00:00.000000000"
+        assert drepr(delta_1ns) == "0 days 00:00:00.000000001"
+        assert drepr(-delta_1d + delta_1ns) == "-1 days +00:00:00.000000001"

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timedelta/test_timedelta.py

@@ -0,0 +1,740 @@
+"""test the scalar Timedelta"""
+
+from datetime import timedelta
+import sys
+
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+from pandas._libs.missing import NA
+from pandas._libs.tslibs import (
+    NaT,
+    iNaT,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import (
+    OutOfBoundsTimedelta,
+    Pandas4Warning,
+)
+
+from pandas import (
+    Timedelta,
+    to_timedelta,
+)
+import pandas._testing as tm
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def unit_str(self, request):
+        return request.param
+
+    @pytest.fixture
+    def unit(self, unit_str):
+        # 7, 8, 9 correspond to second, millisecond, and microsecond, respectively
+        attr = f"NPY_FR_{unit_str}"
+        return getattr(NpyDatetimeUnit, attr).value
+
+    @pytest.fixture
+    def val(self, unit):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        if unit == NpyDatetimeUnit.NPY_FR_us.value:
+            value = us
+        elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+            value = us // 1000
+        else:
+            value = us // 1_000_000
+        return value
+
+    @pytest.fixture
+    def td(self, unit, val):
+        return Timedelta._from_value_and_reso(val, unit)
+
+    def test_from_value_and_reso(self, unit, val):
+        # Just checking that the fixture is giving us what we asked for
+        td = Timedelta._from_value_and_reso(val, unit)
+        assert td._value == val
+        assert td._creso == unit
+        assert td.days == 106752
+
+    def test_unary_non_nano(self, td, unit):
+        assert abs(td)._creso == unit
+        assert (-td)._creso == unit
+        assert (+td)._creso == unit
+
+    def test_sub_preserves_reso(self, td, unit):
+        res = td - td
+        expected = Timedelta._from_value_and_reso(0, unit)
+        assert res == expected
+        assert res._creso == unit
+
+    def test_mul_preserves_reso(self, td, unit):
+        # The td fixture should always be far from the implementation
+        #  bound, so doubling does not risk overflow.
+        res = td * 2
+        assert res._value == td._value * 2
+        assert res._creso == unit
+
+    def test_cmp_cross_reso(self, td):
+        # numpy gets this wrong because of silent overflow
+        other = Timedelta(days=106751)
+        assert other < td
+        assert td > other
+        assert not other == td
+        assert td != other
+
+    def test_to_pytimedelta(self, td):
+        res = td.to_pytimedelta()
+        expected = timedelta(days=106752)
+        assert type(res) is timedelta
+        assert res == expected
+
+    def test_to_timedelta64(self, td, unit):
+        for res in [td.to_timedelta64(), td.to_numpy(), td.asm8]:
+            assert isinstance(res, np.timedelta64)
+            assert res.view("i8") == td._value
+            if unit == NpyDatetimeUnit.NPY_FR_s.value:
+                assert res.dtype == "m8[s]"
+            elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+                assert res.dtype == "m8[ms]"
+            elif unit == NpyDatetimeUnit.NPY_FR_us.value:
+                assert res.dtype == "m8[us]"
+
+    def test_truediv_timedeltalike(self, td):
+        assert td / td == 1
+        assert (2.5 * td) / td == 2.5
+
+        other = Timedelta(td._value)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow."
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td / other
+
+        # Timedelta(other.to_pytimedelta()) has microsecond resolution,
+        #  so the division doesn't require casting all the way to nanos,
+        #  so succeeds
+        res = other.to_pytimedelta() / td
+        expected = other.to_pytimedelta() / td.to_pytimedelta()
+        assert res == expected
+
+        # if there's no overflow, we cast to the higher reso
+        left = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_us.value)
+        right = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_ms.value)
+        result = left / right
+        assert result == 0.001
+
+        result = right / left
+        assert result == 1000
+
+    def test_truediv_numeric(self, td):
+        assert td / np.nan is NaT
+
+        res = td / 2
+        assert res._value == td._value / 2
+        assert res._creso == td._creso
+
+        res = td / 2.0
+        assert res._value == td._value / 2
+        assert res._creso == td._creso
+
+    def test_truediv_na_type_not_supported(self, td):
+        msg_td_floordiv_na = (
+            r"unsupported operand type\(s\) for /: 'Timedelta' and 'NAType'"
+        )
+        with pytest.raises(TypeError, match=msg_td_floordiv_na):
+            td / NA
+
+        msg_na_floordiv_td = (
+            r"unsupported operand type\(s\) for /: 'NAType' and 'Timedelta'"
+        )
+        with pytest.raises(TypeError, match=msg_na_floordiv_td):
+            NA / td
+
+    def test_floordiv_timedeltalike(self, td):
+        assert td // td == 1
+        assert (2.5 * td) // td == 2
+
+        other = Timedelta(td._value)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td // other
+
+        # Timedelta(other.to_pytimedelta()) has microsecond resolution,
+        #  so the floordiv doesn't require casting all the way to nanos,
+        #  so succeeds
+        res = other.to_pytimedelta() // td
+        assert res == 0
+
+        # if there's no overflow, we cast to the higher reso
+        left = Timedelta._from_value_and_reso(50050, NpyDatetimeUnit.NPY_FR_us.value)
+        right = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_ms.value)
+        result = left // right
+        assert result == 1
+        result = right // left
+        assert result == 0
+
+    def test_floordiv_numeric(self, td):
+        assert td // np.nan is NaT
+
+        res = td // 2
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        res = td // 2.0
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        assert td // np.array(np.nan) is NaT
+
+        res = td // np.array(2)
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        res = td // np.array(2.0)
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+    def test_floordiv_na_type_not_supported(self, td):
+        msg_td_floordiv_na = (
+            r"unsupported operand type\(s\) for //: 'Timedelta' and 'NAType'"
+        )
+        with pytest.raises(TypeError, match=msg_td_floordiv_na):
+            td // NA
+
+        msg_na_floordiv_td = (
+            r"unsupported operand type\(s\) for //: 'NAType' and 'Timedelta'"
+        )
+        with pytest.raises(TypeError, match=msg_na_floordiv_td):
+            NA // td
+
+    def test_addsub_mismatched_reso(self, td):
+        # need to cast to since td is out of bounds for ns, so
+        #  so we would raise OverflowError without casting
+        other = Timedelta(days=1).as_unit("us")
+
+        # td is out of bounds for ns
+        result = td + other
+        assert result._creso == other._creso
+        assert result.days == td.days + 1
+
+        result = other + td
+        assert result._creso == other._creso
+        assert result.days == td.days + 1
+
+        result = td - other
+        assert result._creso == other._creso
+        assert result.days == td.days - 1
+
+        result = other - td
+        assert result._creso == other._creso
+        assert result.days == 1 - td.days
+
+        other2 = Timedelta(500)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td + other2
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            other2 + td
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td - other2
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            other2 - td
+
+    def test_min(self, td):
+        assert td.min <= td
+        assert td.min._creso == td._creso
+        assert td.min._value == NaT._value + 1
+
+    def test_max(self, td):
+        assert td.max >= td
+        assert td.max._creso == td._creso
+        assert td.max._value == np.iinfo(np.int64).max
+
+    def test_resolution(self, td):
+        expected = Timedelta._from_value_and_reso(1, td._creso)
+        result = td.resolution
+        assert result == expected
+        assert result._creso == expected._creso
+
+    def test_hash(self) -> None:
+        # GH#54037
+        second_resolution_max = Timedelta(0).as_unit("s").max
+
+        assert hash(second_resolution_max)
+
+
+def test_timedelta_class_min_max_resolution():
+    # when accessed on the class (as opposed to an instance), we default
+    #  to nanoseconds
+    assert Timedelta.min == Timedelta(NaT._value + 1)
+    assert Timedelta.min._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.max == Timedelta(np.iinfo(np.int64).max)
+    assert Timedelta.max._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.resolution == Timedelta(1)
+    assert Timedelta.resolution._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+
+class TestTimedeltaUnaryOps:
+    def test_invert(self):
+        td = Timedelta(10, unit="D")
+
+        msg = "bad operand type for unary ~"
+        with pytest.raises(TypeError, match=msg):
+            ~td
+
+        # check this matches pytimedelta and timedelta64
+        with pytest.raises(TypeError, match=msg):
+            ~(td.to_pytimedelta())
+
+        umsg = "ufunc 'invert' not supported for the input types"
+        with pytest.raises(TypeError, match=umsg):
+            ~(td.to_timedelta64())
+
+    def test_unary_ops(self):
+        td = Timedelta(10, unit="D")
+
+        # __neg__, __pos__
+        assert -td == Timedelta(-10, unit="D")
+        assert -td == Timedelta("-10D")
+        assert +td == Timedelta(10, unit="D")
+
+        # __abs__, __abs__(__neg__)
+        assert abs(td) == td
+        assert abs(-td) == td
+        assert abs(-td) == Timedelta("10D")
+
+
+class TestTimedeltas:
+    @pytest.mark.parametrize(
+        "unit, value, expected",
+        [
+            ("us", 9.999, 9999),
+            ("ms", 9.999999, 9999999),
+            ("s", 9.999999999, 9999999999),
+        ],
+    )
+    def test_rounding_on_int_unit_construction(self, unit, value, expected):
+        # GH 12690
+        result = Timedelta(value, unit=unit)
+        assert result._value == expected
+        result = Timedelta(str(value) + unit)
+        assert result._value == expected
+
+    def test_total_seconds_scalar(self):
+        # see gh-10939
+        rng = Timedelta("1 days, 10:11:12.100123456")
+        expt = 1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456.0 / 1e9
+        tm.assert_almost_equal(rng.total_seconds(), expt)
+
+        rng = Timedelta(np.nan)
+        assert np.isnan(rng.total_seconds())
+
+    def test_conversion(self):
+        for td in [Timedelta(10, unit="D"), Timedelta("1 days, 10:11:12.012345")]:
+            td = td.as_unit("ns")
+            pydt = td.to_pytimedelta()
+            assert td == Timedelta(pydt)
+            assert td == pydt
+            assert isinstance(pydt, timedelta) and not isinstance(pydt, Timedelta)
+
+            assert td == np.timedelta64(td._value, "ns")
+            td64 = td.to_timedelta64()
+
+            assert td64 == np.timedelta64(td._value, "ns")
+            assert td == td64
+
+            assert isinstance(td64, np.timedelta64)
+
+        # this is NOT equal and cannot be roundtripped (because of the nanos)
+        td = Timedelta("1 days, 10:11:12.012345678")
+        assert td != td.to_pytimedelta()
+
+    def test_fields(self):
+        def check(value):
+            # that we are int
+            assert isinstance(value, int)
+
+        # compat to datetime.timedelta
+        rng = to_timedelta("1 days, 10:11:12")
+        assert rng.days == 1
+        assert rng.seconds == 10 * 3600 + 11 * 60 + 12
+        assert rng.microseconds == 0
+        assert rng.nanoseconds == 0
+
+        msg = "'Timedelta' object has no attribute '{}'"
+        with pytest.raises(AttributeError, match=msg.format("hours")):
+            rng.hours
+        with pytest.raises(AttributeError, match=msg.format("minutes")):
+            rng.minutes
+        with pytest.raises(AttributeError, match=msg.format("milliseconds")):
+            rng.milliseconds
+
+        # GH 10050
+        check(rng.days)
+        check(rng.seconds)
+        check(rng.microseconds)
+        check(rng.nanoseconds)
+
+        td = Timedelta("-1 days, 10:11:12")
+        assert abs(td) == Timedelta("13:48:48")
+        assert str(td) == "-1 days +10:11:12"
+        assert -td == Timedelta("0 days 13:48:48")
+        assert -Timedelta("-1 days, 10:11:12")._value == 49728000000
+        assert Timedelta("-1 days, 10:11:12")._value == -49728000000
+
+        rng = to_timedelta("-1 days, 10:11:12.100123456")
+        assert rng.days == -1
+        assert rng.seconds == 10 * 3600 + 11 * 60 + 12
+        assert rng.microseconds == 100 * 1000 + 123
+        assert rng.nanoseconds == 456
+        msg = "'Timedelta' object has no attribute '{}'"
+        with pytest.raises(AttributeError, match=msg.format("hours")):
+            rng.hours
+        with pytest.raises(AttributeError, match=msg.format("minutes")):
+            rng.minutes
+        with pytest.raises(AttributeError, match=msg.format("milliseconds")):
+            rng.milliseconds
+
+        # components
+        tup = to_timedelta(-1, "us").components
+        assert tup.days == -1
+        assert tup.hours == 23
+        assert tup.minutes == 59
+        assert tup.seconds == 59
+        assert tup.milliseconds == 999
+        assert tup.microseconds == 999
+        assert tup.nanoseconds == 0
+
+        # GH 10050
+        check(tup.days)
+        check(tup.hours)
+        check(tup.minutes)
+        check(tup.seconds)
+        check(tup.milliseconds)
+        check(tup.microseconds)
+        check(tup.nanoseconds)
+
+        tup = Timedelta("-1 days 1 us").components
+        assert tup.days == -2
+        assert tup.hours == 23
+        assert tup.minutes == 59
+        assert tup.seconds == 59
+        assert tup.milliseconds == 999
+        assert tup.microseconds == 999
+        assert tup.nanoseconds == 0
+
+    # TODO: this is a test of to_timedelta string parsing
+    def test_iso_conversion(self):
+        # GH #21877
+        expected = Timedelta(1, unit="s")
+        assert to_timedelta("P0DT0H0M1S") == expected
+
+    # TODO: this is a test of to_timedelta returning NaT
+    def test_nat_converters(self):
+        result = to_timedelta("nat").to_numpy()
+        assert result.dtype.kind == "M"
+        assert result.astype("int64") == iNaT
+
+        result = to_timedelta("nan").to_numpy()
+        assert result.dtype.kind == "M"
+        assert result.astype("int64") == iNaT
+
+    def test_numeric_conversions(self):
+        assert Timedelta(0) == np.timedelta64(0, "ns")
+        assert Timedelta(10) == np.timedelta64(10, "ns")
+        assert Timedelta(10, unit="ns") == np.timedelta64(10, "ns")
+
+        assert Timedelta(10, unit="us") == np.timedelta64(10, "us")
+        assert Timedelta(10, unit="ms") == np.timedelta64(10, "ms")
+        assert Timedelta(10, unit="s") == np.timedelta64(10, "s")
+        assert Timedelta(10, unit="D") == np.timedelta64(10, "D")
+
+    def test_timedelta_conversions(self):
+        assert Timedelta(timedelta(seconds=1)) == np.timedelta64(1, "s").astype(
+            "m8[ns]"
+        )
+        assert Timedelta(timedelta(microseconds=1)) == np.timedelta64(1, "us").astype(
+            "m8[ns]"
+        )
+        assert Timedelta(timedelta(days=1)) == np.timedelta64(1, "D").astype("m8[ns]")
+
+    def test_to_numpy_alias(self):
+        # GH 24653: alias .to_numpy() for scalars
+        td = Timedelta("10m7s")
+        assert td.to_timedelta64() == td.to_numpy()
+
+        # GH#44460
+        msg = "dtype and copy arguments are ignored"
+        with pytest.raises(ValueError, match=msg):
+            td.to_numpy("m8[s]")
+        with pytest.raises(ValueError, match=msg):
+            td.to_numpy(copy=True)
+
+    def test_identity(self):
+        td = Timedelta(10, unit="D")
+        assert isinstance(td, Timedelta)
+        assert isinstance(td, timedelta)
+
+    def test_short_format_converters(self):
+        def conv(v):
+            return v.astype("m8[ns]")
+
+        assert Timedelta("10") == np.timedelta64(10, "ns")
+        assert Timedelta("10ns") == np.timedelta64(10, "ns")
+        assert Timedelta("100") == np.timedelta64(100, "ns")
+        assert Timedelta("100ns") == np.timedelta64(100, "ns")
+
+        assert Timedelta("1000") == np.timedelta64(1000, "ns")
+        assert Timedelta("1000ns") == np.timedelta64(1000, "ns")
+
+        msg = "'NS' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            assert Timedelta("1000NS") == np.timedelta64(1000, "ns")
+
+        assert Timedelta("10us") == np.timedelta64(10000, "ns")
+        assert Timedelta("100us") == np.timedelta64(100000, "ns")
+        assert Timedelta("1000us") == np.timedelta64(1000000, "ns")
+        assert Timedelta("1000Us") == np.timedelta64(1000000, "ns")
+        assert Timedelta("1000uS") == np.timedelta64(1000000, "ns")
+
+        assert Timedelta("1ms") == np.timedelta64(1000000, "ns")
+        assert Timedelta("10ms") == np.timedelta64(10000000, "ns")
+        assert Timedelta("100ms") == np.timedelta64(100000000, "ns")
+        assert Timedelta("1000ms") == np.timedelta64(1000000000, "ns")
+
+        assert Timedelta("-1s") == -np.timedelta64(1000000000, "ns")
+        assert Timedelta("1s") == np.timedelta64(1000000000, "ns")
+        assert Timedelta("10s") == np.timedelta64(10000000000, "ns")
+        assert Timedelta("100s") == np.timedelta64(100000000000, "ns")
+        assert Timedelta("1000s") == np.timedelta64(1000000000000, "ns")
+
+        msg = "'d' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            assert Timedelta("1d") == conv(np.timedelta64(1, "D"))
+        assert Timedelta("-1D") == -conv(np.timedelta64(1, "D"))
+        assert Timedelta("1D") == conv(np.timedelta64(1, "D"))
+        assert Timedelta("10D") == conv(np.timedelta64(10, "D"))
+        assert Timedelta("100D") == conv(np.timedelta64(100, "D"))
+        assert Timedelta("1000D") == conv(np.timedelta64(1000, "D"))
+        assert Timedelta("10000D") == conv(np.timedelta64(10000, "D"))
+
+        # space
+        assert Timedelta(" 10000D ") == conv(np.timedelta64(10000, "D"))
+        assert Timedelta(" - 10000D ") == -conv(np.timedelta64(10000, "D"))
+
+        # invalid
+        msg = "invalid unit abbreviation"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("1foo")
+        msg = "unit abbreviation w/o a number"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("foo")
+
+    def test_full_format_converters(self):
+        def conv(v):
+            return v.astype("m8[ns]")
+
+        d1 = np.timedelta64(1, "D")
+
+        assert Timedelta("1days") == conv(d1)
+        assert Timedelta("1days,") == conv(d1)
+        assert Timedelta("- 1days,") == -conv(d1)
+
+        assert Timedelta("00:00:01") == conv(np.timedelta64(1, "s"))
+        assert Timedelta("06:00:01") == conv(np.timedelta64(6 * 3600 + 1, "s"))
+        assert Timedelta("06:00:01.0") == conv(np.timedelta64(6 * 3600 + 1, "s"))
+        assert Timedelta("06:00:01.01") == conv(
+            np.timedelta64(1000 * (6 * 3600 + 1) + 10, "ms")
+        )
+
+        assert Timedelta("- 1days, 00:00:01") == conv(-d1 + np.timedelta64(1, "s"))
+        assert Timedelta("1days, 06:00:01") == conv(
+            d1 + np.timedelta64(6 * 3600 + 1, "s")
+        )
+        assert Timedelta("1days, 06:00:01.01") == conv(
+            d1 + np.timedelta64(1000 * (6 * 3600 + 1) + 10, "ms")
+        )
+
+        # invalid
+        msg = "have leftover units"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("- 1days, 00")
+
+    def test_pickle(self, temp_file):
+        v = Timedelta("1 days 10:11:12.0123456")
+        v_p = tm.round_trip_pickle(v, temp_file)
+        assert v == v_p
+
+    def test_timedelta_hash_equality(self):
+        # GH 11129
+        v = Timedelta(1, "D")
+        td = timedelta(days=1)
+        assert hash(v) == hash(td)
+
+        d = {td: 2}
+        assert d[v] == 2
+
+        tds = [Timedelta(seconds=1) + Timedelta(days=n) for n in range(20)]
+        assert all(hash(td) == hash(td.to_pytimedelta()) for td in tds)
+
+        # python timedeltas drop ns resolution
+        ns_td = Timedelta(1, "ns")
+        assert hash(ns_td) != hash(ns_td.to_pytimedelta())
+
+    @pytest.mark.slow
+    @pytest.mark.xfail(
+        reason="pd.Timedelta violates the Python hash invariant (GH#44504).",
+    )
+    @given(
+        st.integers(
+            min_value=(-sys.maxsize - 1) // 500,
+            max_value=sys.maxsize // 500,
+        )
+    )
+    def test_hash_equality_invariance(self, half_microseconds: int) -> None:
+        # GH#44504
+
+        nanoseconds = half_microseconds * 500
+
+        pandas_timedelta = Timedelta(nanoseconds)
+        numpy_timedelta = np.timedelta64(nanoseconds)
+
+        # See: https://docs.python.org/3/glossary.html#term-hashable
+        # Hashable objects which compare equal must have the same hash value.
+        assert pandas_timedelta != numpy_timedelta or hash(pandas_timedelta) == hash(
+            numpy_timedelta
+        )
+
+    def test_implementation_limits(self):
+        min_td = Timedelta(Timedelta.min)
+        max_td = Timedelta(Timedelta.max)
+
+        # GH 12727
+        # timedelta limits correspond to int64 boundaries
+        assert min_td._value == iNaT + 1
+        assert max_td._value == lib.i8max
+
+        # Beyond lower limit, a NAT before the Overflow
+        assert (min_td - Timedelta(1, "ns")) is NaT
+
+        msg = "int too (large|big) to convert"
+        with pytest.raises(OverflowError, match=msg):
+            min_td - Timedelta(2, "ns")
+
+        with pytest.raises(OverflowError, match=msg):
+            max_td + Timedelta(1, "ns")
+
+        # Same tests using the internal nanosecond values
+        td = Timedelta(min_td._value - 1, "ns")
+        assert td is NaT
+
+        msg = "Cannot cast -9223372036854775809 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta(min_td._value - 2, "ns")
+
+        msg = "Cannot cast 9223372036854775808 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta(max_td._value + 1, "ns")
+
+    def test_total_seconds_precision(self):
+        # GH 19458
+        assert Timedelta("30s").total_seconds() == 30.0
+        assert Timedelta("0").total_seconds() == 0.0
+        assert Timedelta("-2s").total_seconds() == -2.0
+        assert Timedelta("5.324s").total_seconds() == 5.324
+        assert (Timedelta("30s").total_seconds() - 30.0) < 1e-20
+        assert (30.0 - Timedelta("30s").total_seconds()) < 1e-20
+
+    def test_resolution_string(self):
+        assert Timedelta(days=1).resolution_string == "D"
+        assert Timedelta(days=1, hours=6).resolution_string == "h"
+        assert Timedelta(days=1, minutes=6).resolution_string == "min"
+        assert Timedelta(days=1, seconds=6).resolution_string == "s"
+        assert Timedelta(days=1, milliseconds=6).resolution_string == "ms"
+        assert Timedelta(days=1, microseconds=6).resolution_string == "us"
+        assert Timedelta(days=1, nanoseconds=6).resolution_string == "ns"
+
+    def test_resolution_deprecated(self):
+        # GH#21344
+        td = Timedelta(days=4, hours=3)
+        result = td.resolution
+        assert result == Timedelta(microseconds=1)
+
+        # Check that the attribute is available on the class, mirroring
+        #  the stdlib timedelta behavior
+        result = Timedelta.resolution
+        assert result == Timedelta(nanoseconds=1)
+
+    @pytest.mark.parametrize(
+        "unit,unit_depr",
+        [
+            ("W", "w"),
+            ("D", "d"),
+            ("min", "MIN"),
+            ("s", "S"),
+            ("h", "H"),
+            ("ms", "MS"),
+            ("us", "US"),
+        ],
+    )
+    def test_unit_deprecated(self, unit, unit_depr):
+        # GH#59051
+        msg = f"'{unit_depr}' is deprecated and will be removed in a future version."
+
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            result = Timedelta(1, unit_depr)
+        assert result == Timedelta(1, unit)
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        (Timedelta("10s"), True),
+        (Timedelta("-10s"), True),
+        (Timedelta(10, unit="ns"), True),
+        (Timedelta(0, unit="ns"), False),
+        (Timedelta(-10, unit="ns"), True),
+        (Timedelta(None), True),
+        (NaT, True),
+    ],
+)
+def test_truthiness(value, expected):
+    # https://github.com/pandas-dev/pandas/issues/21484
+    assert bool(value) is expected
+
+
+def test_timedelta_attribute_precision():
+    # GH 31354
+    td = Timedelta(1552211999999999872, unit="ns")
+    result = td.days * 86400
+    result += td.seconds
+    result *= 1000000
+    result += td.microseconds
+    result *= 1000
+    result += td.nanoseconds
+    expected = td._value
+    assert result == expected
+
+
+def test_to_pytimedelta_large_values():
+    td = Timedelta(1152921504609987375, unit="ns")
+    result = td.to_pytimedelta()
+    expected = timedelta(days=13343, seconds=86304, microseconds=609987)
+    assert result == expected
+
+
+def test_timedelta_week_suffix():
+    # GH#12691 ensure 'W' suffix works as a string passed to Timedelta
+    expected = Timedelta("7 days")
+    result = Timedelta(1, unit="W")
+    assert result == expected
+
+    result = Timedelta("1W")
+    assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_as_unit.py

@@ -0,0 +1,86 @@
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsDatetime
+
+from pandas import Timestamp
+
+
+class TestTimestampAsUnit:
+    def test_as_unit(self):
+        ts = Timestamp("1970-01-01").as_unit("ns")
+        assert ts.unit == "ns"
+
+        assert ts.as_unit("ns") is ts
+
+        res = ts.as_unit("us")
+        assert res._value == ts._value // 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == ts._value
+        assert rt._creso == ts._creso
+
+        res = ts.as_unit("ms")
+        assert res._value == ts._value // 1_000_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == ts._value
+        assert rt._creso == ts._creso
+
+        res = ts.as_unit("s")
+        assert res._value == ts._value // 1_000_000_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == ts._value
+        assert rt._creso == ts._creso
+
+    def test_as_unit_overflows(self):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        ts = Timestamp._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value, None)
+
+        msg = "Cannot cast 2262-04-12 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            ts.as_unit("ns")
+
+        res = ts.as_unit("ms")
+        assert res._value == us // 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    def test_as_unit_rounding(self):
+        ts = Timestamp(1_500_000)  # i.e. 1500 microseconds
+        res = ts.as_unit("ms")
+
+        expected = Timestamp(1_000_000)  # i.e. 1 millisecond
+        assert res == expected
+
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res._value == 1
+
+        with pytest.raises(ValueError, match="Cannot losslessly convert units"):
+            ts.as_unit("ms", round_ok=False)
+
+    def test_as_unit_non_nano(self):
+        # case where we are going neither to nor from nano
+        ts = Timestamp("1970-01-02").as_unit("ms")
+        assert ts.year == 1970
+        assert ts.month == 1
+        assert ts.day == 2
+        assert ts.hour == ts.minute == ts.second == ts.microsecond == ts.nanosecond == 0
+
+        res = ts.as_unit("s")
+        assert res._value == 24 * 3600
+        assert res.year == 1970
+        assert res.month == 1
+        assert res.day == 2
+        assert (
+            res.hour
+            == res.minute
+            == res.second
+            == res.microsecond
+            == res.nanosecond
+            == 0
+        )

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_normalize.py

@@ -0,0 +1,29 @@
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
+
+class TestTimestampNormalize:
+    @pytest.mark.parametrize("arg", ["2013-11-30", "2013-11-30 12:00:00"])
+    def test_normalize(self, tz_naive_fixture, arg, unit):
+        tz = tz_naive_fixture
+        ts = Timestamp(arg, tz=tz).as_unit(unit)
+        result = ts.normalize()
+        expected = Timestamp("2013-11-30", tz=tz)
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+    def test_normalize_pre_epoch_dates(self):
+        # GH: 36294
+        result = Timestamp("1969-01-01 09:00:00").normalize()
+        expected = Timestamp("1969-01-01 00:00:00")
+        assert result == expected
+
+    def test_normalize_overflow_raises(self):
+        # GH#60583
+        ts = Timestamp.min
+
+        msg = "Cannot normalize Timestamp without integer overflow"
+        with pytest.raises(ValueError, match=msg):
+            ts.normalize()

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_replace.py

@@ -0,0 +1,211 @@
+from datetime import datetime
+import zoneinfo
+
+from dateutil.tz import gettz
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    OutOfBoundsDatetime,
+    Timestamp,
+    conversion,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.compat import WASM
+import pandas.util._test_decorators as td
+
+import pandas._testing as tm
+
+
+class TestTimestampReplace:
+    def test_replace_out_of_pydatetime_bounds(self):
+        # GH#50348
+        ts = Timestamp("2016-01-01").as_unit("ns")
+
+        msg = "Out of bounds timestamp: 99999-01-01 00:00:00 with frequency 'ns'"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            ts.replace(year=99_999)
+
+        ts = ts.as_unit("ms")
+        result = ts.replace(year=99_999)
+        assert result.year == 99_999
+        assert result._value == Timestamp(np.datetime64("99999-01-01", "ms"))._value
+
+    def test_replace_non_nano(self):
+        ts = Timestamp._from_value_and_reso(
+            91514880000000000, NpyDatetimeUnit.NPY_FR_us.value, None
+        )
+        assert ts.to_pydatetime() == datetime(4869, 12, 28)
+
+        result = ts.replace(year=4900)
+        assert result._creso == ts._creso
+        assert result.to_pydatetime() == datetime(4900, 12, 28)
+
+    def test_replace_naive(self):
+        # GH#14621, GH#7825
+        ts = Timestamp("2016-01-01 09:00:00")
+        result = ts.replace(hour=0)
+        expected = Timestamp("2016-01-01 00:00:00")
+        assert result == expected
+
+    def test_replace_aware(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH#14621, GH#7825
+        # replacing datetime components with and w/o presence of a timezone
+        ts = Timestamp("2016-01-01 09:00:00", tz=tz)
+        result = ts.replace(hour=0)
+        expected = Timestamp("2016-01-01 00:00:00", tz=tz)
+        assert result == expected
+
+    def test_replace_preserves_nanos(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH#14621, GH#7825
+        ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz)
+        result = ts.replace(hour=0)
+        expected = Timestamp("2016-01-01 00:00:00.000000123", tz=tz)
+        assert result == expected
+
+    def test_replace_multiple(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH#14621, GH#7825
+        # replacing datetime components with and w/o presence of a timezone
+        # test all
+        ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz)
+        result = ts.replace(
+            year=2015,
+            month=2,
+            day=2,
+            hour=0,
+            minute=5,
+            second=5,
+            microsecond=5,
+            nanosecond=5,
+        )
+        expected = Timestamp("2015-02-02 00:05:05.000005005", tz=tz)
+        assert result == expected
+
+    def test_replace_invalid_kwarg(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH#14621, GH#7825
+        ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz)
+        msg = r"replace\(\) got an unexpected keyword argument"
+        with pytest.raises(TypeError, match=msg):
+            ts.replace(foo=5)
+
+    def test_replace_integer_args(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH#14621, GH#7825
+        ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz)
+        msg = "value must be an integer, received <class 'float'> for hour"
+        with pytest.raises(ValueError, match=msg):
+            ts.replace(hour=0.1)
+
+    @pytest.mark.skipif(WASM, reason="tzset is not available on WASM")
+    def test_replace_tzinfo_equiv_tz_localize_none(self):
+        # GH#14621, GH#7825
+        # assert conversion to naive is the same as replacing tzinfo with None
+        ts = Timestamp("2013-11-03 01:59:59.999999-0400", tz="US/Eastern")
+        assert ts.tz_localize(None) == ts.replace(tzinfo=None)
+
+    @td.skip_if_windows
+    @pytest.mark.skipif(WASM, reason="tzset is not available on WASM")
+    def test_replace_tzinfo(self):
+        # GH#15683
+        dt = datetime(2016, 3, 27, 1, fold=1)
+        tzinfo = dt.astimezone(zoneinfo.ZoneInfo("Europe/Berlin")).tzinfo
+
+        result_dt = dt.replace(tzinfo=tzinfo)
+        result_pd = Timestamp(dt).replace(tzinfo=tzinfo)
+
+        # datetime.timestamp() converts in the local timezone
+        with tm.set_timezone("UTC"):
+            assert result_dt.timestamp() == result_pd.timestamp()
+
+        assert result_dt == result_pd
+        assert result_dt == result_pd.to_pydatetime()
+
+        result_dt = dt.replace(tzinfo=tzinfo).replace(tzinfo=None)
+        result_pd = Timestamp(dt).replace(tzinfo=tzinfo).replace(tzinfo=None)
+
+        # datetime.timestamp() converts in the local timezone
+        with tm.set_timezone("UTC"):
+            assert result_dt.timestamp() == result_pd.timestamp()
+
+        assert result_dt == result_pd
+        assert result_dt == result_pd.to_pydatetime()
+
+    @pytest.mark.parametrize(
+        "tz, normalize",
+        [
+            ("pytz/US/Eastern", lambda x: x.tzinfo.normalize(x)),
+            (gettz("US/Eastern"), lambda x: x),
+        ],
+    )
+    def test_replace_across_dst(self, tz, normalize):
+        # GH#18319 check that 1) timezone is correctly normalized and
+        # 2) that hour is not incorrectly changed by this normalization
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
+        ts_naive = Timestamp("2017-12-03 16:03:30")
+        ts_aware = conversion.localize_pydatetime(ts_naive, tz)
+
+        # Preliminary sanity-check
+        assert ts_aware == normalize(ts_aware)
+
+        # Replace across DST boundary
+        ts2 = ts_aware.replace(month=6)
+
+        # Check that `replace` preserves hour literal
+        assert (ts2.hour, ts2.minute) == (ts_aware.hour, ts_aware.minute)
+
+        # Check that post-replace object is appropriately normalized
+        ts2b = normalize(ts2)
+        assert ts2 == ts2b
+
+    def test_replace_dst_border(self, unit):
+        # Gh 7825
+        t = Timestamp("2013-11-3", tz="America/Chicago").as_unit(unit)
+        result = t.replace(hour=3)
+        expected = Timestamp("2013-11-3 03:00:00", tz="America/Chicago")
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+    @pytest.mark.parametrize("fold", [0, 1])
+    @pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"])
+    def test_replace_dst_fold(self, fold, tz, unit):
+        # GH 25017
+        d = datetime(2019, 10, 27, 2, 30)
+        ts = Timestamp(d, tz=tz).as_unit(unit)
+        result = ts.replace(hour=1, fold=fold)
+        expected = Timestamp(datetime(2019, 10, 27, 1, 30)).tz_localize(
+            tz, ambiguous=not fold
+        )
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+    @pytest.mark.parametrize("fold", [0, 1])
+    def test_replace_preserves_fold(self, fold):
+        # GH#37610. Check that replace preserves Timestamp fold property
+        tz = gettz("Europe/Moscow")
+
+        ts = Timestamp(
+            year=2009, month=10, day=25, hour=2, minute=30, fold=fold, tzinfo=tz
+        )
+        ts_replaced = ts.replace(second=1)
+
+        assert ts_replaced.fold == fold
+
+    def test_replace_updates_unit(self):
+        # GH#57749
+        ts = Timestamp("2023-07-15 23:08:12.134567123")
+        ts2 = Timestamp("2023-07-15 23:08:12.000000")
+        assert ts2.unit == "us"
+        result = ts2.replace(microsecond=ts.microsecond, nanosecond=ts.nanosecond)
+        assert result.unit == "ns"
+        assert result == ts
+
+        ts3 = Timestamp("2023-07-15 23:08:12").as_unit("s")
+        result = ts3.replace(microsecond=ts2.microsecond)
+        assert result.unit == "us"
+        assert result == ts2

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_round.py

@@ -0,0 +1,372 @@
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+from pandas._libs.tslibs import (
+    NaT,
+    OutOfBoundsDatetime,
+    Timedelta,
+    Timestamp,
+    iNaT,
+    to_offset,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+
+import pandas._testing as tm
+
+
+class TestTimestampRound:
+    def test_round_division_by_zero_raises(self):
+        ts = Timestamp("2016-01-01")
+
+        msg = "Division by zero in rounding"
+        with pytest.raises(ValueError, match=msg):
+            ts.round("0ns")
+
+    @pytest.mark.parametrize(
+        "timestamp, freq, expected",
+        [
+            ("20130101 09:10:11", "D", "20130101"),
+            ("20130101 19:10:11", "D", "20130102"),
+            ("20130201 12:00:00", "D", "20130202"),
+            ("20130104 12:00:00", "D", "20130105"),
+            ("2000-01-05 05:09:15.13", "D", "2000-01-05 00:00:00"),
+            ("2000-01-05 05:09:15.13", "h", "2000-01-05 05:00:00"),
+            ("2000-01-05 05:09:15.13", "s", "2000-01-05 05:09:15"),
+        ],
+    )
+    def test_round_frequencies(self, timestamp, freq, expected):
+        dt = Timestamp(timestamp)
+        result = dt.round(freq)
+        expected = Timestamp(expected)
+        assert result == expected
+
+    def test_round_tzaware(self):
+        dt = Timestamp("20130101 09:10:11", tz="US/Eastern")
+        result = dt.round("D")
+        expected = Timestamp("20130101", tz="US/Eastern")
+        assert result == expected
+
+        dt = Timestamp("20130101 09:10:11", tz="US/Eastern")
+        result = dt.round("s")
+        assert result == dt
+
+    def test_round_30min(self):
+        # round
+        dt = Timestamp("20130104 12:32:00")
+        result = dt.round("30Min")
+        expected = Timestamp("20130104 12:30:00")
+        assert result == expected
+
+    def test_round_subsecond(self):
+        # GH#14440 & GH#15578
+        result = Timestamp("2016-10-17 12:00:00.0015").round("ms")
+        expected = Timestamp("2016-10-17 12:00:00.002000")
+        assert result == expected
+
+        result = Timestamp("2016-10-17 12:00:00.00149").round("ms")
+        expected = Timestamp("2016-10-17 12:00:00.001000")
+        assert result == expected
+
+        ts = Timestamp("2016-10-17 12:00:00.0015")
+        for freq in ["us", "ns"]:
+            assert ts == ts.round(freq)
+
+        result = Timestamp("2016-10-17 12:00:00.001501031").round("10ns")
+        expected = Timestamp("2016-10-17 12:00:00.001501030")
+        assert result == expected
+
+    def test_round_nonstandard_freq(self):
+        with tm.assert_produces_warning(False):
+            Timestamp("2016-10-17 12:00:00.001501031").round("1010ns")
+
+    def test_round_invalid_arg(self):
+        stamp = Timestamp("2000-01-05 05:09:15.13")
+        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+            stamp.round("foo")
+
+    @pytest.mark.parametrize(
+        "test_input, rounder, freq, expected",
+        [
+            ("2117-01-01 00:00:45", "floor", "15s", "2117-01-01 00:00:45"),
+            ("2117-01-01 00:00:45", "ceil", "15s", "2117-01-01 00:00:45"),
+            (
+                "2117-01-01 00:00:45.000000012",
+                "floor",
+                "10ns",
+                "2117-01-01 00:00:45.000000010",
+            ),
+            (
+                "1823-01-01 00:00:01.000000012",
+                "ceil",
+                "10ns",
+                "1823-01-01 00:00:01.000000020",
+            ),
+            ("1823-01-01 00:00:01", "floor", "1s", "1823-01-01 00:00:01"),
+            ("1823-01-01 00:00:01", "ceil", "1s", "1823-01-01 00:00:01"),
+            ("NaT", "floor", "1s", "NaT"),
+            ("NaT", "ceil", "1s", "NaT"),
+        ],
+    )
+    def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
+        dt = Timestamp(test_input)
+        func = getattr(dt, rounder)
+        result = func(freq)
+
+        if dt is NaT:
+            assert result is NaT
+        else:
+            expected = Timestamp(expected)
+            assert result == expected
+
+    @pytest.mark.parametrize(
+        "test_input, freq, expected",
+        [
+            ("2018-01-01 00:02:06", "2s", "2018-01-01 00:02:06"),
+            ("2018-01-01 00:02:00", "2min", "2018-01-01 00:02:00"),
+            ("2018-01-01 00:04:00", "4min", "2018-01-01 00:04:00"),
+            ("2018-01-01 00:15:00", "15min", "2018-01-01 00:15:00"),
+            ("2018-01-01 00:20:00", "20min", "2018-01-01 00:20:00"),
+            ("2018-01-01 03:00:00", "3h", "2018-01-01 03:00:00"),
+        ],
+    )
+    @pytest.mark.parametrize("rounder", ["ceil", "floor", "round"])
+    def test_round_minute_freq(self, test_input, freq, expected, rounder):
+        # Ensure timestamps that shouldn't round dont!
+        # GH#21262
+
+        dt = Timestamp(test_input)
+        expected = Timestamp(expected)
+        func = getattr(dt, rounder)
+        result = func(freq)
+        assert result == expected
+
+    def test_ceil(self, unit):
+        dt = Timestamp("20130101 09:10:11").as_unit(unit)
+        result = dt.ceil("D")
+        expected = Timestamp("20130102")
+        assert result == expected
+        assert result._creso == dt._creso
+
+    def test_floor(self, unit):
+        dt = Timestamp("20130101 09:10:11").as_unit(unit)
+        result = dt.floor("D")
+        expected = Timestamp("20130101")
+        assert result == expected
+        assert result._creso == dt._creso
+
+    @pytest.mark.parametrize("method", ["ceil", "round", "floor"])
+    def test_round_dst_border_ambiguous(self, method, unit):
+        # GH 18946 round near "fall back" DST
+        ts = Timestamp("2017-10-29 00:00:00", tz="UTC").tz_convert("Europe/Madrid")
+        ts = ts.as_unit(unit)
+        result = getattr(ts, method)("h", ambiguous=True)
+        assert result == ts
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)("h", ambiguous=False)
+        expected = Timestamp("2017-10-29 01:00:00", tz="UTC").tz_convert(
+            "Europe/Madrid"
+        )
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)("h", ambiguous="NaT")
+        assert result is NaT
+
+        msg = "Cannot infer dst time"
+        with pytest.raises(ValueError, match=msg):
+            getattr(ts, method)("h", ambiguous="raise")
+
+    @pytest.mark.parametrize(
+        "method, ts_str, freq",
+        [
+            ["ceil", "2018-03-11 01:59:00-0600", "5min"],
+            ["round", "2018-03-11 01:59:00-0600", "5min"],
+            ["floor", "2018-03-11 03:01:00-0500", "2h"],
+        ],
+    )
+    def test_round_dst_border_nonexistent(self, method, ts_str, freq, unit):
+        # GH 23324 round near "spring forward" DST
+        ts = Timestamp(ts_str, tz="America/Chicago").as_unit(unit)
+        result = getattr(ts, method)(freq, nonexistent="shift_forward")
+        expected = Timestamp("2018-03-11 03:00:00", tz="America/Chicago")
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)(freq, nonexistent="NaT")
+        assert result is NaT
+
+        msg = "2018-03-11 02:00:00"
+        with pytest.raises(ValueError, match=msg):
+            getattr(ts, method)(freq, nonexistent="raise")
+
+    @pytest.mark.parametrize(
+        "timestamp",
+        [
+            "2018-01-01 0:0:0.124999360",
+            "2018-01-01 0:0:0.125000367",
+            "2018-01-01 0:0:0.125500",
+            "2018-01-01 0:0:0.126500",
+            "2018-01-01 12:00:00",
+            "2019-01-01 12:00:00",
+        ],
+    )
+    @pytest.mark.parametrize(
+        "freq",
+        [
+            "2ns",
+            "3ns",
+            "4ns",
+            "5ns",
+            "6ns",
+            "7ns",
+            "250ns",
+            "500ns",
+            "750ns",
+            "1us",
+            "19us",
+            "250us",
+            "500us",
+            "750us",
+            "1s",
+            "2s",
+            "3s",
+            "1D",
+        ],
+    )
+    def test_round_int64(self, timestamp, freq):
+        # check that all rounding modes are accurate to int64 precision
+        # see GH#22591
+        dt = Timestamp(timestamp).as_unit("ns")
+        unit = to_offset(freq).nanos
+
+        # test floor
+        result = dt.floor(freq)
+        assert result._value % unit == 0, f"floor not a {freq} multiple"
+        assert 0 <= dt._value - result._value < unit, "floor error"
+
+        # test ceil
+        result = dt.ceil(freq)
+        assert result._value % unit == 0, f"ceil not a {freq} multiple"
+        assert 0 <= result._value - dt._value < unit, "ceil error"
+
+        # test round
+        result = dt.round(freq)
+        assert result._value % unit == 0, f"round not a {freq} multiple"
+        assert abs(result._value - dt._value) <= unit // 2, "round error"
+        if unit % 2 == 0 and abs(result._value - dt._value) == unit // 2:
+            # round half to even
+            assert result._value // unit % 2 == 0, "round half to even error"
+
+    def test_round_implementation_bounds(self):
+        # See also: analogous test for Timedelta
+        result = Timestamp.min.ceil("s")
+        expected = Timestamp(1677, 9, 21, 0, 12, 44)
+        assert result == expected
+
+        result = Timestamp.max.floor("s")
+        expected = Timestamp.max - Timedelta(854775807)
+        assert result == expected
+
+        msg = "Cannot round 1677-09-21 00:12:43.145224193 to freq=<Second>"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.min.floor("s")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.min.round("s")
+
+        msg = "Cannot round 2262-04-11 23:47:16.854775807 to freq=<Second>"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.max.ceil("s")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.max.round("s")
+
+    @pytest.mark.slow
+    @given(val=st.integers(iNaT + 1, lib.i8max))
+    @pytest.mark.parametrize(
+        "method", [Timestamp.round, Timestamp.floor, Timestamp.ceil]
+    )
+    def test_round_sanity(self, val, method):
+        cls = Timestamp
+        err_cls = OutOfBoundsDatetime
+
+        val = np.int64(val)
+        ts = cls(val)
+
+        def checker(ts, nanos, unit):
+            # First check that we do raise in cases where we should
+            if nanos == 1:
+                pass
+            else:
+                div, mod = divmod(ts._value, nanos)
+                diff = int(nanos - mod)
+                lb = ts._value - mod
+                assert lb <= ts._value  # i.e. no overflows with python ints
+                ub = ts._value + diff
+                assert ub > ts._value  # i.e. no overflows with python ints
+
+                msg = "without overflow"
+                if mod == 0:
+                    # We should never be raising in this
+                    pass
+                elif method is cls.ceil:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif method is cls.floor:
+                    if lb < cls.min._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif mod >= diff:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif lb < cls.min._value:
+                    with pytest.raises(err_cls, match=msg):
+                        method(ts, unit)
+                    return
+
+            res = method(ts, unit)
+
+            td = res - ts
+            diff = abs(td._value)
+            assert diff < nanos
+            assert res._value % nanos == 0
+
+            if method is cls.round:
+                assert diff <= nanos / 2
+            elif method is cls.floor:
+                assert res <= ts
+            elif method is cls.ceil:
+                assert res >= ts
+
+        nanos = 1
+        checker(ts, nanos, "ns")
+
+        nanos = 1000
+        checker(ts, nanos, "us")
+
+        nanos = 1_000_000
+        checker(ts, nanos, "ms")
+
+        nanos = 1_000_000_000
+        checker(ts, nanos, "s")
+
+        nanos = 60 * 1_000_000_000
+        checker(ts, nanos, "min")
+
+        nanos = 60 * 60 * 1_000_000_000
+        checker(ts, nanos, "h")
+
+        nanos = 24 * 60 * 60 * 1_000_000_000
+        checker(ts, nanos, "D")

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py

@@ -0,0 +1,34 @@
+# NB: This is for the Timestamp.timestamp *method* specifically, not
+# the Timestamp class in general.
+from datetime import timezone
+
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas.compat import WASM
+import pandas.util._test_decorators as td
+
+import pandas._testing as tm
+
+
+class TestTimestampMethod:
+    @td.skip_if_windows
+    @pytest.mark.skipif(WASM, reason="tzset is not available on WASM")
+    def test_timestamp(self, fixed_now_ts):
+        # GH#17329
+        # tz-naive --> treat it as if it were UTC for purposes of timestamp()
+        ts = fixed_now_ts
+        uts = ts.replace(tzinfo=timezone.utc)
+        assert ts.timestamp() == uts.timestamp()
+
+        tsc = Timestamp("2014-10-11 11:00:01.12345678", tz="US/Central")
+        utsc = tsc.tz_convert("UTC")
+
+        # utsc is a different representation of the same time
+        assert tsc.timestamp() == utsc.timestamp()
+
+        # datetime.timestamp() converts in the local timezone
+        with tm.set_timezone("UTC"):
+            # should agree with datetime.timestamp method
+            dt = ts.to_pydatetime()
+            assert dt.timestamp() == ts.timestamp()

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_to_julian_date.py

@@ -0,0 +1,28 @@
+from pandas import Timestamp
+
+
+class TestTimestampToJulianDate:
+    def test_compare_1700(self):
+        ts = Timestamp("1700-06-23")
+        res = ts.to_julian_date()
+        assert res == 2_342_145.5
+
+    def test_compare_2000(self):
+        ts = Timestamp("2000-04-12")
+        res = ts.to_julian_date()
+        assert res == 2_451_646.5
+
+    def test_compare_2100(self):
+        ts = Timestamp("2100-08-12")
+        res = ts.to_julian_date()
+        assert res == 2_488_292.5
+
+    def test_compare_hour01(self):
+        ts = Timestamp("2000-08-12T01:00:00")
+        res = ts.to_julian_date()
+        assert res == 2_451_768.5416666666666666
+
+    def test_compare_hour13(self):
+        ts = Timestamp("2000-08-12T13:00:00")
+        res = ts.to_julian_date()
+        assert res == 2_451_769.0416666666666666

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py

@@ -0,0 +1,83 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import pytest
+
+from pandas._libs.tslibs.timezones import dateutil_gettz as gettz
+import pandas.util._test_decorators as td
+
+from pandas import Timestamp
+import pandas._testing as tm
+
+
+class TestTimestampToPyDatetime:
+    def test_to_pydatetime_fold(self):
+        # GH#45087
+        tzstr = "dateutil/usr/share/zoneinfo/America/Chicago"
+        ts = Timestamp(year=2013, month=11, day=3, hour=1, minute=0, fold=1, tz=tzstr)
+        dt = ts.to_pydatetime()
+        assert dt.fold == 1
+
+    def test_to_pydatetime_nonzero_nano(self):
+        ts = Timestamp("2011-01-01 9:00:00.123456789")
+
+        # Warn the user of data loss (nanoseconds).
+        msg = "Discarding nonzero nanoseconds in conversion"
+        with tm.assert_produces_warning(UserWarning, match=msg):
+            expected = datetime(2011, 1, 1, 9, 0, 0, 123456)
+            result = ts.to_pydatetime()
+            assert result == expected
+
+    def test_timestamp_to_datetime(self):
+        stamp = Timestamp("20090415", tz="US/Eastern")
+        dtval = stamp.to_pydatetime()
+        assert stamp == dtval
+        assert stamp.tzinfo == dtval.tzinfo
+
+    def test_timestamp_to_pydatetime_dateutil(self):
+        stamp = Timestamp("20090415", tz="dateutil/US/Eastern")
+        dtval = stamp.to_pydatetime()
+        assert stamp == dtval
+        assert stamp.tzinfo == dtval.tzinfo
+
+    def test_timestamp_to_pydatetime_explicit_pytz(self):
+        pytz = pytest.importorskip("pytz")
+        stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern"))
+        dtval = stamp.to_pydatetime()
+        assert stamp == dtval
+        assert stamp.tzinfo == dtval.tzinfo
+
+    @td.skip_if_windows
+    def test_timestamp_to_pydatetime_explicit_dateutil(self):
+        stamp = Timestamp("20090415", tz=gettz("US/Eastern"))
+        dtval = stamp.to_pydatetime()
+        assert stamp == dtval
+        assert stamp.tzinfo == dtval.tzinfo
+
+    def test_to_pydatetime_bijective(self):
+        # Ensure that converting to datetime and back only loses precision
+        # by going from nanoseconds to microseconds.
+        exp_warning = None if Timestamp.max.nanosecond == 0 else UserWarning
+        with tm.assert_produces_warning(exp_warning):
+            pydt_max = Timestamp.max.to_pydatetime()
+
+        assert (
+            Timestamp(pydt_max).as_unit("ns")._value / 1000
+            == Timestamp.max._value / 1000
+        )
+
+        exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning
+        with tm.assert_produces_warning(exp_warning):
+            pydt_min = Timestamp.min.to_pydatetime()
+
+        # The next assertion can be enabled once GH#39221 is merged
+        #  assert pydt_min < Timestamp.min  # this is bc nanos are dropped
+        tdus = timedelta(microseconds=1)
+        assert pydt_min + tdus > Timestamp.min
+
+        assert (
+            Timestamp(pydt_min + tdus).as_unit("ns")._value / 1000
+            == Timestamp.min._value / 1000
+        )

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_tz_convert.py

@@ -0,0 +1,51 @@
+import dateutil
+import pytest
+
+from pandas._libs.tslibs import timezones
+import pandas.util._test_decorators as td
+
+from pandas import Timestamp
+
+
+class TestTimestampTZConvert:
+    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_astimezone(self, tzstr):
+        # astimezone is an alias for tz_convert, so keep it with
+        # the tz_convert tests
+        utcdate = Timestamp("3/11/2012 22:00", tz="UTC")
+        expected = utcdate.tz_convert(tzstr)
+        result = utcdate.astimezone(tzstr)
+        assert expected == result
+        assert isinstance(result, Timestamp)
+
+    @pytest.mark.parametrize(
+        "stamp",
+        [
+            "2014-02-01 09:00",
+            "2014-07-08 09:00",
+            "2014-11-01 17:00",
+            "2014-11-05 00:00",
+        ],
+    )
+    def test_tz_convert_roundtrip(self, stamp, tz_aware_fixture):
+        tz = tz_aware_fixture
+
+        ts = Timestamp(stamp, tz="UTC")
+        converted = ts.tz_convert(tz)
+
+        reset = converted.tz_convert(None)
+        assert reset == Timestamp(stamp)
+        assert reset.tzinfo is None
+        assert reset == converted.tz_convert("UTC").tz_localize(None)
+
+    @td.skip_if_windows
+    def test_tz_convert_utc_with_system_utc(self):
+        # from system utc to real utc
+        ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC"))
+        # check that the time hasn't changed.
+        assert ts == ts.tz_convert(dateutil.tz.tzutc())
+
+        # from system utc to real utc
+        ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC"))
+        # check that the time hasn't changed.
+        assert ts == ts.tz_convert(dateutil.tz.tzutc())

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/methods/test_tz_localize.py

@@ -0,0 +1,364 @@
+from datetime import timedelta
+import re
+import zoneinfo
+
+from dateutil.tz import gettz
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsDatetime
+
+from pandas import (
+    NaT,
+    Timestamp,
+)
+
+
+def _distant_date_only_for_zoneinfo(year, tz):
+    if int(year) >= 2200:
+        if isinstance(tz, zoneinfo.ZoneInfo):
+            return
+        elif isinstance(tz, str) and not tz.startswith(("dateutil/", "pytz/")):
+            # zoneinfo tz passed as string
+            return
+        else:
+            pytest.skip("ZoneInfo required for year >= 2200")
+
+
+class TestTimestampTZLocalize:
+    def test_tz_localize_pushes_out_of_bounds(self):
+        # GH#12677
+        # tz_localize that pushes away from the boundary is OK
+        pytz = pytest.importorskip("pytz")
+        msg = (
+            f"Converting {Timestamp.min.strftime('%Y-%m-%d %H:%M:%S')} "
+            f"underflows past {Timestamp.min}"
+        )
+        pac = Timestamp.min.tz_localize(pytz.timezone("US/Pacific"))
+        assert pac._value > Timestamp.min._value
+        pac.tz_convert("Asia/Tokyo")  # tz_convert doesn't change value
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.min.tz_localize(pytz.timezone("Asia/Tokyo"))
+
+        # tz_localize that pushes away from the boundary is OK
+        msg = (
+            f"Converting {Timestamp.max.strftime('%Y-%m-%d %H:%M:%S')} "
+            f"overflows past {Timestamp.max}"
+        )
+        tokyo = Timestamp.max.tz_localize(pytz.timezone("Asia/Tokyo"))
+        assert tokyo._value < Timestamp.max._value
+        tokyo.tz_convert("US/Pacific")  # tz_convert doesn't change value
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.max.tz_localize(pytz.timezone("US/Pacific"))
+
+    @pytest.mark.parametrize(
+        "tz",
+        [zoneinfo.ZoneInfo("US/Central"), "dateutil/US/Central", "pytz/US/Central"],
+    )
+    def test_tz_localize_ambiguous_bool(self, unit, tz):
+        # make sure that we are correctly accepting bool values as ambiguous
+        # GH#14402
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
+        ts = Timestamp("2015-11-01 01:00:03").as_unit(unit)
+        expected0 = Timestamp("2015-11-01 01:00:03-0500", tz=tz)
+        expected1 = Timestamp("2015-11-01 01:00:03-0600", tz=tz)
+
+        msg = "Cannot infer dst time from 2015-11-01 01:00:03"
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize(tz)
+
+        result = ts.tz_localize(tz, ambiguous=True)
+        assert result == expected0
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = ts.tz_localize(tz, ambiguous=False)
+        assert result == expected1
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+    @pytest.mark.parametrize("year", ["2014", "2200"])
+    def test_tz_localize_ambiguous(self, year):
+        ts = Timestamp(f"{year}-11-02 01:00").as_unit("s")
+        ts_dst = ts.tz_localize("US/Eastern", ambiguous=True)
+        ts_no_dst = ts.tz_localize("US/Eastern", ambiguous=False)
+
+        assert ts_no_dst._value - ts_dst._value == 3600
+        msg = re.escape(
+            "'ambiguous' parameter must be one of: "
+            "True, False, 'NaT', 'raise' (default)"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize("US/Eastern", ambiguous="infer")
+
+    def test_tz_localize_invalid(self):
+        # GH#8025
+        msg = "Cannot localize tz-aware Timestamp, use tz_convert for conversions"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp("2011-01-01", tz="US/Eastern").tz_localize("Asia/Tokyo")
+
+        msg = "Cannot convert tz-naive Timestamp, use tz_localize to localize"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp("2011-01-01").tz_convert("Asia/Tokyo")
+
+    @pytest.mark.parametrize("year", ["2015", "2201"])
+    @pytest.mark.parametrize(
+        "stamp, tz",
+        [
+            ("2015-03-08 02:00", "US/Eastern"),
+            ("2015-03-08 02:30", "US/Pacific"),
+            ("2015-03-29 02:00", "Europe/Paris"),
+            ("2015-03-29 02:30", "Europe/Belgrade"),
+        ],
+    )
+    def test_tz_localize_nonexistent(self, stamp, tz, year):
+        # GH#13057
+        stamp = stamp.replace("2015", year)
+        ts = Timestamp(stamp)
+        with pytest.raises(ValueError, match=stamp):
+            ts.tz_localize(tz)
+        # GH 22644
+        with pytest.raises(ValueError, match=stamp):
+            ts.tz_localize(tz, nonexistent="raise")
+        assert ts.tz_localize(tz, nonexistent="NaT") is NaT
+
+    @pytest.mark.parametrize(
+        "stamp, tz, forward_expected, backward_expected",
+        [
+            (
+                "2015-03-29 02:00:00",
+                "Europe/Warsaw",
+                "2015-03-29 03:00:00",
+                "2015-03-29 01:59:59.999999",
+            ),  # utc+1 -> utc+2
+            (
+                "2023-03-12 02:00:00",
+                "America/Los_Angeles",
+                "2023-03-12 03:00:00",
+                "2023-03-12 01:59:59.999999",
+            ),  # utc-8 -> utc-7
+            (
+                "2023-03-26 01:00:00",
+                "Europe/London",
+                "2023-03-26 02:00:00",
+                "2023-03-26 00:59:59.999999",
+            ),  # utc+0 -> utc+1
+            (
+                "2023-03-26 00:00:00",
+                "Atlantic/Azores",
+                "2023-03-26 01:00:00",
+                "2023-03-25 23:59:59.999999",
+            ),  # utc-1 -> utc+0
+        ],
+    )
+    def test_tz_localize_nonexistent_shift(
+        self, stamp, tz, forward_expected, backward_expected
+    ):
+        ts = Timestamp(stamp)
+        forward_ts = ts.tz_localize(tz, nonexistent="shift_forward")
+        assert forward_ts == Timestamp(forward_expected, tz=tz)
+        backward_ts = ts.tz_localize(tz, nonexistent="shift_backward")
+        assert backward_ts == Timestamp(backward_expected, tz=tz)
+
+    def test_tz_localize_ambiguous_raise(self):
+        # GH#13057
+        ts = Timestamp("2015-11-1 01:00")
+        msg = "Cannot infer dst time from 2015-11-01 01:00:00,"
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize("US/Pacific", ambiguous="raise")
+
+    def test_tz_localize_nonexistent_invalid_arg(self, warsaw):
+        # GH 22644
+        tz = warsaw
+        ts = Timestamp("2015-03-29 02:00:00")
+        msg = (
+            "The nonexistent argument must be one of 'raise', 'NaT', "
+            "'shift_forward', 'shift_backward' or a timedelta object"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize(tz, nonexistent="foo")
+
+    @pytest.mark.parametrize(
+        "stamp",
+        [
+            "2014-02-01 09:00",
+            "2014-07-08 09:00",
+            "2014-11-01 17:00",
+            "2014-11-05 00:00",
+        ],
+    )
+    def test_tz_localize_roundtrip(self, stamp, tz_aware_fixture):
+        tz = tz_aware_fixture
+        ts = Timestamp(stamp)
+        localized = ts.tz_localize(tz)
+        assert localized == Timestamp(stamp, tz=tz)
+
+        msg = "Cannot localize tz-aware Timestamp"
+        with pytest.raises(TypeError, match=msg):
+            localized.tz_localize(tz)
+
+        reset = localized.tz_localize(None)
+        assert reset == ts
+        assert reset.tzinfo is None
+
+    def test_tz_localize_ambiguous_compat(self):
+        # validate that pytz and dateutil are compat for dst
+        # when the transition happens
+        pytz = pytest.importorskip("pytz")
+        naive = Timestamp("2013-10-27 01:00:00")
+        assert naive.unit == "us"
+
+        pytz_zone = pytz.timezone("Europe/London")
+        dateutil_zone = "dateutil/Europe/London"
+        result_pytz = naive.tz_localize(pytz_zone, ambiguous=False)
+        result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=False)
+        assert result_pytz._value == result_dateutil._value
+        assert result_pytz._value == 1_382_835_600 * 10**6
+
+        # fixed ambiguous behavior
+        # see gh-14621, GH#45087
+        assert result_pytz.to_pydatetime().tzname() == "GMT"
+        assert result_dateutil.to_pydatetime().tzname() == "GMT"
+        assert str(result_pytz) == str(result_dateutil)
+
+        # 1 hour difference
+        result_pytz = naive.tz_localize(pytz_zone, ambiguous=True)
+        result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=True)
+        assert result_pytz._value == result_dateutil._value
+        assert result_pytz._value == 1_382_832_000 * 10**6
+
+        # see gh-14621
+        assert str(result_pytz) == str(result_dateutil)
+        assert (
+            result_pytz.to_pydatetime().tzname()
+            == result_dateutil.to_pydatetime().tzname()
+        )
+
+    @pytest.mark.parametrize(
+        "tz",
+        [
+            "pytz/US/Eastern",
+            gettz("US/Eastern"),
+            zoneinfo.ZoneInfo("US/Eastern"),
+            "dateutil/US/Eastern",
+        ],
+    )
+    def test_timestamp_tz_localize(self, tz):
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
+        stamp = Timestamp("3/11/2012 04:00")
+
+        result = stamp.tz_localize(tz)
+        expected = Timestamp("3/11/2012 04:00", tz=tz)
+        assert result.hour == expected.hour
+        assert result == expected
+
+    @pytest.mark.parametrize("year", ["2018", "2204"])
+    @pytest.mark.parametrize(
+        "start_ts, tz, end_ts, shift",
+        [
+            ["2018-03-25 02:20:00", "Europe/Warsaw", "2018-03-25 03:00:00", "forward"],
+            [
+                "2018-03-25 02:20:00",
+                "Europe/Warsaw",
+                "2018-03-25 01:59:59.999999999",
+                "backward",
+            ],
+            [
+                "2018-03-25 02:20:00",
+                "Europe/Warsaw",
+                "2018-03-25 03:20:00",
+                timedelta(hours=1),
+            ],
+            [
+                "2018-03-25 02:20:00",
+                "Europe/Warsaw",
+                "2018-03-25 01:20:00",
+                timedelta(hours=-1),
+            ],
+            ["2018-03-11 02:33:00", "US/Pacific", "2018-03-11 03:00:00", "forward"],
+            [
+                "2018-03-11 02:33:00",
+                "US/Pacific",
+                "2018-03-11 01:59:59.999999999",
+                "backward",
+            ],
+            [
+                "2018-03-11 02:33:00",
+                "US/Pacific",
+                "2018-03-11 03:33:00",
+                timedelta(hours=1),
+            ],
+            [
+                "2018-03-11 02:33:00",
+                "US/Pacific",
+                "2018-03-11 01:33:00",
+                timedelta(hours=-1),
+            ],
+        ],
+    )
+    @pytest.mark.parametrize("tz_type", ["", "dateutil/"])
+    def test_timestamp_tz_localize_nonexistent_shift(
+        self, start_ts, tz, end_ts, shift, year, tz_type, unit
+    ):
+        # GH 8917, 24466
+        if year == "2204" and tz_type == "dateutil/":
+            pytest.skip("ZoneInfo required for year >= 2200")
+        start_ts = start_ts.replace("2018", year)
+        end_ts = end_ts.replace("2018", year)
+        tz = tz_type + tz
+        if isinstance(shift, str):
+            shift = "shift_" + shift
+        ts = Timestamp(start_ts).as_unit(unit)
+        result = ts.tz_localize(tz, nonexistent=shift)
+        expected = Timestamp(end_ts).tz_localize(tz)
+
+        if unit == "us":
+            assert result == expected.replace(nanosecond=0)
+        elif unit == "ms":
+            micros = expected.microsecond - expected.microsecond % 1000
+            assert result == expected.replace(microsecond=micros, nanosecond=0)
+        elif unit == "s":
+            assert result == expected.replace(microsecond=0, nanosecond=0)
+        else:
+            assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+    @pytest.mark.parametrize("year", ["2015", "2201"])
+    @pytest.mark.parametrize("offset", [-1, 1])
+    def test_timestamp_tz_localize_nonexistent_shift_invalid(
+        self, offset, year, warsaw
+    ):
+        # GH 8917, 24466
+        tz = warsaw
+        _distant_date_only_for_zoneinfo(year, tz)
+        ts = Timestamp(f"{year}-03-29 02:20:00")
+        msg = "The provided timedelta will relocalize on a nonexistent time"
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize(tz, nonexistent=timedelta(seconds=offset))
+
+    @pytest.mark.parametrize("year", ["2015", "2201"])
+    def test_timestamp_tz_localize_nonexistent_NaT(self, year, warsaw, unit):
+        # GH 8917
+        tz = warsaw
+        _distant_date_only_for_zoneinfo(year, tz)
+        ts = Timestamp(f"{year}-03-29 02:20:00").as_unit(unit)
+        result = ts.tz_localize(tz, nonexistent="NaT")
+        assert result is NaT
+
+    @pytest.mark.parametrize("year", ["2015", "2201"])
+    def test_timestamp_tz_localize_nonexistent_raise(self, year, warsaw, unit):
+        # GH 8917
+        tz = warsaw
+        _distant_date_only_for_zoneinfo(year, tz)
+        ts = Timestamp(f"{year}-03-29 02:20:00").as_unit(unit)
+        msg = f"{year}-03-29 02:20:00"
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize(tz, nonexistent="raise")
+        msg = (
+            "The nonexistent argument must be one of 'raise', 'NaT', "
+            "'shift_forward', 'shift_backward' or a timedelta object"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ts.tz_localize(tz, nonexistent="foo")

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_arithmetic.py

@@ -0,0 +1,346 @@
+from datetime import (
+    datetime,
+    timedelta,
+    timezone,
+)
+
+from dateutil.tz import gettz
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+    Timedelta,
+    Timestamp,
+    offsets,
+    to_offset,
+)
+
+import pandas._testing as tm
+
+
+class TestTimestampArithmetic:
+    def test_overflow_offset(self):
+        # no overflow expected
+
+        stamp = Timestamp("2000/1/1")
+        offset_no_overflow = to_offset("D") * 100
+
+        expected = Timestamp("2000/04/10")
+        assert stamp + offset_no_overflow == expected
+
+        assert offset_no_overflow + stamp == expected
+
+        expected = Timestamp("1999/09/23")
+        assert stamp - offset_no_overflow == expected
+
+    def test_overflow_offset_raises(self):
+        # xref https://github.com/statsmodels/statsmodels/issues/3374
+        # ends up multiplying really large numbers which overflow
+
+        stamp = Timestamp("2017-01-13 00:00:00").as_unit("ns")
+        offset_overflow = 20169940 * offsets.Day(1)
+        lmsg2 = r"Cannot cast -?20169940 days \+?00:00:00 to unit='ns' without overflow"
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
+            stamp + offset_overflow
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
+            offset_overflow + stamp
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
+            stamp - offset_overflow
+
+        # xref https://github.com/pandas-dev/pandas/issues/14080
+        # used to crash, so check for proper overflow exception
+
+        stamp = Timestamp("2000/1/1").as_unit("ns")
+        offset_overflow = to_offset("D") * 100**5
+
+        lmsg3 = (
+            r"Cannot cast -?10000000000 days \+?00:00:00 to unit='ns' without overflow"
+        )
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
+            stamp + offset_overflow
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
+            offset_overflow + stamp
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
+            stamp - offset_overflow
+
+    def test_overflow_timestamp_raises(self):
+        # https://github.com/pandas-dev/pandas/issues/31774
+        msg = "Result is too large"
+        a = Timestamp("2101-01-01 00:00:00").as_unit("ns")
+        b = Timestamp("1688-01-01 00:00:00").as_unit("ns")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            a - b
+
+        # but we're OK for timestamp and datetime.datetime
+        assert (a - b.to_pydatetime()) == (a.to_pydatetime() - b)
+
+    def test_delta_preserve_nanos(self):
+        val = Timestamp(1337299200000000123)
+        result = val + timedelta(1)
+        assert result.nanosecond == val.nanosecond
+
+    def test_rsub_dtscalars(self, tz_naive_fixture):
+        # In particular, check that datetime64 - Timestamp works GH#28286
+        td = Timedelta(1235345642000)
+        ts = Timestamp("2021-01-01", tz=tz_naive_fixture)
+        other = ts + td
+
+        assert other - ts == td
+        assert other.to_pydatetime() - ts == td
+        if tz_naive_fixture is None:
+            assert other.to_datetime64() - ts == td
+        else:
+            msg = "Cannot subtract tz-naive and tz-aware datetime-like objects"
+            with pytest.raises(TypeError, match=msg):
+                other.to_datetime64() - ts
+
+    def test_timestamp_sub_datetime(self):
+        dt = datetime(2013, 10, 12)
+        ts = Timestamp(datetime(2013, 10, 13))
+        assert (ts - dt).days == 1
+        assert (dt - ts).days == -1
+
+    def test_subtract_tzaware_datetime(self):
+        t1 = Timestamp("2020-10-22T22:00:00+00:00")
+        t2 = datetime(2020, 10, 22, 22, tzinfo=timezone.utc)
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days")
+
+    def test_subtract_timestamp_from_different_timezone(self):
+        t1 = Timestamp("20130101").tz_localize("US/Eastern")
+        t2 = Timestamp("20130101").tz_localize("CET")
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 06:00:00")
+
+    def test_subtracting_involving_datetime_with_different_tz(self):
+        t1 = datetime(2013, 1, 1, tzinfo=timezone(timedelta(hours=-5)))
+        t2 = Timestamp("20130101").tz_localize("CET")
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 06:00:00")
+
+        result = t2 - t1
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("-1 days +18:00:00")
+
+    def test_subtracting_different_timezones(self, tz_aware_fixture):
+        t_raw = Timestamp("20130101")
+        t_UTC = t_raw.tz_localize("UTC")
+        t_diff = t_UTC.tz_convert(tz_aware_fixture) + Timedelta("0 days 05:00:00")
+
+        result = t_diff - t_UTC
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 05:00:00")
+
+    def test_addition_subtraction_types(self):
+        # Assert on the types resulting from Timestamp +/- various date/time
+        # objects
+        dt = datetime(2014, 3, 4)
+        td = timedelta(seconds=1)
+        ts = Timestamp(dt)
+
+        msg = "Addition/subtraction of integers"
+        with pytest.raises(TypeError, match=msg):
+            # GH#22535 add/sub with integers is deprecated
+            ts + 1
+        with pytest.raises(TypeError, match=msg):
+            ts - 1
+
+        # Timestamp + datetime not supported, though subtraction is supported
+        # and yields timedelta more tests in tseries/base/tests/test_base.py
+        assert type(ts - dt) == Timedelta
+        assert type(ts + td) == Timestamp
+        assert type(ts - td) == Timestamp
+
+        # Timestamp +/- datetime64 not supported, so not tested (could possibly
+        # assert error raised?)
+        td64 = np.timedelta64(1, "D")
+        assert type(ts + td64) == Timestamp
+        assert type(ts - td64) == Timestamp
+
+    @pytest.mark.parametrize(
+        "td", [Timedelta(hours=3), np.timedelta64(3, "h"), timedelta(hours=3)]
+    )
+    def test_radd_tdscalar(self, td, fixed_now_ts):
+        # GH#24775 timedelta64+Timestamp should not raise
+        ts = fixed_now_ts
+        assert td + ts == ts + td
+
+    @pytest.mark.parametrize(
+        "other,expected_difference",
+        [
+            (np.timedelta64(-123, "ns"), -123),
+            (np.timedelta64(1234567898, "ns"), 1234567898),
+            (np.timedelta64(-123, "us"), -123000),
+            (np.timedelta64(-123, "ms"), -123000000),
+        ],
+    )
+    def test_timestamp_add_timedelta64_unit(self, other, expected_difference):
+        now = datetime.now(timezone.utc)
+        ts = Timestamp(now).as_unit("ns")
+        result = ts + other
+        valdiff = result._value - ts._value
+        assert valdiff == expected_difference
+
+        ts2 = Timestamp(now)
+        assert ts2 + other == result
+
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("1776-07-04"),
+            Timestamp("1776-07-04", tz="UTC"),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "other",
+        [
+            1,
+            np.int64(1),
+            np.array([1, 2], dtype=np.int32),
+            np.array([3, 4], dtype=np.uint64),
+        ],
+    )
+    def test_add_int_with_freq(self, ts, other):
+        msg = "Addition/subtraction of integers and integer-arrays"
+        with pytest.raises(TypeError, match=msg):
+            ts + other
+        with pytest.raises(TypeError, match=msg):
+            other + ts
+
+        with pytest.raises(TypeError, match=msg):
+            ts - other
+
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    @pytest.mark.parametrize("shape", [(6,), (2, 3)])
+    def test_addsub_m8ndarray(self, shape):
+        # GH#33296
+        ts = Timestamp("2020-04-04 15:45").as_unit("ns")
+        other = np.arange(6).astype("m8[h]").reshape(shape)
+
+        result = ts + other
+
+        ex_stamps = [ts + Timedelta(hours=n) for n in range(6)]
+        expected = np.array([x.asm8 for x in ex_stamps], dtype="M8[ns]").reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other + ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts - other
+        ex_stamps = [ts - Timedelta(hours=n) for n in range(6)]
+        expected = np.array([x.asm8 for x in ex_stamps], dtype="M8[ns]").reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    @pytest.mark.parametrize("shape", [(6,), (2, 3)])
+    def test_addsub_m8ndarray_tzaware(self, shape):
+        # GH#33296
+        ts = Timestamp("2020-04-04 15:45", tz="US/Pacific")
+
+        other = np.arange(6).astype("m8[h]").reshape(shape)
+
+        result = ts + other
+
+        ex_stamps = [ts + Timedelta(hours=n) for n in range(6)]
+        expected = np.array(ex_stamps).reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other + ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts - other
+        ex_stamps = [ts - Timedelta(hours=n) for n in range(6)]
+        expected = np.array(ex_stamps).reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    def test_subtract_different_utc_objects(self, utc_fixture, utc_fixture2):
+        # GH 32619
+        dt = datetime(2021, 1, 1)
+        ts1 = Timestamp(dt, tz=utc_fixture)
+        ts2 = Timestamp(dt, tz=utc_fixture2)
+        result = ts1 - ts2
+        expected = Timedelta(0)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "tz",
+        [
+            "pytz/US/Eastern",
+            gettz("US/Eastern"),
+            "US/Eastern",
+            "dateutil/US/Eastern",
+        ],
+    )
+    def test_timestamp_add_timedelta_push_over_dst_boundary(self, tz):
+        # GH#1389
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
+        # 4 hours before DST transition
+        stamp = Timestamp("3/10/2012 22:00", tz=tz)
+
+        result = stamp + timedelta(hours=6)
+
+        # spring forward, + "7" hours
+        expected = Timestamp("3/11/2012 05:00", tz=tz)
+
+        assert result == expected
+
+    def test_timestamp_dst_transition(self):
+        # GH 60084
+        dt_str = "2023-11-05 01:00-08:00"
+        tz_str = "America/Los_Angeles"
+
+        ts1 = Timestamp(dt_str, tz=tz_str)
+        ts2 = ts1 + Timedelta(hours=0)
+
+        assert ts1 == ts2
+        assert hash(ts1) == hash(ts2)
+
+
+class SubDatetime(datetime):
+    pass
+
+
+@pytest.mark.parametrize(
+    "lh,rh",
+    [
+        (SubDatetime(2000, 1, 1), Timedelta(hours=1)),
+        (Timedelta(hours=1), SubDatetime(2000, 1, 1)),
+    ],
+)
+def test_dt_subclass_add_timedelta(lh, rh):
+    # GH#25851
+    # ensure that subclassed datetime works for
+    # Timedelta operations
+    result = lh + rh
+    expected = SubDatetime(2000, 1, 1, 1)
+    assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_comparisons.py

@@ -0,0 +1,313 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import Timestamp
+import pandas._testing as tm
+
+
+class TestTimestampComparison:
+    def test_compare_non_nano_dt64(self):
+        # don't raise when converting dt64 to Timestamp in __richcmp__
+        dt = np.datetime64("1066-10-14")
+        ts = Timestamp(dt)
+
+        assert dt == ts
+
+    def test_comparison_dt64_ndarray(self):
+        ts = Timestamp("2021-01-01")
+        ts2 = Timestamp("2019-04-05")
+        arr = np.array([[ts.asm8, ts2.asm8]], dtype="M8[ns]")
+
+        result = ts == arr
+        expected = np.array([[True, False]], dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr == ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts != arr
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = arr != ts
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = ts2 < arr
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr < ts2
+        tm.assert_numpy_array_equal(result, np.array([[False, False]], dtype=bool))
+
+        result = ts2 <= arr
+        tm.assert_numpy_array_equal(result, np.array([[True, True]], dtype=bool))
+
+        result = arr <= ts2
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = ts >= arr
+        tm.assert_numpy_array_equal(result, np.array([[True, True]], dtype=bool))
+
+        result = arr >= ts
+        tm.assert_numpy_array_equal(result, np.array([[True, False]], dtype=bool))
+
+    @pytest.mark.parametrize("reverse", [True, False])
+    def test_comparison_dt64_ndarray_tzaware(self, reverse, comparison_op):
+        ts = Timestamp("2021-01-01 00:00:00.00000", tz="UTC")
+        arr = np.array([ts.asm8, ts.asm8], dtype="M8[ns]")
+
+        left, right = ts, arr
+        if reverse:
+            left, right = arr, ts
+
+        if comparison_op is operator.eq:
+            expected = np.array([False, False], dtype=bool)
+            result = comparison_op(left, right)
+            tm.assert_numpy_array_equal(result, expected)
+        elif comparison_op is operator.ne:
+            expected = np.array([True, True], dtype=bool)
+            result = comparison_op(left, right)
+            tm.assert_numpy_array_equal(result, expected)
+        else:
+            msg = "Cannot compare tz-naive and tz-aware timestamps"
+            with pytest.raises(TypeError, match=msg):
+                comparison_op(left, right)
+
+    def test_comparison_object_array(self):
+        # GH#15183
+        ts = Timestamp("2011-01-03 00:00:00-0500", tz="US/Eastern")
+        other = Timestamp("2011-01-01 00:00:00-0500", tz="US/Eastern")
+        naive = Timestamp("2011-01-01 00:00:00")
+
+        arr = np.array([other, ts], dtype=object)
+        res = arr == ts
+        expected = np.array([False, True], dtype=bool)
+        assert (res == expected).all()
+
+        # 2D case
+        arr = np.array([[other, ts], [ts, other]], dtype=object)
+        res = arr != ts
+        expected = np.array([[True, False], [False, True]], dtype=bool)
+        assert res.shape == expected.shape
+        assert (res == expected).all()
+
+        # tzaware mismatch
+        arr = np.array([naive], dtype=object)
+        msg = "Cannot compare tz-naive and tz-aware timestamps"
+        with pytest.raises(TypeError, match=msg):
+            arr < ts
+
+    def test_comparison(self):
+        # 5-18-2012 00:00:00.000
+        stamp = 1337299200000000000
+
+        val = Timestamp(stamp)
+
+        assert val == val
+        assert not val != val
+        assert not val < val
+        assert val <= val
+        assert not val > val
+        assert val >= val
+
+        other = datetime(2012, 5, 18)
+        assert val == other
+        assert not val != other
+        assert not val < other
+        assert val <= other
+        assert not val > other
+        assert val >= other
+
+        other = Timestamp(stamp + 100)
+
+        assert val != other
+        assert val != other
+        assert val < other
+        assert val <= other
+        assert other > val
+        assert other >= val
+
+    def test_compare_invalid(self):
+        # GH#8058
+        val = Timestamp("20130101 12:01:02")
+        assert not val == "foo"
+        assert not val == 10.0
+        assert not val == 1
+        assert not val == []
+        assert not val == {"foo": 1}
+        assert not val == np.float64(1)
+        assert not val == np.int64(1)
+
+        assert val != "foo"
+        assert val != 10.0
+        assert val != 1
+        assert val != []
+        assert val != {"foo": 1}
+        assert val != np.float64(1)
+        assert val != np.int64(1)
+
+    @pytest.mark.parametrize("tz", [None, "US/Pacific"])
+    def test_compare_date(self, tz):
+        # GH#36131 comparing Timestamp with date object is deprecated
+        ts = Timestamp("2021-01-01 00:00:00.00000", tz=tz)
+        dt = ts.to_pydatetime().date()
+        # in 2.0 we disallow comparing pydate objects with Timestamps,
+        #  following the stdlib datetime behavior.
+
+        msg = "Cannot compare Timestamp with datetime.date"
+        for left, right in [(ts, dt), (dt, ts)]:
+            assert not left == right
+            assert left != right
+
+            with pytest.raises(TypeError, match=msg):
+                left < right
+            with pytest.raises(TypeError, match=msg):
+                left <= right
+            with pytest.raises(TypeError, match=msg):
+                left > right
+            with pytest.raises(TypeError, match=msg):
+                left >= right
+
+    def test_cant_compare_tz_naive_w_aware(self, utc_fixture):
+        # see GH#1404
+        a = Timestamp("3/12/2012")
+        b = Timestamp("3/12/2012", tz=utc_fixture)
+
+        msg = "Cannot compare tz-naive and tz-aware timestamps"
+        assert not a == b
+        assert a != b
+        with pytest.raises(TypeError, match=msg):
+            a < b
+        with pytest.raises(TypeError, match=msg):
+            a <= b
+        with pytest.raises(TypeError, match=msg):
+            a > b
+        with pytest.raises(TypeError, match=msg):
+            a >= b
+
+        assert not b == a
+        assert b != a
+        with pytest.raises(TypeError, match=msg):
+            b < a
+        with pytest.raises(TypeError, match=msg):
+            b <= a
+        with pytest.raises(TypeError, match=msg):
+            b > a
+        with pytest.raises(TypeError, match=msg):
+            b >= a
+
+        assert not a == b.to_pydatetime()
+        assert not a.to_pydatetime() == b
+
+    def test_timestamp_compare_scalars(self):
+        # case where ndim == 0
+        lhs = np.datetime64(datetime(2013, 12, 6))
+        rhs = Timestamp("now")
+        nat = Timestamp("nat")
+
+        ops = {"gt": "lt", "lt": "gt", "ge": "le", "le": "ge", "eq": "eq", "ne": "ne"}
+
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+            expected = left_f(lhs, rhs)
+
+            result = right_f(rhs, lhs)
+            assert result == expected
+
+            expected = left_f(rhs, nat)
+            result = right_f(nat, rhs)
+            assert result == expected
+
+    def test_timestamp_compare_with_early_datetime(self):
+        # e.g. datetime.min
+        stamp = Timestamp("2012-01-01")
+
+        assert not stamp == datetime.min
+        assert not stamp == datetime(1600, 1, 1)
+        assert not stamp == datetime(2700, 1, 1)
+        assert stamp != datetime.min
+        assert stamp != datetime(1600, 1, 1)
+        assert stamp != datetime(2700, 1, 1)
+        assert stamp > datetime(1600, 1, 1)
+        assert stamp >= datetime(1600, 1, 1)
+        assert stamp < datetime(2700, 1, 1)
+        assert stamp <= datetime(2700, 1, 1)
+
+        other = Timestamp.min.to_pydatetime(warn=False)
+        assert other - timedelta(microseconds=1) < Timestamp.min
+
+    def test_timestamp_compare_oob_dt64(self):
+        us = np.timedelta64(1, "us")
+        other = np.datetime64(Timestamp.min).astype("M8[us]")
+
+        # This may change if the implementation bound is dropped to match
+        #  DatetimeArray/DatetimeIndex GH#24124
+        assert Timestamp.min > other
+        # Note: numpy gets the reversed comparison wrong
+
+        other = np.datetime64(Timestamp.max).astype("M8[us]")
+        assert Timestamp.max > other  # not actually OOB
+        assert other < Timestamp.max
+
+        assert Timestamp.max < other + us
+        # Note: numpy gets the reversed comparison wrong
+
+        # GH-42794
+        other = datetime(9999, 9, 9)
+        assert Timestamp.min < other
+        assert other > Timestamp.min
+        assert Timestamp.max < other
+        assert other > Timestamp.max
+
+        other = datetime(1, 1, 1)
+        assert Timestamp.max > other
+        assert other < Timestamp.max
+        assert Timestamp.min > other
+        assert other < Timestamp.min
+
+    def test_compare_zerodim_array(self, fixed_now_ts):
+        # GH#26916
+        ts = fixed_now_ts
+        dt64 = np.datetime64("2016-01-01", "ns")
+        arr = np.array(dt64)
+        assert arr.ndim == 0
+
+        result = arr < ts
+        assert result is np.bool_(True)
+        result = arr > ts
+        assert result is np.bool_(False)
+
+
+def test_rich_comparison_with_unsupported_type():
+    # Comparisons with unsupported objects should return NotImplemented
+    # (it previously raised TypeError, see #24011)
+
+    class Inf:
+        def __lt__(self, o):
+            return False
+
+        def __le__(self, o):
+            return isinstance(o, Inf)
+
+        def __gt__(self, o):
+            return not isinstance(o, Inf)
+
+        def __ge__(self, o):
+            return True
+
+        def __eq__(self, other) -> bool:
+            return isinstance(other, Inf)
+
+    inf = Inf()
+    timestamp = Timestamp("2018-11-30")
+
+    for left, right in [(inf, timestamp), (timestamp, inf)]:
+        assert left > right or left < right
+        assert left >= right or left <= right
+        assert not left == right
+        assert left != right

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_constructors.py

@@ -0,0 +1,1107 @@
+import calendar
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+    timezone,
+)
+import zoneinfo
+
+import dateutil.tz
+from dateutil.tz import (
+    gettz,
+    tzoffset,
+    tzutc,
+)
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.compat import PY314
+from pandas.errors import (
+    OutOfBoundsDatetime,
+    Pandas4Warning,
+)
+
+from pandas import (
+    NA,
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestTimestampConstructorUnitKeyword:
+    @pytest.mark.parametrize("typ", [int, float])
+    def test_constructor_int_float_with_YM_unit(self, typ):
+        # GH#47266 avoid the conversions in cast_from_unit
+        val = typ(150)
+
+        ts = Timestamp(val, unit="Y")
+        expected = Timestamp("2120-01-01")
+        assert ts == expected
+
+        ts = Timestamp(val, unit="M")
+        expected = Timestamp("1982-07-01")
+        assert ts == expected
+
+    @pytest.mark.parametrize("typ", [int, float])
+    def test_construct_from_int_float_with_unit_out_of_bound_raises(self, typ):
+        # GH#50870  make sure we get an OutOfBoundsDatetime instead of OverflowError
+        val = typ(150000000000000)
+
+        msg = f"cannot convert input {int(val)} with the unit 'D'"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp(val, unit="D")
+
+    def test_constructor_float_not_round_with_YM_unit_raises(self):
+        # GH#47267 avoid the conversions in cast_from-unit
+
+        msg = "Conversion of non-round float with unit=[MY] is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(150.5, unit="Y")
+
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(150.5, unit="M")
+
+    @pytest.mark.parametrize(
+        "value, check_kwargs",
+        [
+            [946688461000000000, {}],
+            [946688461000000000 / 1000, {"unit": "us"}],
+            [946688461000000000 / 1_000_000, {"unit": "ms"}],
+            [946688461000000000 / 1_000_000_000, {"unit": "s"}],
+            [10957, {"unit": "D", "h": 0}],
+            [
+                (946688461000000000 + 500000) / 1000000000,
+                {"unit": "s", "us": 499, "ns": 964},
+            ],
+            [
+                (946688461000000000 + 500000000) / 1000000000,
+                {"unit": "s", "us": 500000},
+            ],
+            [(946688461000000000 + 500000) / 1000000, {"unit": "ms", "us": 500}],
+            [(946688461000000000 + 500000) / 1000, {"unit": "us", "us": 500}],
+            [(946688461000000000 + 500000000) / 1000000, {"unit": "ms", "us": 500000}],
+            [946688461000000000 / 1000.0 + 5, {"unit": "us", "us": 5}],
+            [946688461000000000 / 1000.0 + 5000, {"unit": "us", "us": 5000}],
+            [946688461000000000 / 1000000.0 + 0.5, {"unit": "ms", "us": 500}],
+            [946688461000000000 / 1000000.0 + 0.005, {"unit": "ms", "us": 5, "ns": 5}],
+            [946688461000000000 / 1000000000.0 + 0.5, {"unit": "s", "us": 500000}],
+            [10957 + 0.5, {"unit": "D", "h": 12}],
+        ],
+    )
+    def test_construct_with_unit(self, value, check_kwargs):
+        def check(value, unit=None, h=1, s=1, us=0, ns=0):
+            stamp = Timestamp(value, unit=unit)
+            assert stamp.year == 2000
+            assert stamp.month == 1
+            assert stamp.day == 1
+            assert stamp.hour == h
+            if unit != "D":
+                assert stamp.minute == 1
+                assert stamp.second == s
+                assert stamp.microsecond == us
+            else:
+                assert stamp.minute == 0
+                assert stamp.second == 0
+                assert stamp.microsecond == 0
+            assert stamp.nanosecond == ns
+
+        check(value, **check_kwargs)
+
+
+class TestTimestampConstructorFoldKeyword:
+    def test_timestamp_constructor_invalid_fold_raise(self):
+        # Test for GH#25057
+        # Valid fold values are only [None, 0, 1]
+        msg = "Valid values for the fold argument are None, 0, or 1."
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(123, fold=2)
+
+    def test_timestamp_constructor_pytz_fold_raise(self):
+        # Test for GH#25057
+        # pytz doesn't support fold. Check that we raise
+        # if fold is passed with pytz
+        pytz = pytest.importorskip("pytz")
+        msg = "pytz timezones do not support fold. Please use dateutil timezones."
+        tz = pytz.timezone("Europe/London")
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(datetime(2019, 10, 27, 0, 30, 0, 0), tz=tz, fold=0)
+
+    @pytest.mark.parametrize("fold", [0, 1])
+    @pytest.mark.parametrize(
+        "ts_input",
+        [
+            1572136200000000000,
+            1572136200000000000.0,
+            np.datetime64(1572136200000000000, "ns"),
+            "2019-10-27 01:30:00+01:00",
+            datetime(2019, 10, 27, 0, 30, 0, 0, tzinfo=timezone.utc),
+        ],
+    )
+    def test_timestamp_constructor_fold_conflict(self, ts_input, fold):
+        # Test for GH#25057
+        # Check that we raise on fold conflict
+        msg = (
+            "Cannot pass fold with possibly unambiguous input: int, float, "
+            "numpy.datetime64, str, or timezone-aware datetime-like. "
+            "Pass naive datetime-like or build Timestamp from components."
+        )
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(ts_input=ts_input, fold=fold)
+
+    @pytest.mark.parametrize("tz", ["dateutil/Europe/London", None])
+    @pytest.mark.parametrize("fold", [0, 1])
+    def test_timestamp_constructor_retain_fold(self, tz, fold):
+        # Test for GH#25057
+        # Check that we retain fold
+        ts = Timestamp(year=2019, month=10, day=27, hour=1, minute=30, tz=tz, fold=fold)
+        result = ts.fold
+        expected = fold
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "tz",
+        [
+            "dateutil/Europe/London",
+            zoneinfo.ZoneInfo("Europe/London"),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "ts_input,fold_out",
+        [
+            (1572136200000000000, 0),
+            (1572139800000000000, 1),
+            ("2019-10-27 01:30:00+01:00", 0),
+            ("2019-10-27 01:30:00+00:00", 1),
+            (datetime(2019, 10, 27, 1, 30, 0, 0, fold=0), 0),
+            (datetime(2019, 10, 27, 1, 30, 0, 0, fold=1), 1),
+        ],
+    )
+    def test_timestamp_constructor_infer_fold_from_value(self, tz, ts_input, fold_out):
+        # Test for GH#25057
+        # Check that we infer fold correctly based on timestamps since utc
+        # or strings
+        ts = Timestamp(ts_input, tz=tz)
+        result = ts.fold
+        expected = fold_out
+        assert result == expected
+
+    @pytest.mark.parametrize("tz", ["dateutil/Europe/London"])
+    @pytest.mark.parametrize(
+        "fold,value_out",
+        [
+            (0, 1572136200000000),
+            (1, 1572139800000000),
+        ],
+    )
+    def test_timestamp_constructor_adjust_value_for_fold(self, tz, fold, value_out):
+        # Test for GH#25057
+        # Check that we adjust value for fold correctly
+        # based on timestamps since utc
+        ts_input = datetime(2019, 10, 27, 1, 30)
+        ts = Timestamp(ts_input, tz=tz, fold=fold)
+        result = ts._value
+        expected = value_out
+        assert result == expected
+
+
+class TestTimestampConstructorPositionalAndKeywordSupport:
+    def test_constructor_positional(self):
+        # see GH#10758
+        msg = "'NoneType' object cannot be interpreted as an integer"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp(2000, 1)
+
+        msg = "month must be in 1..12"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(2000, 0, 1)
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(2000, 13, 1)
+
+        if PY314:
+            msg = "must be in range 1..31 for month 1 in year 2000"
+        else:
+            msg = "day is out of range for month"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(2000, 1, 0)
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(2000, 1, 32)
+
+        # see gh-11630
+        assert repr(Timestamp(2015, 11, 12)) == repr(Timestamp("20151112"))
+        assert repr(Timestamp(2015, 11, 12, 1, 2, 3, 999999)) == repr(
+            Timestamp("2015-11-12 01:02:03.999999")
+        )
+
+    def test_constructor_keyword(self):
+        # GH#10758
+        msg = "function missing required argument 'day'|Required argument 'day'"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp(year=2000, month=1)
+
+        msg = "month must be in 1..12"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(year=2000, month=0, day=1)
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(year=2000, month=13, day=1)
+
+        if PY314:
+            msg = "must be in range 1..31 for month 1 in year 2000"
+        else:
+            msg = "day is out of range for month"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(year=2000, month=1, day=0)
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(year=2000, month=1, day=32)
+
+        assert repr(Timestamp(year=2015, month=11, day=12)) == repr(
+            Timestamp("20151112")
+        )
+
+        assert repr(
+            Timestamp(
+                year=2015,
+                month=11,
+                day=12,
+                hour=1,
+                minute=2,
+                second=3,
+                microsecond=999999,
+            )
+        ) == repr(Timestamp("2015-11-12 01:02:03.999999"))
+
+    @pytest.mark.parametrize(
+        "arg",
+        [
+            "year",
+            "month",
+            "day",
+            "hour",
+            "minute",
+            "second",
+            "microsecond",
+            "nanosecond",
+        ],
+    )
+    def test_invalid_date_kwarg_with_string_input(self, arg):
+        kwarg = {arg: 1}
+        msg = "Cannot pass a date attribute keyword argument"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2010-10-10 12:59:59.999999999", **kwarg)
+
+    @pytest.mark.parametrize("kwargs", [{}, {"year": 2020}, {"year": 2020, "month": 1}])
+    def test_constructor_missing_keyword(self, kwargs):
+        # GH#31200
+
+        # The exact error message of datetime() depends on its version
+        msg1 = r"function missing required argument '(year|month|day)' \(pos [123]\)"
+        msg2 = r"Required argument '(year|month|day)' \(pos [123]\) not found"
+        msg = "|".join([msg1, msg2])
+
+        with pytest.raises(TypeError, match=msg):
+            Timestamp(**kwargs)
+
+    def test_constructor_positional_with_tzinfo(self):
+        # GH#31929
+        ts = Timestamp(2020, 12, 31, tzinfo=timezone.utc)
+        expected = Timestamp("2020-12-31", tzinfo=timezone.utc)
+        assert ts == expected
+
+    @pytest.mark.parametrize("kwd", ["nanosecond", "microsecond", "second", "minute"])
+    def test_constructor_positional_keyword_mixed_with_tzinfo(self, kwd, request):
+        # TODO: if we passed microsecond with a keyword we would mess up
+        #  xref GH#45307
+        if kwd != "nanosecond":
+            # nanosecond is keyword-only as of 2.0, others are not
+            mark = pytest.mark.xfail(reason="GH#45307")
+            request.applymarker(mark)
+
+        kwargs = {kwd: 4}
+        ts = Timestamp(2020, 12, 31, tzinfo=timezone.utc, **kwargs)
+
+        td_kwargs = {kwd + "s": 4}
+        td = Timedelta(**td_kwargs)
+        expected = Timestamp("2020-12-31", tz=timezone.utc) + td
+        assert ts == expected
+
+
+class TestTimestampClassMethodConstructors:
+    # Timestamp constructors other than __new__
+
+    def test_utcnow_deprecated(self):
+        # GH#56680
+        msg = "Timestamp.utcnow is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            Timestamp.utcnow()
+
+    def test_utcfromtimestamp_deprecated(self):
+        # GH#56680
+        msg = "Timestamp.utcfromtimestamp is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            Timestamp.utcfromtimestamp(43)
+
+    def test_constructor_strptime(self):
+        # GH#25016
+        # Test support for Timestamp.strptime
+        fmt = "%Y%m%d-%H%M%S-%f%z"
+        ts = "20190129-235348-000001+0000"
+        msg = r"Timestamp.strptime\(\) is not implemented"
+        with pytest.raises(NotImplementedError, match=msg):
+            Timestamp.strptime(ts, fmt)
+
+    def test_constructor_fromisocalendar(self):
+        # GH#30395
+        expected_timestamp = Timestamp("2000-01-03 00:00:00")
+        expected_stdlib = datetime.fromisocalendar(2000, 1, 1)
+        result = Timestamp.fromisocalendar(2000, 1, 1)
+        assert result == expected_timestamp
+        assert result == expected_stdlib
+        assert isinstance(result, Timestamp)
+
+    def test_constructor_fromordinal(self):
+        base = datetime(2000, 1, 1)
+
+        ts = Timestamp.fromordinal(base.toordinal())
+        assert base == ts
+        assert base.toordinal() == ts.toordinal()
+
+        ts = Timestamp.fromordinal(base.toordinal(), tz="US/Eastern")
+        assert Timestamp("2000-01-01", tz="US/Eastern") == ts
+        assert base.toordinal() == ts.toordinal()
+
+        # GH#3042
+        dt = datetime(2011, 4, 16, 0, 0)
+        ts = Timestamp.fromordinal(dt.toordinal())
+        assert ts.to_pydatetime() == dt
+
+        # with a tzinfo
+        stamp = Timestamp("2011-4-16", tz="US/Eastern")
+        dt_tz = stamp.to_pydatetime()
+        ts = Timestamp.fromordinal(dt_tz.toordinal(), tz="US/Eastern")
+        assert ts.to_pydatetime() == dt_tz
+
+    def test_now(self):
+        # GH#9000
+        ts_from_string = Timestamp("now")
+        ts_from_method = Timestamp.now()
+        ts_datetime = datetime.now()
+
+        ts_from_string_tz = Timestamp("now", tz="US/Eastern")
+        ts_from_method_tz = Timestamp.now(tz="US/Eastern")
+
+        # Check that the delta between the times is less than 1s (arbitrarily
+        # small)
+        delta = Timedelta(seconds=1)
+        assert abs(ts_from_method - ts_from_string) < delta
+        assert abs(ts_datetime - ts_from_method) < delta
+        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
+        assert (
+            abs(
+                ts_from_string_tz.tz_localize(None)
+                - ts_from_method_tz.tz_localize(None)
+            )
+            < delta
+        )
+
+    def test_today(self):
+        ts_from_string = Timestamp("today")
+        ts_from_method = Timestamp.today()
+        ts_datetime = datetime.today()
+
+        ts_from_string_tz = Timestamp("today", tz="US/Eastern")
+        ts_from_method_tz = Timestamp.today(tz="US/Eastern")
+
+        # Check that the delta between the times is less than 1s (arbitrarily
+        # small)
+        delta = Timedelta(seconds=1)
+        assert abs(ts_from_method - ts_from_string) < delta
+        assert abs(ts_datetime - ts_from_method) < delta
+        assert abs(ts_from_method_tz - ts_from_string_tz) < delta
+        assert (
+            abs(
+                ts_from_string_tz.tz_localize(None)
+                - ts_from_method_tz.tz_localize(None)
+            )
+            < delta
+        )
+
+
+class TestTimestampResolutionInference:
+    def test_construct_from_time_unit(self):
+        # GH#54097 only passing a time component, no date
+        ts = Timestamp("01:01:01.111")
+        assert ts.unit == "us"
+
+    def test_constructor_str_infer_reso(self):
+        # non-iso8601 path
+
+        # _parse_delimited_date path
+        ts = Timestamp("01/30/2023")
+        assert ts.unit == "us"
+
+        # _parse_dateabbr_string path
+        ts = Timestamp("2015Q1")
+        assert ts.unit == "us"
+
+        # dateutil_parse path
+        ts = Timestamp("2016-01-01 1:30:01 PM")
+        assert ts.unit == "us"
+
+        ts = Timestamp("2016 June 3 15:25:01.345")
+        assert ts.unit == "us"
+
+        ts = Timestamp("300-01-01")
+        assert ts.unit == "us"
+
+        ts = Timestamp("300 June 1:30:01.300")
+        assert ts.unit == "us"
+
+        # dateutil path -> don't drop trailing zeros
+        ts = Timestamp("01-01-2013T00:00:00.000000000+0000")
+        assert ts.unit == "ns"
+
+        ts = Timestamp("2016/01/02 03:04:05.001000 UTC")
+        assert ts.unit == "us"
+
+        # higher-than-nanosecond -> we drop the trailing bits
+        ts = Timestamp("01-01-2013T00:00:00.000000002100+0000")
+        assert ts == Timestamp("01-01-2013T00:00:00.000000002+0000")
+        assert ts.unit == "ns"
+
+        # GH#56208 minute reso through the ISO8601 path with tz offset
+        ts = Timestamp("2020-01-01 00:00+00:00")
+        assert ts.unit == "us"
+
+        ts = Timestamp("2020-01-01 00+00:00")
+        assert ts.unit == "us"
+
+    @pytest.mark.parametrize("method", ["now", "today"])
+    def test_now_today_unit(self, method):
+        # GH#55879
+        ts_from_method = getattr(Timestamp, method)()
+        ts_from_string = Timestamp(method)
+        assert ts_from_method.unit == ts_from_string.unit == "us"
+
+
+class TestTimestampConstructors:
+    def test_disallow_dt64_with_weird_unit(self):
+        # GH#25611
+        dt64 = np.datetime64(1, "500m")
+        msg = "np.datetime64 objects with units containing a multiplier"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(dt64)
+
+    def test_weekday_but_no_day_raises(self):
+        # GH#52659
+        msg = "Parsing datetimes with weekday but no day information is not supported"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2023 Sept Thu")
+
+    def test_construct_from_string_invalid_raises(self):
+        # dateutil (weirdly) parses "200622-12-31" as
+        #  datetime(2022, 6, 20, 12, 0, tzinfo=tzoffset(None, -111600)
+        #  which besides being mis-parsed, is a tzoffset that will cause
+        #  str(ts) to raise ValueError.  Ensure we raise in the constructor
+        #  instead.
+        # see test_to_datetime_malformed_raise for analogous to_datetime test
+        with pytest.raises(ValueError, match="gives an invalid tzoffset"):
+            Timestamp("200622-12-31")
+
+    def test_constructor_from_iso8601_str_with_offset_reso(self):
+        # GH#49737
+        ts = Timestamp("2016-01-01 04:05:06-01:00")
+        assert ts.unit == "us"
+
+        ts = Timestamp("2016-01-01 04:05:06.000-01:00")
+        assert ts.unit == "us"
+
+        ts = Timestamp("2016-01-01 04:05:06.000000-01:00")
+        assert ts.unit == "us"
+
+        ts = Timestamp("2016-01-01 04:05:06.000000001-01:00")
+        assert ts.unit == "ns"
+
+    def test_constructor_from_date_second_reso(self):
+        # GH#49034 constructing from a pydate object gets lowest supported
+        #  reso, i.e. seconds
+        obj = date(2012, 9, 1)
+        ts = Timestamp(obj)
+        assert ts.unit == "s"
+
+    def test_constructor_datetime64_with_tz(self):
+        # GH#42288, GH#24559
+        dt = np.datetime64("1970-01-01 05:00:00")
+        tzstr = "UTC+05:00"
+
+        # pre-2.0 this interpreted dt as a UTC time. in 2.0 this is treated
+        #  as a wall-time, consistent with DatetimeIndex behavior
+        ts = Timestamp(dt, tz=tzstr)
+
+        alt = Timestamp(dt).tz_localize(tzstr)
+        assert ts == alt
+        assert ts.hour == 5
+
+    def test_constructor(self):
+        base_str = "2014-07-01 09:00"
+        base_dt = datetime(2014, 7, 1, 9)
+        base_expected = 1_404_205_200_000_000_000
+
+        # confirm base representation is correct
+        assert calendar.timegm(base_dt.timetuple()) * 1_000_000_000 == base_expected
+
+        tests = [
+            (base_str, base_dt, base_expected),
+            (
+                "2014-07-01 10:00",
+                datetime(2014, 7, 1, 10),
+                base_expected + 3600 * 1_000_000_000,
+            ),
+            (
+                "2014-07-01 09:00:00.000008000",
+                datetime(2014, 7, 1, 9, 0, 0, 8),
+                base_expected + 8000,
+            ),
+            (
+                "2014-07-01 09:00:00.000000005",
+                Timestamp("2014-07-01 09:00:00.000000005"),
+                base_expected + 5,
+            ),
+        ]
+
+        timezones = [
+            (None, 0),
+            ("UTC", 0),
+            (timezone.utc, 0),
+            ("Asia/Tokyo", 9),
+            ("US/Eastern", -4),
+            ("dateutil/US/Pacific", -7),
+            (timezone(timedelta(hours=-3)), -3),
+            (dateutil.tz.tzoffset(None, 18000), 5),
+        ]
+
+        for date_str, date_obj, expected in tests:
+            for result in [Timestamp(date_str), Timestamp(date_obj)]:
+                result = result.as_unit("ns")  # test originally written before non-nano
+                # only with timestring
+                assert result.as_unit("ns")._value == expected
+
+                # re-creation shouldn't affect to internal value
+                result = Timestamp(result)
+                assert result.as_unit("ns")._value == expected
+
+            # with timezone
+            for tz, offset in timezones:
+                for result in [Timestamp(date_str, tz=tz), Timestamp(date_obj, tz=tz)]:
+                    result = result.as_unit(
+                        "ns"
+                    )  # test originally written before non-nano
+                    expected_tz = expected - offset * 3600 * 1_000_000_000
+                    assert result.as_unit("ns")._value == expected_tz
+
+                    # should preserve tz
+                    result = Timestamp(result)
+                    assert result.as_unit("ns")._value == expected_tz
+
+                    # should convert to UTC
+                    if tz is not None:
+                        result = Timestamp(result).tz_convert("UTC")
+                    else:
+                        result = Timestamp(result, tz="UTC")
+                    expected_utc = expected - offset * 3600 * 1_000_000_000
+                    assert result.as_unit("ns")._value == expected_utc
+
+    def test_constructor_with_stringoffset(self):
+        # GH 7833
+        base_str = "2014-07-01 11:00:00+02:00"
+        base_dt = datetime(2014, 7, 1, 9)
+        base_expected = 1_404_205_200_000_000_000
+
+        # confirm base representation is correct
+        assert calendar.timegm(base_dt.timetuple()) * 1_000_000_000 == base_expected
+
+        tests = [
+            (base_str, base_expected),
+            ("2014-07-01 12:00:00+02:00", base_expected + 3600 * 1_000_000_000),
+            ("2014-07-01 11:00:00.000008000+02:00", base_expected + 8000),
+            ("2014-07-01 11:00:00.000000005+02:00", base_expected + 5),
+        ]
+
+        timezones = [
+            ("UTC", 0),
+            (timezone.utc, 0),
+            ("Asia/Tokyo", 9),
+            ("US/Eastern", -4),
+            ("dateutil/US/Pacific", -7),
+            (timezone(timedelta(hours=-3)), -3),
+            (dateutil.tz.tzoffset(None, 18000), 5),
+        ]
+
+        for date_str, expected in tests:
+            for result in [Timestamp(date_str)]:
+                # only with timestring
+                assert result.as_unit("ns")._value == expected
+
+                # re-creation shouldn't affect to internal value
+                result = Timestamp(result)
+                assert result.as_unit("ns")._value == expected
+
+            # with timezone
+            for tz, offset in timezones:
+                result = Timestamp(date_str, tz=tz)
+                expected_tz = expected
+                assert result.as_unit("ns")._value == expected_tz
+
+                # should preserve tz
+                result = Timestamp(result)
+                assert result.as_unit("ns")._value == expected_tz
+
+                # should convert to UTC
+                result = Timestamp(result).tz_convert("UTC")
+                expected_utc = expected
+                assert result.as_unit("ns")._value == expected_utc
+
+        # This should be 2013-11-01 05:00 in UTC
+        # converted to Chicago tz
+        result = Timestamp("2013-11-01 00:00:00-0500", tz="America/Chicago")
+        assert result._value == Timestamp("2013-11-01 05:00")._value
+        expected = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # This should be 2013-11-01 05:00 in UTC
+        # converted to Tokyo tz (+09:00)
+        result = Timestamp("2013-11-01 00:00:00-0500", tz="Asia/Tokyo")
+        assert result._value == Timestamp("2013-11-01 05:00")._value
+        expected = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # GH11708
+        # This should be 2015-11-18 10:00 in UTC
+        # converted to Asia/Katmandu
+        result = Timestamp("2015-11-18 15:45:00+05:45", tz="Asia/Katmandu")
+        assert result._value == Timestamp("2015-11-18 10:00")._value
+        expected = "Timestamp('2015-11-18 15:45:00+0545', tz='Asia/Katmandu')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+        # This should be 2015-11-18 10:00 in UTC
+        # converted to Asia/Kolkata
+        result = Timestamp("2015-11-18 15:30:00+05:30", tz="Asia/Kolkata")
+        assert result._value == Timestamp("2015-11-18 10:00")._value
+        expected = "Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')"
+        assert repr(result) == expected
+        assert result == eval(repr(result))
+
+    def test_constructor_invalid(self):
+        msg = "Cannot convert input"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp(slice(2))
+        msg = "Cannot convert Period"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(Period("1000-01-01"))
+
+    def test_constructor_invalid_tz(self):
+        # GH#17690
+        msg = (
+            "Argument 'tzinfo' has incorrect type "
+            r"\(expected datetime.tzinfo, got str\)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Timestamp("2017-10-22", tzinfo="US/Eastern")
+
+        msg = "at most one of"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2017-10-22", tzinfo=timezone.utc, tz="UTC")
+
+        msg = "Cannot pass a date attribute keyword argument when passing a date string"
+        with pytest.raises(ValueError, match=msg):
+            # GH#5168
+            # case where user tries to pass tz as an arg, not kwarg, gets
+            # interpreted as `year`
+            Timestamp("2012-01-01", "US/Pacific")
+
+    def test_constructor_tz_or_tzinfo(self):
+        # GH#17943, GH#17690, GH#5168
+        stamps = [
+            Timestamp(year=2017, month=10, day=22, tz="UTC"),
+            Timestamp(year=2017, month=10, day=22, tzinfo=timezone.utc),
+            Timestamp(year=2017, month=10, day=22, tz=timezone.utc),
+            Timestamp(datetime(2017, 10, 22), tzinfo=timezone.utc),
+            Timestamp(datetime(2017, 10, 22), tz="UTC"),
+            Timestamp(datetime(2017, 10, 22), tz=timezone.utc),
+        ]
+        assert all(ts == stamps[0] for ts in stamps)
+
+    @pytest.mark.parametrize(
+        "result",
+        [
+            Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), nanosecond=1),
+            Timestamp(
+                year=2000,
+                month=1,
+                day=2,
+                hour=3,
+                minute=4,
+                second=5,
+                microsecond=6,
+                nanosecond=1,
+            ),
+            Timestamp(
+                year=2000,
+                month=1,
+                day=2,
+                hour=3,
+                minute=4,
+                second=5,
+                microsecond=6,
+                nanosecond=1,
+                tz="UTC",
+            ),
+            Timestamp(2000, 1, 2, 3, 4, 5, 6, None, nanosecond=1),
+            Timestamp(2000, 1, 2, 3, 4, 5, 6, tz=timezone.utc, nanosecond=1),
+        ],
+    )
+    def test_constructor_nanosecond(self, result):
+        # GH 18898
+        # As of 2.0 (GH 49416), nanosecond should not be accepted positionally
+        expected = Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), tz=result.tz)
+        expected = expected + Timedelta(nanoseconds=1)
+        assert result == expected
+
+    @pytest.mark.parametrize("z", ["Z0", "Z00"])
+    def test_constructor_invalid_Z0_isostring(self, z):
+        # GH 8910
+        msg = f"Unknown datetime string format, unable to parse: 2014-11-02 01:00{z}"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(f"2014-11-02 01:00{z}")
+
+    def test_out_of_bounds_integer_value(self):
+        # GH#26651 check that we raise OutOfBoundsDatetime, not OverflowError
+        msg = str(Timestamp.max._value * 2)
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp(Timestamp.max._value * 2)
+        msg = str(Timestamp.min._value * 2)
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp(Timestamp.min._value * 2)
+
+    def test_out_of_bounds_value(self):
+        one_us = np.timedelta64(1, "ns").astype("timedelta64[us]")
+
+        # By definition we can't go out of bounds in [ns], so we
+        # convert the datetime64s to [us] so we can go out of bounds
+        min_ts_us = np.datetime64(Timestamp.min).astype("M8[us]") + one_us
+        max_ts_us = np.datetime64(Timestamp.max).astype("M8[us]")
+
+        # No error for the min/max datetimes
+        Timestamp(min_ts_us)
+        Timestamp(max_ts_us)
+
+        # We used to raise on these before supporting non-nano
+        us_val = NpyDatetimeUnit.NPY_FR_us.value
+        assert Timestamp(min_ts_us - one_us)._creso == us_val
+        assert Timestamp(max_ts_us + one_us)._creso == us_val
+
+        # https://github.com/numpy/numpy/issues/22346 for why
+        #  we can't use the same construction as above with minute resolution
+
+        # too_low, too_high are the _just_ outside the range of M8[s]
+        too_low = np.datetime64("-292277022657-01-27T08:29", "m")
+        too_high = np.datetime64("292277026596-12-04T15:31", "m")
+
+        msg = "Out of bounds"
+        # One us less than the minimum is an error
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(too_low)
+
+        # One us more than the maximum is an error
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(too_high)
+
+    def test_out_of_bounds_string(self):
+        msg = "Cannot cast .* to unit='ns' without overflow"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("1676-01-01").as_unit("ns")
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2263-01-01").as_unit("ns")
+
+        ts = Timestamp("2263-01-01")
+        assert ts.unit == "us"
+
+        ts = Timestamp("1676-01-01")
+        assert ts.unit == "us"
+
+    def test_barely_out_of_bounds(self):
+        # GH#19529
+        # GH#19382 close enough to bounds that dropping nanos would result
+        # in an in-bounds datetime
+        msg = "Out of bounds nanosecond timestamp: 2262-04-11 23:47:16"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp("2262-04-11 23:47:16.854775808")
+
+    def test_bounds_with_different_units(self):
+        out_of_bounds_dates = ("1677-09-21", "2262-04-12")
+
+        time_units = ("D", "h", "m", "s", "ms", "us")
+
+        for date_string in out_of_bounds_dates:
+            for unit in time_units:
+                dt64 = np.datetime64(date_string, unit)
+                ts = Timestamp(dt64)
+                if unit in ["s", "ms", "us"]:
+                    # We can preserve the input unit
+                    assert ts._value == dt64.view("i8")
+                else:
+                    # we chose the closest unit that we _do_ support
+                    assert ts._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+        # With more extreme cases, we can't even fit inside second resolution
+        info = np.iinfo(np.int64)
+        msg = "Out of bounds second timestamp:"
+        for value in [info.min + 1, info.max]:
+            for unit in ["D", "h", "m"]:
+                dt64 = np.datetime64(value, unit)
+                with pytest.raises(OutOfBoundsDatetime, match=msg):
+                    Timestamp(dt64)
+
+        in_bounds_dates = ("1677-09-23", "2262-04-11")
+
+        for date_string in in_bounds_dates:
+            for unit in time_units:
+                dt64 = np.datetime64(date_string, unit)
+                Timestamp(dt64)
+
+    @pytest.mark.parametrize("arg", ["001-01-01", "0001-01-01"])
+    def test_out_of_bounds_string_consistency(self, arg):
+        # GH 15829
+        msg = "Cannot cast 0001-01-01 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp(arg).as_unit("ns")
+
+        ts = Timestamp(arg)
+        assert ts.unit == "us"
+        assert ts.year == ts.month == ts.day == 1
+
+    def test_min_valid(self):
+        # Ensure that Timestamp.min is a valid Timestamp
+        Timestamp(Timestamp.min)
+
+    def test_max_valid(self):
+        # Ensure that Timestamp.max is a valid Timestamp
+        Timestamp(Timestamp.max)
+
+    @pytest.mark.parametrize("offset", ["+0300", "+0200"])
+    def test_construct_timestamp_near_dst(self, offset):
+        # GH 20854
+        expected = Timestamp(f"2016-10-30 03:00:00{offset}", tz="Europe/Helsinki")
+        result = Timestamp(expected).tz_convert("Europe/Helsinki")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "arg", ["2013/01/01 00:00:00+09:00", "2013-01-01 00:00:00+09:00"]
+    )
+    def test_construct_with_different_string_format(self, arg):
+        # GH 12064
+        result = Timestamp(arg)
+        expected = Timestamp(datetime(2013, 1, 1), tz=timezone(timedelta(hours=9)))
+        assert result == expected
+
+    @pytest.mark.parametrize("box", [datetime, Timestamp])
+    def test_raise_tz_and_tzinfo_in_datetime_input(self, box):
+        # GH 23579
+        kwargs = {"year": 2018, "month": 1, "day": 1, "tzinfo": timezone.utc}
+        msg = "Cannot pass a datetime or Timestamp"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(box(**kwargs), tz="US/Pacific")
+        msg = "Cannot pass a datetime or Timestamp"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(box(**kwargs), tzinfo=zoneinfo.ZoneInfo("US/Pacific"))
+
+    def test_dont_convert_dateutil_utc_to_default_utc(self):
+        result = Timestamp(datetime(2018, 1, 1), tz=tzutc())
+        expected = Timestamp(datetime(2018, 1, 1)).tz_localize(tzutc())
+        assert result == expected
+
+    def test_constructor_subclassed_datetime(self):
+        # GH 25851
+        # ensure that subclassed datetime works for
+        # Timestamp creation
+        class SubDatetime(datetime):
+            pass
+
+        data = SubDatetime(2000, 1, 1)
+        result = Timestamp(data)
+        expected = Timestamp(2000, 1, 1)
+        assert result == expected
+
+    def test_timestamp_constructor_tz_utc(self):
+        utc_stamp = Timestamp("3/11/2012 05:00", tz="utc")
+        assert utc_stamp.tzinfo is timezone.utc
+        assert utc_stamp.hour == 5
+
+        utc_stamp = Timestamp("3/11/2012 05:00").tz_localize("utc")
+        assert utc_stamp.hour == 5
+
+    def test_timestamp_to_datetime_tzoffset(self):
+        tzinfo = tzoffset(None, 7200)
+        expected = Timestamp("3/11/2012 04:00", tz=tzinfo)
+        result = Timestamp(expected.to_pydatetime())
+        assert expected == result
+
+    def test_timestamp_constructor_near_dst_boundary(self):
+        # GH#11481 & GH#15777
+        # Naive string timestamps were being localized incorrectly
+        # with tz_convert_from_utc_single instead of tz_localize_to_utc
+
+        for tz in ["Europe/Brussels", "Europe/Prague"]:
+            result = Timestamp("2015-10-25 01:00", tz=tz)
+            expected = Timestamp("2015-10-25 01:00").tz_localize(tz)
+            assert result == expected
+
+            msg = "Cannot infer dst time from 2015-10-25 02:00:00"
+            with pytest.raises(ValueError, match=msg):
+                Timestamp("2015-10-25 02:00", tz=tz)
+
+        result = Timestamp("2017-03-26 01:00", tz="Europe/Paris")
+        expected = Timestamp("2017-03-26 01:00").tz_localize("Europe/Paris")
+        assert result == expected
+
+        msg = "2017-03-26 02:00"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2017-03-26 02:00", tz="Europe/Paris")
+
+        # GH#11708
+        naive = Timestamp("2015-11-18 10:00:00")
+        result = naive.tz_localize("UTC").tz_convert("Asia/Kolkata")
+        expected = Timestamp("2015-11-18 15:30:00+0530", tz="Asia/Kolkata")
+        assert result == expected
+
+        # GH#15823
+        result = Timestamp("2017-03-26 00:00", tz="Europe/Paris")
+        expected = Timestamp("2017-03-26 00:00:00+0100", tz="Europe/Paris")
+        assert result == expected
+
+        result = Timestamp("2017-03-26 01:00", tz="Europe/Paris")
+        expected = Timestamp("2017-03-26 01:00:00+0100", tz="Europe/Paris")
+        assert result == expected
+
+        msg = "2017-03-26 02:00"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2017-03-26 02:00", tz="Europe/Paris")
+
+        result = Timestamp("2017-03-26 02:00:00+0100", tz="Europe/Paris")
+        naive = Timestamp(result.as_unit("ns")._value)
+        expected = naive.tz_localize("UTC").tz_convert("Europe/Paris")
+        assert result == expected
+
+        result = Timestamp("2017-03-26 03:00", tz="Europe/Paris")
+        expected = Timestamp("2017-03-26 03:00:00+0200", tz="Europe/Paris")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "tz",
+        [
+            "pytz/US/Eastern",
+            gettz("US/Eastern"),
+            "US/Eastern",
+            "dateutil/US/Eastern",
+        ],
+    )
+    def test_timestamp_constructed_by_date_and_tz(self, tz):
+        # GH#2993, Timestamp cannot be constructed by datetime.date
+        # and tz correctly
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
+        result = Timestamp(date(2012, 3, 11), tz=tz)
+
+        expected = Timestamp("3/11/2012", tz=tz)
+        assert result.hour == expected.hour
+        assert result == expected
+
+    def test_explicit_tz_none(self):
+        # GH#48688
+        msg = "Passed data is timezone-aware, incompatible with 'tz=None'"
+        with pytest.raises(ValueError, match=msg):
+            Timestamp(datetime(2022, 1, 1, tzinfo=timezone.utc), tz=None)
+
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2022-01-01 00:00:00", tzinfo=timezone.utc, tz=None)
+
+        with pytest.raises(ValueError, match=msg):
+            Timestamp("2022-01-01 00:00:00-0400", tz=None)
+
+
+def test_constructor_ambiguous_dst():
+    # GH 24329
+    # Make sure that calling Timestamp constructor
+    # on Timestamp created from ambiguous time
+    # doesn't change Timestamp.value
+    ts = Timestamp(1382835600000000000, tz="dateutil/Europe/London")
+    expected = ts._value
+    result = Timestamp(ts)._value
+    assert result == expected
+
+
+@pytest.mark.parametrize("epoch", [1552211999999999872, 1552211999999999999])
+def test_constructor_before_dst_switch(epoch):
+    # GH 31043
+    # Make sure that calling Timestamp constructor
+    # on time just before DST switch doesn't lead to
+    # nonexistent time or value change
+    ts = Timestamp(epoch, tz="dateutil/America/Los_Angeles")
+    result = ts.tz.dst(ts)
+    expected = timedelta(seconds=0)
+    assert Timestamp(ts)._value == epoch
+    assert result == expected
+
+
+def test_timestamp_constructor_identity():
+    # Test for #30543
+    expected = Timestamp("2017-01-01T12")
+    result = Timestamp(expected)
+    assert result is expected
+
+
+@pytest.mark.parametrize("nano", [-1, 1000])
+def test_timestamp_nano_range(nano):
+    # GH 48255
+    with pytest.raises(ValueError, match="nanosecond must be in 0..999"):
+        Timestamp(year=2022, month=1, day=1, nanosecond=nano)
+
+
+def test_non_nano_value():
+    # https://github.com/pandas-dev/pandas/issues/49076
+    msg = "The 'unit' keyword is only used when"
+    with tm.assert_produces_warning(UserWarning, match=msg):
+        result = Timestamp("1800-01-01", unit="s").value
+    # `.value` shows nanoseconds, even though unit is 's'
+    assert result == -5364662400000000000
+
+    # out-of-nanoseconds-bounds `.value` raises informative message
+    msg = (
+        r"Cannot convert Timestamp to nanoseconds without overflow. "
+        r"Use `.asm8.view\('i8'\)` to cast represent Timestamp in its "
+        r"own unit \(here, us\).$"
+    )
+    ts = Timestamp("0300-01-01")
+    assert ts.unit == "us"
+    with pytest.raises(OverflowError, match=msg):
+        ts.value
+    # check that the suggested workaround actually works
+    result = ts.asm8.view("i8")
+    assert result == -52_700_112_000 * 10**6
+
+
+@pytest.mark.parametrize(
+    "na_value", [None, np.nan, np.datetime64("NaT", "ns"), NaT, NA]
+)
+def test_timestamp_constructor_na_value(na_value):
+    # GH45481
+    result = Timestamp(na_value)
+    expected = NaT
+    assert result is expected

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_formats.py

@@ -0,0 +1,206 @@
+from datetime import (
+    datetime,
+    timezone,
+)
+import pprint
+
+import dateutil.tz
+import pytest
+
+from pandas.compat import WASM
+
+from pandas import Timestamp
+
+ts_no_ns = Timestamp(
+    year=2019,
+    month=5,
+    day=18,
+    hour=15,
+    minute=17,
+    second=8,
+    microsecond=132263,
+)
+ts_no_ns_year1 = Timestamp(
+    year=1,
+    month=5,
+    day=18,
+    hour=15,
+    minute=17,
+    second=8,
+    microsecond=132263,
+)
+ts_ns = Timestamp(
+    year=2019,
+    month=5,
+    day=18,
+    hour=15,
+    minute=17,
+    second=8,
+    microsecond=132263,
+    nanosecond=123,
+)
+ts_ns_tz = Timestamp(
+    year=2019,
+    month=5,
+    day=18,
+    hour=15,
+    minute=17,
+    second=8,
+    microsecond=132263,
+    nanosecond=123,
+    tz="UTC",
+)
+ts_no_us = Timestamp(
+    year=2019,
+    month=5,
+    day=18,
+    hour=15,
+    minute=17,
+    second=8,
+    microsecond=0,
+    nanosecond=123,
+)
+
+
+@pytest.mark.parametrize(
+    "ts, timespec, expected_iso",
+    [
+        (ts_no_ns, "auto", "2019-05-18T15:17:08.132263"),
+        (ts_no_ns, "seconds", "2019-05-18T15:17:08"),
+        (ts_no_ns, "nanoseconds", "2019-05-18T15:17:08.132263000"),
+        (ts_no_ns_year1, "seconds", "0001-05-18T15:17:08"),
+        (ts_no_ns_year1, "nanoseconds", "0001-05-18T15:17:08.132263000"),
+        (ts_ns, "auto", "2019-05-18T15:17:08.132263123"),
+        (ts_ns, "hours", "2019-05-18T15"),
+        (ts_ns, "minutes", "2019-05-18T15:17"),
+        (ts_ns, "seconds", "2019-05-18T15:17:08"),
+        (ts_ns, "milliseconds", "2019-05-18T15:17:08.132"),
+        (ts_ns, "microseconds", "2019-05-18T15:17:08.132263"),
+        (ts_ns, "nanoseconds", "2019-05-18T15:17:08.132263123"),
+        (ts_ns_tz, "auto", "2019-05-18T15:17:08.132263123+00:00"),
+        (ts_ns_tz, "hours", "2019-05-18T15+00:00"),
+        (ts_ns_tz, "minutes", "2019-05-18T15:17+00:00"),
+        (ts_ns_tz, "seconds", "2019-05-18T15:17:08+00:00"),
+        (ts_ns_tz, "milliseconds", "2019-05-18T15:17:08.132+00:00"),
+        (ts_ns_tz, "microseconds", "2019-05-18T15:17:08.132263+00:00"),
+        (ts_ns_tz, "nanoseconds", "2019-05-18T15:17:08.132263123+00:00"),
+        (ts_no_us, "auto", "2019-05-18T15:17:08.000000123"),
+    ],
+)
+def test_isoformat(ts, timespec, expected_iso):
+    assert ts.isoformat(timespec=timespec) == expected_iso
+
+
+class TestTimestampRendering:
+    @pytest.mark.parametrize(
+        "tz", ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/America/Los_Angeles"]
+    )
+    @pytest.mark.parametrize("freq", ["D", "M", "S", "N"])
+    @pytest.mark.parametrize(
+        "date", ["2014-03-07", "2014-01-01 09:00", "2014-01-01 00:00:00.000000001"]
+    )
+    @pytest.mark.skipif(WASM, reason="tzset is not available on WASM")
+    def test_repr(self, date, freq, tz):
+        # avoid to match with timezone name
+        freq_repr = f"'{freq}'"
+        if tz.startswith("dateutil"):
+            tz_repr = tz.replace("dateutil", "")
+        else:
+            tz_repr = tz
+
+        date_only = Timestamp(date)
+        assert date in repr(date_only)
+        assert tz_repr not in repr(date_only)
+        assert freq_repr not in repr(date_only)
+        assert date_only == eval(repr(date_only))
+
+        date_tz = Timestamp(date, tz=tz)
+        assert date in repr(date_tz)
+        assert tz_repr in repr(date_tz)
+        assert freq_repr not in repr(date_tz)
+        assert date_tz == eval(repr(date_tz))
+
+    def test_repr_utcoffset(self):
+        # This can cause the tz field to be populated, but it's redundant to
+        # include this information in the date-string.
+        date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400")
+        assert "2014-03-13 00:00:00-0400" in repr(date_with_utc_offset)
+        assert "tzoffset" not in repr(date_with_utc_offset)
+        assert "UTC-04:00" in repr(date_with_utc_offset)
+        expr = repr(date_with_utc_offset)
+        assert date_with_utc_offset == eval(expr)
+
+    def test_timestamp_repr_pre1900(self):
+        # pre-1900
+        stamp = Timestamp("1850-01-01", tz="US/Eastern")
+        repr(stamp)
+
+        iso8601 = "1850-01-01 01:23:45.012345"
+        stamp = Timestamp(iso8601, tz="US/Eastern")
+        result = repr(stamp)
+        assert iso8601 in result
+
+    def test_pprint(self):
+        # GH#12622
+        nested_obj = {"foo": 1, "bar": [{"w": {"a": Timestamp("2011-01-01")}}] * 10}
+        result = pprint.pformat(nested_obj, width=50)
+        expected = r"""{'bar': [{'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}},
+         {'w': {'a': Timestamp('2011-01-01 00:00:00')}}],
+ 'foo': 1}"""
+        assert result == expected
+
+    def test_to_timestamp_repr_is_code(self):
+        zs = [
+            Timestamp("99-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="UTC"),
+            Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"),
+            Timestamp("2001-04-17 00:00:00", tz=None),
+        ]
+        for z in zs:
+            assert eval(repr(z)) == z
+
+    def test_repr_matches_pydatetime_no_tz(self):
+        dt_date = datetime(2013, 1, 2)
+        assert str(dt_date) == str(Timestamp(dt_date))
+
+        dt_datetime = datetime(2013, 1, 2, 12, 1, 3)
+        assert str(dt_datetime) == str(Timestamp(dt_datetime))
+
+        dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45)
+        assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us))
+
+        ts_nanos_only = Timestamp(200)
+        assert str(ts_nanos_only) == "1970-01-01 00:00:00.000000200"
+
+        ts_nanos_micros = Timestamp(1200)
+        assert str(ts_nanos_micros) == "1970-01-01 00:00:00.000001200"
+
+    def test_repr_matches_pydatetime_tz_stdlib(self):
+        dt_date = datetime(2013, 1, 2, tzinfo=timezone.utc)
+        assert str(dt_date) == str(Timestamp(dt_date))
+
+        dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=timezone.utc)
+        assert str(dt_datetime) == str(Timestamp(dt_datetime))
+
+        dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=timezone.utc)
+        assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us))
+
+    def test_repr_matches_pydatetime_tz_dateutil(self):
+        utc = dateutil.tz.tzutc()
+
+        dt_date = datetime(2013, 1, 2, tzinfo=utc)
+        assert str(dt_date) == str(Timestamp(dt_date))
+
+        dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=utc)
+        assert str(dt_datetime) == str(Timestamp(dt_datetime))
+
+        dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=utc)
+        assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us))

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_timestamp.py

@@ -0,0 +1,938 @@
+"""test the scalar Timestamp"""
+
+import calendar
+from datetime import (
+    datetime,
+    timedelta,
+    timezone,
+)
+import locale
+import time
+import unicodedata
+import zoneinfo
+
+from dateutil.tz import (
+    tzlocal,
+    tzutc,
+)
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas._libs.tslibs.timezones import (
+    dateutil_gettz as gettz,
+    get_timezone,
+    maybe_get_tz,
+    tz_compare,
+)
+from pandas.compat import IS64
+from pandas.compat.numpy import (
+    is_numpy_dev,
+    np_version_gt2_5,
+)
+from pandas.errors import Pandas4Warning
+
+from pandas import (
+    NaT,
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+from pandas.tseries.frequencies import to_offset
+
+
+class TestTimestampProperties:
+    def test_properties_business(self):
+        freq = to_offset("B")
+
+        ts = Timestamp("2017-10-01")
+        assert ts.dayofweek == 6
+        assert ts.day_of_week == 6
+        assert ts.is_month_start  # not a weekday
+        assert not freq.is_month_start(ts)
+        assert freq.is_month_start(ts + Timedelta(days=1))
+        assert not freq.is_quarter_start(ts)
+        assert freq.is_quarter_start(ts + Timedelta(days=1))
+
+        ts = Timestamp("2017-09-30")
+        assert ts.dayofweek == 5
+        assert ts.day_of_week == 5
+        assert ts.is_month_end
+        assert not freq.is_month_end(ts)
+        assert freq.is_month_end(ts - Timedelta(days=1))
+        assert ts.is_quarter_end
+        assert not freq.is_quarter_end(ts)
+        assert freq.is_quarter_end(ts - Timedelta(days=1))
+
+    @pytest.mark.parametrize(
+        "attr, expected",
+        [
+            ["year", 2014],
+            ["month", 12],
+            ["day", 31],
+            ["hour", 23],
+            ["minute", 59],
+            ["second", 0],
+            ["microsecond", 0],
+            ["nanosecond", 0],
+            ["dayofweek", 2],
+            ["day_of_week", 2],
+            ["quarter", 4],
+            ["dayofyear", 365],
+            ["day_of_year", 365],
+            ["week", 1],
+            ["daysinmonth", 31],
+        ],
+    )
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_fields(self, attr, expected, tz):
+        # GH 10050
+        # GH 13303
+        ts = Timestamp("2014-12-31 23:59:00", tz=tz)
+        result = getattr(ts, attr)
+        # that we are int like
+        assert isinstance(result, int)
+        assert result == expected
+
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_millisecond_raises(self, tz):
+        ts = Timestamp("2014-12-31 23:59:00", tz=tz)
+        msg = "'Timestamp' object has no attribute 'millisecond'"
+        with pytest.raises(AttributeError, match=msg):
+            ts.millisecond
+
+    @pytest.mark.parametrize(
+        "start", ["is_month_start", "is_quarter_start", "is_year_start"]
+    )
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_is_start(self, start, tz):
+        ts = Timestamp("2014-01-01 00:00:00", tz=tz)
+        assert getattr(ts, start)
+
+    @pytest.mark.parametrize("end", ["is_month_end", "is_year_end", "is_quarter_end"])
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_is_end(self, end, tz):
+        ts = Timestamp("2014-12-31 23:59:59", tz=tz)
+        assert getattr(ts, end)
+
+    # GH 12806
+    @pytest.mark.parametrize("tz", [None, "EST"])
+    @pytest.mark.parametrize(
+        "time_locale",
+        [None, *tm.get_locales()],
+    )
+    def test_names(self, tz, time_locale):
+        # GH 17354
+        # Test .day_name(), .month_name
+        data = Timestamp("2017-08-28 23:00:00", tz=tz)
+        if time_locale is None:
+            expected_day = "Monday"
+            expected_month = "August"
+        else:
+            with tm.set_locale(time_locale, locale.LC_TIME):
+                expected_day = calendar.day_name[0].capitalize()
+                expected_month = calendar.month_name[8].capitalize()
+
+        result_day = data.day_name(time_locale)
+        result_month = data.month_name(time_locale)
+
+        # Work around https://github.com/pandas-dev/pandas/issues/22342
+        # different normalizations
+        expected_day = unicodedata.normalize("NFD", expected_day)
+        expected_month = unicodedata.normalize("NFD", expected_month)
+
+        result_day = unicodedata.normalize("NFD", result_day)
+        result_month = unicodedata.normalize("NFD", result_month)
+
+        assert result_day == expected_day
+        assert result_month == expected_month
+
+        # Test NaT
+        nan_ts = Timestamp(NaT)
+        assert np.isnan(nan_ts.day_name(time_locale))
+        assert np.isnan(nan_ts.month_name(time_locale))
+
+    def test_is_leap_year(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        if not IS64 and tz == tzlocal():
+            # https://github.com/dateutil/dateutil/issues/197
+            pytest.skip(
+                "tzlocal() on a 32 bit platform causes internal overflow errors"
+            )
+        # GH 13727
+        dt = Timestamp("2000-01-01 00:00:00", tz=tz)
+        assert dt.is_leap_year
+        assert isinstance(dt.is_leap_year, bool)
+
+        dt = Timestamp("1999-01-01 00:00:00", tz=tz)
+        assert not dt.is_leap_year
+
+        dt = Timestamp("2004-01-01 00:00:00", tz=tz)
+        assert dt.is_leap_year
+
+        dt = Timestamp("2100-01-01 00:00:00", tz=tz)
+        assert not dt.is_leap_year
+
+    def test_woy_boundary(self):
+        # make sure weeks at year boundaries are correct
+        d = datetime(2013, 12, 31)
+        result = Timestamp(d).week
+        expected = 1  # ISO standard
+        assert result == expected
+
+        d = datetime(2008, 12, 28)
+        result = Timestamp(d).week
+        expected = 52  # ISO standard
+        assert result == expected
+
+        d = datetime(2009, 12, 31)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        assert result == expected
+
+        d = datetime(2010, 1, 1)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        assert result == expected
+
+        d = datetime(2010, 1, 3)
+        result = Timestamp(d).week
+        expected = 53  # ISO standard
+        assert result == expected
+
+        result = np.array(
+            [
+                Timestamp(datetime(*args)).week
+                for args in [(2000, 1, 1), (2000, 1, 2), (2005, 1, 1), (2005, 1, 2)]
+            ]
+        )
+        assert (result == [52, 52, 53, 53]).all()
+
+    def test_resolution(self):
+        # GH#21336, GH#21365
+        dt = Timestamp("2100-01-01 00:00:00.000000000")
+        assert dt.resolution == Timedelta(nanoseconds=1)
+
+        # Check that the attribute is available on the class, mirroring
+        #  the stdlib datetime behavior
+        assert Timestamp.resolution == Timedelta(nanoseconds=1)
+
+        assert dt.as_unit("us").resolution == Timedelta(microseconds=1)
+        assert dt.as_unit("ms").resolution == Timedelta(milliseconds=1)
+        assert dt.as_unit("s").resolution == Timedelta(seconds=1)
+
+    @pytest.mark.parametrize(
+        "date_string, expected",
+        [
+            ("0000-2-29", 1),
+            ("0000-3-1", 2),
+            ("1582-10-14", 3),
+            ("-0040-1-1", 4),
+            ("2023-06-18", 6),
+        ],
+    )
+    def test_dow_historic(self, date_string, expected):
+        # GH 53738
+        ts = Timestamp(date_string)
+        dow = ts.weekday()
+        assert dow == expected
+
+    @pytest.mark.slow
+    @given(
+        ts=st.datetimes(),
+        sign=st.sampled_from(["-", ""]),
+    )
+    def test_dow_parametric(self, ts, sign):
+        # GH 53738
+        ts = (
+            f"{sign}{str(ts.year).zfill(4)}"
+            f"-{str(ts.month).zfill(2)}"
+            f"-{str(ts.day).zfill(2)}"
+        )
+        result = Timestamp(ts).weekday()
+        expected = (
+            (np.datetime64(ts) - np.datetime64("1970-01-01")).astype("int64") - 4
+        ) % 7
+        assert result == expected
+
+
+class TestTimestamp:
+    @pytest.mark.parametrize("tz", [None, zoneinfo.ZoneInfo("US/Pacific")])
+    def test_disallow_setting_tz(self, tz):
+        # GH#3746
+        ts = Timestamp("2010")
+        msg = "Cannot directly set timezone"
+        with pytest.raises(AttributeError, match=msg):
+            ts.tz = tz
+
+    def test_default_to_stdlib_utc(self):
+        msg = "Timestamp.utcnow is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            assert Timestamp.utcnow().tz is timezone.utc
+        assert Timestamp.now("UTC").tz is timezone.utc
+        assert Timestamp("2016-01-01", tz="UTC").tz is timezone.utc
+
+    def test_tz(self):
+        tstr = "2014-02-01 09:00"
+        ts = Timestamp(tstr)
+        local = ts.tz_localize("Asia/Tokyo")
+        assert local.hour == 9
+        assert local == Timestamp(tstr, tz="Asia/Tokyo")
+        conv = local.tz_convert("US/Eastern")
+        assert conv == Timestamp("2014-01-31 19:00", tz="US/Eastern")
+        assert conv.hour == 19
+
+        # preserves nanosecond
+        ts = Timestamp(tstr) + offsets.Nano(5)
+        local = ts.tz_localize("Asia/Tokyo")
+        assert local.hour == 9
+        assert local.nanosecond == 5
+        conv = local.tz_convert("US/Eastern")
+        assert conv.nanosecond == 5
+        assert conv.hour == 19
+
+    def test_utc_z_designator(self):
+        assert get_timezone(Timestamp("2014-11-02 01:00Z").tzinfo) is timezone.utc
+
+    def test_asm8(self):
+        ns = [Timestamp.min._value, Timestamp.max._value, 1000]
+
+        for n in ns:
+            assert (
+                Timestamp(n).asm8.view("i8") == np.datetime64(n, "ns").view("i8") == n
+            )
+
+        assert Timestamp("nat").asm8.view("i8") == np.datetime64("nat", "ns").view("i8")
+
+    def test_class_ops(self):
+        def compare(x, y):
+            assert int((Timestamp(x)._value - Timestamp(y)._value) / 1e9) == 0
+
+        compare(Timestamp.now(), datetime.now())
+        compare(Timestamp.now("UTC"), datetime.now(timezone.utc))
+        compare(Timestamp.now("UTC"), datetime.now(tzutc()))
+        msg = "Timestamp.utcnow is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            compare(Timestamp.utcnow(), datetime.now(timezone.utc))
+        compare(Timestamp.today(), datetime.today())
+        current_time = calendar.timegm(datetime.now().utctimetuple())
+
+        msg = "Timestamp.utcfromtimestamp is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            ts_utc = Timestamp.utcfromtimestamp(current_time)
+        assert ts_utc.timestamp() == current_time
+        compare(
+            Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time)
+        )
+        compare(
+            # Support tz kwarg in Timestamp.fromtimestamp
+            Timestamp.fromtimestamp(current_time, "UTC"),
+            datetime.fromtimestamp(current_time, timezone.utc),
+        )
+        compare(
+            # Support tz kwarg in Timestamp.fromtimestamp
+            Timestamp.fromtimestamp(current_time, tz="UTC"),
+            datetime.fromtimestamp(current_time, timezone.utc),
+        )
+
+        date_component = datetime.now(timezone.utc)
+        time_component = (date_component + timedelta(minutes=10)).time()
+        compare(
+            Timestamp.combine(date_component, time_component),
+            datetime.combine(date_component, time_component),
+        )
+
+    def test_basics_nanos(self):
+        val = np.int64(946_684_800_000_000_000).view("M8[ns]")
+        stamp = Timestamp(val.view("i8") + 500)
+        assert stamp.year == 2000
+        assert stamp.month == 1
+        assert stamp.microsecond == 0
+        assert stamp.nanosecond == 500
+
+        # GH 14415
+        val = np.iinfo(np.int64).min + 80_000_000_000_000
+        stamp = Timestamp(val)
+        assert stamp.year == 1677
+        assert stamp.month == 9
+        assert stamp.day == 21
+        assert stamp.microsecond == 145224
+        assert stamp.nanosecond == 192
+
+    def test_roundtrip(self):
+        # test value to string and back conversions
+        # further test accessors
+        base = Timestamp("20140101 00:00:00").as_unit("ns")
+
+        result = Timestamp(base._value + Timedelta("5ms").value)
+        assert result == Timestamp(f"{base}.005000")
+        assert result.microsecond == 5000
+
+        result = Timestamp(base._value + Timedelta("5us").value)
+        assert result == Timestamp(f"{base}.000005")
+        assert result.microsecond == 5
+
+        result = Timestamp(base._value + Timedelta("5ns")._value)
+        assert result == Timestamp(f"{base}.000000005")
+        assert result.nanosecond == 5
+        assert result.microsecond == 0
+
+        result = Timestamp(base._value + Timedelta("6ms 5us").value)
+        assert result == Timestamp(f"{base}.006005")
+        assert result.microsecond == 5 + 6 * 1000
+
+        result = Timestamp(base._value + Timedelta("200ms 5us").value)
+        assert result == Timestamp(f"{base}.200005")
+        assert result.microsecond == 5 + 200 * 1000
+
+    def test_hash_equivalent(self):
+        d = {datetime(2011, 1, 1): 5}
+        stamp = Timestamp(datetime(2011, 1, 1))
+        assert d[stamp] == 5
+
+    @pytest.mark.parametrize(
+        "timezone, year, month, day, hour",
+        [["America/Chicago", 2013, 11, 3, 1], ["America/Santiago", 2021, 4, 3, 23]],
+    )
+    def test_hash_timestamp_with_fold(self, timezone, year, month, day, hour):
+        # see gh-33931
+        test_timezone = gettz(timezone)
+        transition_1 = Timestamp(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=0,
+            fold=0,
+            tzinfo=test_timezone,
+        )
+        transition_2 = Timestamp(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=0,
+            fold=1,
+            tzinfo=test_timezone,
+        )
+        assert hash(transition_1) == hash(transition_2)
+
+
+class TestTimestampNsOperations:
+    def test_nanosecond_string_parsing(self):
+        ts = Timestamp("2013-05-01 07:15:45.123456789")
+        # GH 7878
+        expected_repr = "2013-05-01 07:15:45.123456789"
+        expected_value = 1_367_392_545_123_456_789
+        assert ts._value == expected_value
+        assert expected_repr in repr(ts)
+
+        ts = Timestamp("2013-05-01 07:15:45.123456789+09:00", tz="Asia/Tokyo")
+        assert ts._value == expected_value - 9 * 3600 * 1_000_000_000
+        assert expected_repr in repr(ts)
+
+        ts = Timestamp("2013-05-01 07:15:45.123456789", tz="UTC")
+        assert ts._value == expected_value
+        assert expected_repr in repr(ts)
+
+        ts = Timestamp("2013-05-01 07:15:45.123456789", tz="US/Eastern")
+        assert ts._value == expected_value + 4 * 3600 * 1_000_000_000
+        assert expected_repr in repr(ts)
+
+        # GH 10041
+        ts = Timestamp("20130501T071545.123456789")
+        assert ts._value == expected_value
+        assert expected_repr in repr(ts)
+
+    def test_nanosecond_timestamp(self):
+        # GH 7610
+        expected = 1_293_840_000_000_000_005
+        t = Timestamp("2011-01-01") + offsets.Nano(5)
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
+        assert t._value == expected
+        assert t.nanosecond == 5
+
+        t = Timestamp(t)
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
+        assert t._value == expected
+        assert t.nanosecond == 5
+
+        t = Timestamp("2011-01-01 00:00:00.000000005")
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
+        assert t._value == expected
+        assert t.nanosecond == 5
+
+        expected = 1_293_840_000_000_000_010
+        t = t + offsets.Nano(5)
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
+        assert t._value == expected
+        assert t.nanosecond == 10
+
+        t = Timestamp(t)
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
+        assert t._value == expected
+        assert t.nanosecond == 10
+
+        t = Timestamp("2011-01-01 00:00:00.000000010")
+        assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
+        assert t._value == expected
+        assert t.nanosecond == 10
+
+
+class TestTimestampConversion:
+    def test_conversion(self):
+        # GH#9255
+        ts = Timestamp("2000-01-01").as_unit("ns")
+
+        result = ts.to_pydatetime()
+        expected = datetime(2000, 1, 1)
+        assert result == expected
+        assert type(result) == type(expected)
+
+        result = ts.to_datetime64()
+        expected = np.datetime64(ts._value, "ns")
+        assert result == expected
+        assert type(result) == type(expected)
+        assert result.dtype == expected.dtype
+
+    def test_to_period_tz_warning(self):
+        # GH#21333 make sure a warning is issued when timezone
+        # info is lost
+        ts = Timestamp("2009-04-15 16:17:18", tz="US/Eastern")
+        with tm.assert_produces_warning(UserWarning, match="drop timezone information"):
+            ts.to_period("D")
+
+    def test_to_numpy_alias(self):
+        # GH 24653: alias .to_numpy() for scalars
+        ts = Timestamp(datetime.now())
+        assert ts.to_datetime64() == ts.to_numpy()
+
+        # GH#44460
+        msg = "dtype and copy arguments are ignored"
+        with pytest.raises(ValueError, match=msg):
+            ts.to_numpy("M8[s]")
+        with pytest.raises(ValueError, match=msg):
+            ts.to_numpy(copy=True)
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def reso(self, request):
+        return request.param
+
+    @pytest.fixture
+    def dt64(self, reso):
+        # cases that are in-bounds for nanosecond, so we can compare against
+        #  the existing implementation.
+        return np.datetime64("2016-01-01", reso)
+
+    @pytest.fixture
+    def ts(self, dt64):
+        return Timestamp._from_dt64(dt64)
+
+    @pytest.fixture
+    def ts_tz(self, ts, tz_aware_fixture):
+        tz = maybe_get_tz(tz_aware_fixture)
+        return Timestamp._from_value_and_reso(ts._value, ts._creso, tz)
+
+    def test_non_nano_construction(self, dt64, ts, reso):
+        assert ts._value == dt64.view("i8")
+
+        if reso == "s":
+            assert ts._creso == NpyDatetimeUnit.NPY_FR_s.value
+        elif reso == "ms":
+            assert ts._creso == NpyDatetimeUnit.NPY_FR_ms.value
+        elif reso == "us":
+            assert ts._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+    def test_non_nano_fields(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert ts.year == alt.year
+        assert ts.month == alt.month
+        assert ts.day == alt.day
+        assert ts.hour == ts.minute == ts.second == ts.microsecond == 0
+        assert ts.nanosecond == 0
+
+        assert ts.to_julian_date() == alt.to_julian_date()
+        assert ts.weekday() == alt.weekday()
+        assert ts.isoweekday() == alt.isoweekday()
+
+    def test_start_end_fields(self, ts):
+        assert ts.is_year_start
+        assert ts.is_quarter_start
+        assert ts.is_month_start
+        assert not ts.is_year_end
+        assert not ts.is_month_end
+        assert not ts.is_month_end
+
+        # 2016-01-01 is a Friday, so is year/quarter/month start with this freq
+        assert ts.is_year_start
+        assert ts.is_quarter_start
+        assert ts.is_month_start
+        assert not ts.is_year_end
+        assert not ts.is_month_end
+        assert not ts.is_month_end
+
+    def test_day_name(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.day_name() == alt.day_name()
+
+    def test_month_name(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.month_name() == alt.month_name()
+
+    def test_tz_convert(self, ts):
+        ts = Timestamp._from_value_and_reso(ts._value, ts._creso, timezone.utc)
+
+        tz = zoneinfo.ZoneInfo("US/Pacific")
+        result = ts.tz_convert(tz)
+
+        assert isinstance(result, Timestamp)
+        assert result._creso == ts._creso
+        assert tz_compare(result.tz, tz)
+
+    def test_repr(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert str(ts) == str(alt)
+        assert repr(ts) == repr(alt)
+
+    def test_comparison(self, dt64, ts):
+        alt = Timestamp(dt64)
+
+        assert ts == dt64
+        assert dt64 == ts
+        assert ts == alt
+        assert alt == ts
+
+        assert not ts != dt64
+        assert not dt64 != ts
+        assert not ts != alt
+        assert not alt != ts
+
+        assert not ts < dt64
+        assert not dt64 < ts
+        assert not ts < alt
+        assert not alt < ts
+
+        assert not ts > dt64
+        assert not dt64 > ts
+        assert not ts > alt
+        assert not alt > ts
+
+        assert ts >= dt64
+        assert dt64 >= ts
+        assert ts >= alt
+        assert alt >= ts
+
+        assert ts <= dt64
+        assert dt64 <= ts
+        assert ts <= alt
+        assert alt <= ts
+
+    def test_cmp_cross_reso(self):
+        # numpy gets this wrong because of silent overflow
+        dt64 = np.datetime64(9223372800, "s")  # won't fit in M8[ns]
+        ts = Timestamp._from_dt64(dt64)
+
+        # subtracting 3600*24 gives a datetime64 that _can_ fit inside the
+        #  nanosecond implementation bounds.
+        other = Timestamp(dt64 - np.timedelta64(3600 * 24, "s")).as_unit("ns")
+        assert other < ts
+        if not is_numpy_dev and not np_version_gt2_5:
+            assert other.asm8 > ts.asm8  # <- numpy gets this wrong
+        assert ts > other
+        if not is_numpy_dev and not np_version_gt2_5:
+            assert ts.asm8 < other.asm8  # <- numpy gets this wrong
+        assert not other == ts
+        assert ts != other
+
+    @pytest.mark.xfail(reason="Dispatches to np.datetime64 which is wrong")
+    def test_cmp_cross_reso_reversed_dt64(self):
+        dt64 = np.datetime64(106752, "D")  # won't fit in M8[ns]
+        ts = Timestamp._from_dt64(dt64)
+        other = Timestamp(dt64 - 1)
+
+        assert other.asm8 < ts
+
+    def test_pickle(self, ts, tz_aware_fixture, temp_file):
+        tz = tz_aware_fixture
+        tz = maybe_get_tz(tz)
+        ts = Timestamp._from_value_and_reso(ts._value, ts._creso, tz)
+        rt = tm.round_trip_pickle(ts, temp_file)
+        assert rt._creso == ts._creso
+        assert rt == ts
+
+    def test_normalize(self, dt64, ts):
+        alt = Timestamp(dt64)
+        result = ts.normalize()
+        assert result._creso == ts._creso
+        assert result == alt.normalize()
+
+    def test_asm8(self, dt64, ts):
+        rt = ts.asm8
+        assert rt == dt64
+        assert rt.dtype == dt64.dtype
+
+    def test_to_numpy(self, dt64, ts):
+        res = ts.to_numpy()
+        assert res == dt64
+        assert res.dtype == dt64.dtype
+
+    def test_to_datetime64(self, dt64, ts):
+        res = ts.to_datetime64()
+        assert res == dt64
+        assert res.dtype == dt64.dtype
+
+    def test_timestamp(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.timestamp() == alt.timestamp()
+
+    def test_to_period(self, dt64, ts):
+        alt = Timestamp(dt64)
+        assert ts.to_period("D") == alt.to_period("D")
+
+    @pytest.mark.parametrize(
+        "td", [timedelta(days=4), Timedelta(days=4), np.timedelta64(4, "D")]
+    )
+    def test_addsub_timedeltalike_non_nano(self, dt64, ts, td):
+        exp_reso = max(ts._creso, Timedelta(td)._creso)
+
+        result = ts - td
+        expected = Timestamp(dt64) - td
+        assert isinstance(result, Timestamp)
+        assert result._creso == exp_reso
+        assert result == expected
+
+        result = ts + td
+        expected = Timestamp(dt64) + td
+        assert isinstance(result, Timestamp)
+        assert result._creso == exp_reso
+        assert result == expected
+
+        result = td + ts
+        expected = td + Timestamp(dt64)
+        assert isinstance(result, Timestamp)
+        assert result._creso == exp_reso
+        assert result == expected
+
+    def test_addsub_offset(self, ts_tz):
+        # specifically non-Tick offset
+        off = offsets.YearEnd(1)
+        result = ts_tz + off
+
+        assert isinstance(result, Timestamp)
+        assert result._creso == ts_tz._creso
+        if ts_tz.month == 12 and ts_tz.day == 31:
+            assert result.year == ts_tz.year + 1
+        else:
+            assert result.year == ts_tz.year
+        assert result.day == 31
+        assert result.month == 12
+        assert tz_compare(result.tz, ts_tz.tz)
+
+        result = ts_tz - off
+
+        assert isinstance(result, Timestamp)
+        assert result._creso == ts_tz._creso
+        assert result.year == ts_tz.year - 1
+        assert result.day == 31
+        assert result.month == 12
+        assert tz_compare(result.tz, ts_tz.tz)
+
+    def test_sub_datetimelike_mismatched_reso(self, ts_tz):
+        # case with non-lossy rounding
+        ts = ts_tz
+
+        # choose a unit for `other` that doesn't match ts_tz's;
+        #  this construction ensures we get cases with other._creso < ts._creso
+        #  and cases with other._creso > ts._creso
+        unit = {
+            NpyDatetimeUnit.NPY_FR_us.value: "ms",
+            NpyDatetimeUnit.NPY_FR_ms.value: "s",
+            NpyDatetimeUnit.NPY_FR_s.value: "us",
+        }[ts._creso]
+        other = ts.as_unit(unit)
+        assert other._creso != ts._creso
+
+        result = ts - other
+        assert isinstance(result, Timedelta)
+        assert result._value == 0
+        assert result._creso == max(ts._creso, other._creso)
+
+        result = other - ts
+        assert isinstance(result, Timedelta)
+        assert result._value == 0
+        assert result._creso == max(ts._creso, other._creso)
+
+        if ts._creso < other._creso:
+            # Case where rounding is lossy
+            other2 = other + Timedelta._from_value_and_reso(1, other._creso)
+            exp = ts.as_unit(other.unit) - other2
+
+            res = ts - other2
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+
+            res = other2 - ts
+            assert res == -exp
+            assert res._creso == max(ts._creso, other._creso)
+        else:
+            ts2 = ts + Timedelta._from_value_and_reso(1, ts._creso)
+            exp = ts2 - other.as_unit(ts2.unit)
+
+            res = ts2 - other
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+            res = other - ts2
+            assert res == -exp
+            assert res._creso == max(ts._creso, other._creso)
+
+    def test_sub_timedeltalike_mismatched_reso(self, ts_tz):
+        # case with non-lossy rounding
+        ts = ts_tz
+
+        # choose a unit for `other` that doesn't match ts_tz's;
+        #  this construction ensures we get cases with other._creso < ts._creso
+        #  and cases with other._creso > ts._creso
+        unit = {
+            NpyDatetimeUnit.NPY_FR_us.value: "ms",
+            NpyDatetimeUnit.NPY_FR_ms.value: "s",
+            NpyDatetimeUnit.NPY_FR_s.value: "us",
+        }[ts._creso]
+        other = Timedelta(0).as_unit(unit)
+        assert other._creso != ts._creso
+
+        result = ts + other
+        assert isinstance(result, Timestamp)
+        assert result == ts
+        assert result._creso == max(ts._creso, other._creso)
+
+        result = other + ts
+        assert isinstance(result, Timestamp)
+        assert result == ts
+        assert result._creso == max(ts._creso, other._creso)
+
+        if ts._creso < other._creso:
+            # Case where rounding is lossy
+            other2 = other + Timedelta._from_value_and_reso(1, other._creso)
+            exp = ts.as_unit(other.unit) + other2
+            res = ts + other2
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+            res = other2 + ts
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+        else:
+            ts2 = ts + Timedelta._from_value_and_reso(1, ts._creso)
+            exp = ts2 + other.as_unit(ts2.unit)
+
+            res = ts2 + other
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+            res = other + ts2
+            assert res == exp
+            assert res._creso == max(ts._creso, other._creso)
+
+    def test_addition_doesnt_downcast_reso(self):
+        # https://github.com/pandas-dev/pandas/pull/48748#pullrequestreview-1122635413
+        ts = Timestamp(year=2022, month=1, day=1, microsecond=999999).as_unit("us")
+        td = Timedelta(microseconds=1).as_unit("us")
+        res = ts + td
+        assert res._creso == ts._creso
+
+    def test_sub_timedelta64_mismatched_reso(self, ts_tz):
+        ts = ts_tz
+
+        res = ts + np.timedelta64(1, "ns")
+        exp = ts.as_unit("ns") + np.timedelta64(1, "ns")
+        assert exp == res
+        assert exp._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    def test_min(self, ts):
+        assert ts.min <= ts
+        assert ts.min._creso == ts._creso
+        assert ts.min._value == NaT._value + 1
+
+    def test_max(self, ts):
+        assert ts.max >= ts
+        assert ts.max._creso == ts._creso
+        assert ts.max._value == np.iinfo(np.int64).max
+
+    def test_resolution(self, ts):
+        expected = Timedelta._from_value_and_reso(1, ts._creso)
+        result = ts.resolution
+        assert result == expected
+        assert result._creso == expected._creso
+
+    def test_out_of_ns_bounds(self):
+        # https://github.com/pandas-dev/pandas/issues/51060
+        result = Timestamp(-52700112000, unit="s")
+        assert result == Timestamp("0300-01-01")
+        assert result.to_numpy() == np.datetime64("0300-01-01T00:00:00", "s")
+
+
+def test_timestamp_class_min_max_resolution():
+    # when accessed on the class (as opposed to an instance), we default
+    #  to nanoseconds
+    assert Timestamp.min == Timestamp(NaT._value + 1)
+    assert Timestamp.min._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timestamp.max == Timestamp(np.iinfo(np.int64).max)
+    assert Timestamp.max._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timestamp.resolution == Timedelta(1)
+    assert Timestamp.resolution._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+
+def test_delimited_date():
+    # https://github.com/pandas-dev/pandas/issues/50231
+    with tm.assert_produces_warning(None):
+        result = Timestamp("13-01-2000")
+    expected = Timestamp(2000, 1, 13)
+    assert result == expected
+
+
+def test_utctimetuple():
+    # GH 32174
+    ts = Timestamp("2000-01-01", tz="UTC")
+    result = ts.utctimetuple()
+    expected = time.struct_time((2000, 1, 1, 0, 0, 0, 5, 1, 0))
+    assert result == expected
+
+
+def test_negative_dates():
+    # https://github.com/pandas-dev/pandas/issues/50787
+    ts = Timestamp("-2000-01-01")
+    msg = (
+        " not yet supported on Timestamps which are outside the range of "
+        "Python's standard library. For now, please call the components you need "
+        r"\(such as `.year` and `.month`\) and construct your string from there.$"
+    )
+    func = "^strftime"
+    with pytest.raises(NotImplementedError, match=func + msg):
+        ts.strftime("%Y")
+
+    msg = (
+        " not yet supported on Timestamps which "
+        "are outside the range of Python's standard library. "
+    )
+    func = "^date"
+    with pytest.raises(NotImplementedError, match=func + msg):
+        ts.date()
+    func = "^isocalendar"
+    with pytest.raises(NotImplementedError, match=func + msg):
+        ts.isocalendar()
+    func = "^timetuple"
+    with pytest.raises(NotImplementedError, match=func + msg):
+        ts.timetuple()
+    func = "^toordinal"
+    with pytest.raises(NotImplementedError, match=func + msg):
+        ts.toordinal()

.venv/lib/python3.13/site-packages/pandas/tests/scalar/timestamp/test_timezones.py

@@ -0,0 +1,25 @@
+"""
+Tests for Timestamp timezone-related methods
+"""
+
+from datetime import datetime
+
+from pandas._libs.tslibs import timezones
+
+from pandas import Timestamp
+
+
+class TestTimestampTZOperations:
+    # ------------------------------------------------------------------
+
+    def test_timestamp_timetz_equivalent_with_datetime_tz(self, tz_naive_fixture):
+        # GH21358
+        tz = timezones.maybe_get_tz(tz_naive_fixture)
+
+        stamp = Timestamp("2018-06-04 10:20:30", tz=tz)
+        _datetime = datetime(2018, 6, 4, hour=10, minute=20, second=30, tzinfo=tz)
+
+        result = stamp.timetz()
+        expected = _datetime.timetz()
+
+        assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_cat_accessor.py

@@ -0,0 +1,260 @@
+import numpy as np
+import pytest
+
+from pandas.errors import Pandas4Warning
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays.categorical import CategoricalAccessor
+from pandas.core.indexes.accessors import Properties
+
+
+class TestCatAccessor:
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.cat.set_categories([1, 2, 3]),
+            lambda x: x.cat.reorder_categories([2, 3, 1], ordered=True),
+            lambda x: x.cat.rename_categories([1, 2, 3]),
+            lambda x: x.cat.remove_unused_categories(),
+            lambda x: x.cat.remove_categories([2]),
+            lambda x: x.cat.add_categories([4]),
+            lambda x: x.cat.as_ordered(),
+            lambda x: x.cat.as_unordered(),
+        ],
+    )
+    def test_getname_categorical_accessor(self, method):
+        # GH#17509
+        ser = Series([1, 2, 3], name="A").astype("category")
+        expected = "A"
+        result = method(ser).name
+        assert result == expected
+
+    def test_cat_accessor(self):
+        ser = Series(Categorical(["a", "b", np.nan, "a"]))
+        tm.assert_index_equal(ser.cat.categories, Index(["a", "b"]))
+        assert not ser.cat.ordered
+
+        exp = Categorical(["a", "b", np.nan, "a"], categories=["b", "a"])
+
+        res = ser.cat.set_categories(["b", "a"])
+        tm.assert_categorical_equal(res.values, exp)
+
+        ser[:] = "a"
+        ser = ser.cat.remove_unused_categories()
+        tm.assert_index_equal(ser.cat.categories, Index(["a"]))
+
+    def test_cat_accessor_api(self):
+        # GH#9322
+
+        assert Series.cat is CategoricalAccessor
+        ser = Series(list("aabbcde")).astype("category")
+        assert isinstance(ser.cat, CategoricalAccessor)
+
+        invalid = Series([1])
+        with pytest.raises(AttributeError, match="only use .cat accessor"):
+            invalid.cat
+        assert not hasattr(invalid, "cat")
+
+    def test_cat_accessor_no_new_attributes(self):
+        # https://github.com/pandas-dev/pandas/issues/10673
+        cat = Series(list("aabbcde")).astype("category")
+        with pytest.raises(AttributeError, match="You cannot add any new attribute"):
+            cat.cat.xlabel = "a"
+
+    def test_categorical_delegations(self):
+        # invalid accessor
+        msg = r"Can only use \.cat accessor with a 'category' dtype"
+        with pytest.raises(AttributeError, match=msg):
+            Series([1, 2, 3]).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series([1, 2, 3]).cat()
+        with pytest.raises(AttributeError, match=msg):
+            Series(["a", "b", "c"]).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series(np.arange(5.0)).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series([Timestamp("20130101")]).cat
+
+        # Series should delegate calls to '.categories', '.codes', '.ordered'
+        # and the methods '.set_categories()' 'drop_unused_categories()' to the
+        # categorical
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        exp_categories = Index(["a", "b", "c"])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        ser = ser.cat.rename_categories([1, 2, 3])
+        exp_categories = Index([1, 2, 3])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+
+        exp_codes = Series([0, 1, 2, 0], dtype="int8")
+        tm.assert_series_equal(ser.cat.codes, exp_codes)
+
+        assert ser.cat.ordered
+        ser = ser.cat.as_unordered()
+        assert not ser.cat.ordered
+
+        ser = ser.cat.as_ordered()
+        assert ser.cat.ordered
+
+        # reorder
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        exp_categories = Index(["c", "b", "a"])
+        exp_values = np.array(["a", "b", "c", "a"], dtype=np.object_)
+        ser = ser.cat.set_categories(["c", "b", "a"])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        tm.assert_numpy_array_equal(ser.values.__array__(), exp_values)
+        tm.assert_numpy_array_equal(ser.__array__(), exp_values)
+
+        # remove unused categories
+        ser = Series(Categorical(["a", "b", "b", "a"], categories=["a", "b", "c"]))
+        exp_categories = Index(["a", "b"])
+        exp_values = np.array(["a", "b", "b", "a"], dtype=np.object_)
+        ser = ser.cat.remove_unused_categories()
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        tm.assert_numpy_array_equal(ser.values.__array__(), exp_values)
+        tm.assert_numpy_array_equal(ser.__array__(), exp_values)
+
+        # This method is likely to be confused, so test that it raises an error
+        # on wrong inputs:
+        msg = "'Series' object has no attribute 'set_categories'"
+        with pytest.raises(AttributeError, match=msg):
+            ser.set_categories([4, 3, 2, 1])
+
+        # right: ser.cat.set_categories([4,3,2,1])
+
+        # GH#18862 (let Series.cat.rename_categories take callables)
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        result = ser.cat.rename_categories(lambda x: x.upper())
+        expected = Series(
+            Categorical(["A", "B", "C", "A"], categories=["A", "B", "C"], ordered=True)
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            date_range("1/1/2015", periods=5, unit="ns"),
+            date_range("1/1/2015", periods=5, tz="MET", unit="ns"),
+            period_range("1/1/2015", freq="D", periods=5),
+            timedelta_range("1 days", "10 days"),
+        ],
+    )
+    def test_dt_accessor_api_for_categorical(self, idx):
+        # https://github.com/pandas-dev/pandas/issues/10661
+
+        ser = Series(idx)
+        cat = ser.astype("category")
+
+        # only testing field (like .day)
+        # and bool (is_month_start)
+        attr_names = type(ser._values)._datetimelike_ops
+
+        assert isinstance(cat.dt, Properties)
+
+        special_func_defs = [
+            ("strftime", ("%Y-%m-%d",), {}),
+            ("round", ("D",), {}),
+            ("floor", ("D",), {}),
+            ("ceil", ("D",), {}),
+            ("asfreq", ("D",), {}),
+            ("as_unit", ("s"), {}),
+        ]
+        if idx.dtype == "M8[ns]":
+            # exclude dt64tz since that is already localized and would raise
+            tup = ("tz_localize", ("UTC",), {})
+            special_func_defs.append(tup)
+        elif idx.dtype.kind == "M":
+            # exclude dt64 since that is not localized so would raise
+            tup = ("tz_convert", ("EST",), {})
+            special_func_defs.append(tup)
+
+        _special_func_names = [f[0] for f in special_func_defs]
+
+        _ignore_names = ["components", "tz_localize", "tz_convert"]
+
+        func_names = [
+            fname
+            for fname in dir(ser.dt)
+            if not (
+                fname.startswith("_")
+                or fname in attr_names
+                or fname in _special_func_names
+                or fname in _ignore_names
+            )
+        ]
+
+        func_defs = [(fname, (), {}) for fname in func_names]
+        func_defs.extend(
+            f_def for f_def in special_func_defs if f_def[0] in dir(ser.dt)
+        )
+
+        for func, args, kwargs in func_defs:
+            warn_cls = []
+            if func == "to_period" and getattr(idx, "tz", None) is not None:
+                # dropping TZ
+                warn_cls.append(UserWarning)
+            elif func == "to_pytimedelta":
+                # GH 57463
+                warn_cls.append(Pandas4Warning)
+            if warn_cls:
+                warn_cls = tuple(warn_cls)
+            else:
+                warn_cls = None
+            with tm.assert_produces_warning(warn_cls):
+                res = getattr(cat.dt, func)(*args, **kwargs)
+                exp = getattr(ser.dt, func)(*args, **kwargs)
+
+            tm.assert_equal(res, exp)
+
+        for attr in attr_names:
+            res = getattr(cat.dt, attr)
+            exp = getattr(ser.dt, attr)
+
+            tm.assert_equal(res, exp)
+
+    def test_dt_accessor_api_for_categorical_invalid(self):
+        invalid = Series([1, 2, 3]).astype("category")
+        msg = "Can only use .dt accessor with datetimelike"
+
+        with pytest.raises(AttributeError, match=msg):
+            invalid.dt
+        assert not hasattr(invalid, "str")
+
+    def test_set_categories_setitem(self):
+        # GH#43334
+
+        df = DataFrame({"Survived": [1, 0, 1], "Sex": [0, 1, 1]}, dtype="category")
+
+        df["Survived"] = df["Survived"].cat.rename_categories(["No", "Yes"])
+        df["Sex"] = df["Sex"].cat.rename_categories(["female", "male"])
+
+        # values should not be coerced to NaN
+        assert list(df["Sex"]) == ["female", "male", "male"]
+        assert list(df["Survived"]) == ["Yes", "No", "Yes"]
+
+        df["Sex"] = Categorical(df["Sex"], categories=["female", "male"], ordered=False)
+        df["Survived"] = Categorical(
+            df["Survived"], categories=["No", "Yes"], ordered=False
+        )
+
+        # values should not be coerced to NaN
+        assert list(df["Sex"]) == ["female", "male", "male"]
+        assert list(df["Survived"]) == ["Yes", "No", "Yes"]
+
+    def test_categorical_of_booleans_is_boolean(self):
+        # https://github.com/pandas-dev/pandas/issues/46313
+        df = DataFrame(
+            {"int_cat": [1, 2, 3], "bool_cat": [True, False, False]}, dtype="category"
+        )
+        value = df["bool_cat"].cat.categories.dtype
+        expected = np.dtype(np.bool_)
+        assert value is expected

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_dt_accessor.py

@@ -0,0 +1,832 @@
+import calendar
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+import locale
+import unicodedata
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.timezones import maybe_get_tz
+from pandas.errors import Pandas4Warning
+
+from pandas.core.dtypes.common import (
+    is_integer_dtype,
+    is_list_like,
+)
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Period,
+    PeriodIndex,
+    Series,
+    StringDtype,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+
+ok_for_period = PeriodArray._datetimelike_ops
+ok_for_period_methods = ["strftime", "to_timestamp", "asfreq"]
+ok_for_dt = DatetimeArray._datetimelike_ops
+ok_for_dt_methods = [
+    "to_period",
+    "to_pydatetime",
+    "tz_localize",
+    "tz_convert",
+    "normalize",
+    "strftime",
+    "round",
+    "floor",
+    "ceil",
+    "day_name",
+    "month_name",
+    "isocalendar",
+    "as_unit",
+]
+ok_for_td = TimedeltaArray._datetimelike_ops
+ok_for_td_methods = [
+    "components",
+    "to_pytimedelta",
+    "total_seconds",
+    "round",
+    "floor",
+    "ceil",
+    "as_unit",
+]
+
+
+def get_dir(ser):
+    # check limited display api
+    results = [r for r in ser.dt.__dir__() if not r.startswith("_")]
+    return sorted(set(results))
+
+
+class TestSeriesDatetimeValues:
+    def _compare(self, ser, name):
+        # GH 7207, 11128
+        # test .dt namespace accessor
+
+        def get_expected(ser, prop):
+            result = getattr(Index(ser._values), prop)
+            if isinstance(result, np.ndarray):
+                if is_integer_dtype(result):
+                    result = result.astype("int64")
+            elif not is_list_like(result) or isinstance(result, DataFrame):
+                return result
+            return Series(result, index=ser.index, name=ser.name)
+
+        left = getattr(ser.dt, name)
+        right = get_expected(ser, name)
+        if not (is_list_like(left) and is_list_like(right)):
+            assert left == right
+        elif isinstance(left, DataFrame):
+            tm.assert_frame_equal(left, right)
+        else:
+            tm.assert_series_equal(left, right)
+
+    @pytest.mark.parametrize("freq", ["D", "s", "ms"])
+    def test_dt_namespace_accessor_datetime64(self, freq):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # datetimeindex
+        dti = date_range("20130101", periods=5, freq=freq)
+        ser = Series(dti, name="xxx")
+
+        for prop in ok_for_dt:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_dt_methods:
+            getattr(ser.dt, prop)
+
+        result = ser.dt.to_pydatetime()
+        assert isinstance(result, Series)
+        assert result.dtype == object
+
+        result = ser.dt.tz_localize("US/Eastern")
+        exp_values = DatetimeIndex(ser.values).tz_localize("US/Eastern")
+        expected = Series(exp_values, index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+        tz_result = result.dt.tz
+        assert str(tz_result) == "US/Eastern"
+        freq_result = ser.dt.freq
+        assert freq_result == DatetimeIndex(ser.values, freq="infer").freq
+
+        # let's localize, then convert
+        result = ser.dt.tz_localize("UTC").dt.tz_convert("US/Eastern")
+        exp_values = (
+            DatetimeIndex(ser.values).tz_localize("UTC").tz_convert("US/Eastern")
+        )
+        expected = Series(exp_values, index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_namespace_accessor_datetime64tz(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # datetimeindex with tz
+        dti = date_range("20130101", periods=5, tz="US/Eastern")
+        ser = Series(dti, name="xxx")
+        for prop in ok_for_dt:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_dt_methods:
+            getattr(ser.dt, prop)
+
+        result = ser.dt.to_pydatetime()
+        assert isinstance(result, Series)
+        assert result.dtype == object
+
+        result = ser.dt.tz_convert("CET")
+        expected = Series(ser._values.tz_convert("CET"), index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+        tz_result = result.dt.tz
+        assert str(tz_result) == "CET"
+        freq_result = ser.dt.freq
+        assert freq_result == DatetimeIndex(ser.values, freq="infer").freq
+
+    def test_dt_namespace_accessor_timedelta(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # timedelta index
+        cases = [
+            Series(
+                timedelta_range("1 day", periods=5), index=list("abcde"), name="xxx"
+            ),
+            Series(timedelta_range("1 day 01:23:45", periods=5, freq="s"), name="xxx"),
+            Series(
+                timedelta_range("2 days 01:23:45.012345", periods=5, freq="ms"),
+                name="xxx",
+            ),
+        ]
+        for ser in cases:
+            for prop in ok_for_td:
+                # we test freq below
+                if prop != "freq":
+                    self._compare(ser, prop)
+
+            for prop in ok_for_td_methods:
+                getattr(ser.dt, prop)
+
+            result = ser.dt.components
+            assert isinstance(result, DataFrame)
+            tm.assert_index_equal(result.index, ser.index)
+
+            msg = "The behavior of TimedeltaProperties.to_pytimedelta is deprecated"
+            with tm.assert_produces_warning(Pandas4Warning, match=msg):
+                result = ser.dt.to_pytimedelta()
+            assert isinstance(result, np.ndarray)
+            assert result.dtype == object
+
+            result = ser.dt.total_seconds()
+            assert isinstance(result, Series)
+            assert result.dtype == "float64"
+
+            freq_result = ser.dt.freq
+            assert freq_result == TimedeltaIndex(ser.values, freq="infer").freq
+
+    def test_dt_namespace_accessor_period(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # periodindex
+        pi = period_range("20130101", periods=5, freq="D")
+        ser = Series(pi, name="xxx")
+
+        for prop in ok_for_period:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_period_methods:
+            getattr(ser.dt, prop)
+
+        freq_result = ser.dt.freq
+        assert freq_result == PeriodIndex(ser.values).freq
+
+    def test_dt_namespace_accessor_index_and_values(self):
+        # both
+        index = date_range("20130101", periods=3, freq="D")
+        dti = date_range("20140204", periods=3, freq="s")
+        ser = Series(dti, index=index, name="xxx")
+        exp = Series(
+            np.array([2014, 2014, 2014], dtype="int32"), index=index, name="xxx"
+        )
+        tm.assert_series_equal(ser.dt.year, exp)
+
+        exp = Series(np.array([2, 2, 2], dtype="int32"), index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.month, exp)
+
+        exp = Series(np.array([0, 1, 2], dtype="int32"), index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.second, exp)
+
+        exp = Series([ser.iloc[0]] * 3, index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.normalize(), exp)
+
+    def test_dt_accessor_limited_display_api(self):
+        # tznaive
+        ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
+        results = get_dir(ser)
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
+
+        # tzaware
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="min"), name="xxx")
+        ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
+        results = get_dir(ser)
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
+
+        # Period
+        idx = period_range("20130101", periods=5, freq="D", name="xxx")
+        ser = Series(idx)
+        results = get_dir(ser)
+        tm.assert_almost_equal(
+            results, sorted(set(ok_for_period + ok_for_period_methods))
+        )
+
+    def test_dt_accessor_ambiguous_freq_conversions(self):
+        # GH#11295
+        # ambiguous time error on the conversions
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="min"), name="xxx")
+        ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
+
+        exp_values = date_range(
+            "2015-01-01", "2016-01-01", freq="min", tz="UTC"
+        ).tz_convert("America/Chicago")
+        # freq not preserved by tz_localize above
+        exp_values = exp_values._with_freq(None)
+        expected = Series(exp_values, name="xxx")
+        tm.assert_series_equal(ser, expected)
+
+    def test_dt_accessor_not_writeable(self):
+        # no setting allowed
+        ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
+        with pytest.raises(ValueError, match="modifications"):
+            ser.dt.hour = 5
+
+        # trying to set a copy
+        with tm.raises_chained_assignment_error():
+            ser.dt.hour[0] = 5
+
+    @pytest.mark.parametrize(
+        "method, dates",
+        [
+            ["round", ["2012-01-02", "2012-01-02", "2012-01-01"]],
+            ["floor", ["2012-01-01", "2012-01-01", "2012-01-01"]],
+            ["ceil", ["2012-01-02", "2012-01-02", "2012-01-02"]],
+        ],
+    )
+    def test_dt_round(self, method, dates):
+        # round
+        ser = Series(
+            pd.to_datetime(
+                ["2012-01-01 13:00:00", "2012-01-01 12:01:00", "2012-01-01 08:00:00"]
+            ),
+            name="xxx",
+        )
+        result = getattr(ser.dt, method)("D")
+        expected = Series(pd.to_datetime(dates), name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_round_tz(self):
+        ser = Series(
+            pd.to_datetime(
+                ["2012-01-01 13:00:00", "2012-01-01 12:01:00", "2012-01-01 08:00:00"]
+            ),
+            name="xxx",
+        )
+        result = ser.dt.tz_localize("UTC").dt.tz_convert("US/Eastern").dt.round("D")
+
+        exp_values = pd.to_datetime(
+            ["2012-01-01", "2012-01-01", "2012-01-01"]
+        ).tz_localize("US/Eastern")
+        expected = Series(exp_values, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("method", ["ceil", "round", "floor"])
+    def test_dt_round_tz_ambiguous(self, method):
+        # GH 18946 round near "fall back" DST
+        df1 = DataFrame(
+            [
+                pd.to_datetime("2017-10-29 02:00:00+02:00", utc=True),
+                pd.to_datetime("2017-10-29 02:00:00+01:00", utc=True),
+                pd.to_datetime("2017-10-29 03:00:00+01:00", utc=True),
+            ],
+            columns=["date"],
+        )
+        df1["date"] = df1["date"].dt.tz_convert("Europe/Madrid")
+        # infer
+        result = getattr(df1.date.dt, method)("h", ambiguous="infer")
+        expected = df1["date"]
+        tm.assert_series_equal(result, expected)
+
+        # bool-array
+        result = getattr(df1.date.dt, method)("h", ambiguous=[True, False, False])
+        tm.assert_series_equal(result, expected)
+
+        # NaT
+        result = getattr(df1.date.dt, method)("h", ambiguous="NaT")
+        expected = df1["date"].copy()
+        expected.iloc[0:2] = pd.NaT
+        tm.assert_series_equal(result, expected)
+
+        # raise
+        with tm.external_error_raised(ValueError):
+            getattr(df1.date.dt, method)("h", ambiguous="raise")
+
+    @pytest.mark.parametrize(
+        "method, ts_str, freq",
+        [
+            ["ceil", "2018-03-11 01:59:00-0600", "5min"],
+            ["round", "2018-03-11 01:59:00-0600", "5min"],
+            ["floor", "2018-03-11 03:01:00-0500", "2h"],
+        ],
+    )
+    def test_dt_round_tz_nonexistent(self, method, ts_str, freq):
+        # GH 23324 round near "spring forward" DST
+        ser = Series([pd.Timestamp(ts_str, tz="America/Chicago").as_unit("s")])
+        result = getattr(ser.dt, method)(freq, nonexistent="shift_forward")
+        expected = Series(
+            [pd.Timestamp("2018-03-11 03:00:00", tz="America/Chicago").as_unit("s")]
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = getattr(ser.dt, method)(freq, nonexistent="NaT")
+        expected = Series([pd.NaT]).dt.tz_localize(result.dt.tz)
+        tm.assert_series_equal(result, expected)
+
+        with pytest.raises(ValueError, match="2018-03-11 02:00:00"):
+            getattr(ser.dt, method)(freq, nonexistent="raise")
+
+    @pytest.mark.parametrize("freq", ["ns", "us", "1000us"])
+    def test_dt_round_nonnano_higher_resolution_no_op(self, freq):
+        # GH 52761
+        ser = Series(
+            ["2020-05-31 08:00:00", "2000-12-31 04:00:05", "1800-03-14 07:30:20"],
+            dtype="datetime64[ms]",
+        )
+        expected = ser.copy()
+        result = ser.dt.round(freq)
+        tm.assert_series_equal(result, expected)
+
+        assert not np.shares_memory(ser.array._ndarray, result.array._ndarray)
+
+    def test_dt_namespace_accessor_categorical(self):
+        # GH 19468
+        dti = DatetimeIndex(["20171111", "20181212"]).repeat(2)
+        ser = Series(pd.Categorical(dti), name="foo")
+        result = ser.dt.year
+        expected = Series([2017, 2017, 2018, 2018], dtype="int32", name="foo")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_tz_localize_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_localize(tz)
+        expected = datetimes.dt.tz_localize(tz)
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_tz_convert_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns, MET]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_convert(tz)
+        expected = datetimes.dt.tz_convert(tz)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("accessor", ["year", "month", "day"])
+    def test_dt_other_accessors_categorical(self, accessor):
+        # GH 27952
+        datetimes = Series(
+            ["2018-01-01", "2018-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = getattr(categorical.dt, accessor)
+        expected = getattr(datetimes.dt, accessor)
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_accessor_no_new_attributes(self):
+        # https://github.com/pandas-dev/pandas/issues/10673
+        ser = Series(date_range("20130101", periods=5, freq="D"))
+        with pytest.raises(AttributeError, match="You cannot add any new attribute"):
+            ser.dt.xlabel = "a"
+
+    @pytest.mark.parametrize(
+        "time_locale",
+        [None, *tm.get_locales()],
+    )
+    def test_dt_accessor_datetime_name_accessors(self, time_locale):
+        # Test Monday -> Sunday and January -> December, in that sequence
+        if time_locale is None:
+            # If the time_locale is None, day-name and month_name should
+            # return the english attributes
+            expected_days = [
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+                "Sunday",
+            ]
+            expected_months = [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December",
+            ]
+        else:
+            with tm.set_locale(time_locale, locale.LC_TIME):
+                expected_days = calendar.day_name[:]
+                expected_months = calendar.month_name[1:]
+
+        ser = Series(date_range(freq="D", start=datetime(1998, 1, 1), periods=365))
+        english_days = [
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "Sunday",
+        ]
+        for day, name, eng_name in zip(range(4, 11), expected_days, english_days):
+            name = name.capitalize()
+            assert ser.dt.day_name(locale=time_locale)[day] == name
+            assert ser.dt.day_name(locale=None)[day] == eng_name
+        ser = pd.concat([ser, Series([pd.NaT])])
+        assert np.isnan(ser.dt.day_name(locale=time_locale).iloc[-1])
+
+        ser = Series(date_range(freq="ME", start="2012", end="2013"))
+        result = ser.dt.month_name(locale=time_locale)
+        expected = Series([month.capitalize() for month in expected_months])
+
+        # work around https://github.com/pandas-dev/pandas/issues/22342
+        result = result.str.normalize("NFD")
+        expected = expected.str.normalize("NFD")
+
+        tm.assert_series_equal(result, expected)
+
+        for s_date, expected in zip(ser, expected_months):
+            result = s_date.month_name(locale=time_locale)
+            expected = expected.capitalize()
+
+            result = unicodedata.normalize("NFD", result)
+            expected = unicodedata.normalize("NFD", expected)
+
+            assert result == expected
+
+        ser = pd.concat([ser, Series([pd.NaT])])
+        assert np.isnan(ser.dt.month_name(locale=time_locale).iloc[-1])
+
+    def test_strftime(self):
+        # GH 10086
+        ser = Series(date_range("20130101", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            ["2013/01/01", "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(date_range("2015-02-03 11:22:33.4567", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d %H-%M-%S")
+        expected = Series(
+            [
+                "2015/02/03 11-22-33",
+                "2015/02/04 11-22-33",
+                "2015/02/05 11-22-33",
+                "2015/02/06 11-22-33",
+                "2015/02/07 11-22-33",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(period_range("20130101", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            ["2013/01/01", "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(period_range("2015-02-03 11:22:33.4567", periods=5, freq="s"))
+        result = ser.dt.strftime("%Y/%m/%d %H-%M-%S")
+        expected = Series(
+            [
+                "2015/02/03 11-22-33",
+                "2015/02/03 11-22-34",
+                "2015/02/03 11-22-35",
+                "2015/02/03 11-22-36",
+                "2015/02/03 11-22-37",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_dt64_days(self):
+        ser = Series(date_range("20130101", periods=5))
+        ser.iloc[0] = pd.NaT
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            [np.nan, "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        datetime_index = date_range("20150301", periods=5)
+        result = datetime_index.strftime("%Y/%m/%d")
+
+        expected = Index(
+            ["2015/03/01", "2015/03/02", "2015/03/03", "2015/03/04", "2015/03/05"],
+        )
+        # dtype may be S10 or U10 depending on python version
+        tm.assert_index_equal(result, expected)
+
+    def test_strftime_period_days(self, using_infer_string):
+        period_index = period_range("20150301", periods=5)
+        result = period_index.strftime("%Y/%m/%d")
+        expected = Index(
+            ["2015/03/01", "2015/03/02", "2015/03/03", "2015/03/04", "2015/03/05"],
+            dtype="=U10",
+        )
+        if using_infer_string:
+            expected = expected.astype(StringDtype(na_value=np.nan))
+        tm.assert_index_equal(result, expected)
+
+    def test_strftime_dt64_microsecond_resolution(self):
+        ser = Series([datetime(2013, 1, 1, 2, 32, 59), datetime(2013, 1, 2, 14, 32, 1)])
+        result = ser.dt.strftime("%Y-%m-%d %H:%M:%S")
+        expected = Series(["2013-01-01 02:32:59", "2013-01-02 14:32:01"])
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_period_hours(self):
+        ser = Series(period_range("20130101", periods=4, freq="h"))
+        result = ser.dt.strftime("%Y/%m/%d %H:%M:%S")
+        expected = Series(
+            [
+                "2013/01/01 00:00:00",
+                "2013/01/01 01:00:00",
+                "2013/01/01 02:00:00",
+                "2013/01/01 03:00:00",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_period_minutes(self):
+        ser = Series(period_range("20130101", periods=4, freq="ms"))
+        result = ser.dt.strftime("%Y/%m/%d %H:%M:%S.%l")
+        expected = Series(
+            [
+                "2013/01/01 00:00:00.000",
+                "2013/01/01 00:00:00.001",
+                "2013/01/01 00:00:00.002",
+                "2013/01/01 00:00:00.003",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            DatetimeIndex(["2019-01-01", pd.NaT]),
+            PeriodIndex(["2019-01-01", pd.NaT], dtype="period[D]"),
+        ],
+    )
+    def test_strftime_nat(self, data):
+        # GH 29578
+        ser = Series(data)
+        result = ser.dt.strftime("%Y-%m-%d")
+        expected = Series(["2019-01-01", np.nan])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data", [DatetimeIndex([pd.NaT]), PeriodIndex([pd.NaT], dtype="period[D]")]
+    )
+    def test_strftime_all_nat(self, data):
+        # https://github.com/pandas-dev/pandas/issues/45858
+        ser = Series(data)
+        with tm.assert_produces_warning(None):
+            result = ser.dt.strftime("%Y-%m-%d")
+        expected = Series([np.nan], dtype="str")
+        tm.assert_series_equal(result, expected)
+
+    def test_valid_dt_with_missing_values(self):
+        # GH 8689
+        ser = Series(date_range("20130101", periods=5, freq="D"))
+        ser.iloc[2] = pd.NaT
+
+        for attr in ["microsecond", "nanosecond", "second", "minute", "hour", "day"]:
+            expected = getattr(ser.dt, attr).copy()
+            expected.iloc[2] = np.nan
+            result = getattr(ser.dt, attr)
+            tm.assert_series_equal(result, expected)
+
+        result = ser.dt.date
+        expected = Series(
+            [
+                date(2013, 1, 1),
+                date(2013, 1, 2),
+                pd.NaT,
+                date(2013, 1, 4),
+                date(2013, 1, 5),
+            ],
+            dtype="object",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = ser.dt.time
+        expected = Series([time(0), time(0), pd.NaT, time(0), time(0)], dtype="object")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_accessor_api(self):
+        # GH 9322
+        from pandas.core.indexes.accessors import (
+            CombinedDatetimelikeProperties,
+            DatetimeProperties,
+        )
+
+        assert Series.dt is CombinedDatetimelikeProperties
+
+        ser = Series(date_range("2000-01-01", periods=3))
+        assert isinstance(ser.dt, DatetimeProperties)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            np.arange(5),
+            list("abcde"),
+            np.random.default_rng(2).standard_normal(5),
+        ],
+    )
+    def test_dt_accessor_invalid(self, data):
+        # GH#9322 check that series with incorrect dtypes don't have attr
+        ser = Series(data)
+        with pytest.raises(AttributeError, match="only use .dt accessor"):
+            ser.dt
+        assert not hasattr(ser, "dt")
+
+    def test_dt_accessor_updates_on_inplace(self):
+        ser = Series(date_range("2018-01-01", periods=10))
+        ser[2] = None
+        result = ser.fillna(pd.Timestamp("2018-01-01"), inplace=True)
+        assert result is ser
+        result = ser.dt.date
+        assert result[0] == result[2]
+
+    def test_date_tz(self):
+        # GH11757
+        rng = DatetimeIndex(
+            ["2014-04-04 23:56", "2014-07-18 21:24", "2015-11-22 22:14"],
+            tz="US/Eastern",
+        )
+        ser = Series(rng)
+        expected = Series([date(2014, 4, 4), date(2014, 7, 18), date(2015, 11, 22)])
+        tm.assert_series_equal(ser.dt.date, expected)
+        tm.assert_series_equal(ser.apply(lambda x: x.date()), expected)
+
+    def test_dt_timetz_accessor(self, tz_naive_fixture):
+        # GH21358
+        tz = maybe_get_tz(tz_naive_fixture)
+
+        dtindex = DatetimeIndex(
+            ["2014-04-04 23:56", "2014-07-18 21:24", "2015-11-22 22:14"], tz=tz
+        )
+        ser = Series(dtindex)
+        expected = Series(
+            [time(23, 56, tzinfo=tz), time(21, 24, tzinfo=tz), time(22, 14, tzinfo=tz)]
+        )
+        result = ser.dt.timetz
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input_series, expected_output",
+        [
+            [["2020-01-01"], [[2020, 1, 3]]],
+            [[pd.NaT], [[None, None, None]]],
+            [["2019-12-31", "2019-12-29"], [[2020, 1, 2], [2019, 52, 7]]],
+            [["2010-01-01", pd.NaT], [[2009, 53, 5], [None, None, None]]],
+            # see GH#36032
+            [["2016-01-08", "2016-01-04"], [[2016, 1, 5], [2016, 1, 1]]],
+            [["2016-01-07", "2016-01-01"], [[2016, 1, 4], [2015, 53, 5]]],
+        ],
+    )
+    def test_isocalendar(self, input_series, expected_output):
+        result = pd.to_datetime(Series(input_series)).dt.isocalendar()
+        expected_frame = DataFrame(
+            expected_output, columns=["year", "week", "day"], dtype="UInt32"
+        )
+        tm.assert_frame_equal(result, expected_frame)
+
+    def test_hour_index(self):
+        dt_series = Series(
+            date_range(start="2021-01-01", periods=5, freq="h"),
+            index=[2, 6, 7, 8, 11],
+            dtype="category",
+        )
+        result = dt_series.dt.hour
+        expected = Series(
+            [0, 1, 2, 3, 4],
+            dtype="int32",
+            index=[2, 6, 7, 8, 11],
+        )
+        tm.assert_series_equal(result, expected)
+
+
+class TestSeriesPeriodValuesDtAccessor:
+    @pytest.mark.parametrize(
+        "input_vals",
+        [
+            [Period("2016-01", freq="M"), Period("2016-02", freq="M")],
+            [Period("2016-01-01", freq="D"), Period("2016-01-02", freq="D")],
+            [
+                Period("2016-01-01 00:00:00", freq="h"),
+                Period("2016-01-01 01:00:00", freq="h"),
+            ],
+            [
+                Period("2016-01-01 00:00:00", freq="M"),
+                Period("2016-01-01 00:01:00", freq="M"),
+            ],
+            [
+                Period("2016-01-01 00:00:00", freq="s"),
+                Period("2016-01-01 00:00:01", freq="s"),
+            ],
+        ],
+    )
+    def test_end_time_timevalues(self, input_vals):
+        # GH#17157
+        # Check that the time part of the Period is adjusted by end_time
+        # when using the dt accessor on a Series
+        dtype = pd.PeriodDtype(input_vals[0].freq)
+        input_vals = PeriodArray._from_sequence(np.asarray(input_vals), dtype=dtype)
+
+        ser = Series(input_vals)
+        result = ser.dt.end_time
+        expected = ser.apply(lambda x: x.end_time)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("input_vals", [("2001"), ("NaT")])
+    def test_to_period(self, input_vals):
+        # GH#21205
+        expected = Series([input_vals], dtype="Period[D]")
+        result = Series([input_vals], dtype="datetime64[ns]").dt.to_period("D")
+        tm.assert_series_equal(result, expected)
+
+
+def test_normalize_pre_epoch_dates():
+    # GH: 36294
+    ser = pd.to_datetime(Series(["1969-01-01 09:00:00", "2016-01-01 09:00:00"]))
+    result = ser.dt.normalize()
+    expected = pd.to_datetime(Series(["1969-01-01", "2016-01-01"]))
+    tm.assert_series_equal(result, expected)
+
+
+def test_day_attribute_non_nano_beyond_int32():
+    # GH 52386
+    data = np.array(
+        [
+            136457654736252,
+            134736784364431,
+            245345345545332,
+            223432411,
+            2343241,
+            3634548734,
+            23234,
+        ],
+        dtype="timedelta64[s]",
+    )
+    ser = Series(data)
+    result = ser.dt.days
+    expected = Series([1579371003, 1559453522, 2839645203, 2586, 27, 42066, 0])
+    tm.assert_series_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_list_accessor.py

@@ -0,0 +1,146 @@
+import re
+
+import pytest
+
+from pandas import (
+    ArrowDtype,
+    Series,
+)
+import pandas._testing as tm
+
+pa = pytest.importorskip("pyarrow")
+
+
+@pytest.mark.parametrize(
+    "list_dtype",
+    (
+        pa.list_(pa.int64()),
+        pa.list_(pa.int64(), list_size=3),
+        pa.large_list(pa.int64()),
+    ),
+)
+def test_list_getitem(list_dtype):
+    ser = Series(
+        [[1, 2, 3], [4, None, 5], None],
+        dtype=ArrowDtype(list_dtype),
+        name="a",
+    )
+    actual = ser.list[1]
+    expected = Series([2, None, None], dtype="int64[pyarrow]", name="a")
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_getitem_index():
+    # GH 58425
+    ser = Series(
+        [[1, 2, 3], [4, None, 5], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+        index=[1, 3, 7],
+        name="a",
+    )
+    actual = ser.list[1]
+    expected = Series(
+        [2, None, None],
+        dtype="int64[pyarrow]",
+        index=[1, 3, 7],
+        name="a",
+    )
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_getitem_slice():
+    ser = Series(
+        [[1, 2, 3], [4, None, 5], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+        index=[1, 3, 7],
+        name="a",
+    )
+    actual = ser.list[1:None:None]
+    expected = Series(
+        [[2, 3], [None, 5], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+        index=[1, 3, 7],
+        name="a",
+    )
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_len():
+    ser = Series(
+        [[1, 2, 3], [4, None], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+        name="a",
+    )
+    actual = ser.list.len()
+    expected = Series([3, 2, None], dtype=ArrowDtype(pa.int32()), name="a")
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_flatten():
+    ser = Series(
+        [[1, 2, 3], None, [4, None], [], [7, 8]],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+        name="a",
+    )
+    actual = ser.list.flatten()
+    expected = Series(
+        [1, 2, 3, 4, None, 7, 8],
+        dtype=ArrowDtype(pa.int64()),
+        index=[0, 0, 0, 2, 2, 4, 4],
+        name="a",
+    )
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_getitem_slice_invalid():
+    ser = Series(
+        [[1, 2, 3], [4, None, 5], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+    )
+    with tm.external_error_raised(pa.ArrowInvalid):
+        ser.list[1:None:0]
+
+
+def test_list_accessor_non_list_dtype():
+    ser = Series(
+        [1, 2, 4],
+        dtype=ArrowDtype(pa.int64()),
+    )
+    with pytest.raises(
+        AttributeError,
+        match=re.escape(
+            "Can only use the '.list' accessor with 'list[pyarrow]' dtype, "
+            "not int64[pyarrow]."
+        ),
+    ):
+        ser.list[1:None:0]
+
+
+@pytest.mark.parametrize(
+    "list_dtype",
+    (
+        pa.list_(pa.int64()),
+        pa.list_(pa.int64(), list_size=3),
+        pa.large_list(pa.int64()),
+    ),
+)
+def test_list_getitem_invalid_index(list_dtype):
+    ser = Series(
+        [[1, 2, 3], [4, None, 5], None],
+        dtype=ArrowDtype(list_dtype),
+    )
+    with tm.external_error_raised(pa.ArrowInvalid):
+        ser.list[-1]
+    with tm.external_error_raised(pa.ArrowInvalid):
+        ser.list[5]
+    with pytest.raises(ValueError, match="key must be an int or slice, got str"):
+        ser.list["abc"]
+
+
+def test_list_accessor_not_iterable():
+    ser = Series(
+        [[1, 2, 3], [4, None], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+    )
+    with pytest.raises(TypeError, match="'ListAccessor' object is not iterable"):
+        iter(ser.list)

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py

@@ -0,0 +1,9 @@
+from pandas import Series
+
+
+class TestSparseAccessor:
+    def test_sparse_accessor_updates_on_inplace(self):
+        ser = Series([1, 1, 2, 3], dtype="Sparse[int]")
+        return_value = ser.drop([0, 1], inplace=True)
+        assert return_value is None
+        assert ser.sparse.density == 1.0

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_str_accessor.py

@@ -0,0 +1,26 @@
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestStrAccessor:
+    def test_str_attribute(self):
+        # GH#9068
+        methods = ["strip", "rstrip", "lstrip"]
+        ser = Series([" jack", "jill ", " jesse ", "frank"])
+        for method in methods:
+            expected = Series([getattr(str, method)(x) for x in ser.values])
+            tm.assert_series_equal(getattr(Series.str, method)(ser.str), expected)
+
+        # str accessor only valid with string values
+        ser = Series(range(5))
+        msg = "Can only use .str accessor with string values, not integer"
+        with pytest.raises(AttributeError, match=msg):
+            ser.str.repeat(2)
+
+    def test_str_accessor_updates_on_inplace(self):
+        ser = Series(list("abc"))
+        return_value = ser.drop([0], inplace=True)
+        assert return_value is None
+        assert len(ser.str.lower()) == 2

.venv/lib/python3.13/site-packages/pandas/tests/series/accessors/test_struct_accessor.py

@@ -0,0 +1,188 @@
+import re
+
+import pytest
+
+from pandas import (
+    ArrowDtype,
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+pa = pytest.importorskip("pyarrow")
+pc = pytest.importorskip("pyarrow.compute")
+
+
+def test_struct_accessor_dtypes():
+    ser = Series(
+        [],
+        dtype=ArrowDtype(
+            pa.struct(
+                [
+                    ("int_col", pa.int64()),
+                    ("string_col", pa.string()),
+                    (
+                        "struct_col",
+                        pa.struct(
+                            [
+                                ("int_col", pa.int64()),
+                                ("float_col", pa.float64()),
+                            ]
+                        ),
+                    ),
+                ]
+            )
+        ),
+    )
+    actual = ser.struct.dtypes
+    expected = Series(
+        [
+            ArrowDtype(pa.int64()),
+            ArrowDtype(pa.string()),
+            ArrowDtype(
+                pa.struct(
+                    [
+                        ("int_col", pa.int64()),
+                        ("float_col", pa.float64()),
+                    ]
+                )
+            ),
+        ],
+        index=Index(["int_col", "string_col", "struct_col"]),
+    )
+    tm.assert_series_equal(actual, expected)
+
+
+def test_struct_accessor_field():
+    index = Index([-100, 42, 123])
+    ser = Series(
+        [
+            {"rice": 1.0, "maize": -1, "wheat": "a"},
+            {"rice": 2.0, "maize": 0, "wheat": "b"},
+            {"rice": 3.0, "maize": 1, "wheat": "c"},
+        ],
+        dtype=ArrowDtype(
+            pa.struct(
+                [
+                    ("rice", pa.float64()),
+                    ("maize", pa.int64()),
+                    ("wheat", pa.string()),
+                ]
+            )
+        ),
+        index=index,
+    )
+    by_name = ser.struct.field("maize")
+    by_name_expected = Series(
+        [-1, 0, 1],
+        dtype=ArrowDtype(pa.int64()),
+        index=index,
+        name="maize",
+    )
+    tm.assert_series_equal(by_name, by_name_expected)
+
+    by_index = ser.struct.field(2)
+    by_index_expected = Series(
+        ["a", "b", "c"],
+        dtype=ArrowDtype(pa.string()),
+        index=index,
+        name="wheat",
+    )
+    tm.assert_series_equal(by_index, by_index_expected)
+
+
+def test_struct_accessor_field_with_invalid_name_or_index():
+    ser = Series([], dtype=ArrowDtype(pa.struct([("field", pa.int64())])))
+
+    with pytest.raises(ValueError, match="name_or_index must be an int, str,"):
+        ser.struct.field(1.1)
+
+
+def test_struct_accessor_explode():
+    index = Index([-100, 42, 123])
+    ser = Series(
+        [
+            {"painted": 1, "snapping": {"sea": "green"}},
+            {"painted": 2, "snapping": {"sea": "leatherback"}},
+            {"painted": 3, "snapping": {"sea": "hawksbill"}},
+        ],
+        dtype=ArrowDtype(
+            pa.struct(
+                [
+                    ("painted", pa.int64()),
+                    ("snapping", pa.struct([("sea", pa.string())])),
+                ]
+            )
+        ),
+        index=index,
+    )
+    actual = ser.struct.explode()
+    expected = DataFrame(
+        {
+            "painted": Series([1, 2, 3], index=index, dtype=ArrowDtype(pa.int64())),
+            "snapping": Series(
+                [{"sea": "green"}, {"sea": "leatherback"}, {"sea": "hawksbill"}],
+                index=index,
+                dtype=ArrowDtype(pa.struct([("sea", pa.string())])),
+            ),
+        },
+    )
+    tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize(
+    "invalid",
+    [
+        pytest.param(Series([1, 2, 3], dtype="int64"), id="int64"),
+        pytest.param(
+            Series(["a", "b", "c"], dtype="string[pyarrow]"), id="string-pyarrow"
+        ),
+    ],
+)
+def test_struct_accessor_api_for_invalid(invalid):
+    with pytest.raises(
+        AttributeError,
+        match=re.escape(
+            "Can only use the '.struct' accessor with 'struct[pyarrow]' dtype, "
+            f"not {invalid.dtype}."
+        ),
+    ):
+        invalid.struct
+
+
+@pytest.mark.parametrize(
+    ["indices", "name"],
+    [
+        (0, "int_col"),
+        ([1, 2], "str_col"),
+        (pc.field("int_col"), "int_col"),
+        ("int_col", "int_col"),
+        (b"string_col", b"string_col"),
+        ([b"string_col"], "string_col"),
+    ],
+)
+def test_struct_accessor_field_expanded(indices, name):
+    arrow_type = pa.struct(
+        [
+            ("int_col", pa.int64()),
+            (
+                "struct_col",
+                pa.struct(
+                    [
+                        ("int_col", pa.int64()),
+                        ("float_col", pa.float64()),
+                        ("str_col", pa.string()),
+                    ]
+                ),
+            ),
+            (b"string_col", pa.string()),
+        ]
+    )
+
+    data = pa.array([], type=arrow_type)
+    ser = Series(data, dtype=ArrowDtype(arrow_type))
+    expected = pc.struct_field(data, indices)
+    result = ser.struct.field(indices)
+    tm.assert_equal(result.array._pa_array.combine_chunks(), expected)
+    assert result.name == name

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_datetime.py

@@ -0,0 +1,493 @@
+"""
+Also test support for datetime64[ns] in Series / DataFrame
+"""
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+import re
+
+from dateutil.tz import (
+    gettz,
+    tzutc,
+)
+import numpy as np
+import pytest
+
+from pandas._libs import index as libindex
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+def test_fancy_getitem():
+    dti = date_range(
+        freq="WOM-1FRI", start=datetime(2005, 1, 1), end=datetime(2010, 1, 1)
+    )
+
+    s = Series(np.arange(len(dti)), index=dti)
+
+    assert s["1/2/2009"] == 48
+    assert s["2009-1-2"] == 48
+    assert s[datetime(2009, 1, 2)] == 48
+    assert s[Timestamp(datetime(2009, 1, 2))] == 48
+    with pytest.raises(KeyError, match=r"^'2009-1-3'$"):
+        s["2009-1-3"]
+    tm.assert_series_equal(
+        s["3/6/2009":"2009-06-05"], s[datetime(2009, 3, 6) : datetime(2009, 6, 5)]
+    )
+
+
+def test_fancy_setitem():
+    dti = date_range(
+        freq="WOM-1FRI", start=datetime(2005, 1, 1), end=datetime(2010, 1, 1)
+    )
+
+    s = Series(np.arange(len(dti)), index=dti)
+
+    s["1/2/2009"] = -2
+    assert s.iloc[48] == -2
+    s["1/2/2009":"2009-06-05"] = -3
+    assert (s[48:54] == -3).all()
+
+
+@pytest.mark.parametrize("tz_source", ["pytz", "dateutil"])
+def test_getitem_setitem_datetime_tz(tz_source):
+    if tz_source == "pytz":
+        pytz = pytest.importorskip(tz_source)
+        tzget = pytz.timezone
+    else:
+        # handle special case for utc in dateutil
+        tzget = lambda x: tzutc() if x == "UTC" else gettz(x)
+
+    N = 50
+    # testing with timezone, GH #2785
+    rng = date_range("1/1/1990", periods=N, freq="h", tz=tzget("US/Eastern"))
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    # also test Timestamp tz handling, GH #2789
+    result = ts.copy()
+    result["1990-01-01 09:00:00+00:00"] = 0
+    result["1990-01-01 09:00:00+00:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts.copy()
+    result["1990-01-01 03:00:00-06:00"] = 0
+    result["1990-01-01 03:00:00-06:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    # repeat with datetimes
+    result = ts.copy()
+    result[datetime(1990, 1, 1, 9, tzinfo=tzget("UTC"))] = 0
+    result[datetime(1990, 1, 1, 9, tzinfo=tzget("UTC"))] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts.copy()
+    dt = Timestamp(1990, 1, 1, 3).tz_localize(tzget("US/Central"))
+    dt = dt.to_pydatetime()
+    result[dt] = 0
+    result[dt] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+
+def test_getitem_setitem_datetimeindex():
+    N = 50
+    # testing with timezone, GH #2785
+    rng = date_range("1/1/1990", periods=N, freq="h", tz="US/Eastern", unit="ns")
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    result = ts["1990-01-01 04:00:00"]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts.copy()
+    result["1990-01-01 04:00:00"] = 0
+    result["1990-01-01 04:00:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts["1990-01-01 04:00:00":"1990-01-01 07:00:00"]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = 0
+    result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = ts[4:8]
+    tm.assert_series_equal(result, ts)
+
+    lb = "1990-01-01 04:00:00"
+    rb = "1990-01-01 07:00:00"
+    # GH#18435 strings get a pass from tzawareness compat
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    lb = "1990-01-01 04:00:00-0500"
+    rb = "1990-01-01 07:00:00-0500"
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    # But we do not give datetimes a pass on tzawareness compat
+    msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+    naive = datetime(1990, 1, 1, 4)
+    for key in [naive, Timestamp(naive), np.datetime64(naive, "ns")]:
+        with pytest.raises(KeyError, match=re.escape(repr(key))):
+            # GH#36148 as of 2.0 we require tzawareness-compat
+            ts[key]
+
+    result = ts.copy()
+    # GH#36148 as of 2.0 we do not ignore tzawareness mismatch in indexing,
+    #  so setting it as a new key casts to object rather than matching
+    #  rng[4]
+    result[naive] = ts.iloc[4]
+    assert result.index.dtype == object
+    tm.assert_index_equal(result.index[:-1], rng.astype(object))
+    assert result.index[-1] == naive
+
+    msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        ts[naive : datetime(1990, 1, 1, 7)]
+
+    result = ts.copy()
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        result[naive : datetime(1990, 1, 1, 7)] = 0
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        result[naive : datetime(1990, 1, 1, 7)] = 99
+    # the __setitems__ here failed, so result should still match ts
+    tm.assert_series_equal(result, ts)
+
+    lb = naive
+    rb = datetime(1990, 1, 1, 7)
+    msg = r"Invalid comparison between dtype=datetime64\[ns, US/Eastern\] and datetime"
+    with pytest.raises(TypeError, match=msg):
+        # tznaive vs tzaware comparison is invalid
+        # see GH#18376, GH#18162
+        ts[(ts.index >= lb) & (ts.index <= rb)]
+
+    lb = Timestamp(naive).tz_localize(rng.tzinfo)
+    rb = Timestamp(datetime(1990, 1, 1, 7)).tz_localize(rng.tzinfo)
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts[ts.index[4]]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts[ts.index[4:8]]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result[ts.index[4:8]] = 0
+    result.iloc[4:8] = ts.iloc[4:8]
+    tm.assert_series_equal(result, ts)
+
+    # also test partial date slicing
+    result = ts["1990-01-02"]
+    expected = ts[24:48]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-02"] = 0
+    result["1990-01-02"] = ts[24:48]
+    tm.assert_series_equal(result, ts)
+
+
+def test_getitem_setitem_periodindex():
+    N = 50
+    rng = period_range("1/1/1990", periods=N, freq="h")
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    result = ts["1990-01-01 04"]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts.copy()
+    result["1990-01-01 04"] = 0
+    result["1990-01-01 04"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts["1990-01-01 04":"1990-01-01 07"]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-01 04":"1990-01-01 07"] = 0
+    result["1990-01-01 04":"1990-01-01 07"] = ts[4:8]
+    tm.assert_series_equal(result, ts)
+
+    lb = "1990-01-01 04"
+    rb = "1990-01-01 07"
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    # GH 2782
+    result = ts[ts.index[4]]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts[ts.index[4:8]]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result[ts.index[4:8]] = 0
+    result.iloc[4:8] = ts.iloc[4:8]
+    tm.assert_series_equal(result, ts)
+
+
+def test_datetime_indexing():
+    index = date_range("1/1/2000", "1/7/2000")
+    index = index.repeat(3)
+
+    s = Series(len(index), index=index)
+    stamp = Timestamp("1/8/2000")
+
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
+        s[stamp]
+    s[stamp] = 0
+    assert s[stamp] == 0
+
+    # not monotonic
+    s = Series(len(index), index=index)
+    s = s[::-1]
+
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
+        s[stamp]
+    s[stamp] = 0
+    assert s[stamp] == 0
+
+
+# test duplicates in time series
+
+
+def test_indexing_with_duplicate_datetimeindex(
+    rand_series_with_duplicate_datetimeindex,
+):
+    ts = rand_series_with_duplicate_datetimeindex
+
+    uniques = ts.index.unique()
+    for date in uniques:
+        result = ts[date]
+
+        mask = ts.index == date
+        total = (ts.index == date).sum()
+        expected = ts[mask]
+        if total > 1:
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_almost_equal(result, expected.iloc[0])
+
+        cp = ts.copy()
+        cp[date] = 0
+        expected = Series(np.where(mask, 0, ts), index=ts.index)
+        tm.assert_series_equal(cp, expected)
+
+    key = datetime(2000, 1, 6)
+    with pytest.raises(KeyError, match=re.escape(repr(key))):
+        ts[key]
+
+    # new index
+    ts[datetime(2000, 1, 6)] = 0
+    assert ts[datetime(2000, 1, 6)] == 0
+
+
+def test_loc_getitem_over_size_cutoff(monkeypatch):
+    # #1821
+
+    monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 1000)
+
+    # create large list of non periodic datetime
+    dates = []
+    sec = timedelta(seconds=1)
+    half_sec = timedelta(microseconds=500000)
+    d = datetime(2011, 12, 5, 20, 30)
+    n = 1100
+    for i in range(n):
+        dates.append(d)
+        dates.append(d + sec)
+        dates.append(d + sec + half_sec)
+        dates.append(d + sec + sec + half_sec)
+        d += 3 * sec
+
+    # duplicate some values in the list
+    duplicate_positions = np.random.default_rng(2).integers(0, len(dates) - 1, 20)
+    for p in duplicate_positions:
+        dates[p + 1] = dates[p]
+
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((len(dates), 4)),
+        index=dates,
+        columns=list("ABCD"),
+    )
+
+    pos = n * 3
+    timestamp = df.index[pos]
+    assert timestamp in df.index
+
+    # it works!
+    df.loc[timestamp]
+    assert len(df.loc[[timestamp]]) > 0
+
+
+def test_indexing_over_size_cutoff_period_index(monkeypatch):
+    # GH 27136
+
+    monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 1000)
+
+    n = 1100
+    idx = period_range("1/1/2000", freq="min", periods=n)
+    assert idx._engine.over_size_threshold
+
+    s = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+
+    pos = n - 1
+    timestamp = idx[pos]
+    assert timestamp in s.index
+
+    # it works!
+    s[timestamp]
+    assert len(s.loc[[timestamp]]) > 0
+
+
+def test_indexing_unordered():
+    # GH 2437
+    rng = date_range(start="2011-01-01", end="2011-01-15")
+    ts = Series(np.random.default_rng(2).random(len(rng)), index=rng)
+    ts2 = pd.concat([ts[0:4], ts[-4:], ts[4:-4]])
+
+    for t in ts.index:
+        expected = ts[t]
+        result = ts2[t]
+        assert expected == result
+
+    # GH 3448 (ranges)
+    def compare(slobj):
+        result = ts2[slobj].copy()
+        result = result.sort_index()
+        expected = ts[slobj]
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+    for key in [
+        slice("2011-01-01", "2011-01-15"),
+        slice("2010-12-30", "2011-01-15"),
+        slice("2011-01-01", "2011-01-16"),
+        # partial ranges
+        slice("2011-01-01", "2011-01-6"),
+        slice("2011-01-06", "2011-01-8"),
+        slice("2011-01-06", "2011-01-12"),
+    ]:
+        with pytest.raises(
+            KeyError, match="Value based partial slicing on non-monotonic"
+        ):
+            compare(key)
+
+    # single values
+    result = ts2["2011"].sort_index()
+    expected = ts["2011"]
+    expected.index = expected.index._with_freq(None)
+    tm.assert_series_equal(result, expected)
+
+
+def test_indexing_unordered2():
+    # diff freq
+    rng = date_range(datetime(2005, 1, 1), periods=20, freq="ME")
+    ts = Series(np.arange(len(rng)), index=rng)
+    ts = ts.take(np.random.default_rng(2).permutation(20))
+
+    result = ts["2005"]
+    for t in result.index:
+        assert t.year == 2005
+
+
+def test_indexing():
+    idx = date_range("2001-1-1", periods=20, freq="ME")
+    ts = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+
+    # getting
+
+    # GH 3070, make sure semantics work on Series/Frame
+    result = ts["2001"]
+    tm.assert_series_equal(result, ts.iloc[:12])
+
+    df = DataFrame({"A": ts})
+
+    # GH#36179 pre-2.0 df["2001"] operated as slicing on rows. in 2.0 it behaves
+    #  like any other key, so raises
+    with pytest.raises(KeyError, match="2001"):
+        df["2001"]
+
+    # setting
+    ts = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+    expected = ts.copy()
+    expected.iloc[:12] = 1
+    ts["2001"] = 1
+    tm.assert_series_equal(ts, expected)
+
+    expected = df.copy()
+    expected.iloc[:12, 0] = 1
+    df.loc["2001", "A"] = 1
+    tm.assert_frame_equal(df, expected)
+
+
+def test_getitem_str_month_with_datetimeindex():
+    # GH3546 (not including times on the last day)
+    idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:00", freq="h")
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013-05"]
+    tm.assert_series_equal(expected, ts)
+
+    idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:59", freq="s")
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013-05"]
+    tm.assert_series_equal(expected, ts)
+
+
+def test_getitem_str_year_with_datetimeindex():
+    idx = [
+        Timestamp("2013-05-31 00:00"),
+        Timestamp(datetime(2013, 5, 31, 23, 59, 59, 999999)),
+    ]
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013"]
+    tm.assert_series_equal(expected, ts)
+
+
+def test_getitem_str_second_with_datetimeindex():
+    # GH14826, indexing with a seconds resolution string / datetime object
+    df = DataFrame(
+        np.random.default_rng(2).random((5, 5)),
+        columns=["open", "high", "low", "close", "volume"],
+        index=date_range("2012-01-02 18:01:00", periods=5, tz="US/Central", freq="s"),
+    )
+
+    # this is a single date, so will raise
+    with pytest.raises(KeyError, match=r"^'2012-01-02 18:01:02'$"):
+        df["2012-01-02 18:01:02"]
+
+    msg = r"Timestamp\('2012-01-02 18:01:02-0600', tz='US/Central'\)"
+    with pytest.raises(KeyError, match=msg):
+        df[df.index[2]]
+
+
+def test_compare_datetime_with_all_none():
+    # GH#54870
+    ser = Series(["2020-01-01", "2020-01-02"], dtype="datetime64[ns]")
+    ser2 = Series([None, None])
+    result = ser > ser2
+    expected = Series([False, False])
+    tm.assert_series_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_delitem.py

@@ -0,0 +1,69 @@
+import pytest
+
+from pandas import (
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDelItem:
+    def test_delitem(self):
+        # GH#5542
+        # should delete the item inplace
+        s = Series(range(5))
+        del s[0]
+
+        expected = Series(range(1, 5), index=range(1, 5))
+        tm.assert_series_equal(s, expected)
+
+        del s[1]
+        expected = Series(range(2, 5), index=range(2, 5))
+        tm.assert_series_equal(s, expected)
+
+        # only 1 left, del, add, del
+        s = Series(1)
+        del s[0]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+        s[0] = 1
+        tm.assert_series_equal(s, Series(1))
+        del s[0]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+
+    def test_delitem_object_index(self):
+        # Index(dtype=object)
+        s = Series(1, index=Index(["a"], dtype="str"))
+        del s["a"]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="str")))
+        s["a"] = 1
+        tm.assert_series_equal(s, Series(1, index=Index(["a"], dtype="str")))
+        del s["a"]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="str")))
+
+    def test_delitem_missing_key(self):
+        # empty
+        s = Series(dtype=object)
+
+        with pytest.raises(KeyError, match=r"^0$"):
+            del s[0]
+
+    def test_delitem_extension_dtype(self):
+        # GH#40386
+        # DatetimeTZDtype
+        dti = date_range("2016-01-01", periods=3, tz="US/Pacific")
+        ser = Series(dti)
+
+        expected = ser[[0, 2]]
+        del ser[1]
+        assert ser.dtype == dti.dtype
+        tm.assert_series_equal(ser, expected)
+
+        # PeriodDtype
+        pi = dti.tz_localize(None).to_period("D")
+        ser = Series(pi)
+
+        expected = ser[:2]
+        del ser[2]
+        assert ser.dtype == pi.dtype
+        tm.assert_series_equal(ser, expected)

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_get.py

@@ -0,0 +1,228 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def test_get():
+    # GH 6383
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        )
+    )
+
+    result = s.get(25, 0)
+    expected = 0
+    assert result == expected
+
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        ),
+        index=Index(
+            [
+                25.0,
+                36.0,
+                49.0,
+                64.0,
+                81.0,
+                100.0,
+                121.0,
+                144.0,
+                169.0,
+                196.0,
+                1225.0,
+                1296.0,
+                1369.0,
+                1444.0,
+                1521.0,
+                1600.0,
+                1681.0,
+                1764.0,
+                1849.0,
+                1936.0,
+            ],
+            dtype=np.float64,
+        ),
+    )
+
+    result = s.get(25, 0)
+    expected = 43
+    assert result == expected
+
+    # GH 7407
+    # with a boolean accessor
+    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
+    vc = df.i.value_counts()
+    result = vc.get(99, default="Missing")
+    assert result == "Missing"
+
+    vc = df.b.value_counts()
+    result = vc.get(False, default="Missing")
+    assert result == 3
+
+    result = vc.get(True, default="Missing")
+    assert result == "Missing"
+
+
+def test_get_nan(float_numpy_dtype):
+    # GH 8569
+    s = Index(range(10), dtype=float_numpy_dtype).to_series()
+    assert s.get(np.nan) is None
+    assert s.get(np.nan, default="Missing") == "Missing"
+
+
+def test_get_nan_multiple(float_numpy_dtype):
+    # GH 8569
+    # ensure that fixing "test_get_nan" above hasn't broken get
+    # with multiple elements
+    s = Index(range(10), dtype=float_numpy_dtype).to_series()
+
+    idx = [2, 30]
+    assert s.get(idx) is None
+
+    idx = [2, np.nan]
+    assert s.get(idx) is None
+
+    # GH 17295 - all missing keys
+    idx = [20, 30]
+    assert s.get(idx) is None
+
+    idx = [np.nan, np.nan]
+    assert s.get(idx) is None
+
+
+def test_get_with_default():
+    # GH#7725
+    d0 = ["a", "b", "c", "d"]
+    d1 = np.arange(4, dtype="int64")
+
+    for data, index in ((d0, d1), (d1, d0)):
+        s = Series(data, index=index)
+        for i, d in zip(index, data):
+            assert s.get(i) == d
+            assert s.get(i, d) == d
+            assert s.get(i, "z") == d
+
+            assert s.get("e", "z") == "z"
+            assert s.get("e", "e") == "e"
+
+            assert s.get(10, "z") == "z"
+            assert s.get(10, 10) == 10
+
+
+@pytest.mark.parametrize(
+    "arr",
+    [
+        np.random.default_rng(2).standard_normal(10),
+        DatetimeIndex(date_range("2020-01-01", periods=10), name="a").tz_localize(
+            tz="US/Eastern"
+        ),
+    ],
+)
+def test_get_with_ea(arr):
+    # GH#21260
+    ser = Series(arr, index=[2 * i for i in range(len(arr))])
+    assert ser.get(4) == ser.iloc[2]
+
+    result = ser.get([4, 6])
+    expected = ser.iloc[[2, 3]]
+    tm.assert_series_equal(result, expected)
+
+    result = ser.get(slice(2))
+    expected = ser.iloc[[0, 1]]
+    tm.assert_series_equal(result, expected)
+
+    assert ser.get(-1) is None
+    assert ser.get(ser.index.max() + 1) is None
+
+    ser = Series(arr[:6], index=list("abcdef"))
+    assert ser.get("c") == ser.iloc[2]
+
+    result = ser.get(slice("b", "d"))
+    expected = ser.iloc[[1, 2, 3]]
+    tm.assert_series_equal(result, expected)
+
+    result = ser.get("Z")
+    assert result 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)
+    ser2 = ser[::2]
+    assert ser2.get(1) is None
+
+
+def test_getitem_get(string_series, object_series):
+    for obj in [string_series, object_series]:
+        idx = obj.index[5]
+
+        assert obj[idx] == obj.get(idx)
+        assert obj[idx] == obj.iloc[5]
+
+    # 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])
+
+
+def test_get_none():
+    # GH#5652
+    s1 = Series(dtype=object)
+    s2 = Series(dtype=object, index=list("abc"))
+    for s in [s1, s2]:
+        result = s.get(None)
+        assert result is None

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_getitem.py

@@ -0,0 +1,721 @@
+"""
+Series.__getitem__ test classes are organized by the type of key passed.
+"""
+
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    conversion,
+    timezones,
+)
+from pandas.compat.numpy import np_version_gt2
+from pandas.errors import Pandas4Warning
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.indexing import IndexingError
+
+from pandas.tseries.offsets import BDay
+
+
+class TestSeriesGetitemScalars:
+    def test_getitem_object_index_float_string(self):
+        # GH#17286
+        ser = Series([1] * 4, index=Index(["a", "b", "c", 1.0]))
+        assert ser["a"] == 1
+        assert ser[1.0] == 1
+
+    def test_getitem_float_keys_tuple_values(self):
+        # see GH#13509
+
+        # unique Index
+        ser = Series([(1, 1), (2, 2), (3, 3)], index=[0.0, 0.1, 0.2], name="foo")
+        result = ser[0.0]
+        assert result == (1, 1)
+
+        # non-unique Index
+        expected = Series([(1, 1), (2, 2)], index=[0.0, 0.0], name="foo")
+        ser = Series([(1, 1), (2, 2), (3, 3)], index=[0.0, 0.0, 0.2], name="foo")
+
+        result = ser[0.0]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_unrecognized_scalar(self):
+        # GH#32684 a scalar key that is not recognized by lib.is_scalar
+
+        # a series that might be produced via `frame.dtypes`
+        ser = Series([1, 2], index=[np.dtype("O"), np.dtype("i8")])
+
+        key = ser.index[1]
+
+        result = ser[key]
+        assert result == 2
+
+    def test_getitem_negative_out_of_bounds(self):
+        ser = Series(["a"] * 10, index=["a"] * 10)
+
+        with pytest.raises(KeyError, match="^-11$"):
+            ser[-11]
+
+    def test_getitem_out_of_bounds_indexerror(self, datetime_series):
+        # don't segfault, GH#495
+        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
+        # With a RangeIndex, an int key gives a KeyError
+        ser = Series([], dtype=object)
+        with pytest.raises(KeyError, match="-1"):
+            ser[-1]
+
+    def test_getitem_keyerror_with_integer_index(self, any_int_numpy_dtype):
+        dtype = any_int_numpy_dtype
+        ser = Series(
+            np.random.default_rng(2).standard_normal(6),
+            index=Index([0, 0, 1, 1, 2, 2], dtype=dtype),
+        )
+
+        with pytest.raises(KeyError, match=r"^5$"):
+            ser[5]
+
+        with pytest.raises(KeyError, match=r"^'c'$"):
+            ser["c"]
+
+        # not monotonic
+        ser = Series(
+            np.random.default_rng(2).standard_normal(6), index=[2, 2, 0, 0, 1, 1]
+        )
+
+        with pytest.raises(KeyError, match=r"^5$"):
+            ser[5]
+
+        with pytest.raises(KeyError, match=r"^'c'$"):
+            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=msg):
+            datetime_series[idx]
+
+    def test_getitem_full_range(self):
+        # github.com/pandas-dev/pandas/commit/4f433773141d2eb384325714a2776bcc5b2e20f7
+        ser = Series(range(5), index=list(range(5)))
+        result = ser[list(range(5))]
+        tm.assert_series_equal(result, ser)
+
+    # ------------------------------------------------------------------
+    # Series with DatetimeIndex
+
+    @pytest.mark.parametrize("tzstr", ["Europe/Berlin", "dateutil/Europe/Berlin"])
+    def test_getitem_pydatetime_tz(self, tzstr):
+        tz = timezones.maybe_get_tz(tzstr)
+
+        index = date_range(
+            start="2012-12-24 16:00", end="2012-12-24 18:00", freq="h", tz=tzstr
+        )
+        ts = Series(index=index, data=index.hour)
+        time_pandas = Timestamp("2012-12-24 17:00", tz=tzstr)
+
+        dt = datetime(2012, 12, 24, 17, 0)
+        time_datetime = conversion.localize_pydatetime(dt, tz)
+        assert ts[time_pandas] == ts[time_datetime]
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_string_index_alias_tz_aware(self, tz):
+        rng = date_range("1/1/2000", periods=10, tz=tz)
+        ser = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        result = ser["1/3/2000"]
+        tm.assert_almost_equal(result, ser.iloc[2])
+
+    def test_getitem_time_object(self):
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        mask = (rng.hour == 9) & (rng.minute == 30)
+        result = ts[time(9, 30)]
+        expected = ts[mask]
+        result.index = result.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+    # ------------------------------------------------------------------
+    # Series with CategoricalIndex
+
+    def test_getitem_scalar_categorical_index(self):
+        cats = Categorical([Timestamp("12-31-1999"), Timestamp("12-31-2000")])
+
+        ser = Series([1, 2], index=cats)
+
+        expected = ser.iloc[0]
+        result = ser[cats[0]]
+        assert result == expected
+
+    def test_getitem_numeric_categorical_listlike_matches_scalar(self):
+        # GH#15470
+        ser = Series(["a", "b", "c"], index=pd.CategoricalIndex([2, 1, 0]))
+
+        # 0 is treated as a label
+        assert ser[0] == "c"
+
+        # the listlike analogue should also be treated as labels
+        res = ser[[0]]
+        expected = ser.iloc[-1:]
+        tm.assert_series_equal(res, expected)
+
+        res2 = ser[[0, 1, 2]]
+        tm.assert_series_equal(res2, ser.iloc[::-1])
+
+    def test_getitem_integer_categorical_not_positional(self):
+        # GH#14865
+        ser = Series(["a", "b", "c"], index=Index([1, 2, 3], dtype="category"))
+        assert ser.get(3) == "c"
+        assert ser[3] == "c"
+
+    def test_getitem_str_with_timedeltaindex(self):
+        rng = timedelta_range("1 day 10:11:12", freq="h", periods=500)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        key = "6 days, 23:11:12"
+        indexer = rng.get_loc(key)
+        assert indexer == 133
+
+        result = ser[key]
+        assert result == ser.iloc[133]
+
+        msg = r"^Timedelta\('50 days 00:00:00'\)$"
+        with pytest.raises(KeyError, match=msg):
+            rng.get_loc("50 days")
+        with pytest.raises(KeyError, match=msg):
+            ser["50 days"]
+
+    def test_getitem_bool_index_positional(self):
+        # GH#48653
+        ser = Series({True: 1, False: 0})
+        with pytest.raises(KeyError, match="^0$"):
+            ser[0]
+
+
+class TestSeriesGetitemSlices:
+    def test_getitem_partial_str_slice_with_datetimeindex(self):
+        # GH#34860
+        arr = date_range("1/1/2008", "1/1/2009")
+        ser = arr.to_series()
+        result = ser["2008"]
+
+        rng = date_range(start="2008-01-01", end="2008-12-31")
+        expected = Series(rng, index=rng)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_slice_strings_with_datetimeindex(self):
+        idx = DatetimeIndex(
+            ["1/1/2000", "1/2/2000", "1/2/2000", "1/3/2000", "1/4/2000"]
+        )
+
+        ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+
+        result = ts["1/2/2000":]
+        expected = ts[1:]
+        tm.assert_series_equal(result, expected)
+
+        result = ts["1/2/2000":"1/3/2000"]
+        expected = ts[1:4]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_partial_str_slice_with_timedeltaindex(self):
+        rng = timedelta_range("1 day 10:11:12", freq="h", periods=500)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        result = ser["5 day":"6 day"]
+        expected = ser.iloc[86:134]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["5 day":]
+        expected = ser.iloc[86:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser[:"6 day"]
+        expected = ser.iloc[:134]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_partial_str_slice_high_reso_with_timedeltaindex(self):
+        # higher reso
+        rng = timedelta_range("1 day 10:11:12", freq="us", periods=2000)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        result = ser["1 day 10:11:12":]
+        expected = ser.iloc[0:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["1 day 10:11:12.001":]
+        expected = ser.iloc[1000:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["1 days, 10:11:12.001001"]
+        assert result == ser.iloc[1001]
+
+    def test_getitem_slice_2d(self, datetime_series):
+        # GH#30588 multi-dimensional indexing deprecated
+        with pytest.raises(ValueError, match="Multi-dimensional indexing"):
+            datetime_series[:, np.newaxis]
+
+    def test_getitem_median_slice_bug(self):
+        index = date_range("20090415", "20090519", freq="2B")
+        ser = Series(np.random.default_rng(2).standard_normal(13), index=index)
+
+        indexer = [slice(6, 7, None)]
+        msg = "Indexing with a single-item list"
+        with pytest.raises(ValueError, match=msg):
+            # GH#31299
+            ser[indexer]
+        # but we're OK with a single-element tuple
+        result = ser[(indexer[0],)]
+        expected = ser[indexer[0]]
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "slc, positions",
+        [
+            [slice(date(2018, 1, 1), None), [0, 1, 2]],
+            [slice(date(2019, 1, 2), None), [2]],
+            [slice(date(2020, 1, 1), None), []],
+            [slice(None, date(2020, 1, 1)), [0, 1, 2]],
+            [slice(None, date(2019, 1, 1)), [0]],
+        ],
+    )
+    def test_getitem_slice_date(self, slc, positions):
+        # https://github.com/pandas-dev/pandas/issues/31501
+        ser = Series(
+            [0, 1, 2],
+            DatetimeIndex(["2019-01-01", "2019-01-01T06:00:00", "2019-01-02"]),
+        )
+        msg = "Slicing with a datetime.date object is deprecated"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            result = ser[slc]
+        expected = ser.take(positions)
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_slice_float_raises(self, datetime_series):
+        msg = (
+            "cannot do slice indexing on DatetimeIndex with these indexers "
+            r"\[{key}\] of type float"
+        )
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
+            datetime_series[4.0:10.0]
+
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+            datetime_series[4.5:10.0]
+
+    def test_getitem_slice_bug(self):
+        ser = Series(range(10), index=list(range(10)))
+        result = ser[-12:]
+        tm.assert_series_equal(result, ser)
+
+        result = ser[-7:]
+        tm.assert_series_equal(result, ser[3:])
+
+        result = ser[:-12]
+        tm.assert_series_equal(result, ser[:0])
+
+    def test_getitem_slice_integers(self):
+        ser = Series(
+            np.random.default_rng(2).standard_normal(8),
+            index=[2, 4, 6, 8, 10, 12, 14, 16],
+        )
+
+        result = ser[:4]
+        expected = Series(ser.values[:4], index=[2, 4, 6, 8])
+        tm.assert_series_equal(result, expected)
+
+
+class TestSeriesGetitemListLike:
+    @pytest.mark.parametrize("box", [list, np.array, Index, Series])
+    def test_getitem_no_matches(self, box):
+        # GH#33462 we expect the same behavior for list/ndarray/Index/Series
+        ser = Series(["A", "B"])
+
+        key = Series(["C"], dtype=object)
+        key = box(key)
+
+        msg = r"None of \[Index\(\['C'\], dtype='object|str'\)\] are in the \[index\]"
+        with pytest.raises(KeyError, match=msg):
+            ser[key]
+
+    def test_getitem_intlist_intindex_periodvalues(self):
+        ser = Series(period_range("2000-01-01", periods=10, freq="D"))
+
+        result = ser[[2, 4]]
+        exp = Series(
+            [pd.Period("2000-01-03", freq="D"), pd.Period("2000-01-05", freq="D")],
+            index=[2, 4],
+            dtype="Period[D]",
+        )
+        tm.assert_series_equal(result, exp)
+        assert result.dtype == "Period[D]"
+
+    @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;
+        #  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)
+
+        key = box([0])
+        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])
+    @pytest.mark.parametrize("dtype", [np.int64, np.float64, np.uint64])
+    def test_getitem_intlist_multiindex_numeric_level(self, dtype, box):
+        # GH#33404 do _not_ fall back to positional since ints are ambiguous
+        idx = Index(range(4)).astype(dtype)
+        dti = date_range("2000-01-03", periods=3)
+        mi = pd.MultiIndex.from_product([idx, dti])
+        ser = Series(range(len(mi))[::-1], index=mi)
+
+        key = box([5])
+        with pytest.raises(KeyError, match="5"):
+            ser[key]
+
+    def test_getitem_uint_array_key(self, any_unsigned_int_numpy_dtype):
+        # GH #37218
+        ser = Series([1, 2, 3])
+        key = np.array([4], dtype=any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(KeyError, match="4"):
+            ser[key]
+        with pytest.raises(KeyError, match="4"):
+            ser.loc[key]
+
+
+class TestGetitemBooleanMask:
+    def test_getitem_boolean(self, string_series):
+        ser = string_series
+        mask = ser > ser.median()
+
+        # passing list is OK
+        result = ser[list(mask)]
+        expected = ser[mask]
+        tm.assert_series_equal(result, expected)
+        tm.assert_index_equal(result.index, ser.index[mask])
+
+    def test_getitem_boolean_empty(self):
+        ser = Series([], dtype=np.int64)
+        ser.index.name = "index_name"
+        ser = ser[ser.isna()]
+        assert ser.index.name == "index_name"
+        assert ser.dtype == np.int64
+
+        # GH#5877
+        # indexing with empty series
+        ser = Series(["A", "B"], dtype=object)
+        expected = Series(dtype=object, index=Index([], dtype="int64"))
+        result = ser[Series([], dtype=object)]
+        tm.assert_series_equal(result, expected)
+
+        # invalid because of the boolean indexer
+        # that's empty or not-aligned
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ser[Series([], dtype=bool)]
+
+        with pytest.raises(IndexingError, match=msg):
+            ser[Series([True], dtype=bool)]
+
+    def test_getitem_boolean_object(self, string_series):
+        # using column from DataFrame
+
+        ser = string_series
+        mask = ser > ser.median()
+        omask = mask.astype(object)
+
+        # getitem
+        result = ser[omask]
+        expected = ser[mask]
+        tm.assert_series_equal(result, expected)
+
+        # setitem
+        s2 = ser.copy()
+        cop = ser.copy()
+        cop[omask] = 5
+        s2[mask] = 5
+        tm.assert_series_equal(cop, s2)
+
+        # nans raise exception
+        omask[5:10] = np.nan
+        msg = "Cannot mask with non-boolean array containing NA / NaN values"
+        with pytest.raises(ValueError, match=msg):
+            ser[omask]
+        with pytest.raises(ValueError, match=msg):
+            ser[omask] = 5
+
+    def test_getitem_boolean_dt64_copies(self):
+        # GH#36210
+        dti = date_range("2016-01-01", periods=4, tz="US/Pacific")
+        key = np.array([True, True, False, False])
+
+        ser = Series(dti._data)
+
+        res = ser[key]
+        assert res._values._ndarray.base is None
+
+        # compare with numeric case for reference
+        ser2 = Series(range(4))
+        res2 = ser2[key]
+        assert res2._values.base is None
+
+    def test_getitem_boolean_corner(self, datetime_series):
+        ts = datetime_series
+        mask_shifted = ts.shift(1, freq=BDay()) > ts.median()
+
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ts[mask_shifted]
+
+        with pytest.raises(IndexingError, match=msg):
+            ts.loc[mask_shifted]
+
+    def test_getitem_boolean_different_order(self, string_series):
+        ordered = string_series.sort_values()
+
+        sel = string_series[ordered > 0]
+        exp = string_series[string_series > 0]
+        tm.assert_series_equal(sel, exp)
+
+    def test_getitem_boolean_contiguous_preserve_freq(self):
+        rng = date_range("1/1/2000", "3/1/2000", freq="B")
+
+        mask = np.zeros(len(rng), dtype=bool)
+        mask[10:20] = True
+
+        masked = rng[mask]
+        expected = rng[10:20]
+        assert expected.freq == rng.freq
+        tm.assert_index_equal(masked, expected)
+
+        mask[22] = True
+        masked = rng[mask]
+        assert masked.freq is None
+
+
+class TestGetitemCallable:
+    def test_getitem_callable(self):
+        # GH#12533
+        ser = Series(4, index=list("ABCD"))
+        result = ser[lambda x: "A"]
+        assert result == ser.loc["A"]
+
+        result = ser[lambda x: ["A", "B"]]
+        expected = ser.loc[["A", "B"]]
+        tm.assert_series_equal(result, expected)
+
+        result = ser[lambda x: [True, False, True, True]]
+        expected = ser.iloc[[0, 2, 3]]
+        tm.assert_series_equal(result, expected)
+
+
+def test_getitem_generator(string_series):
+    gen = (x > 0 for x in string_series)
+    result = string_series[gen]
+    result2 = string_series[iter(string_series > 0)]
+    expected = string_series[string_series > 0]
+    tm.assert_series_equal(result, expected)
+    tm.assert_series_equal(result2, expected)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        [0, 1],
+        date_range("2012-01-01", periods=2),
+        date_range("2012-01-01", periods=2, tz="CET"),
+    ],
+)
+def test_getitem_ndim_deprecated(data):
+    series = Series(data)
+    with pytest.raises(ValueError, match="Multi-dimensional indexing"):
+        series[:, None]
+
+
+def test_getitem_multilevel_scalar_slice_not_implemented(
+    multiindex_year_month_day_dataframe_random_data,
+):
+    # not implementing this for now
+    df = multiindex_year_month_day_dataframe_random_data
+    ser = df["A"]
+
+    msg = r"\(2000, slice\(3, 4, None\)\)"
+    with pytest.raises(TypeError, match=msg):
+        ser[2000, 3:4]
+
+
+def test_getitem_dataframe_raises():
+    rng = list(range(10))
+    ser = Series(10, index=rng)
+    df = DataFrame(rng, index=rng)
+    msg = (
+        "Indexing a Series with DataFrame is not supported, "
+        "use the appropriate DataFrame column"
+    )
+    with pytest.raises(TypeError, match=msg):
+        ser[df > 5]
+
+
+def test_getitem_assignment_series_alignment():
+    # https://github.com/pandas-dev/pandas/issues/37427
+    # with getitem, when assigning with a Series, it is not first aligned
+    ser = Series(range(10))
+    idx = np.array([2, 4, 9])
+    ser[idx] = Series([10, 11, 12])
+    expected = Series([0, 1, 10, 3, 11, 5, 6, 7, 8, 12])
+    tm.assert_series_equal(ser, expected)
+
+
+def test_getitem_duplicate_index_mistyped_key_raises_keyerror():
+    # GH#29189 float_index.get_loc(None) should raise KeyError, not TypeError
+    ser = Series([2, 5, 6, 8], index=[2.0, 4.0, 4.0, 5.0])
+    with pytest.raises(KeyError, match="None"):
+        ser[None]
+
+    with pytest.raises(KeyError, match="None"):
+        ser.index.get_loc(None)
+
+    with pytest.raises(KeyError, match="None"):
+        ser.index._engine.get_loc(None)
+
+
+def test_getitem_1tuple_slice_without_multiindex():
+    ser = Series(range(5))
+    key = (slice(3),)
+
+    result = ser[key]
+    expected = ser[key[0]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_preserve_name(datetime_series):
+    result = datetime_series[datetime_series > 0]
+    assert result.name == datetime_series.name
+
+    result = datetime_series[5:10]
+    assert result.name == datetime_series.name
+
+
+def test_getitem_with_integer_labels():
+    # integer indexes, be careful
+    ser = Series(
+        np.random.default_rng(2).standard_normal(10), index=list(range(0, 20, 2))
+    )
+    inds = [0, 2, 5, 7, 8]
+    arr_inds = np.array([0, 2, 5, 7, 8])
+    with pytest.raises(KeyError, match="not in index"):
+        ser[inds]
+
+    with pytest.raises(KeyError, match="not in index"):
+        ser[arr_inds]
+
+
+def test_getitem_missing(datetime_series):
+    # missing
+    d = datetime_series.index[0] - BDay()
+    msg = r"Timestamp\('1999-12-31 00:00:00'\)"
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[d]
+
+
+def test_getitem_fancy(string_series, object_series):
+    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=msg):
+        object_series[[1, 2, 3]]
+
+
+def test_getitem_box_float64(datetime_series):
+    with pytest.raises(KeyError, match="^5$"):
+        datetime_series[5]
+
+
+def test_getitem_unordered_dup():
+    obj = Series(range(5), index=["c", "a", "a", "b", "b"])
+    assert is_scalar(obj["c"])
+    assert obj["c"] == 0
+
+
+def test_getitem_dups():
+    ser = Series(range(5), index=["A", "A", "B", "C", "C"], dtype=np.int64)
+    expected = Series([3, 4], index=["C", "C"], dtype=np.int64)
+    result = ser["C"]
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_categorical_str():
+    # GH#31765
+    ser = Series(range(5), index=Categorical(["a", "b", "c", "a", "b"]))
+    result = ser["a"]
+    expected = ser.iloc[[0, 3]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_slice_can_reorder_not_uniquely_indexed():
+    ser = Series(1, index=["a", "a", "b", "b", "c"])
+    ser[::-1]  # it works!
+
+
+@pytest.mark.parametrize("index_vals", ["aabcd", "aadcb"])
+def test_duplicated_index_getitem_positional_indexer(index_vals):
+    # GH 11747; changed in 3.0 integers are treated as always-labels
+    s = Series(range(5), index=list(index_vals))
+
+    with pytest.raises(KeyError, match="^3$"):
+        s[3]
+
+
+class TestGetitemDeprecatedIndexers:
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_getitem_dict_and_set_deprecated(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2, 3])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_setitem_dict_and_set_disallowed(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2, 3])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser[key] = 1

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_indexing.py

@@ -0,0 +1,510 @@
+"""test get/set & misc"""
+
+from datetime import timedelta
+import re
+
+import numpy as np
+import pytest
+
+from pandas.errors import IndexingError
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    IndexSlice,
+    MultiIndex,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    concat,
+    date_range,
+    isna,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+def test_basic_indexing():
+    s = Series(
+        np.random.default_rng(2).standard_normal(5), index=["a", "b", "a", "a", "b"]
+    )
+
+    with pytest.raises(KeyError, match="^5$"):
+        s[5]
+
+    with pytest.raises(KeyError, match=r"^'c'$"):
+        s["c"]
+
+    s = s.sort_index()
+
+    with pytest.raises(KeyError, match="^5$"):
+        s[5]
+
+
+def test_getitem_numeric_should_not_fallback_to_positional(any_numeric_dtype):
+    # GH51053
+    dtype = any_numeric_dtype
+    idx = Index([1, 0, 1], dtype=dtype)
+    ser = Series(range(3), index=idx)
+    result = ser[1]
+    expected = Series([0, 2], index=Index([1, 1], dtype=dtype))
+    tm.assert_series_equal(result, expected, check_exact=True)
+
+
+def test_setitem_numeric_should_not_fallback_to_positional(any_numeric_dtype):
+    # GH51053
+    dtype = any_numeric_dtype
+    idx = Index([1, 0, 1], dtype=dtype)
+    ser = Series(range(3), index=idx)
+    ser[1] = 10
+    expected = Series([10, 1, 10], index=idx)
+    tm.assert_series_equal(ser, expected, check_exact=True)
+
+
+def test_basic_getitem_with_labels(datetime_series):
+    indices = datetime_series.index[[5, 10, 15]]
+
+    result = datetime_series[indices]
+    expected = datetime_series.reindex(indices)
+    tm.assert_series_equal(result, expected)
+
+    result = datetime_series[indices[0] : indices[2]]
+    expected = datetime_series.loc[indices[0] : indices[2]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_basic_getitem_dt64tz_values():
+    # GH12089
+    # with tz for values
+    ser = Series(
+        date_range("2011-01-01", periods=3, tz="US/Eastern"), index=["a", "b", "c"]
+    )
+    expected = Timestamp("2011-01-01", tz="US/Eastern")
+    result = ser.loc["a"]
+    assert result == expected
+    result = ser.iloc[0]
+    assert result == expected
+    result = ser["a"]
+    assert result == expected
+
+
+def test_getitem_setitem_ellipsis():
+    s = Series(np.random.default_rng(2).standard_normal(10))
+
+    result = s[...]
+    tm.assert_series_equal(result, s)
+
+
+@pytest.mark.parametrize(
+    "result_1, duplicate_item, expected_1",
+    [
+        [
+            {1: 12, 2: [1, 2, 2, 3]},
+            {1: 313},
+            Series({1: 12}, dtype=object),
+        ],
+        [
+            {1: [1, 2, 3], 2: [1, 2, 2, 3]},
+            {1: [1, 2, 3]},
+            Series({1: [1, 2, 3]}),
+        ],
+    ],
+)
+def test_getitem_with_duplicates_indices(result_1, duplicate_item, expected_1):
+    # GH 17610
+    result_1 = Series(result_1)
+    duplicate_item = Series(duplicate_item)
+    result = result_1._append_internal(duplicate_item)
+    expected = expected_1._append_internal(duplicate_item)
+    tm.assert_series_equal(result[1], expected)
+    assert result[2] == result_1[2]
+
+
+def test_getitem_setitem_integers():
+    # caused bug without test
+    s = Series([1, 2, 3], ["a", "b", "c"])
+
+    assert s.iloc[0] == s["a"]
+    s.iloc[0] = 5
+    tm.assert_almost_equal(s["a"], 5)
+
+
+def test_series_box_timestamp():
+    rng = date_range("20090415", "20090519", freq="B")
+    ser = Series(rng)
+    assert isinstance(ser[0], Timestamp)
+    assert isinstance(ser.at[1], Timestamp)
+    assert isinstance(ser.iat[2], Timestamp)
+    assert isinstance(ser.loc[3], Timestamp)
+    assert isinstance(ser.iloc[4], Timestamp)
+
+    ser = Series(rng, index=rng)
+    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)
+    assert isinstance(ser.iloc[4], Timestamp)
+
+
+def test_series_box_timedelta():
+    rng = timedelta_range("1 day 1 s", periods=5, freq="h")
+    ser = Series(rng)
+    assert isinstance(ser[0], Timedelta)
+    assert isinstance(ser.at[1], Timedelta)
+    assert isinstance(ser.iat[2], Timedelta)
+    assert isinstance(ser.loc[3], Timedelta)
+    assert isinstance(ser.iloc[4], Timedelta)
+
+
+def test_getitem_ambiguous_keyerror(indexer_sl):
+    ser = Series(range(10), index=list(range(0, 20, 2)))
+    with pytest.raises(KeyError, match=r"^1$"):
+        indexer_sl(ser)[1]
+
+
+def test_getitem_dups_with_missing(indexer_sl):
+    # breaks reindex, so need to use .loc internally
+    # GH 4246
+    ser = Series([1, 2, 3, 4], ["foo", "bar", "foo", "bah"])
+    with pytest.raises(KeyError, match=re.escape("['bam'] not in index")):
+        indexer_sl(ser)[["foo", "bar", "bah", "bam"]]
+
+
+def test_setitem_ambiguous_keyerror(indexer_sl):
+    s = Series(range(10), index=list(range(0, 20, 2)))
+
+    # equivalent of an append
+    s2 = s.copy()
+    indexer_sl(s2)[1] = 5
+    expected = concat([s, Series([5], index=[1])])
+    tm.assert_series_equal(s2, expected)
+
+
+def test_setitem(datetime_series):
+    datetime_series[datetime_series.index[5]] = np.nan
+    datetime_series.iloc[[1, 2, 17]] = np.nan
+    datetime_series.iloc[6] = np.nan
+    assert np.isnan(datetime_series.iloc[6])
+    assert np.isnan(datetime_series.iloc[2])
+    datetime_series[np.isnan(datetime_series)] = 5
+    assert not np.isnan(datetime_series.iloc[2])
+
+
+def test_setslice(datetime_series):
+    sl = datetime_series[5:20]
+    assert len(sl) == len(sl.index)
+    assert sl.index.is_unique is True
+
+
+def test_basic_getitem_setitem_corner(datetime_series):
+    # invalid tuples, e.g. td.ts[:, None] vs. td.ts[:, 2]
+    msg = "key of type tuple not found and not a MultiIndex"
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[:, 2]
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[:, 2] = 2
+
+    # weird lists. [slice(0, 5)] raises but not two slices
+    msg = "Indexing with a single-item list"
+    with pytest.raises(ValueError, match=msg):
+        # GH#31299
+        datetime_series[[slice(None, 5)]]
+
+    # but we're OK with a single-element tuple
+    result = datetime_series[(slice(None, 5),)]
+    expected = datetime_series[:5]
+    tm.assert_series_equal(result, expected)
+
+    # OK
+    msg = r"unhashable type(: 'slice')?"
+    with pytest.raises(TypeError, match=msg):
+        datetime_series[[5, [None, None]]]
+    with pytest.raises(TypeError, match=msg):
+        datetime_series[[5, [None, None]]] = 2
+
+
+def test_slice(string_series, object_series):
+    original = string_series.copy()
+    numSlice = string_series[10:20]
+    numSliceEnd = string_series[-10:]
+    objSlice = object_series[10:20]
+
+    assert string_series.index[9] not in numSlice.index
+    assert object_series.index[9] not in objSlice.index
+
+    assert len(numSlice) == len(numSlice.index)
+    assert string_series[numSlice.index[0]] == numSlice[numSlice.index[0]]
+
+    assert numSlice.index[1] == string_series.index[11]
+    tm.assert_numpy_array_equal(np.array(numSliceEnd), np.array(string_series)[-10:])
+
+    # Test return view.
+    sl = string_series[10:20]
+    sl[:] = 0
+
+    # Doesn't modify parent (CoW)
+    tm.assert_series_equal(string_series, original)
+
+
+def test_timedelta_assignment():
+    # GH 8209
+    s = Series([], dtype=object)
+    s.loc["B"] = timedelta(1)
+    expected = Series(Timedelta("1 days"), dtype="timedelta64[us]", index=["B"])
+    tm.assert_series_equal(s, expected)
+
+    s = s.reindex(s.index.insert(0, "A"))
+    expected = Series(
+        [np.nan, Timedelta("1 days")], dtype="timedelta64[us]", index=["A", "B"]
+    )
+    tm.assert_series_equal(s, expected)
+
+    s.loc["A"] = timedelta(1)
+    expected = Series(Timedelta("1 days"), dtype="timedelta64[us]", index=["A", "B"])
+    tm.assert_series_equal(s, expected)
+
+
+def test_underlying_data_conversion():
+    # GH 4080
+    df = DataFrame({c: [1, 2, 3] for c in ["a", "b", "c"]})
+    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_original = df.copy()
+    df
+
+    with tm.raises_chained_assignment_error():
+        df["val"].update(s)
+    expected = df_original
+    tm.assert_frame_equal(df, expected)
+
+
+def test_preserve_refs(datetime_series):
+    seq = datetime_series.iloc[[5, 10, 15]]
+    seq.iloc[1] = np.nan
+    assert not np.isnan(datetime_series.iloc[10])
+
+
+def test_multilevel_preserve_name(lexsorted_two_level_string_multiindex, indexer_sl):
+    index = lexsorted_two_level_string_multiindex
+    ser = Series(
+        np.random.default_rng(2).standard_normal(len(index)), index=index, name="sth"
+    )
+
+    result = indexer_sl(ser)["foo"]
+    assert result.name == ser.name
+
+
+# miscellaneous methods
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        date_range("2014-01-01", periods=20, freq="MS"),
+        period_range("2014-01", periods=20, freq="M"),
+        timedelta_range("0", periods=20, freq="h"),
+    ],
+)
+def test_slice_with_negative_step(index):
+    keystr1 = str(index[9])
+    keystr2 = str(index[13])
+
+    ser = Series(np.arange(20), index)
+    SLC = IndexSlice
+
+    for key in [keystr1, index[9]]:
+        tm.assert_indexing_slices_equivalent(ser, SLC[key::-1], SLC[9::-1])
+        tm.assert_indexing_slices_equivalent(ser, SLC[:key:-1], SLC[:8:-1])
+
+        for key2 in [keystr2, index[13]]:
+            tm.assert_indexing_slices_equivalent(ser, SLC[key2:key:-1], SLC[13:8:-1])
+            tm.assert_indexing_slices_equivalent(ser, SLC[key:key2:-1], SLC[0:0:-1])
+
+
+def test_tuple_index():
+    # GH 35534 - Selecting values when a Series has an Index of tuples
+    s = Series([1, 2], index=[("a",), ("b",)])
+    assert s[("a",)] == 1
+    assert s[("b",)] == 2
+    s[("b",)] = 3
+    assert s[("b",)] == 3
+
+
+def test_frozenset_index():
+    # GH35747 - Selecting values when a Series has an Index of frozenset
+    idx0, idx1 = frozenset("a"), frozenset("b")
+    s = Series([1, 2], index=[idx0, idx1])
+    assert s[idx0] == 1
+    assert s[idx1] == 2
+    s[idx1] = 3
+    assert s[idx1] == 3
+
+
+def test_loc_setitem_all_false_indexer():
+    # GH#45778
+    ser = Series([1, 2], index=["a", "b"])
+    expected = ser.copy()
+    rhs = Series([6, 7], index=["a", "b"])
+    ser.loc[ser > 100] = rhs
+    tm.assert_series_equal(ser, expected)
+
+
+def test_loc_boolean_indexer_non_matching_index():
+    # GH#46551
+    ser = Series([1])
+    result = ser.loc[Series([NA, False], dtype="boolean")]
+    expected = Series([], dtype="int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_boolean_indexer_miss_matching_index():
+    # GH#46551
+    ser = Series([1])
+    indexer = Series([NA, False], dtype="boolean", index=[1, 2])
+    with pytest.raises(IndexingError, match="Unalignable"):
+        ser.loc[indexer]
+
+
+def test_loc_setitem_nested_data_enlargement():
+    # GH#48614
+    df = DataFrame({"a": [1]})
+    ser = Series({"label": df})
+    ser.loc["new_label"] = df
+    expected = Series({"label": df, "new_label": df})
+    tm.assert_series_equal(ser, expected)
+
+
+def test_loc_ea_numeric_index_oob_slice_end():
+    # GH#50161
+    ser = Series(1, index=Index([0, 1, 2], dtype="Int64"))
+    result = ser.loc[2:3]
+    expected = Series(1, index=Index([2], dtype="Int64"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_bool_int_key():
+    # GH#48653
+    ser = Series({True: 1, False: 0})
+    with pytest.raises(KeyError, match="0"):
+        ser.loc[0]
+
+
+@pytest.mark.parametrize("val", [{}, {"b": "x"}])
+@pytest.mark.parametrize("indexer", [[], [False, False], slice(0, -1), np.array([])])
+def test_setitem_empty_indexer(indexer, val):
+    # GH#45981
+    df = DataFrame({"a": [1, 2], **val})
+    expected = df.copy()
+    df.loc[indexer] = 1.5
+    tm.assert_frame_equal(df, expected)
+
+
+def test_loc_non_monotonic_index_with_a_missing_label():
+    msg = "Cannot get left slice bound for non-monotonic index with a missing label 4"
+    ser = Series([3, 6, 7, 6], index=[3, 8, 7, 6])
+    with pytest.raises(KeyError, match=msg):
+        ser.loc[4:7]
+
+
+class TestDeprecatedIndexers:
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_getitem_dict_and_set_deprecated(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}, ({1}, 2), ({1: 1}, 2)])
+    def test_getitem_dict_and_set_deprecated_multiindex(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2], index=MultiIndex.from_tuples([(1, 2), (3, 4)]))
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_setitem_dict_and_set_disallowed(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key] = 1
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}, ({1}, 2), ({1: 1}, 2)])
+    def test_setitem_dict_and_set_disallowed_multiindex(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2], index=MultiIndex.from_tuples([(1, 2), (3, 4)]))
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key] = 1
+
+
+class TestSetitemValidation:
+    # This is adapted from pandas/tests/arrays/masked/test_indexing.py
+    def _check_setitem_invalid(self, ser, invalid, indexer):
+        orig_ser = ser.copy()
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser.iloc[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser.loc[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[:] = invalid
+
+    def _check_setitem_valid(self, ser, value, indexer):
+        orig_ser = ser.copy()
+
+        ser[indexer] = value
+        ser = orig_ser.copy()
+
+        ser.iloc[indexer] = value
+        ser = orig_ser.copy()
+
+        ser.loc[indexer] = value
+        ser = orig_ser.copy()
+
+        ser[:] = value
+
+    _invalid_scalars = [
+        1 + 2j,
+        "True",
+        "1",
+        "1.0",
+        NaT,
+        np.datetime64("NaT", "ns"),
+        np.timedelta64("NaT", "ns"),
+    ]
+    _indexers = [0, [0], slice(0, 1), [True, False, False], slice(None, None, None)]
+
+    @pytest.mark.parametrize(
+        "invalid", [*_invalid_scalars, 1, 1.0, np.int64(1), np.float64(1)]
+    )
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_bool(self, invalid, indexer):
+        ser = Series([True, False, False], dtype="bool")
+        self._check_setitem_invalid(ser, invalid, indexer)
+
+    @pytest.mark.parametrize("invalid", [*_invalid_scalars, True, 1.5, np.float64(1.5)])
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_int(self, invalid, any_int_numpy_dtype, indexer):
+        ser = Series([1, 2, 3], dtype=any_int_numpy_dtype)
+        if isna(invalid) and invalid is not NaT and not np.isnat(invalid):
+            self._check_setitem_valid(ser, invalid, indexer)
+        else:
+            self._check_setitem_invalid(ser, invalid, indexer)
+
+    @pytest.mark.parametrize("invalid", [*_invalid_scalars, True])
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_float(self, invalid, float_numpy_dtype, indexer):
+        ser = Series([1, 2, None], dtype=float_numpy_dtype)
+        self._check_setitem_invalid(ser, invalid, indexer)

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_mask.py

@@ -0,0 +1,69 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_mask():
+    # compare with tested results in test_where
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.where(~cond, np.nan)
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.where(~cond)
+    rs2 = s.mask(cond)
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(~cond, -s)
+    rs2 = s.mask(cond, -s)
+    tm.assert_series_equal(rs, rs2)
+
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+    rs = s2.where(~cond[:3])
+    rs2 = s2.mask(cond[:3])
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s2.where(~cond[:3], -s2)
+    rs2 = s2.mask(cond[:3], -s2)
+    tm.assert_series_equal(rs, rs2)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.mask(1)
+    with pytest.raises(ValueError, match=msg):
+        s.mask(cond[:3].values, -s)
+
+
+def test_mask_casts():
+    # dtype changes
+    ser = Series([1, 2, 3, 4])
+    result = ser.mask(ser > 2, np.nan)
+    expected = Series([1, 2, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_mask_casts2():
+    # see gh-21891
+    ser = Series([1, 2])
+    res = ser.mask([True, False])
+
+    exp = Series([np.nan, 2])
+    tm.assert_series_equal(res, exp)
+
+
+def test_mask_inplace():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.copy()
+    rs.mask(cond, inplace=True)
+    tm.assert_series_equal(rs.dropna(), s[~cond])
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.copy()
+    rs.mask(cond, -s, inplace=True)
+    tm.assert_series_equal(rs, s.mask(cond, -s))

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_set_value.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import (
+    DatetimeIndex,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_series_set_value(using_infer_string):
+    # GH#1561, GH#51363 as of 3.0 we do not do inference in Index.insert
+
+    dates = [datetime(2001, 1, 1), datetime(2001, 1, 2)]
+    if using_infer_string:
+        index = DatetimeIndex(dates)
+    else:
+        index = Index(dates, dtype=object)
+
+    s = Series(dtype=object)
+    s._set_value(dates[0], 1.0)
+    s._set_value(dates[1], np.nan)
+
+    expected = Series([1.0, np.nan], index=index)
+
+    tm.assert_series_equal(s, expected)
+
+
+def test_set_value_dt64(datetime_series):
+    idx = datetime_series.index[10]
+    res = datetime_series._set_value(idx, 0)
+    assert res is None
+    assert datetime_series[idx] == 0
+
+
+def test_set_value_str_index(string_series):
+    # equiv
+    ser = string_series.copy()
+    res = ser._set_value("foobar", 0)
+    assert res is None
+    assert ser.index[-1] == "foobar"
+    assert ser["foobar"] == 0
+
+    ser2 = string_series.copy()
+    ser2.loc["foobar"] = 0
+    assert ser2.index[-1] == "foobar"
+    assert ser2["foobar"] == 0

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_setitem.py

@@ -0,0 +1,1843 @@
+import contextlib
+from datetime import (
+    date,
+    datetime,
+)
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gt2
+from pandas.errors import IndexingError
+
+from pandas.core.dtypes.common import is_list_like
+
+from pandas import (
+    NA,
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    NaT,
+    Period,
+    Series,
+    StringDtype,
+    Timedelta,
+    Timestamp,
+    array,
+    concat,
+    date_range,
+    interval_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay
+
+
+class TestSetitemDT64Values:
+    def test_setitem_none_nan(self):
+        series = Series(date_range("1/1/2000", periods=10, unit="ns"))
+        series[3] = None
+        assert series[3] is NaT
+
+        series[3:5] = None
+        assert series[4] is NaT
+
+        series[5] = np.nan
+        assert series[5] is NaT
+
+        series[5:7] = np.nan
+        assert series[6] is NaT
+
+    def test_setitem_multiindex_empty_slice(self):
+        # https://github.com/pandas-dev/pandas/issues/35878
+        idx = MultiIndex.from_tuples([("a", 1), ("b", 2)])
+        result = Series([1, 2], index=idx)
+        expected = result.copy()
+        result.loc[[]] = 0
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_with_string_index(self):
+        # GH#23451
+        # Set object dtype to avoid upcast when setting date.today()
+        ser = Series([1, 2, 3], index=["Date", "b", "other"], dtype=object)
+        ser["Date"] = date.today()
+        assert ser.Date == date.today()
+        assert ser["Date"] == date.today()
+
+    def test_setitem_tuple_with_datetimetz_values(self):
+        # GH#20441
+        arr = date_range("2017", periods=4, tz="US/Eastern", unit="ns")
+        index = [(0, 1), (0, 2), (0, 3), (0, 4)]
+        result = Series(arr, index=index)
+        expected = result.copy()
+        result[(0, 1)] = np.nan
+        expected.iloc[0] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Tokyo"])
+    def test_setitem_with_tz(self, tz, indexer_sli):
+        orig = Series(date_range("2016-01-01", freq="h", periods=3, tz=tz, unit="ns"))
+        assert orig.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-01-01 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2016-01-01 02:00", tz=tz),
+            ],
+            dtype=orig.dtype,
+        )
+
+        # scalar
+        ser = orig.copy()
+        indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz)
+        tm.assert_series_equal(ser, exp)
+
+        # vector
+        vals = Series(
+            [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
+            index=[1, 2],
+            dtype=orig.dtype,
+        )
+        assert vals.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-01-01 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2012-01-01 00:00", tz=tz),
+            ],
+            dtype=orig.dtype,
+        )
+
+        ser = orig.copy()
+        indexer_sli(ser)[[1, 2]] = vals
+        tm.assert_series_equal(ser, exp)
+
+    def test_setitem_with_tz_dst(self, indexer_sli):
+        # GH#14146 trouble setting values near DST boundary
+        tz = "US/Eastern"
+        orig = Series(date_range("2016-11-06", freq="h", periods=3, tz=tz, unit="ns"))
+        assert orig.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-11-06 00:00-04:00", tz=tz),
+                Timestamp("2011-01-01 00:00-05:00", tz=tz),
+                Timestamp("2016-11-06 01:00-05:00", tz=tz),
+            ],
+            dtype=orig.dtype,
+        )
+
+        # scalar
+        ser = orig.copy()
+        indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz)
+        tm.assert_series_equal(ser, exp)
+
+        # vector
+        vals = Series(
+            [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
+            index=[1, 2],
+            dtype=orig.dtype,
+        )
+        assert vals.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-11-06 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2012-01-01 00:00", tz=tz),
+            ],
+            dtype=orig.dtype,
+        )
+
+        ser = orig.copy()
+        indexer_sli(ser)[[1, 2]] = vals
+        tm.assert_series_equal(ser, exp)
+
+    def test_object_series_setitem_dt64array_exact_match(self):
+        # make sure the dt64 isn't cast by numpy to integers
+        # https://github.com/numpy/numpy/issues/12550
+
+        ser = Series({"X": np.nan}, dtype=object)
+
+        indexer = [True]
+
+        # "exact_match" -> size of array being set matches size of ser
+        value = np.array([4], dtype="M8[ns]")
+
+        ser.iloc[indexer] = value
+
+        expected = Series([value[0]], index=["X"], dtype=object)
+        assert all(isinstance(x, np.datetime64) for x in expected.values)
+
+        tm.assert_series_equal(ser, expected)
+
+
+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)
+        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])
+    def test_setitem_series_object_dtype(self, indexer, ser_index):
+        # GH#38303
+        ser = Series([0, 0], dtype="object")
+        idxr = indexer(ser)
+        idxr[0] = Series([42], index=[ser_index])
+        expected = Series([Series([42], index=[ser_index]), 0], dtype="object")
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("index, exp_value", [(0, 42), (1, np.nan)])
+    def test_setitem_series(self, index, exp_value):
+        # GH#38303
+        ser = Series([0, 0])
+        ser.loc[0] = Series([42], index=[index])
+        expected = Series([exp_value, 0])
+        tm.assert_series_equal(ser, expected)
+
+
+class TestSetitemSlices:
+    def test_setitem_slice_float_raises(self, datetime_series):
+        msg = (
+            "cannot do slice indexing on DatetimeIndex with these indexers "
+            r"\[{key}\] of type float"
+        )
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
+            datetime_series[4.0:10.0] = 0
+
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+            datetime_series[4.5:10.0] = 0
+
+    def test_setitem_slice(self):
+        ser = Series(range(10), index=list(range(10)))
+        ser[-12:] = 0
+        assert (ser == 0).all()
+
+        ser[:-12] = 5
+        assert (ser == 0).all()
+
+    def test_setitem_slice_integers(self):
+        ser = Series(
+            np.random.default_rng(2).standard_normal(8),
+            index=[2, 4, 6, 8, 10, 12, 14, 16],
+        )
+
+        ser[:4] = 0
+        assert (ser[:4] == 0).all()
+        assert not (ser[4:] == 0).any()
+
+    def test_setitem_slicestep(self):
+        # caught this bug when writing tests
+        series = Series(
+            np.arange(20, dtype=np.float64), index=np.arange(20, dtype=np.int64)
+        )
+
+        series[::2] = 0
+        assert (series[::2] == 0).all()
+
+    def test_setitem_multiindex_slice(self, indexer_sli):
+        # GH 8856
+        mi = MultiIndex.from_product(([0, 1], list("abcde")))
+        result = Series(np.arange(10, dtype=np.int64), mi)
+        indexer_sli(result)[::4] = 100
+        expected = Series([100, 1, 2, 3, 100, 5, 6, 7, 100, 9], mi)
+        tm.assert_series_equal(result, expected)
+
+
+class TestSetitemBooleanMask:
+    def test_setitem_mask_cast(self):
+        # GH#2746
+        # need to upcast
+        ser = Series([1, 2], index=[1, 2], dtype="int64")
+        ser[[True, False]] = Series([0], index=[1], dtype="int64")
+        expected = Series([0, 2], index=[1, 2], dtype="int64")
+
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_mask_align_and_promote(self):
+        # GH#8387: test that changing types does not break alignment
+        ts = Series(
+            np.random.default_rng(2).standard_normal(100), index=np.arange(100, 0, -1)
+        ).round(5)
+        mask = ts > 0
+        left = ts.copy()
+        right = ts[mask].copy().map(str)
+        with pytest.raises(TypeError, match="Invalid value"):
+            left[mask] = right
+
+    def test_setitem_mask_promote_strs(self):
+        ser = Series([0, 1, 2, 0])
+        mask = ser > 0
+        ser2 = ser[mask].map(str)
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[mask] = ser2
+
+    def test_setitem_mask_promote(self):
+        ser = Series([0, "foo", "bar", 0])
+        mask = Series([False, True, True, False])
+        ser2 = ser[mask]
+        ser[mask] = ser2
+
+        expected = Series([0, "foo", "bar", 0])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_boolean(self, string_series):
+        mask = string_series > string_series.median()
+
+        # similar indexed series
+        result = string_series.copy()
+        result[mask] = string_series * 2
+        expected = string_series * 2
+        tm.assert_series_equal(result[mask], expected[mask])
+
+        # needs alignment
+        result = string_series.copy()
+        result[mask] = (string_series * 2)[0:5]
+        expected = (string_series * 2)[0:5].reindex_like(string_series)
+        expected[-mask] = string_series[mask]
+        tm.assert_series_equal(result[mask], expected[mask])
+
+    def test_setitem_boolean_corner(self, datetime_series):
+        ts = datetime_series
+        mask_shifted = ts.shift(1, freq=BDay()) > ts.median()
+
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ts[mask_shifted] = 1
+
+        with pytest.raises(IndexingError, match=msg):
+            ts.loc[mask_shifted] = 1
+
+    def test_setitem_boolean_different_order(self, string_series):
+        ordered = string_series.sort_values()
+
+        copy = string_series.copy()
+        copy[ordered > 0] = 0
+
+        expected = string_series.copy()
+        expected[expected > 0] = 0
+
+        tm.assert_series_equal(copy, expected)
+
+    @pytest.mark.parametrize("func", [list, np.array, Series])
+    def test_setitem_boolean_python_list(self, func):
+        # GH19406
+        ser = Series([None, "b", None])
+        mask = func([True, False, True])
+        ser[mask] = ["a", "c"]
+        expected = Series(["a", "b", "c"])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_boolean_nullable_int_types(self, any_numeric_ea_dtype):
+        # GH: 26468
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        ser[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype)
+        expected = Series([5, 6, 2, 3], dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        ser.loc[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        loc_ser = Series(range(4), dtype=any_numeric_ea_dtype)
+        ser.loc[ser > 6] = loc_ser.loc[loc_ser > 1]
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_with_bool_mask_and_values_matching_n_trues_in_length(self):
+        # GH#30567
+        ser = Series([None] * 10)
+        mask = [False] * 3 + [True] * 5 + [False] * 2
+        ser[mask] = range(5)
+        result = ser
+        expected = Series([None] * 3 + list(range(5)) + [None] * 2, dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_nan_with_bool(self):
+        # GH 13034
+        result = Series([True, False, True])
+        with pytest.raises(TypeError, match="Invalid value"):
+            result[0] = np.nan
+
+    def test_setitem_mask_smallint_upcast(self):
+        orig = Series([1, 2, 3], dtype="int8")
+        alt = np.array([999, 1000, 1001], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[mask] = Series(alt)
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser.mask(mask, alt, inplace=True)
+
+        res = ser.where(~mask, Series(alt))
+        expected = Series([999, 2, 1001])
+        tm.assert_series_equal(res, expected)
+
+    def test_setitem_mask_smallint_no_upcast(self):
+        # like test_setitem_mask_smallint_upcast, but while we can't hold 'alt',
+        #  we *can* hold alt[mask] without casting
+        orig = Series([1, 2, 3], dtype="uint8")
+        alt = Series([245, 1000, 246], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        ser[mask] = alt
+        expected = Series([245, 2, 246], dtype="uint8")
+        tm.assert_series_equal(ser, expected)
+
+        ser2 = orig.copy()
+        ser2.mask(mask, alt, inplace=True)
+        tm.assert_series_equal(ser2, expected)
+
+        # TODO: ser.where(~mask, alt) unnecessarily upcasts to int64
+        ser3 = orig.copy()
+        res = ser3.where(~mask, alt)
+        tm.assert_series_equal(res, expected, check_dtype=False)
+
+
+class TestSetitemViewCopySemantics:
+    def test_setitem_invalidates_datetime_index_freq(self):
+        # GH#24096 altering a datetime64tz Series inplace invalidates the
+        #  `freq` attribute on the underlying DatetimeIndex
+
+        dti = date_range("20130101", periods=3, tz="US/Eastern")
+        ts = dti[1]
+        ser = Series(dti)
+        assert ser._values is not dti
+        assert ser._values._ndarray.base is dti._data._ndarray.base
+        assert dti.freq == "D"
+        ser.iloc[1] = NaT
+        assert ser._values.freq is None
+
+        # check that the DatetimeIndex was not altered in place
+        assert ser._values is not dti
+        assert ser._values._ndarray.base is not dti._data._ndarray.base
+        assert dti[1] == ts
+        assert dti.freq == "D"
+
+    def test_dt64tz_setitem_does_not_mutate_dti(self):
+        # GH#21907, GH#24096
+        dti = date_range("2016-01-01", periods=10, tz="US/Pacific")
+        ts = dti[0]
+        ser = Series(dti)
+        assert ser._values is not dti
+        assert ser._values._ndarray.base is dti._data._ndarray.base
+        assert ser._mgr.blocks[0].values._ndarray.base is dti._data._ndarray.base
+
+        assert ser._mgr.blocks[0].values is not dti
+
+        ser[::3] = NaT
+        assert ser[0] is NaT
+        assert dti[0] == ts
+
+
+class TestSetitemCallable:
+    def test_setitem_callable_key(self):
+        # GH#12533
+        ser = Series([1, 2, 3, 4], index=list("ABCD"))
+        ser[lambda x: "A"] = -1
+
+        expected = Series([-1, 2, 3, 4], index=list("ABCD"))
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_callable_other(self):
+        # GH#13299
+        inc = lambda x: x + 1
+
+        # set object dtype to avoid upcast when setting inc
+        ser = Series([1, 2, -1, 4], dtype=object)
+        ser[ser < 0] = inc
+
+        expected = Series([1, 2, inc, 4])
+        tm.assert_series_equal(ser, expected)
+
+
+class TestSetitemWithExpansion:
+    def test_setitem_empty_series(self, using_infer_string):
+        # GH#10193
+        key = Timestamp("2012-01-01")
+        series = Series(dtype=object)
+        series[key] = 47
+        expected = Series(
+            47, index=[key] if using_infer_string else Index([key], dtype=object)
+        )
+        tm.assert_series_equal(series, expected)
+
+    def test_setitem_empty_series_datetimeindex_preserves_freq(self):
+        # GH#33573 our index should retain its freq
+        dti = DatetimeIndex([], freq="D", dtype="M8[ns]")
+        series = Series([], index=dti, dtype=object)
+        key = Timestamp("2012-01-01")
+        series[key] = 47
+        expected = Series(47, DatetimeIndex([key], freq="D").as_unit("ns"))
+        tm.assert_series_equal(series, expected)
+        assert series.index.freq == expected.index.freq
+
+    def test_setitem_empty_series_timestamp_preserves_dtype(self):
+        # GH 21881
+        timestamp = Timestamp(1412526600000000000)
+        series = Series([timestamp], index=["timestamp"], dtype=object)
+        expected = series["timestamp"]
+
+        series = Series([], dtype=object)
+        series["anything"] = 300.0
+        series["timestamp"] = timestamp
+        result = series["timestamp"]
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "td",
+        [
+            Timedelta("9 days"),
+            Timedelta("9 days").to_timedelta64(),
+            Timedelta("9 days").to_pytimedelta(),
+        ],
+    )
+    def test_append_timedelta_does_not_cast(self, td, using_infer_string, request):
+        # GH#22717 inserting a Timedelta should _not_ cast to int64
+        if using_infer_string and not isinstance(td, Timedelta):
+            # TODO: GH#56010
+            request.applymarker(pytest.mark.xfail(reason="inferred as string"))
+
+        expected = Series(["x", td], index=[0, "td"], dtype=object)
+
+        ser = Series(["x"])
+        ser["td"] = td
+        tm.assert_series_equal(ser, expected)
+        assert isinstance(ser["td"], Timedelta)
+
+        ser = Series(["x"])
+        ser.loc["td"] = Timedelta("9 days")
+        tm.assert_series_equal(ser, expected)
+        assert isinstance(ser["td"], Timedelta)
+
+    def test_setitem_with_expansion_type_promotion(self):
+        # GH#12599
+        ser = Series(dtype=object)
+        ser["a"] = Timestamp("2016-01-01")
+        ser["b"] = 3.0
+        ser["c"] = "foo"
+        expected = Series([Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_not_contained(self, string_series):
+        # set item that's not contained
+        ser = string_series.copy()
+        assert "foobar" not in ser.index
+        ser["foobar"] = 1
+
+        app = Series([1], index=["foobar"], name="series")
+        expected = concat([string_series, app])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_keep_precision(self, any_numeric_ea_dtype):
+        # GH#32346
+        ser = Series([1, 2], dtype=any_numeric_ea_dtype)
+        ser[2] = 10
+        expected = Series([1, 2, 10], dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize(
+        "na, target_na, dtype, target_dtype, indexer, raises",
+        [
+            (NA, NA, "Int64", "Int64", 1, False),
+            (NA, NA, "Int64", "Int64", 2, False),
+            (NA, np.nan, "int64", "float64", 1, False),
+            (NA, np.nan, "int64", "float64", 2, False),
+            (NaT, NaT, "int64", "object", 1, True),
+            (NaT, NaT, "int64", "object", 2, False),
+            (np.nan, NA, "Int64", "Int64", 1, False),
+            (np.nan, NA, "Int64", "Int64", 2, False),
+            (np.nan, NA, "Float64", "Float64", 1, False),
+            (np.nan, NA, "Float64", "Float64", 2, False),
+            (np.nan, np.nan, "int64", "float64", 1, False),
+            (np.nan, np.nan, "int64", "float64", 2, False),
+        ],
+    )
+    def test_setitem_enlarge_with_na(
+        self, na, target_na, dtype, target_dtype, indexer, raises
+    ):
+        # GH#32346
+        ser = Series([1, 2], dtype=dtype)
+        if raises:
+            with pytest.raises(TypeError, match="Invalid value"):
+                ser[indexer] = na
+        else:
+            ser[indexer] = na
+            expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
+            expected = Series(expected_values, dtype=target_dtype)
+            tm.assert_series_equal(ser, expected)
+
+    def test_setitem_enlargement_object_none(self, nulls_fixture, using_infer_string):
+        # GH#48665
+        ser = Series(["a", "b"])
+        ser[3] = nulls_fixture
+        dtype = (
+            "str"
+            if using_infer_string and not isinstance(nulls_fixture, Decimal)
+            else object
+        )
+        expected = Series(["a", "b", nulls_fixture], index=[0, 1, 3], dtype=dtype)
+        tm.assert_series_equal(ser, expected)
+        if using_infer_string:
+            ser[3] is np.nan
+        else:
+            assert ser[3] is nulls_fixture
+
+
+def test_setitem_scalar_into_readonly_backing_data():
+    # GH#14359: test that you cannot mutate a read only buffer
+
+    array = np.zeros(5)
+    array.flags.writeable = False  # make the array immutable
+    series = Series(array, copy=False)
+
+    for n in series.index:
+        msg = "assignment destination is read-only"
+        with pytest.raises(ValueError, match=msg):
+            series[n] = 1
+
+        assert array[n] == 0
+
+
+def test_setitem_slice_into_readonly_backing_data():
+    # GH#14359: test that you cannot mutate a read only buffer
+
+    array = np.zeros(5)
+    array.flags.writeable = False  # make the array immutable
+    series = Series(array, copy=False)
+
+    msg = "assignment destination is read-only"
+    with pytest.raises(ValueError, match=msg):
+        series[1:3] = 1
+
+    assert not array.any()
+
+
+def test_setitem_categorical_assigning_ops():
+    orig = Series(Categorical(["b", "b"], categories=["a", "b"]))
+    ser = orig.copy()
+    ser[:] = "a"
+    exp = Series(Categorical(["a", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[1] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[ser.index > 0] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[[False, True]] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser.index = ["x", "y"]
+    ser["y"] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]), index=["x", "y"])
+    tm.assert_series_equal(ser, exp)
+
+
+def test_setitem_nan_into_categorical():
+    # ensure that one can set something to np.nan
+    ser = Series(Categorical([1, 2, 3]))
+    exp = Series(Categorical([1, np.nan, 3], categories=[1, 2, 3]))
+    ser[1] = np.nan
+    tm.assert_series_equal(ser, exp)
+
+
+class TestSetitemCasting:
+    @pytest.mark.parametrize("unique", [True, False])
+    @pytest.mark.parametrize("val", [3, 3.0, "3"], ids=type)
+    def test_setitem_non_bool_into_bool(self, val, indexer_sli, unique):
+        # dont cast these 3-like values to bool
+        ser = Series([True, False])
+        if not unique:
+            ser.index = [1, 1]
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            indexer_sli(ser)[1] = val
+
+    def test_setitem_boolean_array_into_npbool(self):
+        # GH#45462
+        ser = Series([True, False, True])
+        values = ser._values
+        arr = array([True, False, None])
+
+        ser[:2] = arr[:2]  # no NAs -> can set inplace
+        assert ser._values is values
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[1:] = arr[1:]  # has an NA -> cast to boolean dtype
+
+
+class SetitemCastingEquivalents:
+    """
+    Check each of several methods that _should_ be equivalent to `obj[key] = val`
+
+    We assume that
+        - obj.index is the default Index(range(len(obj)))
+        - the setitem does not expand the obj
+    """
+
+    @pytest.fixture
+    def is_inplace(self, obj, expected):
+        """
+        Whether we expect the setting to be in-place or not.
+        """
+        return expected.dtype == obj.dtype
+
+    def check_indexer(self, obj, key, expected, val, indexer, is_inplace):
+        orig = obj
+        obj = obj.copy()
+        arr = obj._values
+
+        indexer(obj)[key] = val
+        tm.assert_series_equal(obj, expected)
+
+        self._check_inplace(is_inplace, orig, arr, obj)
+
+    def _check_inplace(self, is_inplace, orig, arr, obj):
+        if is_inplace is None:
+            # We are not (yet) checking whether setting is inplace or not
+            pass
+        elif is_inplace:
+            if arr.dtype.kind in ["m", "M"]:
+                # We may not have the same DTA/TDA, but will have the same
+                #  underlying data
+                assert arr._ndarray is obj._values._ndarray
+            else:
+                assert obj._values is arr
+        else:
+            # otherwise original array should be unchanged
+            tm.assert_equal(arr, orig._values)
+
+    def test_int_key(self, obj, key, expected, raises, val, indexer_sli, is_inplace):
+        if not isinstance(key, int):
+            pytest.skip("Not relevant for int key")
+        if raises:
+            ctx = pytest.raises(TypeError, match="Invalid value")
+        else:
+            ctx = contextlib.nullcontext()
+
+        with ctx:
+            self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
+
+        if indexer_sli is tm.loc:
+            with ctx:
+                self.check_indexer(obj, key, expected, val, tm.at, is_inplace)
+        elif indexer_sli is tm.iloc:
+            with ctx:
+                self.check_indexer(obj, key, expected, val, tm.iat, is_inplace)
+
+        rng = range(key, key + 1)
+        with ctx:
+            self.check_indexer(obj, rng, expected, val, indexer_sli, is_inplace)
+
+        if indexer_sli is not tm.loc:
+            # Note: no .loc because that handles slice edges differently
+            slc = slice(key, key + 1)
+            with ctx:
+                self.check_indexer(obj, slc, expected, val, indexer_sli, is_inplace)
+
+        ilkey = [key]
+        with ctx:
+            self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
+
+        indkey = np.array(ilkey)
+        with ctx:
+            self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
+
+        genkey = (x for x in [key])
+        with ctx:
+            self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
+
+    def test_slice_key(self, obj, key, expected, raises, val, indexer_sli, is_inplace):
+        if not isinstance(key, slice):
+            pytest.skip("Not relevant for slice key")
+        if raises:
+            ctx = pytest.raises(TypeError, match="Invalid value")
+        else:
+            ctx = contextlib.nullcontext()
+
+        if indexer_sli is not tm.loc:
+            # Note: no .loc because that handles slice edges differently
+            with ctx:
+                self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
+
+        ilkey = list(range(len(obj)))[key]
+        with ctx:
+            self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
+
+        indkey = np.array(ilkey)
+        with ctx:
+            self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
+
+        genkey = (x for x in indkey)
+        with ctx:
+            self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
+
+    def test_mask_key(self, obj, key, expected, raises, val, indexer_sli):
+        # setitem with boolean mask
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        obj = obj.copy()
+
+        if is_list_like(val) and len(val) < mask.sum():
+            msg = "boolean index did not match indexed array along dimension"
+            with pytest.raises(IndexError, match=msg):
+                indexer_sli(obj)[mask] = val
+            return
+
+        if raises:
+            with pytest.raises(TypeError, match="Invalid value"):
+                indexer_sli(obj)[mask] = val
+        else:
+            indexer_sli(obj)[mask] = val
+
+    def test_series_where(self, obj, key, expected, raises, val, is_inplace):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        if is_list_like(val) and len(val) < len(obj):
+            # Series.where is not valid here
+            msg = "operands could not be broadcast together with shapes"
+            with pytest.raises(ValueError, match=msg):
+                obj.where(~mask, val)
+            return
+
+        orig = obj
+        obj = obj.copy()
+        arr = obj._values
+
+        res = obj.where(~mask, val)
+
+        if val is NA and res.dtype == object:
+            expected = expected.fillna(NA)
+        elif val is None and res.dtype == object:
+            assert expected.dtype == object
+            expected = expected.copy()
+            expected[expected.isna()] = None
+        tm.assert_series_equal(res, expected)
+
+        self._check_inplace(is_inplace, orig, arr, obj)
+
+    def test_index_where(self, obj, key, expected, raises, val):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        res = Index(obj).where(~mask, val)
+        expected_idx = Index(expected, dtype=expected.dtype)
+        tm.assert_index_equal(res, expected_idx)
+
+    def test_index_putmask(self, obj, key, expected, raises, val):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        res = Index(obj).putmask(mask, val)
+        tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
+
+
+@pytest.mark.parametrize(
+    "obj,expected,key,raises",
+    [
+        pytest.param(
+            # GH#45568 setting a valid NA value into IntervalDtype[int] should
+            #  cast to IntervalDtype[float]
+            Series(interval_range(1, 5)),
+            Series(
+                [Interval(1, 2), np.nan, Interval(3, 4), Interval(4, 5)],
+                dtype="interval[float64]",
+            ),
+            1,
+            True,
+            id="interval_int_na_value",
+        ),
+        pytest.param(
+            # these induce dtype changes
+            Series([2, 3, 4, 5, 6, 7, 8, 9, 10]),
+            Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan]),
+            slice(None, None, 2),
+            False,
+            id="int_series_slice_key_step",
+        ),
+        pytest.param(
+            Series([True, True, False, False]),
+            Series([np.nan, True, np.nan, False], dtype=object),
+            slice(None, None, 2),
+            True,
+            id="bool_series_slice_key_step",
+        ),
+        pytest.param(
+            # these induce dtype changes
+            Series(np.arange(10)),
+            Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9]),
+            slice(None, 5),
+            False,
+            id="int_series_slice_key",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([1, 2, 3]),
+            Series([np.nan, 2, 3]),
+            0,
+            False,
+            id="int_series_int_key",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([False]),
+            Series([np.nan], dtype=object),
+            # TODO: maybe go to float64 since we are changing the _whole_ Series?
+            0,
+            True,
+            id="bool_series_int_key_change_all",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([False, True]),
+            Series([np.nan, True], dtype=object),
+            0,
+            True,
+            id="bool_series_int_key",
+        ),
+    ],
+)
+class TestSetitemCastingEquivalents(SetitemCastingEquivalents):
+    @pytest.fixture(params=[np.nan, np.float64("NaN"), None, NA])
+    def val(self, request):
+        """
+        NA values that should generally be valid_na for *all* dtypes.
+
+        Include both python float NaN and np.float64; only np.float64 has a
+        `dtype` attribute.
+        """
+        return request.param
+
+
+class TestSetitemTimedelta64IntoNumeric(SetitemCastingEquivalents):
+    # timedelta64 should not be treated as integers when setting into
+    #  numeric Series
+
+    @pytest.fixture
+    def val(self):
+        td = np.timedelta64(4, "ns")
+        return td
+        # TODO: could also try np.full((1,), td)
+
+    @pytest.fixture(params=[complex, int, float])
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def obj(self, dtype):
+        arr = np.arange(5).astype(dtype)
+        ser = Series(arr)
+        return ser
+
+    @pytest.fixture
+    def expected(self, dtype):
+        arr = np.arange(5).astype(dtype)
+        ser = Series(arr)
+        ser = ser.astype(object)
+        ser.iloc[0] = np.timedelta64(4, "ns")
+        return ser
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+class TestSetitemDT64IntoInt(SetitemCastingEquivalents):
+    # GH#39619 dont cast dt64 to int when doing this setitem
+
+    @pytest.fixture(params=["M8[ns]", "m8[ns]"])
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def scalar(self, dtype):
+        val = np.datetime64("2021-01-18 13:25:00", "ns")
+        if dtype == "m8[ns]":
+            val = val - val
+        return val
+
+    @pytest.fixture
+    def expected(self, scalar):
+        expected = Series([scalar, scalar, 3], dtype=object)
+        assert isinstance(expected[0], type(scalar))
+        return expected
+
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3])
+
+    @pytest.fixture
+    def key(self):
+        return slice(None, -1)
+
+    @pytest.fixture(params=[None, list, np.array])
+    def val(self, scalar, request):
+        box = request.param
+        if box is None:
+            return scalar
+        return box([scalar, scalar])
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+class TestSetitemNAPeriodDtype(SetitemCastingEquivalents):
+    # Setting compatible NA values into Series with PeriodDtype
+
+    @pytest.fixture
+    def expected(self, key):
+        exp = Series(period_range("2000-01-01", periods=10, freq="D"))
+        exp._values.view("i8")[key] = NaT._value
+        assert exp[key] is NaT or all(x is NaT for x in exp[key])
+        return exp
+
+    @pytest.fixture
+    def obj(self):
+        return Series(period_range("2000-01-01", periods=10, freq="D"))
+
+    @pytest.fixture(params=[3, slice(3, 5)])
+    def key(self, request):
+        return request.param
+
+    @pytest.fixture(params=[None, np.nan])
+    def val(self, request):
+        return request.param
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+class TestSetitemNADatetimeLikeDtype(SetitemCastingEquivalents):
+    # some nat-like values should be cast to datetime64/timedelta64 when
+    #  inserting into a datetime64/timedelta64 series.  Others should coerce
+    #  to object and retain their dtypes.
+    # GH#18586 for td64 and boolean mask case
+
+    @pytest.fixture(
+        params=["m8[ns]", "M8[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Central]"]
+    )
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def obj(self, dtype):
+        i8vals = date_range("2016-01-01", periods=3).asi8
+        idx = Index(i8vals, dtype=dtype)
+        assert idx.dtype == dtype
+        return Series(idx)
+
+    @pytest.fixture(
+        params=[
+            None,
+            np.nan,
+            NaT,
+            np.timedelta64("NaT", "ns"),
+            np.datetime64("NaT", "ns"),
+        ]
+    )
+    def val(self, request):
+        return request.param
+
+    @pytest.fixture
+    def is_inplace(self, val, obj):
+        # td64   -> cast to object iff val is datetime64("NaT")
+        # dt64   -> cast to object iff val is timedelta64("NaT")
+        # dt64tz -> cast to object with anything _but_ NaT
+        return val is NaT or val is None or val is np.nan or obj.dtype == val.dtype
+
+    @pytest.fixture
+    def expected(self, obj, val, is_inplace):
+        dtype = obj.dtype if is_inplace else object
+        expected = Series([val, *list(obj[1:])], dtype=dtype)
+        return expected
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def raises(self, is_inplace):
+        return False if is_inplace else True
+
+
+class TestSetitemMismatchedTZCastsToObject(SetitemCastingEquivalents):
+    # GH#24024
+    @pytest.fixture
+    def obj(self):
+        return Series(date_range("2000", periods=2, tz="US/Central"))
+
+    @pytest.fixture
+    def val(self):
+        return Timestamp("2000", tz="US/Eastern")
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def expected(self, obj, val):
+        # pre-2.0 this would cast to object, in 2.0 we cast the val to
+        #  the target tz
+        expected = Series(
+            [
+                val.tz_convert("US/Central"),
+                Timestamp("2000-01-02 00:00:00-06:00", tz="US/Central"),
+            ],
+            dtype=obj.dtype,
+        )
+        return expected
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "obj,expected",
+    [
+        # For numeric series, we should coerce to NaN.
+        (Series([1, 2, 3]), Series([np.nan, 2, 3])),
+        (Series([1.0, 2.0, 3.0]), Series([np.nan, 2.0, 3.0])),
+        # For datetime series, we should coerce to NaT.
+        (
+            Series([datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]),
+            Series([NaT, datetime(2000, 1, 2), datetime(2000, 1, 3)]),
+        ),
+        # For objects, we should preserve the None value.
+        (Series(["foo", "bar", "baz"]), Series([None, "bar", "baz"])),
+    ],
+)
+class TestSeriesNoneCoercion(SetitemCastingEquivalents):
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def val(self):
+        return None
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+class TestSetitemFloatIntervalWithIntIntervalValues(SetitemCastingEquivalents):
+    # GH#44201 Cast to shared IntervalDtype rather than object
+
+    def test_setitem_example(self):
+        # Just a case here to make obvious what this test class is aimed at
+        idx = IntervalIndex.from_breaks(range(4))
+        obj = Series(idx)
+        val = Interval(0.5, 1.5)
+
+        with pytest.raises(TypeError, match="Invalid value"):
+            obj[0] = val
+
+    @pytest.fixture
+    def obj(self):
+        """
+        Fixture to create a Series [(0, 1], (1, 2], (2, 3]]
+        """
+        idx = IntervalIndex.from_breaks(range(4))
+        return Series(idx)
+
+    @pytest.fixture
+    def val(self):
+        """
+        Fixture to get an interval (0.5, 1.5]
+        """
+        return Interval(0.5, 1.5)
+
+    @pytest.fixture
+    def key(self):
+        """
+        Fixture to get a key 0
+        """
+        return 0
+
+    @pytest.fixture
+    def expected(self, obj, val):
+        """
+        Fixture to get a Series [(0.5, 1.5], (1.0, 2.0], (2.0, 3.0]]
+        """
+        data = [val, *list(obj[1:])]
+        idx = IntervalIndex(data, dtype="Interval[float64]")
+        return Series(idx)
+
+    @pytest.fixture
+    def raises(self):
+        """
+        Fixture to enable raising pytest exceptions
+        """
+        return True
+
+
+class TestSetitemRangeIntoIntegerSeries(SetitemCastingEquivalents):
+    # GH#44261 Setting a range with sufficiently-small integers into
+    #  small-itemsize integer dtypes should not need to upcast
+
+    @pytest.fixture
+    def obj(self, any_int_numpy_dtype):
+        dtype = np.dtype(any_int_numpy_dtype)
+        ser = Series(range(5), dtype=dtype)
+        return ser
+
+    @pytest.fixture
+    def val(self):
+        return range(2, 4)
+
+    @pytest.fixture
+    def key(self):
+        return slice(0, 2)
+
+    @pytest.fixture
+    def expected(self, any_int_numpy_dtype):
+        dtype = np.dtype(any_int_numpy_dtype)
+        exp = Series([2, 3, 2, 3, 4], dtype=dtype)
+        return exp
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "val, raises",
+    [
+        (np.array([2.0, 3.0]), False),
+        (np.array([2.5, 3.5]), True),
+        (
+            np.array([2**65, 2**65 + 1], dtype=np.float64),
+            True,
+        ),  # all ints, but can't cast
+    ],
+)
+class TestSetitemFloatNDarrayIntoIntegerSeries(SetitemCastingEquivalents):
+    @pytest.fixture
+    def obj(self):
+        return Series(range(5), dtype=np.int64)
+
+    @pytest.fixture
+    def key(self):
+        return slice(0, 2)
+
+    @pytest.fixture
+    def expected(self, val):
+        if val[0] == 2:
+            # NB: this condition is based on currently-hardcoded "val" cases
+            dtype = np.int64
+        else:
+            dtype = np.float64
+        res_values = np.array(range(5), dtype=dtype)
+        res_values[:2] = val
+        return Series(res_values)
+
+
+@pytest.mark.parametrize("val", [512, np.int16(512)])
+class TestSetitemIntoIntegerSeriesNeedsUpcast(SetitemCastingEquivalents):
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3], dtype=np.int8)
+
+    @pytest.fixture
+    def key(self):
+        return 1
+
+    @pytest.fixture
+    def expected(self):
+        return Series([1, 512, 3], dtype=np.int16)
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+@pytest.mark.parametrize("val", [2**33 + 1.0, 2**33 + 1.1, 2**62])
+class TestSmallIntegerSetitemUpcast(SetitemCastingEquivalents):
+    # https://github.com/pandas-dev/pandas/issues/39584#issuecomment-941212124
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3], dtype="i4")
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def expected(self, val):
+        if val % 1 != 0:
+            dtype = "f8"
+        else:
+            dtype = "i8"
+        return Series([val, 2, 3], dtype=dtype)
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+class CoercionTest(SetitemCastingEquivalents):
+    # Tests ported from tests.indexing.test_coercion
+
+    @pytest.fixture
+    def key(self):
+        return 1
+
+    @pytest.fixture
+    def expected(self, obj, key, val, exp_dtype):
+        vals = list(obj)
+        vals[key] = val
+        return Series(vals, dtype=exp_dtype)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [(np.int32(1), np.int8, None), (np.int16(2**9), np.int16, True)],
+)
+class TestCoercionInt8(CoercionTest):
+    # previously test_setitem_series_int8 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4], dtype=np.int8)
+
+
+@pytest.mark.parametrize("val", [1, 1.1, 1 + 1j, True])
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestCoercionObject(CoercionTest):
+    # previously test_setitem_series_object in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(["a", "b", "c", "d"], dtype=object)
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, object, True),
+        ("e", StringDtype(na_value=np.nan), False),
+    ],
+)
+class TestCoercionString(CoercionTest):
+    @pytest.fixture
+    def obj(self):
+        return Series(["a", "b", "c", "d"], dtype=StringDtype(na_value=np.nan))
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, np.complex128, False),
+        (1.1, np.complex128, False),
+        (1 + 1j, np.complex128, False),
+        (True, object, True),
+    ],
+)
+class TestCoercionComplex(CoercionTest):
+    # previously test_setitem_series_complex128 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, object, True),
+        ("3", object, True),
+        (3, object, True),
+        (1.1, object, True),
+        (1 + 1j, object, True),
+        (True, bool, False),
+    ],
+)
+class TestCoercionBool(CoercionTest):
+    # previously test_setitem_series_bool in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([True, False, True, False], dtype=bool)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, np.int64, False),
+        (1.1, np.float64, True),
+        (1 + 1j, np.complex128, True),
+        (True, object, True),
+    ],
+)
+class TestCoercionInt64(CoercionTest):
+    # previously test_setitem_series_int64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, np.float64, False),
+        (1.1, np.float64, False),
+        (1 + 1j, np.complex128, True),
+        (True, object, True),
+    ],
+)
+class TestCoercionFloat64(CoercionTest):
+    # previously test_setitem_series_float64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (1, np.float32, False),
+        pytest.param(
+            1.1,
+            np.float32,
+            False,
+            marks=pytest.mark.xfail(
+                not np_version_gt2,
+                reason="np.float32(1.1) ends up as 1.100000023841858, so "
+                "np_can_hold_element raises and we cast to float64",
+            ),
+        ),
+        (1 + 1j, np.complex128, True),
+        (True, object, True),
+        (np.uint8(2), np.float32, False),
+        (np.uint32(2), np.float32, False),
+        # float32 cannot hold np.iinfo(np.uint32).max exactly
+        # (closest it can hold is 4294967300.0 which off by 5.0), so
+        # we cast to float64
+        (np.uint32(np.iinfo(np.uint32).max), np.float64, True),
+        (np.uint64(2), np.float32, False),
+        (np.int64(2), np.float32, False),
+    ],
+)
+class TestCoercionFloat32(CoercionTest):
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4], dtype=np.float32)
+
+    def test_slice_key(self, obj, key, expected, raises, val, indexer_sli, is_inplace):
+        super().test_slice_key(obj, key, expected, raises, val, indexer_sli, is_inplace)
+
+        if isinstance(val, float):
+            # the xfail would xpass bc test_slice_key short-circuits
+            raise AssertionError("xfail not relevant for this test.")
+
+
+@pytest.mark.parametrize(
+    "exp_dtype",
+    [
+        "M8[ms]",
+        "M8[ms, UTC]",
+        "m8[ms]",
+    ],
+)
+class TestCoercionDatetime64HigherReso(CoercionTest):
+    @pytest.fixture
+    def obj(self, exp_dtype):
+        idx = date_range("2011-01-01", freq="D", periods=4, unit="s")
+        if exp_dtype == "m8[ms]":
+            idx = idx - Timestamp("1970-01-01").as_unit("s")
+            assert idx.dtype == "m8[s]"
+        elif exp_dtype == "M8[ms, UTC]":
+            idx = idx.tz_localize("UTC")
+        return Series(idx)
+
+    @pytest.fixture
+    def val(self, exp_dtype):
+        ts = Timestamp("2011-01-02 03:04:05.678").as_unit("ms")
+        if exp_dtype == "m8[ms]":
+            return ts - Timestamp("1970-01-01").as_unit("s")
+        elif exp_dtype == "M8[ms, UTC]":
+            return ts.tz_localize("UTC")
+        return ts
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (Timestamp("2012-01-01"), "datetime64[ns]", False),
+        (1, object, True),
+        ("x", object, True),
+    ],
+)
+class TestCoercionDatetime64(CoercionTest):
+    # previously test_setitem_series_datetime64 in tests.indexing.test_coercion
+
+    @pytest.fixture
+    def obj(self):
+        return Series(date_range("2011-01-01", freq="D", periods=4, unit="ns"))
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]", False),
+        # pre-2.0, a mis-matched tz would end up casting to object
+        (Timestamp("2012-01-01", tz="US/Pacific"), "datetime64[ns, US/Eastern]", False),
+        (Timestamp("2012-01-01"), object, True),
+        (1, object, True),
+    ],
+)
+class TestCoercionDatetime64TZ(CoercionTest):
+    # previously test_setitem_series_datetime64tz in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        tz = "US/Eastern"
+        return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz, unit="ns"))
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,raises",
+    [
+        (Timedelta("12 day"), "timedelta64[us]", False),
+        (1, object, True),
+        ("x", object, True),
+    ],
+)
+class TestCoercionTimedelta64(CoercionTest):
+    # previously test_setitem_series_timedelta64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(timedelta_range("1 day", periods=4))
+
+    @pytest.fixture
+    def raises(self):
+        return False
+
+
+@pytest.mark.parametrize(
+    "val", ["foo", Period("2016", freq="Y"), Interval(1, 2, closed="both")]
+)
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestPeriodIntervalCoercion(CoercionTest):
+    # GH#45768
+    @pytest.fixture(
+        params=[
+            period_range("2016-01-01", periods=3, freq="D"),
+            interval_range(1, 5),
+        ]
+    )
+    def obj(self, request):
+        return Series(request.param)
+
+    @pytest.fixture
+    def raises(self):
+        return True
+
+
+def test_20643():
+    # closed by GH#45121
+    orig = Series([0, 1, 2], index=["a", "b", "c"])
+
+    ser = orig.copy()
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.at["b"] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.loc["b"] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser["b"] = 2.7
+
+    ser = orig.copy()
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.iat[1] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.iloc[1] = 2.7
+
+    orig_df = orig.to_frame("A")
+
+    df = orig_df.copy()
+    with pytest.raises(TypeError, match="Invalid value"):
+        df.at["b", "A"] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        df.loc["b", "A"] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        df.iloc[1, 0] = 2.7
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        df.iat[1, 0] = 2.7
+
+
+def test_20643_comment():
+    # https://github.com/pandas-dev/pandas/issues/20643#issuecomment-431244590
+    # fixed sometime prior to GH#45121
+    orig = Series([0, 1, 2], index=["a", "b", "c"])
+    expected = Series([np.nan, 1, 2], index=["a", "b", "c"])
+
+    ser = orig.copy()
+    ser.iat[0] = None
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    ser.iloc[0] = None
+    tm.assert_series_equal(ser, expected)
+
+
+def test_15413():
+    # fixed by GH#45121
+    ser = Series([1, 2, 3])
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser[ser == 2] += 0.5
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser[1] += 0.5
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.loc[1] += 0.5
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.iloc[1] += 0.5
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.iat[1] += 0.5
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser.at[1] += 0.5
+
+
+def test_32878_int_itemsize():
+    # Fixed by GH#45121
+    arr = np.arange(5).astype("i4")
+    ser = Series(arr)
+    val = np.int64(np.iinfo(np.int64).max)
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser[0] = val
+
+
+def test_32878_complex_itemsize():
+    arr = np.arange(5).astype("c8")
+    ser = Series(arr)
+    val = np.finfo(np.float64).max
+    val = val.astype("c16")
+
+    # GH#32878 used to coerce val to inf+0.000000e+00j
+    with pytest.raises(TypeError, match="Invalid value"):
+        ser[0] = val
+
+
+def test_37692(indexer_al):
+    # GH#37692
+    ser = Series([1, 2, 3], index=["a", "b", "c"])
+    with pytest.raises(TypeError, match="Invalid value"):
+        indexer_al(ser)["b"] = "test"
+
+
+def test_setitem_bool_int_float_consistency(indexer_sli):
+    # GH#21513
+    # bool-with-int and bool-with-float both upcast to object
+    #  int-with-float and float-with-int are both non-casting so long
+    #  as the setitem can be done losslessly
+    for dtype in [np.float64, np.int64]:
+        ser = Series(0, index=range(3), dtype=dtype)
+        with pytest.raises(TypeError, match="Invalid value"):
+            indexer_sli(ser)[0] = True
+
+        ser = Series(0, index=range(3), dtype=bool)
+        with pytest.raises(TypeError, match="Invalid value"):
+            ser[0] = dtype(1)
+
+    # 1.0 can be held losslessly, so no casting
+    ser = Series(0, index=range(3), dtype=np.int64)
+    indexer_sli(ser)[0] = np.float64(1.0)
+    assert ser.dtype == np.int64
+
+    # 1 can be held losslessly, so no casting
+    ser = Series(0, index=range(3), dtype=np.float64)
+    indexer_sli(ser)[0] = np.int64(1)
+
+
+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"])
+
+    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;
+    # 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"])
+
+    ser[0] = 1.5
+    expected = Series([1, 2, 3, 1.5], index=["a", "b", "c", 0])
+    tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_int_not_positional():
+    # GH#42215 deprecated falling back to positional on __setitem__ with an
+    #  int not contained in the index; enforced in 2.0
+    ser = Series([1, 2, 3, 4], index=[1.1, 2.1, 3.0, 4.1])
+    assert not ser.index._should_fallback_to_positional
+    # assert not ser.index.astype(object)._should_fallback_to_positional
+
+    # 3.0 is in our index, so post-enforcement behavior is unchanged
+    ser[3] = 10
+    expected = Series([1, 2, 10, 4], index=ser.index)
+    tm.assert_series_equal(ser, expected)
+
+    # pre-enforcement `ser[5] = 5` raised IndexError
+    ser[5] = 5
+    expected = Series([1, 2, 10, 4, 5], index=[1.1, 2.1, 3.0, 4.1, 5.0])
+    tm.assert_series_equal(ser, expected)
+
+    ii = IntervalIndex.from_breaks(range(10))[::2]
+    ser2 = Series(range(len(ii)), index=ii)
+    exp_index = ii.astype(object).append(Index([4]))
+    expected2 = Series([0, 1, 2, 3, 4, 9], index=exp_index)
+    # pre-enforcement `ser2[4] = 9` interpreted 4 as positional
+    ser2[4] = 9
+    tm.assert_series_equal(ser2, expected2)
+
+    mi = MultiIndex.from_product([ser.index, ["A", "B"]])
+    ser3 = Series(range(len(mi)), index=mi)
+    expected3 = ser3.copy()
+    expected3.loc[4] = 99
+    # pre-enforcement `ser3[4] = 99` interpreted 4 as positional
+    ser3[4] = 99
+    tm.assert_series_equal(ser3, expected3)
+
+
+def test_setitem_with_bool_indexer():
+    # GH#42530
+
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    result = df.pop("b").copy()
+    result[[True, False, False]] = 9
+    expected = Series(data=[9, 5, 6], name="b")
+    tm.assert_series_equal(result, expected)
+
+    df.loc[[True, False, False], "a"] = 10
+    expected = DataFrame({"a": [10, 2, 3]})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("size", range(2, 6))
+@pytest.mark.parametrize(
+    "mask", [[True, False, False, False, False], [True, False], [False]]
+)
+@pytest.mark.parametrize(
+    "item", [2.0, np.nan, np.finfo(float).max, np.finfo(float).min]
+)
+@pytest.mark.parametrize("box", [np.array, list, tuple])
+def test_setitem_bool_indexer_dont_broadcast_length1_values(size, mask, item, box):
+    # GH#44265
+    # see also tests.series.indexing.test_where.test_broadcast
+
+    selection = np.resize(mask, size)
+
+    data = np.arange(size, dtype=float)
+
+    ser = Series(data)
+
+    if selection.sum() != 1:
+        msg = (
+            "cannot set using a list-like indexer with a different "
+            "length than the value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            # GH#44265
+            ser[selection] = box([item])
+    else:
+        # In this corner case setting is equivalent to setting with the unboxed
+        #  item
+        ser[selection] = box([item])
+
+        expected = Series(np.arange(size, dtype=float))
+        expected[selection] = item
+        tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_empty_mask_dont_upcast_dt64():
+    dti = date_range("2016-01-01", periods=3)
+    ser = Series(dti)
+    orig = ser.copy()
+    mask = np.zeros(3, dtype=bool)
+
+    ser[mask] = "foo"
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
+
+    ser.mask(mask, "foo", inplace=True)
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
+
+
+def test_setitem_bool_dtype_with_boolean_indexer():
+    # GH 57338
+    s1 = Series([True, True, True], dtype=bool)
+    s2 = Series([False, False, False], dtype=bool)
+    condition = [False, True, False]
+    s1[condition] = s2[condition]
+    expected = Series([True, False, True], dtype=bool)
+    tm.assert_series_equal(s1, expected)

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_take.py

@@ -0,0 +1,50 @@
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_take_validate_axis():
+    # GH#51022
+    ser = Series([-1, 5, 6, 2, 4])
+
+    msg = "No axis named foo for object type Series"
+    with pytest.raises(ValueError, match=msg):
+        ser.take([1, 2], axis="foo")
+
+
+def test_take():
+    ser = Series([-1, 5, 6, 2, 4])
+
+    actual = ser.take([1, 3, 4])
+    expected = Series([5, 2, 4], index=[1, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    actual = ser.take([-1, 3, 4])
+    expected = Series([4, 2, 4], index=[4, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    msg = "indices are out-of-bounds"
+    with pytest.raises(IndexError, match=msg):
+        ser.take([1, 10])
+    with pytest.raises(IndexError, match=msg):
+        ser.take([2, 5])
+
+
+def test_take_categorical():
+    # https://github.com/pandas-dev/pandas/issues/20664
+    ser = Series(pd.Categorical(["a", "b", "c"]))
+    result = ser.take([-2, -2, 0])
+    expected = Series(
+        pd.Categorical(["b", "b", "a"], categories=["a", "b", "c"]), index=[1, 1, 0]
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_take_slice_raises():
+    ser = Series([-1, 5, 6, 2, 4])
+
+    msg = "Series.take requires a sequence of integers, not slice"
+    with pytest.raises(TypeError, match=msg):
+        ser.take(slice(0, 3, 1))

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_where.py

@@ -0,0 +1,446 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+import pandas as pd
+from pandas import (
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+
+
+def test_where_unsafe_int(any_signed_int_numpy_dtype):
+    s = Series(np.arange(10), dtype=any_signed_int_numpy_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    expected = Series(
+        list(range(2, 7)) + list(range(5, 10)),
+        dtype=any_signed_int_numpy_dtype,
+    )
+
+    tm.assert_series_equal(s, expected)
+
+
+def test_where_unsafe_float(float_numpy_dtype):
+    s = Series(np.arange(10), dtype=float_numpy_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    data = list(range(2, 7)) + list(range(5, 10))
+    expected = Series(data, dtype=float_numpy_dtype)
+
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize(
+    "dtype,expected_dtype",
+    [
+        (np.int8, np.float64),
+        (np.int16, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+    ],
+)
+def test_where_unsafe_upcast(dtype, expected_dtype):
+    # see gh-9743
+    s = Series(np.arange(10), dtype=dtype)
+    values = [2.5, 3.5, 4.5, 5.5, 6.5]
+    mask = s < 5
+    if np.dtype(dtype).kind == np.dtype(expected_dtype).kind == "f":
+        s[mask] = values
+        expected = Series(values + list(range(5, 10)), dtype=expected_dtype)
+        tm.assert_series_equal(s, expected)
+    else:
+        with pytest.raises(TypeError, match="Invalid value"):
+            s[mask] = values
+
+
+def test_where_unsafe():
+    # see gh-9731
+    s = Series(np.arange(10), dtype="int64")
+    values = [2.5, 3.5, 4.5, 5.5]
+
+    mask = s > 5
+    expected = Series(list(range(6)) + values, dtype="float64")
+
+    with pytest.raises(TypeError, match="Invalid value"):
+        s[mask] = values
+    s = s.astype("float64")
+    s[mask] = values
+
+    # see gh-3235
+    s = Series(np.arange(10), dtype="int64")
+    mask = s < 5
+    s[mask] = range(2, 7)
+    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype="int64")
+    tm.assert_series_equal(s, expected)
+    assert s.dtype == expected.dtype
+
+    s = Series(np.arange(10), dtype="int64")
+    mask = s > 5
+    s[mask] = [0] * 4
+    expected = Series([0, 1, 2, 3, 4, 5] + [0] * 4, dtype="int64")
+    tm.assert_series_equal(s, expected)
+
+    s = Series(np.arange(10))
+    mask = s > 5
+
+    msg = "cannot set using a list-like indexer with a different length than the value"
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [5, 4, 3, 2, 1]
+
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [0] * 5
+
+    # dtype changes
+    s = Series([1, 2, 3, 4])
+    result = s.where(s > 2, np.nan)
+    expected = Series([np.nan, np.nan, 3, 4])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4667
+    # setting with None changes dtype
+    s = Series(range(10)).astype(float)
+    s[8] = None
+    result = s[8]
+    assert isna(result)
+
+    s = Series(range(10)).astype(float)
+    s[s > 8] = None
+    result = s[isna(s)]
+    expected = Series(np.nan, index=[9])
+    tm.assert_series_equal(result, expected)
+
+
+def test_where():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.where(cond).dropna()
+    rs2 = s[cond]
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(cond, -s)
+    tm.assert_series_equal(rs, s.abs())
+
+    rs = s.where(cond)
+    assert s.shape == rs.shape
+    assert rs is not s
+
+    # test alignment
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+
+    expected = s2[cond].reindex(s2.index[:3]).reindex(s2.index)
+    rs = s2.where(cond[:3])
+    tm.assert_series_equal(rs, expected)
+
+    expected = s2.abs()
+    expected.iloc[0] = s2[0]
+    rs = s2.where(cond[:3], -s2)
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_error():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where(1)
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond[:3].values, -s)
+
+    # GH 2745
+    s = Series([1, 2])
+    s[[True, False]] = [0, 1]
+    expected = Series([0, 2])
+    tm.assert_series_equal(s, expected)
+
+    # failures
+    msg = "cannot set using a list-like indexer with a different length than the value"
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = [0, 2, 3]
+
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = []
+
+
+@pytest.mark.parametrize("klass", [list, tuple, np.array, Series])
+def test_where_array_like(klass):
+    # see gh-15414
+    s = Series([1, 2, 3])
+    cond = [False, True, True]
+    expected = Series([np.nan, 2, 3])
+
+    result = s.where(klass(cond))
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "cond",
+    [
+        [1, 0, 1],
+        Series([2, 5, 7]),
+        ["True", "False", "True"],
+        [Timestamp("2017-01-01"), pd.NaT, Timestamp("2017-01-02")],
+    ],
+)
+def test_where_invalid_input(cond):
+    # see gh-15414: only boolean arrays accepted
+    s = Series([1, 2, 3])
+    msg = "Boolean array expected for the condition"
+
+    with pytest.raises(TypeError, match=msg):
+        s.where(cond)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where([True])
+
+
+def test_where_ndframe_align():
+    msg = "Array conditional must be same shape as self"
+    s = Series([1, 2, 3])
+
+    cond = [True]
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([1, np.nan, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+    cond = np.array([False, True, False, True])
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([np.nan, 2, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+
+def test_where_setitem_invalid():
+    # GH 2702
+    # make sure correct exceptions are raised on invalid list assignment
+
+    msg = lambda x: (
+        f"cannot set using a {x} indexer with a different length than the value"
+    )
+    # slice
+    s = Series(list("abc"), dtype=object)
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[0:3] = list(range(27))
+
+    s[0:3] = list(range(3))
+    expected = Series([0, 1, 2])
+    tm.assert_series_equal(s.astype(np.int64), expected)
+
+    # slice with step
+    s = Series(list("abcdef"), dtype=object)
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[0:4:2] = list(range(27))
+
+    s = Series(list("abcdef"), dtype=object)
+    s[0:4:2] = list(range(2))
+    expected = Series([0, "b", 1, "d", "e", "f"])
+    tm.assert_series_equal(s, expected)
+
+    # neg slices
+    s = Series(list("abcdef"), dtype=object)
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[:-1] = list(range(27))
+
+    s[-3:-1] = list(range(2))
+    expected = Series(["a", "b", "c", 0, 1, "f"])
+    tm.assert_series_equal(s, expected)
+
+    # list
+    s = Series(list("abc"), dtype=object)
+
+    with pytest.raises(ValueError, match=msg("list-like")):
+        s[[0, 1, 2]] = list(range(27))
+
+    s = Series(list("abc"), dtype=object)
+
+    with pytest.raises(ValueError, match=msg("list-like")):
+        s[[0, 1, 2]] = list(range(2))
+
+    # scalar
+    s = Series(list("abc"), dtype=object)
+    s[0] = list(range(10))
+    expected = Series([list(range(10)), "b", "c"])
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize("size", range(2, 6))
+@pytest.mark.parametrize(
+    "mask", [[True, False, False, False, False], [True, False], [False]]
+)
+@pytest.mark.parametrize(
+    "item", [2.0, np.nan, np.finfo(float).max, np.finfo(float).min]
+)
+@pytest.mark.parametrize("box", [np.array, list, tuple])
+def test_broadcast(size, mask, item, box):
+    # GH#8801, GH#4195
+    selection = np.resize(mask, size)
+
+    data = np.arange(size, dtype=float)
+
+    # Construct the expected series by taking the source
+    # data or item based on the selection
+    expected = Series(
+        [item if use_item else data[i] for i, use_item in enumerate(selection)]
+    )
+
+    s = Series(data)
+
+    s[selection] = item
+    tm.assert_series_equal(s, expected)
+
+    s = Series(data)
+    result = s.where(~selection, box([item]))
+    tm.assert_series_equal(result, expected)
+
+    s = Series(data)
+    result = s.mask(selection, box([item]))
+    tm.assert_series_equal(result, expected)
+
+
+def test_where_inplace():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.copy()
+
+    result = rs.where(cond, inplace=True)
+    assert result is rs
+    tm.assert_series_equal(rs.dropna(), s[cond])
+    tm.assert_series_equal(rs, s.where(cond))
+
+    rs = s.copy()
+    result = rs.where(cond, -s, inplace=True)
+    assert result is rs
+    tm.assert_series_equal(rs, s.where(cond, -s))
+
+
+def test_where_dups():
+    # GH 4550
+    # where crashes with dups in index
+    s1 = Series(list(range(3)))
+    s2 = Series(list(range(3)))
+    comb = pd.concat([s1, s2])
+    result = comb.where(comb < 2)
+    expected = Series([0, 1, np.nan, 0, 1, np.nan], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4548
+    # inplace updating not working with dups
+    comb[comb < 1] = 5
+    expected = Series([5, 1, 2, 5, 1, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+    comb[comb < 2] += 10
+    expected = Series([5, 11, 2, 5, 11, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+
+def test_where_numeric_with_string():
+    # GH 9280
+    s = Series([1, 2, 3])
+    w = s.where(s > 1, "X")
+
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, ["X", "Y", "Z"])
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, np.array(["X", "Y", "Z"]))
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+
+def test_where_datetimetz():
+    # GH 15701
+    timestamps = ["2016-12-31 12:00:04+00:00", "2016-12-31 12:00:04.010000+00:00"]
+    ser = Series([Timestamp(t) for t in timestamps], dtype="datetime64[ns, UTC]")
+    rs = ser.where(Series([False, True]))
+    expected = Series([pd.NaT, ser[1]], dtype="datetime64[ns, UTC]")
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_sparse():
+    # GH#17198 make sure we dont get an AttributeError for sp_index
+    ser = Series(pd.arrays.SparseArray([1, 2]))
+    result = ser.where(ser >= 2, 0)
+    expected = Series(pd.arrays.SparseArray([0, 2]))
+    tm.assert_series_equal(result, expected)
+
+
+def test_where_empty_series_and_empty_cond_having_non_bool_dtypes():
+    # https://github.com/pandas-dev/pandas/issues/34592
+    ser = Series([], dtype=float)
+    result = ser.where([])
+    tm.assert_series_equal(result, ser)
+
+
+def test_where_categorical(frame_or_series):
+    # https://github.com/pandas-dev/pandas/issues/18888
+    exp = frame_or_series(
+        pd.Categorical(["A", "A", "B", "B", np.nan], categories=["A", "B", "C"]),
+        dtype="category",
+    )
+    df = frame_or_series(["A", "A", "B", "B", "C"], dtype="category")
+    res = df.where(df != "C")
+    tm.assert_equal(exp, res)
+
+
+def test_where_datetimelike_categorical(tz_naive_fixture):
+    # GH#37682
+    tz = tz_naive_fixture
+
+    dr = date_range("2001-01-01", periods=3, tz=tz)._with_freq(None)
+    lvals = pd.DatetimeIndex([dr[0], dr[1], pd.NaT])
+    rvals = pd.Categorical([dr[0], pd.NaT, dr[2]])
+
+    mask = np.array([True, True, False])
+
+    # DatetimeIndex.where
+    res = lvals.where(mask, rvals)
+    tm.assert_index_equal(res, dr)
+
+    # DatetimeArray.where
+    res = lvals._data._where(mask, rvals)
+    tm.assert_datetime_array_equal(res, dr._data)
+
+    # Series.where
+    res = Series(lvals).where(mask, rvals)
+    tm.assert_series_equal(res, Series(dr))
+
+    # DataFrame.where
+    res = pd.DataFrame(lvals).where(mask[:, None], pd.DataFrame(rvals))
+
+    tm.assert_frame_equal(res, pd.DataFrame(dr))

.venv/lib/python3.13/site-packages/pandas/tests/series/indexing/test_xs.py

@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def test_xs_datetimelike_wrapping():
+    # GH#31630 a case where we shouldn't wrap datetime64 in Timestamp
+    arr = date_range("2016-01-01", periods=3)._data._ndarray
+
+    ser = Series(arr, dtype=object)
+    for i in range(len(ser)):
+        ser.iloc[i] = arr[i]
+    assert ser.dtype == object
+    assert isinstance(ser[0], np.datetime64)
+
+    result = ser.xs(0)
+    assert isinstance(result, np.datetime64)
+
+
+class TestXSWithMultiIndex:
+    def test_xs_level_series(self, multiindex_dataframe_random_data):
+        df = multiindex_dataframe_random_data
+        ser = df["A"]
+        expected = ser[:, "two"]
+        result = df.xs("two", level=1)["A"]
+        tm.assert_series_equal(result, expected)
+
+    def test_series_getitem_multiindex_xs_by_label(self):
+        # GH#5684
+        idx = MultiIndex.from_tuples(
+            [("a", "one"), ("a", "two"), ("b", "one"), ("b", "two")]
+        )
+        ser = Series([1, 2, 3, 4], index=idx)
+        return_value = ser.index.set_names(["L1", "L2"], inplace=True)
+        assert return_value is None
+        expected = Series([1, 3], index=["a", "b"])
+        return_value = expected.index.set_names(["L1"], inplace=True)
+        assert return_value is None
+
+        result = ser.xs("one", level="L2")
+        tm.assert_series_equal(result, expected)
+
+    def test_series_getitem_multiindex_xs(self):
+        # GH#6258
+        dt = list(date_range("20130903", periods=3))
+        idx = MultiIndex.from_product([list("AB"), dt])
+        ser = Series([1, 3, 4, 1, 3, 4], index=idx)
+        expected = Series([1, 1], index=list("AB"))
+
+        result = ser.xs("20130903", level=1)
+        tm.assert_series_equal(result, expected)
+
+    def test_series_xs_droplevel_false(self):
+        # GH: 19056
+        mi = MultiIndex.from_tuples(
+            [("a", "x"), ("a", "y"), ("b", "x")], names=["level1", "level2"]
+        )
+        ser = Series([1, 1, 1], index=mi)
+        result = ser.xs("a", axis=0, drop_level=False)
+        expected = Series(
+            [1, 1],
+            index=MultiIndex.from_tuples(
+                [("a", "x"), ("a", "y")], names=["level1", "level2"]
+            ),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_xs_key_as_list(self):
+        # GH#41760
+        mi = MultiIndex.from_tuples([("a", "x")], names=["level1", "level2"])
+        ser = Series([1], index=mi)
+        with pytest.raises(TypeError, match="list keys are not supported"):
+            ser.xs(["a", "x"], axis=0, drop_level=False)
+
+        with pytest.raises(TypeError, match="list keys are not supported"):
+            ser.xs(["a"], axis=0, drop_level=False)

.venv/lib/python3.13/site-packages/pandas/tests/series/methods/__init__.py

@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) Series methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.frame.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""