diff --git a/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_154_mp_rank_02_optim_states.pt b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_154_mp_rank_02_optim_states.pt
new file mode 100644
index 0000000000000000000000000000000000000000..bdcec7b35f4f0f8e9caefea1efb9c1d15d0e648f
--- /dev/null
+++ b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_154_mp_rank_02_optim_states.pt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c12da66071dd9401416b3c8580432ab018803543ac3dbc698b984a5b303b3fa
+size 41830340
diff --git a/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_21_mp_rank_00_optim_states.pt b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_21_mp_rank_00_optim_states.pt
new file mode 100644
index 0000000000000000000000000000000000000000..0d5b99de3922bd7921d2e6983713ff16e5729899
--- /dev/null
+++ b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_21_mp_rank_00_optim_states.pt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76bb8375dc5d377e2c83c124898c72eca4a971cba91b03ea93e055f3ba6c1777
+size 41830138
diff --git a/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_239_mp_rank_02_optim_states.pt b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_239_mp_rank_02_optim_states.pt
new file mode 100644
index 0000000000000000000000000000000000000000..7904cd216c0224969c04874ae01e3fdd648e988a
--- /dev/null
+++ b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_239_mp_rank_02_optim_states.pt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d00a94ebaf98e3cb257ca75c5b6f08b5eff9390a9820a9a17764a6ce4927de4
+size 41830340
diff --git a/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_78_mp_rank_00_optim_states.pt b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_78_mp_rank_00_optim_states.pt
new file mode 100644
index 0000000000000000000000000000000000000000..abd872a6a6dfd248ba9857e60a0a6e2460b8bf35
--- /dev/null
+++ b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_78_mp_rank_00_optim_states.pt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9358076afb92f578440362e7ab096cd1a880fef74a9270b1fc9326b25e27ad3
+size 41830138
diff --git a/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_92_mp_rank_01_optim_states.pt b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_92_mp_rank_01_optim_states.pt
new file mode 100644
index 0000000000000000000000000000000000000000..35c5c08fe79404735181335f5dd7fd3d0bfbfee6
--- /dev/null
+++ b/ckpts/llama-3b/global_step100/bf16_zero_pp_rank_92_mp_rank_01_optim_states.pt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d6deaa2e1ee352bdaaa3e9a3a4df2f2fbea38cca99fbbffec5c29f28b62d5b5
+size 41830202
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/conftest.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d284a46b38b7dd883c4099777d48dde4127bb905
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/conftest.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_at.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_at.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..378b1a0a3a561465df4121c0f26842696e8ab5bb
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_at.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_categorical.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_categorical.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58d6f35638d879e609fa112d6501bb6656792860
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_categorical.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_chaining_and_caching.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_chaining_and_caching.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0f2af1a8b53b9060a850128a909a70ff35336ab
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_chaining_and_caching.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_coercion.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_coercion.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5cbe45dcb50f4aed40891a9c4bc039adec8ad4c
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_coercion.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_floats.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_floats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef17057a0884fc2116fc1cc91e10111fda20c376
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_floats.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iat.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed884a5ef4a4b2d548c3fcd99613913b3aa67bed
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iat.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iloc.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iloc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..475741af0880f850985bd46a9bc3902a4796a32e
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_iloc.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_indexing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8130b605d3444b4a1cdb54e63b97e79f5ac2e27a
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39090fe42deb0cb648a98cbbff9d35dc28c233cc
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_na_indexing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_na_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5fe6d6df99adb270faff9be3fc3c1123e76b95dc
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_na_indexing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_partial.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_partial.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39abc239a68751bc174df80551796a14713f8d52
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_partial.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/interval/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/indexing/interval/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/interval/test_interval.py b/venv/lib/python3.10/site-packages/pandas/tests/indexing/interval/test_interval.py
new file mode 100644
index 0000000000000000000000000000000000000000..cabfee9aa040a1718d91062d895b13387ee2fcb9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexing/interval/test_interval.py
@@ -0,0 +1,227 @@
+import numpy as np
+import pytest
+
+from pandas._libs import index as libindex
+from pandas.compat import IS64
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    IntervalIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIntervalIndex:
+    @pytest.fixture
+    def series_with_interval_index(self):
+        return Series(np.arange(5), IntervalIndex.from_breaks(np.arange(6)))
+
+    def test_getitem_with_scalar(self, series_with_interval_index, indexer_sl):
+        ser = series_with_interval_index.copy()
+
+        expected = ser.iloc[:3]
+        tm.assert_series_equal(expected, indexer_sl(ser)[:3])
+        tm.assert_series_equal(expected, indexer_sl(ser)[:2.5])
+        tm.assert_series_equal(expected, indexer_sl(ser)[0.1:2.5])
+        if indexer_sl is tm.loc:
+            tm.assert_series_equal(expected, ser.loc[-1:3])
+
+        expected = ser.iloc[1:4]
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 2.5, 3.5]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[2, 3, 4]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 3, 4]])
+
+        expected = ser.iloc[2:5]
+        tm.assert_series_equal(expected, indexer_sl(ser)[ser >= 2])
+
+    @pytest.mark.parametrize("direction", ["increasing", "decreasing"])
+    def test_getitem_nonoverlapping_monotonic(self, direction, closed, indexer_sl):
+        tpls = [(0, 1), (2, 3), (4, 5)]
+        if direction == "decreasing":
+            tpls = tpls[::-1]
+
+        idx = IntervalIndex.from_tuples(tpls, closed=closed)
+        ser = Series(list("abc"), idx)
+
+        for key, expected in zip(idx.left, ser):
+            if idx.closed_left:
+                assert indexer_sl(ser)[key] == expected
+            else:
+                with pytest.raises(KeyError, match=str(key)):
+                    indexer_sl(ser)[key]
+
+        for key, expected in zip(idx.right, ser):
+            if idx.closed_right:
+                assert indexer_sl(ser)[key] == expected
+            else:
+                with pytest.raises(KeyError, match=str(key)):
+                    indexer_sl(ser)[key]
+
+        for key, expected in zip(idx.mid, ser):
+            assert indexer_sl(ser)[key] == expected
+
+    def test_getitem_non_matching(self, series_with_interval_index, indexer_sl):
+        ser = series_with_interval_index.copy()
+
+        # this is a departure from our current
+        # indexing scheme, but simpler
+        with pytest.raises(KeyError, match=r"\[-1\] not in index"):
+            indexer_sl(ser)[[-1, 3, 4, 5]]
+
+        with pytest.raises(KeyError, match=r"\[-1\] not in index"):
+            indexer_sl(ser)[[-1, 3]]
+
+    def test_loc_getitem_large_series(self, monkeypatch):
+        size_cutoff = 20
+        with monkeypatch.context():
+            monkeypatch.setattr(libindex, "_SIZE_CUTOFF", size_cutoff)
+            ser = Series(
+                np.arange(size_cutoff),
+                index=IntervalIndex.from_breaks(np.arange(size_cutoff + 1)),
+            )
+
+            result1 = ser.loc[:8]
+            result2 = ser.loc[0:8]
+            result3 = ser.loc[0:8:1]
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+
+    def test_loc_getitem_frame(self):
+        # CategoricalIndex with IntervalIndex categories
+        df = DataFrame({"A": range(10)})
+        ser = pd.cut(df.A, 5)
+        df["B"] = ser
+        df = df.set_index("B")
+
+        result = df.loc[4]
+        expected = df.iloc[4:6]
+        tm.assert_frame_equal(result, expected)
+
+        with pytest.raises(KeyError, match="10"):
+            df.loc[10]
+
+        # single list-like
+        result = df.loc[[4]]
+        expected = df.iloc[4:6]
+        tm.assert_frame_equal(result, expected)
+
+        # non-unique
+        result = df.loc[[4, 5]]
+        expected = df.take([4, 5, 4, 5])
+        tm.assert_frame_equal(result, expected)
+
+        msg = (
+            r"None of \[Index\(\[10\], dtype='object', name='B'\)\] "
+            r"are in the \[index\]"
+        )
+        with pytest.raises(KeyError, match=msg):
+            df.loc[[10]]
+
+        # partial missing
+        with pytest.raises(KeyError, match=r"\[10\] not in index"):
+            df.loc[[10, 4]]
+
+    def test_getitem_interval_with_nans(self, frame_or_series, indexer_sl):
+        # GH#41831
+
+        index = IntervalIndex([np.nan, np.nan])
+        key = index[:-1]
+
+        obj = frame_or_series(range(2), index=index)
+        if frame_or_series is DataFrame and indexer_sl is tm.setitem:
+            obj = obj.T
+
+        result = indexer_sl(obj)[key]
+        expected = obj
+
+        tm.assert_equal(result, expected)
+
+    def test_setitem_interval_with_slice(self):
+        # GH#54722
+        ii = IntervalIndex.from_breaks(range(4, 15))
+        ser = Series(range(10), index=ii)
+
+        orig = ser.copy()
+
+        # This should be a no-op (used to raise)
+        ser.loc[1:3] = 20
+        tm.assert_series_equal(ser, orig)
+
+        ser.loc[6:8] = 19
+        orig.iloc[1:4] = 19
+        tm.assert_series_equal(ser, orig)
+
+        ser2 = Series(range(5), index=ii[::2])
+        orig2 = ser2.copy()
+
+        # this used to raise
+        ser2.loc[6:8] = 22  # <- raises on main, sets on branch
+        orig2.iloc[1] = 22
+        tm.assert_series_equal(ser2, orig2)
+
+        ser2.loc[5:7] = 21
+        orig2.iloc[:2] = 21
+        tm.assert_series_equal(ser2, orig2)
+
+
+class TestIntervalIndexInsideMultiIndex:
+    def test_mi_intervalindex_slicing_with_scalar(self):
+        # GH#27456
+        ii = IntervalIndex.from_arrays(
+            [0, 1, 10, 11, 0, 1, 10, 11], [1, 2, 11, 12, 1, 2, 11, 12], name="MP"
+        )
+        idx = pd.MultiIndex.from_arrays(
+            [
+                pd.Index(["FC", "FC", "FC", "FC", "OWNER", "OWNER", "OWNER", "OWNER"]),
+                pd.Index(
+                    ["RID1", "RID1", "RID2", "RID2", "RID1", "RID1", "RID2", "RID2"]
+                ),
+                ii,
+            ]
+        )
+
+        idx.names = ["Item", "RID", "MP"]
+        df = DataFrame({"value": [1, 2, 3, 4, 5, 6, 7, 8]})
+        df.index = idx
+
+        query_df = DataFrame(
+            {
+                "Item": ["FC", "OWNER", "FC", "OWNER", "OWNER"],
+                "RID": ["RID1", "RID1", "RID1", "RID2", "RID2"],
+                "MP": [0.2, 1.5, 1.6, 11.1, 10.9],
+            }
+        )
+
+        query_df = query_df.sort_index()
+
+        idx = pd.MultiIndex.from_arrays([query_df.Item, query_df.RID, query_df.MP])
+        query_df.index = idx
+        result = df.value.loc[query_df.index]
+
+        # the IntervalIndex level is indexed with floats, which map to
+        #  the intervals containing them.  Matching the behavior we would get
+        #  with _only_ an IntervalIndex, we get an IntervalIndex level back.
+        sliced_level = ii.take([0, 1, 1, 3, 2])
+        expected_index = pd.MultiIndex.from_arrays(
+            [idx.get_level_values(0), idx.get_level_values(1), sliced_level]
+        )
+        expected = Series([1, 6, 2, 8, 7], index=expected_index, name="value")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.xfail(not IS64, reason="GH 23440")
+    @pytest.mark.parametrize(
+        "base",
+        [101, 1010],
+    )
+    def test_reindex_behavior_with_interval_index(self, base):
+        # GH 51826
+
+        ser = Series(
+            range(base),
+            index=IntervalIndex.from_arrays(range(base), range(1, base + 1)),
+        )
+        expected_result = Series([np.nan, 0], index=[np.nan, 1.0], dtype=float)
+        result = ser.reindex(index=[np.nan, 1.0])
+        tm.assert_series_equal(result, expected_result)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_multiindex.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_multiindex.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a76c92130e45ab325a4e415317f480da5674f2b
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_multiindex.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_slice.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_slice.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57565b9bed04a2c30fa316d1596a83cb93d90df2
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/__pycache__/test_slice.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/internals/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..288426eadecd8afd450ba20a74d08456c46f1bc8
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_api.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b30b548d454e3e14d525473fa66853c454e2f3d
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_api.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_internals.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_internals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c41b060a25beb09791980a2381879ce3dac26113
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_internals.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_managers.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_managers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c89ab852338ebfefb6a2a2a9c59d65b04d69a1e
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/internals/__pycache__/test_managers.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/test_api.py b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..1251a6ae97a1cb9304de036dba252de54e7fb10b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_api.py
@@ -0,0 +1,86 @@
+"""
+Tests for the pseudo-public API implemented in internals/api.py and exposed
+in core.internals
+"""
+
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core import internals
+from pandas.core.internals import api
+
+
+def test_internals_api():
+    assert internals.make_block is api.make_block
+
+
+def test_namespace():
+    # SUBJECT TO CHANGE
+
+    modules = [
+        "blocks",
+        "concat",
+        "managers",
+        "construction",
+        "array_manager",
+        "base",
+        "api",
+        "ops",
+    ]
+    expected = [
+        "make_block",
+        "DataManager",
+        "ArrayManager",
+        "BlockManager",
+        "SingleDataManager",
+        "SingleBlockManager",
+        "SingleArrayManager",
+        "concatenate_managers",
+    ]
+
+    result = [x for x in dir(internals) if not x.startswith("__")]
+    assert set(result) == set(expected + modules)
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "NumericBlock",
+        "ObjectBlock",
+        "Block",
+        "ExtensionBlock",
+        "DatetimeTZBlock",
+    ],
+)
+def test_deprecations(name):
+    # GH#55139
+    msg = f"{name} is deprecated.* Use public APIs instead"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        getattr(internals, name)
+
+    if name not in ["NumericBlock", "ObjectBlock"]:
+        # NumericBlock and ObjectBlock are not in the internals.api namespace
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            getattr(api, name)
+
+
+def test_make_block_2d_with_dti():
+    # GH#41168
+    dti = pd.date_range("2012", periods=3, tz="UTC")
+    blk = api.make_block(dti, placement=[0])
+
+    assert blk.shape == (1, 3)
+    assert blk.values.shape == (1, 3)
+
+
+def test_create_block_manager_from_blocks_deprecated():
+    # GH#33892
+    # If they must, downstream packages should get this from internals.api,
+    #  not internals.
+    msg = (
+        "create_block_manager_from_blocks is deprecated and will be "
+        "removed in a future version. Use public APIs instead"
+    )
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        internals.create_block_manager_from_blocks
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/test_internals.py b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_internals.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce88bae6e02f2892d7c8e4ee8f6315904bbbd65a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_internals.py
@@ -0,0 +1,1422 @@
+from datetime import (
+    date,
+    datetime,
+)
+import itertools
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.internals import BlockPlacement
+from pandas.compat import IS64
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    period_range,
+)
+import pandas._testing as tm
+import pandas.core.algorithms as algos
+from pandas.core.arrays import (
+    DatetimeArray,
+    SparseArray,
+    TimedeltaArray,
+)
+from pandas.core.internals import (
+    BlockManager,
+    SingleBlockManager,
+    make_block,
+)
+from pandas.core.internals.blocks import (
+    ensure_block_shape,
+    maybe_coerce_values,
+    new_block,
+)
+
+# this file contains BlockManager specific tests
+# TODO(ArrayManager) factor out interleave_dtype tests
+pytestmark = td.skip_array_manager_invalid_test
+
+
+@pytest.fixture(params=[new_block, make_block])
+def block_maker(request):
+    """
+    Fixture to test both the internal new_block and pseudo-public make_block.
+    """
+    return request.param
+
+
+@pytest.fixture
+def mgr():
+    return create_mgr(
+        "a: f8; b: object; c: f8; d: object; e: f8;"
+        "f: bool; g: i8; h: complex; i: datetime-1; j: datetime-2;"
+        "k: M8[ns, US/Eastern]; l: M8[ns, CET];"
+    )
+
+
+def assert_block_equal(left, right):
+    tm.assert_numpy_array_equal(left.values, right.values)
+    assert left.dtype == right.dtype
+    assert isinstance(left.mgr_locs, BlockPlacement)
+    assert isinstance(right.mgr_locs, BlockPlacement)
+    tm.assert_numpy_array_equal(left.mgr_locs.as_array, right.mgr_locs.as_array)
+
+
+def get_numeric_mat(shape):
+    arr = np.arange(shape[0])
+    return np.lib.stride_tricks.as_strided(
+        x=arr, shape=shape, strides=(arr.itemsize,) + (0,) * (len(shape) - 1)
+    ).copy()
+
+
+N = 10
+
+
+def create_block(typestr, placement, item_shape=None, num_offset=0, maker=new_block):
+    """
+    Supported typestr:
+
+        * float, f8, f4, f2
+        * int, i8, i4, i2, i1
+        * uint, u8, u4, u2, u1
+        * complex, c16, c8
+        * bool
+        * object, string, O
+        * datetime, dt, M8[ns], M8[ns, tz]
+        * timedelta, td, m8[ns]
+        * sparse (SparseArray with fill_value=0.0)
+        * sparse_na (SparseArray with fill_value=np.nan)
+        * category, category2
+
+    """
+    placement = BlockPlacement(placement)
+    num_items = len(placement)
+
+    if item_shape is None:
+        item_shape = (N,)
+
+    shape = (num_items,) + item_shape
+
+    mat = get_numeric_mat(shape)
+
+    if typestr in (
+        "float",
+        "f8",
+        "f4",
+        "f2",
+        "int",
+        "i8",
+        "i4",
+        "i2",
+        "i1",
+        "uint",
+        "u8",
+        "u4",
+        "u2",
+        "u1",
+    ):
+        values = mat.astype(typestr) + num_offset
+    elif typestr in ("complex", "c16", "c8"):
+        values = 1.0j * (mat.astype(typestr) + num_offset)
+    elif typestr in ("object", "string", "O"):
+        values = np.reshape([f"A{i:d}" for i in mat.ravel() + num_offset], shape)
+    elif typestr in ("b", "bool"):
+        values = np.ones(shape, dtype=np.bool_)
+    elif typestr in ("datetime", "dt", "M8[ns]"):
+        values = (mat * 1e9).astype("M8[ns]")
+    elif typestr.startswith("M8[ns"):
+        # datetime with tz
+        m = re.search(r"M8\[ns,\s*(\w+\/?\w*)\]", typestr)
+        assert m is not None, f"incompatible typestr -> {typestr}"
+        tz = m.groups()[0]
+        assert num_items == 1, "must have only 1 num items for a tz-aware"
+        values = DatetimeIndex(np.arange(N) * 10**9, tz=tz)._data
+        values = ensure_block_shape(values, ndim=len(shape))
+    elif typestr in ("timedelta", "td", "m8[ns]"):
+        values = (mat * 1).astype("m8[ns]")
+    elif typestr in ("category",):
+        values = Categorical([1, 1, 2, 2, 3, 3, 3, 3, 4, 4])
+    elif typestr in ("category2",):
+        values = Categorical(["a", "a", "a", "a", "b", "b", "c", "c", "c", "d"])
+    elif typestr in ("sparse", "sparse_na"):
+        if shape[-1] != 10:
+            # We also are implicitly assuming this in the category cases above
+            raise NotImplementedError
+
+        assert all(s == 1 for s in shape[:-1])
+        if typestr.endswith("_na"):
+            fill_value = np.nan
+        else:
+            fill_value = 0.0
+        values = SparseArray(
+            [fill_value, fill_value, 1, 2, 3, fill_value, 4, 5, fill_value, 6],
+            fill_value=fill_value,
+        )
+        arr = values.sp_values.view()
+        arr += num_offset - 1
+    else:
+        raise ValueError(f'Unsupported typestr: "{typestr}"')
+
+    values = maybe_coerce_values(values)
+    return maker(values, placement=placement, ndim=len(shape))
+
+
+def create_single_mgr(typestr, num_rows=None):
+    if num_rows is None:
+        num_rows = N
+
+    return SingleBlockManager(
+        create_block(typestr, placement=slice(0, num_rows), item_shape=()),
+        Index(np.arange(num_rows)),
+    )
+
+
+def create_mgr(descr, item_shape=None):
+    """
+    Construct BlockManager from string description.
+
+    String description syntax looks similar to np.matrix initializer.  It looks
+    like this::
+
+        a,b,c: f8; d,e,f: i8
+
+    Rules are rather simple:
+
+    * see list of supported datatypes in `create_block` method
+    * components are semicolon-separated
+    * each component is `NAME,NAME,NAME: DTYPE_ID`
+    * whitespace around colons & semicolons are removed
+    * components with same DTYPE_ID are combined into single block
+    * to force multiple blocks with same dtype, use '-SUFFIX'::
+
+        'a:f8-1; b:f8-2; c:f8-foobar'
+
+    """
+    if item_shape is None:
+        item_shape = (N,)
+
+    offset = 0
+    mgr_items = []
+    block_placements = {}
+    for d in descr.split(";"):
+        d = d.strip()
+        if not len(d):
+            continue
+        names, blockstr = d.partition(":")[::2]
+        blockstr = blockstr.strip()
+        names = names.strip().split(",")
+
+        mgr_items.extend(names)
+        placement = list(np.arange(len(names)) + offset)
+        try:
+            block_placements[blockstr].extend(placement)
+        except KeyError:
+            block_placements[blockstr] = placement
+        offset += len(names)
+
+    mgr_items = Index(mgr_items)
+
+    blocks = []
+    num_offset = 0
+    for blockstr, placement in block_placements.items():
+        typestr = blockstr.split("-")[0]
+        blocks.append(
+            create_block(
+                typestr, placement, item_shape=item_shape, num_offset=num_offset
+            )
+        )
+        num_offset += len(placement)
+
+    sblocks = sorted(blocks, key=lambda b: b.mgr_locs[0])
+    return BlockManager(
+        tuple(sblocks),
+        [mgr_items] + [Index(np.arange(n)) for n in item_shape],
+    )
+
+
+@pytest.fixture
+def fblock():
+    return create_block("float", [0, 2, 4])
+
+
+class TestBlock:
+    def test_constructor(self):
+        int32block = create_block("i4", [0])
+        assert int32block.dtype == np.int32
+
+    @pytest.mark.parametrize(
+        "typ, data",
+        [
+            ["float", [0, 2, 4]],
+            ["complex", [7]],
+            ["object", [1, 3]],
+            ["bool", [5]],
+        ],
+    )
+    def test_pickle(self, typ, data):
+        blk = create_block(typ, data)
+        assert_block_equal(tm.round_trip_pickle(blk), blk)
+
+    def test_mgr_locs(self, fblock):
+        assert isinstance(fblock.mgr_locs, BlockPlacement)
+        tm.assert_numpy_array_equal(
+            fblock.mgr_locs.as_array, np.array([0, 2, 4], dtype=np.intp)
+        )
+
+    def test_attrs(self, fblock):
+        assert fblock.shape == fblock.values.shape
+        assert fblock.dtype == fblock.values.dtype
+        assert len(fblock) == len(fblock.values)
+
+    def test_copy(self, fblock):
+        cop = fblock.copy()
+        assert cop is not fblock
+        assert_block_equal(fblock, cop)
+
+    def test_delete(self, fblock):
+        newb = fblock.copy()
+        locs = newb.mgr_locs
+        nb = newb.delete(0)[0]
+        assert newb.mgr_locs is locs
+
+        assert nb is not newb
+
+        tm.assert_numpy_array_equal(
+            nb.mgr_locs.as_array, np.array([2, 4], dtype=np.intp)
+        )
+        assert not (newb.values[0] == 1).all()
+        assert (nb.values[0] == 1).all()
+
+        newb = fblock.copy()
+        locs = newb.mgr_locs
+        nb = newb.delete(1)
+        assert len(nb) == 2
+        assert newb.mgr_locs is locs
+
+        tm.assert_numpy_array_equal(
+            nb[0].mgr_locs.as_array, np.array([0], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            nb[1].mgr_locs.as_array, np.array([4], dtype=np.intp)
+        )
+        assert not (newb.values[1] == 2).all()
+        assert (nb[1].values[0] == 2).all()
+
+        newb = fblock.copy()
+        nb = newb.delete(2)
+        assert len(nb) == 1
+        tm.assert_numpy_array_equal(
+            nb[0].mgr_locs.as_array, np.array([0, 2], dtype=np.intp)
+        )
+        assert (nb[0].values[1] == 1).all()
+
+        newb = fblock.copy()
+
+        with pytest.raises(IndexError, match=None):
+            newb.delete(3)
+
+    def test_delete_datetimelike(self):
+        # dont use np.delete on values, as that will coerce from DTA/TDA to ndarray
+        arr = np.arange(20, dtype="i8").reshape(5, 4).view("m8[ns]")
+        df = DataFrame(arr)
+        blk = df._mgr.blocks[0]
+        assert isinstance(blk.values, TimedeltaArray)
+
+        nb = blk.delete(1)
+        assert len(nb) == 2
+        assert isinstance(nb[0].values, TimedeltaArray)
+        assert isinstance(nb[1].values, TimedeltaArray)
+
+        df = DataFrame(arr.view("M8[ns]"))
+        blk = df._mgr.blocks[0]
+        assert isinstance(blk.values, DatetimeArray)
+
+        nb = blk.delete([1, 3])
+        assert len(nb) == 2
+        assert isinstance(nb[0].values, DatetimeArray)
+        assert isinstance(nb[1].values, DatetimeArray)
+
+    def test_split(self):
+        # GH#37799
+        values = np.random.default_rng(2).standard_normal((3, 4))
+        blk = new_block(values, placement=BlockPlacement([3, 1, 6]), ndim=2)
+        result = blk._split()
+
+        # check that we get views, not copies
+        values[:] = -9999
+        assert (blk.values == -9999).all()
+
+        assert len(result) == 3
+        expected = [
+            new_block(values[[0]], placement=BlockPlacement([3]), ndim=2),
+            new_block(values[[1]], placement=BlockPlacement([1]), ndim=2),
+            new_block(values[[2]], placement=BlockPlacement([6]), ndim=2),
+        ]
+        for res, exp in zip(result, expected):
+            assert_block_equal(res, exp)
+
+
+class TestBlockManager:
+    def test_attrs(self):
+        mgr = create_mgr("a,b,c: f8-1; d,e,f: f8-2")
+        assert mgr.nblocks == 2
+        assert len(mgr) == 6
+
+    def test_duplicate_ref_loc_failure(self):
+        tmp_mgr = create_mgr("a:bool; a: f8")
+
+        axes, blocks = tmp_mgr.axes, tmp_mgr.blocks
+
+        blocks[0].mgr_locs = BlockPlacement(np.array([0]))
+        blocks[1].mgr_locs = BlockPlacement(np.array([0]))
+
+        # test trying to create block manager with overlapping ref locs
+
+        msg = "Gaps in blk ref_locs"
+
+        with pytest.raises(AssertionError, match=msg):
+            mgr = BlockManager(blocks, axes)
+            mgr._rebuild_blknos_and_blklocs()
+
+        blocks[0].mgr_locs = BlockPlacement(np.array([0]))
+        blocks[1].mgr_locs = BlockPlacement(np.array([1]))
+        mgr = BlockManager(blocks, axes)
+        mgr.iget(1)
+
+    def test_pickle(self, mgr):
+        mgr2 = tm.round_trip_pickle(mgr)
+        tm.assert_frame_equal(
+            DataFrame._from_mgr(mgr, axes=mgr.axes),
+            DataFrame._from_mgr(mgr2, axes=mgr2.axes),
+        )
+
+        # GH2431
+        assert hasattr(mgr2, "_is_consolidated")
+        assert hasattr(mgr2, "_known_consolidated")
+
+        # reset to False on load
+        assert not mgr2._is_consolidated
+        assert not mgr2._known_consolidated
+
+    @pytest.mark.parametrize("mgr_string", ["a,a,a:f8", "a: f8; a: i8"])
+    def test_non_unique_pickle(self, mgr_string):
+        mgr = create_mgr(mgr_string)
+        mgr2 = tm.round_trip_pickle(mgr)
+        tm.assert_frame_equal(
+            DataFrame._from_mgr(mgr, axes=mgr.axes),
+            DataFrame._from_mgr(mgr2, axes=mgr2.axes),
+        )
+
+    def test_categorical_block_pickle(self):
+        mgr = create_mgr("a: category")
+        mgr2 = tm.round_trip_pickle(mgr)
+        tm.assert_frame_equal(
+            DataFrame._from_mgr(mgr, axes=mgr.axes),
+            DataFrame._from_mgr(mgr2, axes=mgr2.axes),
+        )
+
+        smgr = create_single_mgr("category")
+        smgr2 = tm.round_trip_pickle(smgr)
+        tm.assert_series_equal(
+            Series()._constructor_from_mgr(smgr, axes=smgr.axes),
+            Series()._constructor_from_mgr(smgr2, axes=smgr2.axes),
+        )
+
+    def test_iget(self):
+        cols = Index(list("abc"))
+        values = np.random.default_rng(2).random((3, 3))
+        block = new_block(
+            values=values.copy(),
+            placement=BlockPlacement(np.arange(3, dtype=np.intp)),
+            ndim=values.ndim,
+        )
+        mgr = BlockManager(blocks=(block,), axes=[cols, Index(np.arange(3))])
+
+        tm.assert_almost_equal(mgr.iget(0).internal_values(), values[0])
+        tm.assert_almost_equal(mgr.iget(1).internal_values(), values[1])
+        tm.assert_almost_equal(mgr.iget(2).internal_values(), values[2])
+
+    def test_set(self):
+        mgr = create_mgr("a,b,c: int", item_shape=(3,))
+
+        mgr.insert(len(mgr.items), "d", np.array(["foo"] * 3))
+        mgr.iset(1, np.array(["bar"] * 3))
+        tm.assert_numpy_array_equal(mgr.iget(0).internal_values(), np.array([0] * 3))
+        tm.assert_numpy_array_equal(
+            mgr.iget(1).internal_values(), np.array(["bar"] * 3, dtype=np.object_)
+        )
+        tm.assert_numpy_array_equal(mgr.iget(2).internal_values(), np.array([2] * 3))
+        tm.assert_numpy_array_equal(
+            mgr.iget(3).internal_values(), np.array(["foo"] * 3, dtype=np.object_)
+        )
+
+    def test_set_change_dtype(self, mgr):
+        mgr.insert(len(mgr.items), "baz", np.zeros(N, dtype=bool))
+
+        mgr.iset(mgr.items.get_loc("baz"), np.repeat("foo", N))
+        idx = mgr.items.get_loc("baz")
+        assert mgr.iget(idx).dtype == np.object_
+
+        mgr2 = mgr.consolidate()
+        mgr2.iset(mgr2.items.get_loc("baz"), np.repeat("foo", N))
+        idx = mgr2.items.get_loc("baz")
+        assert mgr2.iget(idx).dtype == np.object_
+
+        mgr2.insert(
+            len(mgr2.items),
+            "quux",
+            np.random.default_rng(2).standard_normal(N).astype(int),
+        )
+        idx = mgr2.items.get_loc("quux")
+        assert mgr2.iget(idx).dtype == np.dtype(int)
+
+        mgr2.iset(
+            mgr2.items.get_loc("quux"), np.random.default_rng(2).standard_normal(N)
+        )
+        assert mgr2.iget(idx).dtype == np.float64
+
+    def test_copy(self, mgr):
+        cp = mgr.copy(deep=False)
+        for blk, cp_blk in zip(mgr.blocks, cp.blocks):
+            # view assertion
+            tm.assert_equal(cp_blk.values, blk.values)
+            if isinstance(blk.values, np.ndarray):
+                assert cp_blk.values.base is blk.values.base
+            else:
+                # DatetimeTZBlock has DatetimeIndex values
+                assert cp_blk.values._ndarray.base is blk.values._ndarray.base
+
+        # copy(deep=True) consolidates, so the block-wise assertions will
+        #  fail is mgr is not consolidated
+        mgr._consolidate_inplace()
+        cp = mgr.copy(deep=True)
+        for blk, cp_blk in zip(mgr.blocks, cp.blocks):
+            bvals = blk.values
+            cpvals = cp_blk.values
+
+            tm.assert_equal(cpvals, bvals)
+
+            if isinstance(cpvals, np.ndarray):
+                lbase = cpvals.base
+                rbase = bvals.base
+            else:
+                lbase = cpvals._ndarray.base
+                rbase = bvals._ndarray.base
+
+            # copy assertion we either have a None for a base or in case of
+            # some blocks it is an array (e.g. datetimetz), but was copied
+            if isinstance(cpvals, DatetimeArray):
+                assert (lbase is None and rbase is None) or (lbase is not rbase)
+            elif not isinstance(cpvals, np.ndarray):
+                assert lbase is not rbase
+            else:
+                assert lbase is None and rbase is None
+
+    def test_sparse(self):
+        mgr = create_mgr("a: sparse-1; b: sparse-2")
+        assert mgr.as_array().dtype == np.float64
+
+    def test_sparse_mixed(self):
+        mgr = create_mgr("a: sparse-1; b: sparse-2; c: f8")
+        assert len(mgr.blocks) == 3
+        assert isinstance(mgr, BlockManager)
+
+    @pytest.mark.parametrize(
+        "mgr_string, dtype",
+        [("c: f4; d: f2", np.float32), ("c: f4; d: f2; e: f8", np.float64)],
+    )
+    def test_as_array_float(self, mgr_string, dtype):
+        mgr = create_mgr(mgr_string)
+        assert mgr.as_array().dtype == dtype
+
+    @pytest.mark.parametrize(
+        "mgr_string, dtype",
+        [
+            ("a: bool-1; b: bool-2", np.bool_),
+            ("a: i8-1; b: i8-2; c: i4; d: i2; e: u1", np.int64),
+            ("c: i4; d: i2; e: u1", np.int32),
+        ],
+    )
+    def test_as_array_int_bool(self, mgr_string, dtype):
+        mgr = create_mgr(mgr_string)
+        assert mgr.as_array().dtype == dtype
+
+    def test_as_array_datetime(self):
+        mgr = create_mgr("h: datetime-1; g: datetime-2")
+        assert mgr.as_array().dtype == "M8[ns]"
+
+    def test_as_array_datetime_tz(self):
+        mgr = create_mgr("h: M8[ns, US/Eastern]; g: M8[ns, CET]")
+        assert mgr.iget(0).dtype == "datetime64[ns, US/Eastern]"
+        assert mgr.iget(1).dtype == "datetime64[ns, CET]"
+        assert mgr.as_array().dtype == "object"
+
+    @pytest.mark.parametrize("t", ["float16", "float32", "float64", "int32", "int64"])
+    def test_astype(self, t):
+        # coerce all
+        mgr = create_mgr("c: f4; d: f2; e: f8")
+
+        t = np.dtype(t)
+        tmgr = mgr.astype(t)
+        assert tmgr.iget(0).dtype.type == t
+        assert tmgr.iget(1).dtype.type == t
+        assert tmgr.iget(2).dtype.type == t
+
+        # mixed
+        mgr = create_mgr("a,b: object; c: bool; d: datetime; e: f4; f: f2; g: f8")
+
+        t = np.dtype(t)
+        tmgr = mgr.astype(t, errors="ignore")
+        assert tmgr.iget(2).dtype.type == t
+        assert tmgr.iget(4).dtype.type == t
+        assert tmgr.iget(5).dtype.type == t
+        assert tmgr.iget(6).dtype.type == t
+
+        assert tmgr.iget(0).dtype.type == np.object_
+        assert tmgr.iget(1).dtype.type == np.object_
+        if t != np.int64:
+            assert tmgr.iget(3).dtype.type == np.datetime64
+        else:
+            assert tmgr.iget(3).dtype.type == t
+
+    def test_convert(self, using_infer_string):
+        def _compare(old_mgr, new_mgr):
+            """compare the blocks, numeric compare ==, object don't"""
+            old_blocks = set(old_mgr.blocks)
+            new_blocks = set(new_mgr.blocks)
+            assert len(old_blocks) == len(new_blocks)
+
+            # compare non-numeric
+            for b in old_blocks:
+                found = False
+                for nb in new_blocks:
+                    if (b.values == nb.values).all():
+                        found = True
+                        break
+                assert found
+
+            for b in new_blocks:
+                found = False
+                for ob in old_blocks:
+                    if (b.values == ob.values).all():
+                        found = True
+                        break
+                assert found
+
+        # noops
+        mgr = create_mgr("f: i8; g: f8")
+        new_mgr = mgr.convert(copy=True)
+        _compare(mgr, new_mgr)
+
+        # convert
+        mgr = create_mgr("a,b,foo: object; f: i8; g: f8")
+        mgr.iset(0, np.array(["1"] * N, dtype=np.object_))
+        mgr.iset(1, np.array(["2."] * N, dtype=np.object_))
+        mgr.iset(2, np.array(["foo."] * N, dtype=np.object_))
+        new_mgr = mgr.convert(copy=True)
+        dtype = "string[pyarrow_numpy]" if using_infer_string else np.object_
+        assert new_mgr.iget(0).dtype == dtype
+        assert new_mgr.iget(1).dtype == dtype
+        assert new_mgr.iget(2).dtype == dtype
+        assert new_mgr.iget(3).dtype == np.int64
+        assert new_mgr.iget(4).dtype == np.float64
+
+        mgr = create_mgr(
+            "a,b,foo: object; f: i4; bool: bool; dt: datetime; i: i8; g: f8; h: f2"
+        )
+        mgr.iset(0, np.array(["1"] * N, dtype=np.object_))
+        mgr.iset(1, np.array(["2."] * N, dtype=np.object_))
+        mgr.iset(2, np.array(["foo."] * N, dtype=np.object_))
+        new_mgr = mgr.convert(copy=True)
+        assert new_mgr.iget(0).dtype == dtype
+        assert new_mgr.iget(1).dtype == dtype
+        assert new_mgr.iget(2).dtype == dtype
+        assert new_mgr.iget(3).dtype == np.int32
+        assert new_mgr.iget(4).dtype == np.bool_
+        assert new_mgr.iget(5).dtype.type, np.datetime64
+        assert new_mgr.iget(6).dtype == np.int64
+        assert new_mgr.iget(7).dtype == np.float64
+        assert new_mgr.iget(8).dtype == np.float16
+
+    def test_interleave(self):
+        # self
+        for dtype in ["f8", "i8", "object", "bool", "complex", "M8[ns]", "m8[ns]"]:
+            mgr = create_mgr(f"a: {dtype}")
+            assert mgr.as_array().dtype == dtype
+            mgr = create_mgr(f"a: {dtype}; b: {dtype}")
+            assert mgr.as_array().dtype == dtype
+
+    @pytest.mark.parametrize(
+        "mgr_string, dtype",
+        [
+            ("a: category", "i8"),
+            ("a: category; b: category", "i8"),
+            ("a: category; b: category2", "object"),
+            ("a: category2", "object"),
+            ("a: category2; b: category2", "object"),
+            ("a: f8", "f8"),
+            ("a: f8; b: i8", "f8"),
+            ("a: f4; b: i8", "f8"),
+            ("a: f4; b: i8; d: object", "object"),
+            ("a: bool; b: i8", "object"),
+            ("a: complex", "complex"),
+            ("a: f8; b: category", "object"),
+            ("a: M8[ns]; b: category", "object"),
+            ("a: M8[ns]; b: bool", "object"),
+            ("a: M8[ns]; b: i8", "object"),
+            ("a: m8[ns]; b: bool", "object"),
+            ("a: m8[ns]; b: i8", "object"),
+            ("a: M8[ns]; b: m8[ns]", "object"),
+        ],
+    )
+    def test_interleave_dtype(self, mgr_string, dtype):
+        # will be converted according the actual dtype of the underlying
+        mgr = create_mgr("a: category")
+        assert mgr.as_array().dtype == "i8"
+        mgr = create_mgr("a: category; b: category2")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: category2")
+        assert mgr.as_array().dtype == "object"
+
+        # combinations
+        mgr = create_mgr("a: f8")
+        assert mgr.as_array().dtype == "f8"
+        mgr = create_mgr("a: f8; b: i8")
+        assert mgr.as_array().dtype == "f8"
+        mgr = create_mgr("a: f4; b: i8")
+        assert mgr.as_array().dtype == "f8"
+        mgr = create_mgr("a: f4; b: i8; d: object")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: bool; b: i8")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: complex")
+        assert mgr.as_array().dtype == "complex"
+        mgr = create_mgr("a: f8; b: category")
+        assert mgr.as_array().dtype == "f8"
+        mgr = create_mgr("a: M8[ns]; b: category")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: M8[ns]; b: bool")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: M8[ns]; b: i8")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: m8[ns]; b: bool")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: m8[ns]; b: i8")
+        assert mgr.as_array().dtype == "object"
+        mgr = create_mgr("a: M8[ns]; b: m8[ns]")
+        assert mgr.as_array().dtype == "object"
+
+    def test_consolidate_ordering_issues(self, mgr):
+        mgr.iset(mgr.items.get_loc("f"), np.random.default_rng(2).standard_normal(N))
+        mgr.iset(mgr.items.get_loc("d"), np.random.default_rng(2).standard_normal(N))
+        mgr.iset(mgr.items.get_loc("b"), np.random.default_rng(2).standard_normal(N))
+        mgr.iset(mgr.items.get_loc("g"), np.random.default_rng(2).standard_normal(N))
+        mgr.iset(mgr.items.get_loc("h"), np.random.default_rng(2).standard_normal(N))
+
+        # we have datetime/tz blocks in mgr
+        cons = mgr.consolidate()
+        assert cons.nblocks == 4
+        cons = mgr.consolidate().get_numeric_data()
+        assert cons.nblocks == 1
+        assert isinstance(cons.blocks[0].mgr_locs, BlockPlacement)
+        tm.assert_numpy_array_equal(
+            cons.blocks[0].mgr_locs.as_array, np.arange(len(cons.items), dtype=np.intp)
+        )
+
+    def test_reindex_items(self):
+        # mgr is not consolidated, f8 & f8-2 blocks
+        mgr = create_mgr("a: f8; b: i8; c: f8; d: i8; e: f8; f: bool; g: f8-2")
+
+        reindexed = mgr.reindex_axis(["g", "c", "a", "d"], axis=0)
+        # reindex_axis does not consolidate_inplace, as that risks failing to
+        #  invalidate _item_cache
+        assert not reindexed.is_consolidated()
+
+        tm.assert_index_equal(reindexed.items, Index(["g", "c", "a", "d"]))
+        tm.assert_almost_equal(
+            mgr.iget(6).internal_values(), reindexed.iget(0).internal_values()
+        )
+        tm.assert_almost_equal(
+            mgr.iget(2).internal_values(), reindexed.iget(1).internal_values()
+        )
+        tm.assert_almost_equal(
+            mgr.iget(0).internal_values(), reindexed.iget(2).internal_values()
+        )
+        tm.assert_almost_equal(
+            mgr.iget(3).internal_values(), reindexed.iget(3).internal_values()
+        )
+
+    def test_get_numeric_data(self, using_copy_on_write):
+        mgr = create_mgr(
+            "int: int; float: float; complex: complex;"
+            "str: object; bool: bool; obj: object; dt: datetime",
+            item_shape=(3,),
+        )
+        mgr.iset(5, np.array([1, 2, 3], dtype=np.object_))
+
+        numeric = mgr.get_numeric_data()
+        tm.assert_index_equal(numeric.items, Index(["int", "float", "complex", "bool"]))
+        tm.assert_almost_equal(
+            mgr.iget(mgr.items.get_loc("float")).internal_values(),
+            numeric.iget(numeric.items.get_loc("float")).internal_values(),
+        )
+
+        # Check sharing
+        numeric.iset(
+            numeric.items.get_loc("float"),
+            np.array([100.0, 200.0, 300.0]),
+            inplace=True,
+        )
+        if using_copy_on_write:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([1.0, 1.0, 1.0]),
+            )
+        else:
+            tm.assert_almost_equal(
+                mgr.iget(mgr.items.get_loc("float")).internal_values(),
+                np.array([100.0, 200.0, 300.0]),
+            )
+
+    def test_get_bool_data(self, using_copy_on_write):
+        mgr = create_mgr(
+            "int: int; float: float; complex: complex;"
+            "str: object; bool: bool; obj: object; dt: datetime",
+            item_shape=(3,),
+        )
+        mgr.iset(6, np.array([True, False, True], dtype=np.object_))
+
+        bools = mgr.get_bool_data()
+        tm.assert_index_equal(bools.items, Index(["bool"]))
+        tm.assert_almost_equal(
+            mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+            bools.iget(bools.items.get_loc("bool")).internal_values(),
+        )
+
+        bools.iset(0, np.array([True, False, True]), inplace=True)
+        if using_copy_on_write:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, True, True]),
+            )
+        else:
+            tm.assert_numpy_array_equal(
+                mgr.iget(mgr.items.get_loc("bool")).internal_values(),
+                np.array([True, False, True]),
+            )
+
+    def test_unicode_repr_doesnt_raise(self):
+        repr(create_mgr("b,\u05d0: object"))
+
+    @pytest.mark.parametrize(
+        "mgr_string", ["a,b,c: i8-1; d,e,f: i8-2", "a,a,a: i8-1; b,b,b: i8-2"]
+    )
+    def test_equals(self, mgr_string):
+        # unique items
+        bm1 = create_mgr(mgr_string)
+        bm2 = BlockManager(bm1.blocks[::-1], bm1.axes)
+        assert bm1.equals(bm2)
+
+    @pytest.mark.parametrize(
+        "mgr_string",
+        [
+            "a:i8;b:f8",  # basic case
+            "a:i8;b:f8;c:c8;d:b",  # many types
+            "a:i8;e:dt;f:td;g:string",  # more types
+            "a:i8;b:category;c:category2",  # categories
+            "c:sparse;d:sparse_na;b:f8",  # sparse
+        ],
+    )
+    def test_equals_block_order_different_dtypes(self, mgr_string):
+        # GH 9330
+        bm = create_mgr(mgr_string)
+        block_perms = itertools.permutations(bm.blocks)
+        for bm_perm in block_perms:
+            bm_this = BlockManager(tuple(bm_perm), bm.axes)
+            assert bm.equals(bm_this)
+            assert bm_this.equals(bm)
+
+    def test_single_mgr_ctor(self):
+        mgr = create_single_mgr("f8", num_rows=5)
+        assert mgr.external_values().tolist() == [0.0, 1.0, 2.0, 3.0, 4.0]
+
+    @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+    def test_validate_bool_args(self, value):
+        bm1 = create_mgr("a,b,c: i8-1; d,e,f: i8-2")
+
+        msg = (
+            'For argument "inplace" expected type bool, '
+            f"received type {type(value).__name__}."
+        )
+        with pytest.raises(ValueError, match=msg):
+            bm1.replace_list([1], [2], inplace=value)
+
+    def test_iset_split_block(self):
+        bm = create_mgr("a,b,c: i8; d: f8")
+        bm._iset_split_block(0, np.array([0]))
+        tm.assert_numpy_array_equal(
+            bm.blklocs, np.array([0, 0, 1, 0], dtype="int64" if IS64 else "int32")
+        )
+        # First indexer currently does not have a block associated with it in case
+        tm.assert_numpy_array_equal(
+            bm.blknos, np.array([0, 0, 0, 1], dtype="int64" if IS64 else "int32")
+        )
+        assert len(bm.blocks) == 2
+
+    def test_iset_split_block_values(self):
+        bm = create_mgr("a,b,c: i8; d: f8")
+        bm._iset_split_block(0, np.array([0]), np.array([list(range(10))]))
+        tm.assert_numpy_array_equal(
+            bm.blklocs, np.array([0, 0, 1, 0], dtype="int64" if IS64 else "int32")
+        )
+        # First indexer currently does not have a block associated with it in case
+        tm.assert_numpy_array_equal(
+            bm.blknos, np.array([0, 2, 2, 1], dtype="int64" if IS64 else "int32")
+        )
+        assert len(bm.blocks) == 3
+
+
+def _as_array(mgr):
+    if mgr.ndim == 1:
+        return mgr.external_values()
+    return mgr.as_array().T
+
+
+class TestIndexing:
+    # Nosetests-style data-driven tests.
+    #
+    # This test applies different indexing routines to block managers and
+    # compares the outcome to the result of same operations on np.ndarray.
+    #
+    # NOTE: sparse (SparseBlock with fill_value != np.nan) fail a lot of tests
+    #       and are disabled.
+
+    MANAGERS = [
+        create_single_mgr("f8", N),
+        create_single_mgr("i8", N),
+        # 2-dim
+        create_mgr("a,b,c,d,e,f: f8", item_shape=(N,)),
+        create_mgr("a,b,c,d,e,f: i8", item_shape=(N,)),
+        create_mgr("a,b: f8; c,d: i8; e,f: string", item_shape=(N,)),
+        create_mgr("a,b: f8; c,d: i8; e,f: f8", item_shape=(N,)),
+    ]
+
+    @pytest.mark.parametrize("mgr", MANAGERS)
+    def test_get_slice(self, mgr):
+        def assert_slice_ok(mgr, axis, slobj):
+            mat = _as_array(mgr)
+
+            # we maybe using an ndarray to test slicing and
+            # might not be the full length of the axis
+            if isinstance(slobj, np.ndarray):
+                ax = mgr.axes[axis]
+                if len(ax) and len(slobj) and len(slobj) != len(ax):
+                    slobj = np.concatenate(
+                        [slobj, np.zeros(len(ax) - len(slobj), dtype=bool)]
+                    )
+
+            if isinstance(slobj, slice):
+                sliced = mgr.get_slice(slobj, axis=axis)
+            elif (
+                mgr.ndim == 1
+                and axis == 0
+                and isinstance(slobj, np.ndarray)
+                and slobj.dtype == bool
+            ):
+                sliced = mgr.get_rows_with_mask(slobj)
+            else:
+                # BlockManager doesn't support non-slice, SingleBlockManager
+                #  doesn't support axis > 0
+                raise TypeError(slobj)
+
+            mat_slobj = (slice(None),) * axis + (slobj,)
+            tm.assert_numpy_array_equal(
+                mat[mat_slobj], _as_array(sliced), check_dtype=False
+            )
+            tm.assert_index_equal(mgr.axes[axis][slobj], sliced.axes[axis])
+
+        assert mgr.ndim <= 2, mgr.ndim
+        for ax in range(mgr.ndim):
+            # slice
+            assert_slice_ok(mgr, ax, slice(None))
+            assert_slice_ok(mgr, ax, slice(3))
+            assert_slice_ok(mgr, ax, slice(100))
+            assert_slice_ok(mgr, ax, slice(1, 4))
+            assert_slice_ok(mgr, ax, slice(3, 0, -2))
+
+            if mgr.ndim < 2:
+                # 2D only support slice objects
+
+                # boolean mask
+                assert_slice_ok(mgr, ax, np.ones(mgr.shape[ax], dtype=np.bool_))
+                assert_slice_ok(mgr, ax, np.zeros(mgr.shape[ax], dtype=np.bool_))
+
+                if mgr.shape[ax] >= 3:
+                    assert_slice_ok(mgr, ax, np.arange(mgr.shape[ax]) % 3 == 0)
+                    assert_slice_ok(
+                        mgr, ax, np.array([True, True, False], dtype=np.bool_)
+                    )
+
+    @pytest.mark.parametrize("mgr", MANAGERS)
+    def test_take(self, mgr):
+        def assert_take_ok(mgr, axis, indexer):
+            mat = _as_array(mgr)
+            taken = mgr.take(indexer, axis)
+            tm.assert_numpy_array_equal(
+                np.take(mat, indexer, axis), _as_array(taken), check_dtype=False
+            )
+            tm.assert_index_equal(mgr.axes[axis].take(indexer), taken.axes[axis])
+
+        for ax in range(mgr.ndim):
+            # take/fancy indexer
+            assert_take_ok(mgr, ax, indexer=np.array([], dtype=np.intp))
+            assert_take_ok(mgr, ax, indexer=np.array([0, 0, 0], dtype=np.intp))
+            assert_take_ok(
+                mgr, ax, indexer=np.array(list(range(mgr.shape[ax])), dtype=np.intp)
+            )
+
+            if mgr.shape[ax] >= 3:
+                assert_take_ok(mgr, ax, indexer=np.array([0, 1, 2], dtype=np.intp))
+                assert_take_ok(mgr, ax, indexer=np.array([-1, -2, -3], dtype=np.intp))
+
+    @pytest.mark.parametrize("mgr", MANAGERS)
+    @pytest.mark.parametrize("fill_value", [None, np.nan, 100.0])
+    def test_reindex_axis(self, fill_value, mgr):
+        def assert_reindex_axis_is_ok(mgr, axis, new_labels, fill_value):
+            mat = _as_array(mgr)
+            indexer = mgr.axes[axis].get_indexer_for(new_labels)
+
+            reindexed = mgr.reindex_axis(new_labels, axis, fill_value=fill_value)
+            tm.assert_numpy_array_equal(
+                algos.take_nd(mat, indexer, axis, fill_value=fill_value),
+                _as_array(reindexed),
+                check_dtype=False,
+            )
+            tm.assert_index_equal(reindexed.axes[axis], new_labels)
+
+        for ax in range(mgr.ndim):
+            assert_reindex_axis_is_ok(mgr, ax, Index([]), fill_value)
+            assert_reindex_axis_is_ok(mgr, ax, mgr.axes[ax], fill_value)
+            assert_reindex_axis_is_ok(mgr, ax, mgr.axes[ax][[0, 0, 0]], fill_value)
+            assert_reindex_axis_is_ok(mgr, ax, Index(["foo", "bar", "baz"]), fill_value)
+            assert_reindex_axis_is_ok(
+                mgr, ax, Index(["foo", mgr.axes[ax][0], "baz"]), fill_value
+            )
+
+            if mgr.shape[ax] >= 3:
+                assert_reindex_axis_is_ok(mgr, ax, mgr.axes[ax][:-3], fill_value)
+                assert_reindex_axis_is_ok(mgr, ax, mgr.axes[ax][-3::-1], fill_value)
+                assert_reindex_axis_is_ok(
+                    mgr, ax, mgr.axes[ax][[0, 1, 2, 0, 1, 2]], fill_value
+                )
+
+    @pytest.mark.parametrize("mgr", MANAGERS)
+    @pytest.mark.parametrize("fill_value", [None, np.nan, 100.0])
+    def test_reindex_indexer(self, fill_value, mgr):
+        def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer, fill_value):
+            mat = _as_array(mgr)
+            reindexed_mat = algos.take_nd(mat, indexer, axis, fill_value=fill_value)
+            reindexed = mgr.reindex_indexer(
+                new_labels, indexer, axis, fill_value=fill_value
+            )
+            tm.assert_numpy_array_equal(
+                reindexed_mat, _as_array(reindexed), check_dtype=False
+            )
+            tm.assert_index_equal(reindexed.axes[axis], new_labels)
+
+        for ax in range(mgr.ndim):
+            assert_reindex_indexer_is_ok(
+                mgr, ax, Index([]), np.array([], dtype=np.intp), fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax]), fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr,
+                ax,
+                Index(["foo"] * mgr.shape[ax]),
+                np.arange(mgr.shape[ax]),
+                fill_value,
+            )
+            assert_reindex_indexer_is_ok(
+                mgr, ax, mgr.axes[ax][::-1], np.arange(mgr.shape[ax]), fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax])[::-1], fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr, ax, Index(["foo", "bar", "baz"]), np.array([0, 0, 0]), fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr, ax, Index(["foo", "bar", "baz"]), np.array([-1, 0, -1]), fill_value
+            )
+            assert_reindex_indexer_is_ok(
+                mgr,
+                ax,
+                Index(["foo", mgr.axes[ax][0], "baz"]),
+                np.array([-1, -1, -1]),
+                fill_value,
+            )
+
+            if mgr.shape[ax] >= 3:
+                assert_reindex_indexer_is_ok(
+                    mgr,
+                    ax,
+                    Index(["foo", "bar", "baz"]),
+                    np.array([0, 1, 2]),
+                    fill_value,
+                )
+
+
+class TestBlockPlacement:
+    @pytest.mark.parametrize(
+        "slc, expected",
+        [
+            (slice(0, 4), 4),
+            (slice(0, 4, 2), 2),
+            (slice(0, 3, 2), 2),
+            (slice(0, 1, 2), 1),
+            (slice(1, 0, -1), 1),
+        ],
+    )
+    def test_slice_len(self, slc, expected):
+        assert len(BlockPlacement(slc)) == expected
+
+    @pytest.mark.parametrize("slc", [slice(1, 1, 0), slice(1, 2, 0)])
+    def test_zero_step_raises(self, slc):
+        msg = "slice step cannot be zero"
+        with pytest.raises(ValueError, match=msg):
+            BlockPlacement(slc)
+
+    def test_slice_canonize_negative_stop(self):
+        # GH#37524 negative stop is OK with negative step and positive start
+        slc = slice(3, -1, -2)
+
+        bp = BlockPlacement(slc)
+        assert bp.indexer == slice(3, None, -2)
+
+    @pytest.mark.parametrize(
+        "slc",
+        [
+            slice(None, None),
+            slice(10, None),
+            slice(None, None, -1),
+            slice(None, 10, -1),
+            # These are "unbounded" because negative index will
+            #  change depending on container shape.
+            slice(-1, None),
+            slice(None, -1),
+            slice(-1, -1),
+            slice(-1, None, -1),
+            slice(None, -1, -1),
+            slice(-1, -1, -1),
+        ],
+    )
+    def test_unbounded_slice_raises(self, slc):
+        msg = "unbounded slice"
+        with pytest.raises(ValueError, match=msg):
+            BlockPlacement(slc)
+
+    @pytest.mark.parametrize(
+        "slc",
+        [
+            slice(0, 0),
+            slice(100, 0),
+            slice(100, 100),
+            slice(100, 100, -1),
+            slice(0, 100, -1),
+        ],
+    )
+    def test_not_slice_like_slices(self, slc):
+        assert not BlockPlacement(slc).is_slice_like
+
+    @pytest.mark.parametrize(
+        "arr, slc",
+        [
+            ([0], slice(0, 1, 1)),
+            ([100], slice(100, 101, 1)),
+            ([0, 1, 2], slice(0, 3, 1)),
+            ([0, 5, 10], slice(0, 15, 5)),
+            ([0, 100], slice(0, 200, 100)),
+            ([2, 1], slice(2, 0, -1)),
+        ],
+    )
+    def test_array_to_slice_conversion(self, arr, slc):
+        assert BlockPlacement(arr).as_slice == slc
+
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            [],
+            [-1],
+            [-1, -2, -3],
+            [-10],
+            [-1],
+            [-1, 0, 1, 2],
+            [-2, 0, 2, 4],
+            [1, 0, -1],
+            [1, 1, 1],
+        ],
+    )
+    def test_not_slice_like_arrays(self, arr):
+        assert not BlockPlacement(arr).is_slice_like
+
+    @pytest.mark.parametrize(
+        "slc, expected",
+        [(slice(0, 3), [0, 1, 2]), (slice(0, 0), []), (slice(3, 0), [])],
+    )
+    def test_slice_iter(self, slc, expected):
+        assert list(BlockPlacement(slc)) == expected
+
+    @pytest.mark.parametrize(
+        "slc, arr",
+        [
+            (slice(0, 3), [0, 1, 2]),
+            (slice(0, 0), []),
+            (slice(3, 0), []),
+            (slice(3, 0, -1), [3, 2, 1]),
+        ],
+    )
+    def test_slice_to_array_conversion(self, slc, arr):
+        tm.assert_numpy_array_equal(
+            BlockPlacement(slc).as_array, np.asarray(arr, dtype=np.intp)
+        )
+
+    def test_blockplacement_add(self):
+        bpl = BlockPlacement(slice(0, 5))
+        assert bpl.add(1).as_slice == slice(1, 6, 1)
+        assert bpl.add(np.arange(5)).as_slice == slice(0, 10, 2)
+        assert list(bpl.add(np.arange(5, 0, -1))) == [5, 5, 5, 5, 5]
+
+    @pytest.mark.parametrize(
+        "val, inc, expected",
+        [
+            (slice(0, 0), 0, []),
+            (slice(1, 4), 0, [1, 2, 3]),
+            (slice(3, 0, -1), 0, [3, 2, 1]),
+            ([1, 2, 4], 0, [1, 2, 4]),
+            (slice(0, 0), 10, []),
+            (slice(1, 4), 10, [11, 12, 13]),
+            (slice(3, 0, -1), 10, [13, 12, 11]),
+            ([1, 2, 4], 10, [11, 12, 14]),
+            (slice(0, 0), -1, []),
+            (slice(1, 4), -1, [0, 1, 2]),
+            ([1, 2, 4], -1, [0, 1, 3]),
+        ],
+    )
+    def test_blockplacement_add_int(self, val, inc, expected):
+        assert list(BlockPlacement(val).add(inc)) == expected
+
+    @pytest.mark.parametrize("val", [slice(1, 4), [1, 2, 4]])
+    def test_blockplacement_add_int_raises(self, val):
+        msg = "iadd causes length change"
+        with pytest.raises(ValueError, match=msg):
+            BlockPlacement(val).add(-10)
+
+
+class TestCanHoldElement:
+    @pytest.fixture(
+        params=[
+            lambda x: x,
+            lambda x: x.to_series(),
+            lambda x: x._data,
+            lambda x: list(x),
+            lambda x: x.astype(object),
+            lambda x: np.asarray(x),
+            lambda x: x[0],
+            lambda x: x[:0],
+        ]
+    )
+    def element(self, request):
+        """
+        Functions that take an Index and return an element that should have
+        blk._can_hold_element(element) for a Block with this index's dtype.
+        """
+        return request.param
+
+    def test_datetime_block_can_hold_element(self):
+        block = create_block("datetime", [0])
+
+        assert block._can_hold_element([])
+
+        # We will check that block._can_hold_element iff arr.__setitem__ works
+        arr = pd.array(block.values.ravel())
+
+        # coerce None
+        assert block._can_hold_element(None)
+        arr[0] = None
+        assert arr[0] is pd.NaT
+
+        # coerce different types of datetime objects
+        vals = [np.datetime64("2010-10-10"), datetime(2010, 10, 10)]
+        for val in vals:
+            assert block._can_hold_element(val)
+            arr[0] = val
+
+        val = date(2010, 10, 10)
+        assert not block._can_hold_element(val)
+
+        msg = (
+            "value should be a 'Timestamp', 'NaT', "
+            "or array of those. Got 'date' instead."
+        )
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = val
+
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64, np.float64])
+    def test_interval_can_hold_element_emptylist(self, dtype, element):
+        arr = np.array([1, 3, 4], dtype=dtype)
+        ii = IntervalIndex.from_breaks(arr)
+        blk = new_block(ii._data, BlockPlacement([1]), ndim=2)
+
+        assert blk._can_hold_element([])
+        # TODO: check this holds for all blocks
+
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64, np.float64])
+    def test_interval_can_hold_element(self, dtype, element):
+        arr = np.array([1, 3, 4, 9], dtype=dtype)
+        ii = IntervalIndex.from_breaks(arr)
+        blk = new_block(ii._data, BlockPlacement([1]), ndim=2)
+
+        elem = element(ii)
+        self.check_series_setitem(elem, ii, True)
+        assert blk._can_hold_element(elem)
+
+        # Careful: to get the expected Series-inplace behavior we need
+        # `elem` to not have the same length as `arr`
+        ii2 = IntervalIndex.from_breaks(arr[:-1], closed="neither")
+        elem = element(ii2)
+        with tm.assert_produces_warning(FutureWarning):
+            self.check_series_setitem(elem, ii, False)
+        assert not blk._can_hold_element(elem)
+
+        ii3 = IntervalIndex.from_breaks([Timestamp(1), Timestamp(3), Timestamp(4)])
+        elem = element(ii3)
+        with tm.assert_produces_warning(FutureWarning):
+            self.check_series_setitem(elem, ii, False)
+        assert not blk._can_hold_element(elem)
+
+        ii4 = IntervalIndex.from_breaks([Timedelta(1), Timedelta(3), Timedelta(4)])
+        elem = element(ii4)
+        with tm.assert_produces_warning(FutureWarning):
+            self.check_series_setitem(elem, ii, False)
+        assert not blk._can_hold_element(elem)
+
+    def test_period_can_hold_element_emptylist(self):
+        pi = period_range("2016", periods=3, freq="Y")
+        blk = new_block(pi._data.reshape(1, 3), BlockPlacement([1]), ndim=2)
+
+        assert blk._can_hold_element([])
+
+    def test_period_can_hold_element(self, element):
+        pi = period_range("2016", periods=3, freq="Y")
+
+        elem = element(pi)
+        self.check_series_setitem(elem, pi, True)
+
+        # Careful: to get the expected Series-inplace behavior we need
+        # `elem` to not have the same length as `arr`
+        pi2 = pi.asfreq("D")[:-1]
+        elem = element(pi2)
+        with tm.assert_produces_warning(FutureWarning):
+            self.check_series_setitem(elem, pi, False)
+
+        dti = pi.to_timestamp("s")[:-1]
+        elem = element(dti)
+        with tm.assert_produces_warning(FutureWarning):
+            self.check_series_setitem(elem, pi, False)
+
+    def check_can_hold_element(self, obj, elem, inplace: bool):
+        blk = obj._mgr.blocks[0]
+        if inplace:
+            assert blk._can_hold_element(elem)
+        else:
+            assert not blk._can_hold_element(elem)
+
+    def check_series_setitem(self, elem, index: Index, inplace: bool):
+        arr = index._data.copy()
+        ser = Series(arr, copy=False)
+
+        self.check_can_hold_element(ser, elem, inplace)
+
+        if is_scalar(elem):
+            ser[0] = elem
+        else:
+            ser[: len(elem)] = elem
+
+        if inplace:
+            assert ser.array is arr  # i.e. setting was done inplace
+        else:
+            assert ser.dtype == object
+
+
+class TestShouldStore:
+    def test_should_store_categorical(self):
+        cat = Categorical(["A", "B", "C"])
+        df = DataFrame(cat)
+        blk = df._mgr.blocks[0]
+
+        # matching dtype
+        assert blk.should_store(cat)
+        assert blk.should_store(cat[:-1])
+
+        # different dtype
+        assert not blk.should_store(cat.as_ordered())
+
+        # ndarray instead of Categorical
+        assert not blk.should_store(np.asarray(cat))
+
+
+def test_validate_ndim():
+    values = np.array([1.0, 2.0])
+    placement = BlockPlacement(slice(2))
+    msg = r"Wrong number of dimensions. values.ndim != ndim \[1 != 2\]"
+
+    with pytest.raises(ValueError, match=msg):
+        make_block(values, placement, ndim=2)
+
+
+def test_block_shape():
+    idx = Index([0, 1, 2, 3, 4])
+    a = Series([1, 2, 3]).reindex(idx)
+    b = Series(Categorical([1, 2, 3])).reindex(idx)
+
+    assert a._mgr.blocks[0].mgr_locs.indexer == b._mgr.blocks[0].mgr_locs.indexer
+
+
+def test_make_block_no_pandas_array(block_maker):
+    # https://github.com/pandas-dev/pandas/pull/24866
+    arr = pd.arrays.NumpyExtensionArray(np.array([1, 2]))
+
+    # NumpyExtensionArray, no dtype
+    result = block_maker(arr, BlockPlacement(slice(len(arr))), ndim=arr.ndim)
+    assert result.dtype.kind in ["i", "u"]
+
+    if block_maker is make_block:
+        # new_block requires caller to unwrap NumpyExtensionArray
+        assert result.is_extension is False
+
+        # NumpyExtensionArray, NumpyEADtype
+        result = block_maker(arr, slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim)
+        assert result.dtype.kind in ["i", "u"]
+        assert result.is_extension is False
+
+        # new_block no longer taked dtype keyword
+        # ndarray, NumpyEADtype
+        result = block_maker(
+            arr.to_numpy(), slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim
+        )
+        assert result.dtype.kind in ["i", "u"]
+        assert result.is_extension is False
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/internals/test_managers.py b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_managers.py
new file mode 100644
index 0000000000000000000000000000000000000000..f40362c299717be5f2e8665e4547276c2af05fb0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/internals/test_managers.py
@@ -0,0 +1,103 @@
+"""
+Testing interaction between the different managers (BlockManager, ArrayManager)
+"""
+import os
+import subprocess
+import sys
+
+import pytest
+
+from pandas.core.dtypes.missing import array_equivalent
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.internals import (
+    ArrayManager,
+    BlockManager,
+    SingleArrayManager,
+    SingleBlockManager,
+)
+
+
+def test_dataframe_creation():
+    msg = "data_manager option is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with pd.option_context("mode.data_manager", "block"):
+            df_block = pd.DataFrame(
+                {"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "c": [4, 5, 6]}
+            )
+    assert isinstance(df_block._mgr, BlockManager)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with pd.option_context("mode.data_manager", "array"):
+            df_array = pd.DataFrame(
+                {"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "c": [4, 5, 6]}
+            )
+    assert isinstance(df_array._mgr, ArrayManager)
+
+    # also ensure both are seen as equal
+    tm.assert_frame_equal(df_block, df_array)
+
+    # conversion from one manager to the other
+    result = df_block._as_manager("block")
+    assert isinstance(result._mgr, BlockManager)
+    result = df_block._as_manager("array")
+    assert isinstance(result._mgr, ArrayManager)
+    tm.assert_frame_equal(result, df_block)
+    assert all(
+        array_equivalent(left, right)
+        for left, right in zip(result._mgr.arrays, df_array._mgr.arrays)
+    )
+
+    result = df_array._as_manager("array")
+    assert isinstance(result._mgr, ArrayManager)
+    result = df_array._as_manager("block")
+    assert isinstance(result._mgr, BlockManager)
+    tm.assert_frame_equal(result, df_array)
+    assert len(result._mgr.blocks) == 2
+
+
+def test_series_creation():
+    msg = "data_manager option is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with pd.option_context("mode.data_manager", "block"):
+            s_block = pd.Series([1, 2, 3], name="A", index=["a", "b", "c"])
+    assert isinstance(s_block._mgr, SingleBlockManager)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with pd.option_context("mode.data_manager", "array"):
+            s_array = pd.Series([1, 2, 3], name="A", index=["a", "b", "c"])
+    assert isinstance(s_array._mgr, SingleArrayManager)
+
+    # also ensure both are seen as equal
+    tm.assert_series_equal(s_block, s_array)
+
+    # conversion from one manager to the other
+    result = s_block._as_manager("block")
+    assert isinstance(result._mgr, SingleBlockManager)
+    result = s_block._as_manager("array")
+    assert isinstance(result._mgr, SingleArrayManager)
+    tm.assert_series_equal(result, s_block)
+
+    result = s_array._as_manager("array")
+    assert isinstance(result._mgr, SingleArrayManager)
+    result = s_array._as_manager("block")
+    assert isinstance(result._mgr, SingleBlockManager)
+    tm.assert_series_equal(result, s_array)
+
+
+@pytest.mark.single_cpu
+@pytest.mark.parametrize("manager", ["block", "array"])
+def test_array_manager_depr_env_var(manager):
+    # GH#55043
+    test_env = os.environ.copy()
+    test_env["PANDAS_DATA_MANAGER"] = manager
+    response = subprocess.run(
+        [sys.executable, "-c", "import pandas"],
+        capture_output=True,
+        env=test_env,
+        check=True,
+    )
+    msg = "FutureWarning: The env variable PANDAS_DATA_MANAGER is set"
+    stderr_msg = response.stderr.decode("utf-8")
+    assert msg in stderr_msg, stderr_msg
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/series/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a866abee2514b4e0c9f9d8aea5954f14cb5e4e70
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_api.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2aafc551023e3f78b126d88d0033a65439ee8f51
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_api.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..feafb3909479209aef7c5fe563b20e25e4f4ca7c
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7dadd3baaec8ff9d7915febaf6b7209a1b5911c
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c16066f72df832b468e7e1b7ebe266a2cf7ac867
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_formats.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_formats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8480273d9126fbb4837c9065b374bd1aaa127b9d
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_formats.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf50989e2640c49507d2ff6bb69bff010e176543
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..471822ea724f4792defd15d87e450db24b9ecd07
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a26c5490f5e8464333a7b07153917149820ff57d
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4903710992289f3afe6a68c50f459ba9a472ade
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9015eea0ab7d2cb32ea0a9811fdb6924227ea538
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..40b894761308748beb2fd6ae2c0d247bf91c48db
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb6badc07cf26e42c019cbe04c542225aa951469
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7f66ac260fa1ce3b03a61c3c2cf88b08796edc48
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b1de1b482ce83a9e27b84567b73dceb5f11682d
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5b0f89d17749577ce906f43040552c3ee3d13c3
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e2217064b28bd5773530d4f0d45813175bbea5e
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_list_accessor.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_list_accessor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..195716194216222023845b96501af2b6d52ad8df
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_list_accessor.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e010067fbb287904ca62a148e58e8f5cdca69ac
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_cat_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_cat_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d50b0f36904a94e7e16aac426e1d098fe320c94
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_cat_accessor.py
@@ -0,0 +1,258 @@
+import numpy as np
+import pytest
+
+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, False
+
+        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),
+            date_range("1/1/2015", periods=5, tz="MET"),
+            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)
+            if func == "to_pydatetime":
+                # deprecated to return Index[object]
+                warn_cls.append(FutureWarning)
+            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
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_dt_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_dt_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..34465a7c12c180dbab607d949c7e9e5a940dc86e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_dt_accessor.py
@@ -0,0 +1,843 @@
+import calendar
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+import locale
+import unicodedata
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs.timezones import maybe_get_tz
+from pandas.errors import SettingWithCopyError
+
+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,
+    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)
+
+        msg = "The behavior of DatetimeProperties.to_pydatetime is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.dt.to_pydatetime()
+        assert isinstance(result, np.ndarray)
+        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)
+
+        msg = "The behavior of DatetimeProperties.to_pydatetime is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.dt.to_pydatetime()
+        assert isinstance(result, np.ndarray)
+        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)
+
+            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").astype(object)
+        with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+            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, using_copy_on_write, warn_copy_on_write):
+        # 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
+        msg = "modifications to a property of a datetimelike.+not supported"
+        with pd.option_context("chained_assignment", "raise"):
+            if using_copy_on_write:
+                with tm.raises_chained_assignment_error():
+                    ser.dt.hour[0] = 5
+            elif warn_copy_on_write:
+                with tm.assert_produces_warning(
+                    FutureWarning, match="ChainedAssignmentError"
+                ):
+                    ser.dt.hour[0] = 5
+            else:
+                with pytest.raises(SettingWithCopyError, match=msg):
+                    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(pytz.AmbiguousTimeError):
+            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")])
+        result = getattr(ser.dt, method)(freq, nonexistent="shift_forward")
+        expected = Series([pd.Timestamp("2018-03-11 03:00:00", tz="America/Chicago")])
+        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(pytz.NonExistentTimeError, 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"
+
+    # error: Unsupported operand types for + ("List[None]" and "List[str]")
+    @pytest.mark.parametrize(
+        "time_locale", [None] + tm.get_locales()  # type: ignore[operator]
+    )
+    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=np.object_,
+        )
+        # 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("string[pyarrow_numpy]")
+        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=object)
+        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(
+        "ser",
+        [
+            Series(np.arange(5)),
+            Series(list("abcde")),
+            Series(np.random.default_rng(2).standard_normal(5)),
+        ],
+    )
+    def test_dt_accessor_invalid(self, ser):
+        # GH#9322 check that series with incorrect dtypes don't have attr
+        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
+        return_value = ser.fillna(pd.Timestamp("2018-01-01"), inplace=True)
+        assert return_value is None
+        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], [[np.nan, np.nan, np.nan]]],
+            [["2019-12-31", "2019-12-29"], [[2020, 1, 2], [2019, 52, 7]]],
+            [["2010-01-01", pd.NaT], [[2009, 53, 5], [np.nan, np.nan, np.nan]]],
+            # 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
+        input_vals = PeriodArray._from_sequence(np.asarray(input_vals))
+
+        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)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_list_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_list_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c60567c1a5300dd4118ae729c3c784eabd4d747
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_list_accessor.py
@@ -0,0 +1,129 @@
+import re
+
+import pytest
+
+from pandas import (
+    ArrowDtype,
+    Series,
+)
+import pandas._testing as tm
+
+pa = pytest.importorskip("pyarrow")
+
+from pandas.compat import pa_version_under11p0
+
+
+@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),
+    )
+    actual = ser.list[1]
+    expected = Series([2, None, None], dtype="int64[pyarrow]")
+    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())),
+    )
+    if pa_version_under11p0:
+        with pytest.raises(
+            NotImplementedError, match="List slice not supported by pyarrow "
+        ):
+            ser.list[1:None:None]
+    else:
+        actual = ser.list[1:None:None]
+        expected = Series(
+            [[2, 3], [None, 5], None], dtype=ArrowDtype(pa.list_(pa.int64()))
+        )
+        tm.assert_series_equal(actual, expected)
+
+
+def test_list_len():
+    ser = Series(
+        [[1, 2, 3], [4, None], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+    )
+    actual = ser.list.len()
+    expected = Series([3, 2, None], dtype=ArrowDtype(pa.int32()))
+    tm.assert_series_equal(actual, expected)
+
+
+def test_list_flatten():
+    ser = Series(
+        [[1, 2, 3], [4, None], None],
+        dtype=ArrowDtype(pa.list_(pa.int64())),
+    )
+    actual = ser.list.flatten()
+    expected = Series([1, 2, 3, 4, None], dtype=ArrowDtype(pa.int64()))
+    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())),
+    )
+    if pa_version_under11p0:
+        with pytest.raises(
+            NotImplementedError, match="List slice not supported by pyarrow "
+        ):
+            ser.list[1:None:0]
+    else:
+        with pytest.raises(pa.lib.ArrowInvalid, match=re.escape("`step` must be >= 1")):
+            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 pytest.raises(pa.lib.ArrowInvalid, match="Index -1 is out of bounds"):
+        ser.list[-1]
+    with pytest.raises(pa.lib.ArrowInvalid, match="Index 5 is out of bounds"):
+        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)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..118095b5dcdbc4f63ba511feb954673485f34427
--- /dev/null
+++ b/venv/lib/python3.10/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
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_str_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_str_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..09d965ef1f32268550bbf35a17f11529545054ed
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_str_accessor.py
@@ -0,0 +1,25 @@
+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))
+        with pytest.raises(AttributeError, match="only use .str accessor"):
+            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
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_struct_accessor.py b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_struct_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..80aea75fda406cf77e0fda73a6d9849c393e7d83
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/accessors/test_struct_accessor.py
@@ -0,0 +1,196 @@
+import re
+
+import pytest
+
+from pandas.compat.pyarrow import (
+    pa_version_under11p0,
+    pa_version_under13p0,
+)
+
+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)
+
+
+@pytest.mark.skipif(pa_version_under13p0, reason="pyarrow>=13.0.0 required")
+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)
+
+
+@pytest.mark.skipif(pa_version_under11p0, reason="pyarrow>=11.0.0 required")
+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"),
+    ],
+)
+@pytest.mark.skipif(pa_version_under13p0, reason="pyarrow>=13.0.0 required")
+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
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_api.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..29d6e2036476ef62ed1a7eea734400915d71f0ab
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_api.py
@@ -0,0 +1,300 @@
+import inspect
+import pydoc
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesMisc:
+    def test_tab_completion(self):
+        # GH 9910
+        s = Series(list("abcd"))
+        # Series of str values should have .str but not .dt/.cat in __dir__
+        assert "str" in dir(s)
+        assert "dt" not in dir(s)
+        assert "cat" not in dir(s)
+
+    def test_tab_completion_dt(self):
+        # similarly for .dt
+        s = Series(date_range("1/1/2015", periods=5))
+        assert "dt" in dir(s)
+        assert "str" not in dir(s)
+        assert "cat" not in dir(s)
+
+    def test_tab_completion_cat(self):
+        # Similarly for .cat, but with the twist that str and dt should be
+        # there if the categories are of that type first cat and str.
+        s = Series(list("abbcd"), dtype="category")
+        assert "cat" in dir(s)
+        assert "str" in dir(s)  # as it is a string categorical
+        assert "dt" not in dir(s)
+
+    def test_tab_completion_cat_str(self):
+        # similar to cat and str
+        s = Series(date_range("1/1/2015", periods=5)).astype("category")
+        assert "cat" in dir(s)
+        assert "str" not in dir(s)
+        assert "dt" in dir(s)  # as it is a datetime categorical
+
+    def test_tab_completion_with_categorical(self):
+        # test the tab completion display
+        ok_for_cat = [
+            "categories",
+            "codes",
+            "ordered",
+            "set_categories",
+            "add_categories",
+            "remove_categories",
+            "rename_categories",
+            "reorder_categories",
+            "remove_unused_categories",
+            "as_ordered",
+            "as_unordered",
+        ]
+
+        s = Series(list("aabbcde")).astype("category")
+        results = sorted({r for r in s.cat.__dir__() if not r.startswith("_")})
+        tm.assert_almost_equal(results, sorted(set(ok_for_cat)))
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            Index(list("ab") * 5, dtype="category"),
+            Index([str(i) for i in range(10)]),
+            Index(["foo", "bar", "baz"] * 2),
+            date_range("2020-01-01", periods=10),
+            period_range("2020-01-01", periods=10, freq="D"),
+            timedelta_range("1 day", periods=10),
+            Index(np.arange(10), dtype=np.uint64),
+            Index(np.arange(10), dtype=np.int64),
+            Index(np.arange(10), dtype=np.float64),
+            Index([True, False]),
+            Index([f"a{i}" for i in range(101)]),
+            pd.MultiIndex.from_tuples(zip("ABCD", "EFGH")),
+            pd.MultiIndex.from_tuples(zip([0, 1, 2, 3], "EFGH")),
+        ],
+    )
+    def test_index_tab_completion(self, index):
+        # dir contains string-like values of the Index.
+        s = Series(index=index, dtype=object)
+        dir_s = dir(s)
+        for i, x in enumerate(s.index.unique(level=0)):
+            if i < 100:
+                assert not isinstance(x, str) or not x.isidentifier() or x in dir_s
+            else:
+                assert x not in dir_s
+
+    @pytest.mark.parametrize("ser", [Series(dtype=object), Series([1])])
+    def test_not_hashable(self, ser):
+        msg = "unhashable type: 'Series'"
+        with pytest.raises(TypeError, match=msg):
+            hash(ser)
+
+    def test_contains(self, datetime_series):
+        tm.assert_contains_all(datetime_series.index, datetime_series)
+
+    def test_axis_alias(self):
+        s = Series([1, 2, np.nan])
+        tm.assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
+        assert s.dropna().sum("rows") == 3
+        assert s._get_axis_number("rows") == 0
+        assert s._get_axis_name("rows") == "index"
+
+    def test_class_axis(self):
+        # https://github.com/pandas-dev/pandas/issues/18147
+        # no exception and no empty docstring
+        assert pydoc.getdoc(Series.index)
+
+    def test_ndarray_compat(self):
+        # test numpy compat with Series as sub-class of NDFrame
+        tsdf = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 3)),
+            columns=["A", "B", "C"],
+            index=date_range("1/1/2000", periods=1000),
+        )
+
+        def f(x):
+            return x[x.idxmax()]
+
+        result = tsdf.apply(f)
+        expected = tsdf.max()
+        tm.assert_series_equal(result, expected)
+
+    def test_ndarray_compat_like_func(self):
+        # using an ndarray like function
+        s = Series(np.random.default_rng(2).standard_normal(10))
+        result = Series(np.ones_like(s))
+        expected = Series(1, index=range(10), dtype="float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_ndarray_compat_ravel(self):
+        # ravel
+        s = Series(np.random.default_rng(2).standard_normal(10))
+        with tm.assert_produces_warning(FutureWarning, match="ravel is deprecated"):
+            result = s.ravel(order="F")
+        tm.assert_almost_equal(result, s.values.ravel(order="F"))
+
+    def test_empty_method(self):
+        s_empty = Series(dtype=object)
+        assert s_empty.empty
+
+    @pytest.mark.parametrize("dtype", ["int64", object])
+    def test_empty_method_full_series(self, dtype):
+        full_series = Series(index=[1], dtype=dtype)
+        assert not full_series.empty
+
+    @pytest.mark.parametrize("dtype", [None, "Int64"])
+    def test_integer_series_size(self, dtype):
+        # GH 25580
+        s = Series(range(9), dtype=dtype)
+        assert s.size == 9
+
+    def test_attrs(self):
+        s = Series([0, 1], name="abc")
+        assert s.attrs == {}
+        s.attrs["version"] = 1
+        result = s + 1
+        assert result.attrs == {"version": 1}
+
+    def test_inspect_getmembers(self):
+        # GH38782
+        pytest.importorskip("jinja2")
+        ser = Series(dtype=object)
+        msg = "Series._data is deprecated"
+        with tm.assert_produces_warning(
+            DeprecationWarning, match=msg, check_stacklevel=False
+        ):
+            inspect.getmembers(ser)
+
+    def test_unknown_attribute(self):
+        # GH#9680
+        tdi = timedelta_range(start=0, periods=10, freq="1s")
+        ser = Series(np.random.default_rng(2).normal(size=10), index=tdi)
+        assert "foo" not in ser.__dict__
+        msg = "'Series' object has no attribute 'foo'"
+        with pytest.raises(AttributeError, match=msg):
+            ser.foo
+
+    @pytest.mark.parametrize("op", ["year", "day", "second", "weekday"])
+    def test_datetime_series_no_datelike_attrs(self, op, datetime_series):
+        # GH#7206
+        msg = f"'Series' object has no attribute '{op}'"
+        with pytest.raises(AttributeError, match=msg):
+            getattr(datetime_series, op)
+
+    def test_series_datetimelike_attribute_access(self):
+        # attribute access should still work!
+        ser = Series({"year": 2000, "month": 1, "day": 10})
+        assert ser.year == 2000
+        assert ser.month == 1
+        assert ser.day == 10
+
+    def test_series_datetimelike_attribute_access_invalid(self):
+        ser = Series({"year": 2000, "month": 1, "day": 10})
+        msg = "'Series' object has no attribute 'weekday'"
+        with pytest.raises(AttributeError, match=msg):
+            ser.weekday
+
+    @pytest.mark.filterwarnings("ignore:Downcasting object dtype arrays:FutureWarning")
+    @pytest.mark.parametrize(
+        "kernel, has_numeric_only",
+        [
+            ("skew", True),
+            ("var", True),
+            ("all", False),
+            ("prod", True),
+            ("any", False),
+            ("idxmin", False),
+            ("quantile", False),
+            ("idxmax", False),
+            ("min", True),
+            ("sem", True),
+            ("mean", True),
+            ("nunique", False),
+            ("max", True),
+            ("sum", True),
+            ("count", False),
+            ("median", True),
+            ("std", True),
+            ("backfill", False),
+            ("rank", True),
+            ("pct_change", False),
+            ("cummax", False),
+            ("shift", False),
+            ("diff", False),
+            ("cumsum", False),
+            ("cummin", False),
+            ("cumprod", False),
+            ("fillna", False),
+            ("ffill", False),
+            ("pad", False),
+            ("bfill", False),
+            ("sample", False),
+            ("tail", False),
+            ("take", False),
+            ("head", False),
+            ("cov", False),
+            ("corr", False),
+        ],
+    )
+    @pytest.mark.parametrize("dtype", [bool, int, float, object])
+    def test_numeric_only(self, kernel, has_numeric_only, dtype):
+        # GH#47500
+        ser = Series([0, 1, 1], dtype=dtype)
+        if kernel == "corrwith":
+            args = (ser,)
+        elif kernel == "corr":
+            args = (ser,)
+        elif kernel == "cov":
+            args = (ser,)
+        elif kernel == "nth":
+            args = (0,)
+        elif kernel == "fillna":
+            args = (True,)
+        elif kernel == "fillna":
+            args = ("ffill",)
+        elif kernel == "take":
+            args = ([0],)
+        elif kernel == "quantile":
+            args = (0.5,)
+        else:
+            args = ()
+        method = getattr(ser, kernel)
+        if not has_numeric_only:
+            msg = (
+                "(got an unexpected keyword argument 'numeric_only'"
+                "|too many arguments passed in)"
+            )
+            with pytest.raises(TypeError, match=msg):
+                method(*args, numeric_only=True)
+        elif dtype is object:
+            msg = f"Series.{kernel} does not allow numeric_only=True with non-numeric"
+            with pytest.raises(TypeError, match=msg):
+                method(*args, numeric_only=True)
+        else:
+            result = method(*args, numeric_only=True)
+            expected = method(*args, numeric_only=False)
+            if isinstance(expected, Series):
+                # transformer
+                tm.assert_series_equal(result, expected)
+            else:
+                # reducer
+                assert result == expected
+
+
+@pytest.mark.parametrize("converter", [int, float, complex])
+def test_float_int_deprecated(converter):
+    # GH 51101
+    with tm.assert_produces_warning(FutureWarning):
+        assert converter(Series([1])) == converter(1)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_arithmetic.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_arithmetic.py
new file mode 100644
index 0000000000000000000000000000000000000000..b40e2e99dae2eed2d1673797fcb9810bb412de0c
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_arithmetic.py
@@ -0,0 +1,984 @@
+from datetime import (
+    date,
+    timedelta,
+    timezone,
+)
+from decimal import Decimal
+import operator
+
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+from pandas._libs.tslibs import IncompatibleFrequency
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DatetimeTZDtype,
+    Index,
+    Series,
+    Timedelta,
+    bdate_range,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+from pandas.core import ops
+from pandas.core.computation import expressions as expr
+from pandas.core.computation.check import NUMEXPR_INSTALLED
+
+
+@pytest.fixture(autouse=True, params=[0, 1000000], ids=["numexpr", "python"])
+def switch_numexpr_min_elements(request, monkeypatch):
+    with monkeypatch.context() as m:
+        m.setattr(expr, "_MIN_ELEMENTS", request.param)
+        yield
+
+
+def _permute(obj):
+    return obj.take(np.random.default_rng(2).permutation(len(obj)))
+
+
+class TestSeriesFlexArithmetic:
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            (lambda x: x, lambda x: x * 2, False),
+            (lambda x: x, lambda x: x[::2], False),
+            (lambda x: x, lambda x: 5, True),
+            (
+                lambda x: Series(range(10), dtype=np.float64),
+                lambda x: Series(range(10), dtype=np.float64),
+                True,
+            ),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "opname", ["add", "sub", "mul", "floordiv", "truediv", "pow"]
+    )
+    def test_flex_method_equivalence(self, opname, ts):
+        # check that Series.{opname} behaves like Series.__{opname}__,
+        tser = Series(
+            np.arange(20, dtype=np.float64),
+            index=date_range("2020-01-01", periods=20),
+            name="ts",
+        )
+
+        series = ts[0](tser)
+        other = ts[1](tser)
+        check_reverse = ts[2]
+
+        op = getattr(Series, opname)
+        alt = getattr(operator, opname)
+
+        result = op(series, other)
+        expected = alt(series, other)
+        tm.assert_almost_equal(result, expected)
+        if check_reverse:
+            rop = getattr(Series, "r" + opname)
+            result = rop(series, other)
+            expected = alt(other, series)
+            tm.assert_almost_equal(result, expected)
+
+    def test_flex_method_subclass_metadata_preservation(self, all_arithmetic_operators):
+        # GH 13208
+        class MySeries(Series):
+            _metadata = ["x"]
+
+            @property
+            def _constructor(self):
+                return MySeries
+
+        opname = all_arithmetic_operators
+        op = getattr(Series, opname)
+        m = MySeries([1, 2, 3], name="test")
+        m.x = 42
+        result = op(m, 1)
+        assert result.x == 42
+
+    def test_flex_add_scalar_fill_value(self):
+        # GH12723
+        ser = Series([0, 1, np.nan, 3, 4, 5])
+
+        exp = ser.fillna(0).add(2)
+        res = ser.add(2, fill_value=0)
+        tm.assert_series_equal(res, exp)
+
+    pairings = [(Series.div, operator.truediv, 1), (Series.rdiv, ops.rtruediv, 1)]
+    for op in ["add", "sub", "mul", "pow", "truediv", "floordiv"]:
+        fv = 0
+        lop = getattr(Series, op)
+        lequiv = getattr(operator, op)
+        rop = getattr(Series, "r" + op)
+        # bind op at definition time...
+        requiv = lambda x, y, op=op: getattr(operator, op)(y, x)
+        pairings.append((lop, lequiv, fv))
+        pairings.append((rop, requiv, fv))
+
+    @pytest.mark.parametrize("op, equiv_op, fv", pairings)
+    def test_operators_combine(self, op, equiv_op, fv):
+        def _check_fill(meth, op, a, b, fill_value=0):
+            exp_index = a.index.union(b.index)
+            a = a.reindex(exp_index)
+            b = b.reindex(exp_index)
+
+            amask = isna(a)
+            bmask = isna(b)
+
+            exp_values = []
+            for i in range(len(exp_index)):
+                with np.errstate(all="ignore"):
+                    if amask[i]:
+                        if bmask[i]:
+                            exp_values.append(np.nan)
+                            continue
+                        exp_values.append(op(fill_value, b[i]))
+                    elif bmask[i]:
+                        if amask[i]:
+                            exp_values.append(np.nan)
+                            continue
+                        exp_values.append(op(a[i], fill_value))
+                    else:
+                        exp_values.append(op(a[i], b[i]))
+
+            result = meth(a, b, fill_value=fill_value)
+            expected = Series(exp_values, exp_index)
+            tm.assert_series_equal(result, expected)
+
+        a = Series([np.nan, 1.0, 2.0, 3.0, np.nan], index=np.arange(5))
+        b = Series([np.nan, 1, np.nan, 3, np.nan, 4.0], index=np.arange(6))
+
+        result = op(a, b)
+        exp = equiv_op(a, b)
+        tm.assert_series_equal(result, exp)
+        _check_fill(op, equiv_op, a, b, fill_value=fv)
+        # should accept axis=0 or axis='rows'
+        op(a, b, axis=0)
+
+
+class TestSeriesArithmetic:
+    # Some of these may end up in tests/arithmetic, but are not yet sorted
+
+    def test_add_series_with_period_index(self):
+        rng = pd.period_range("1/1/2000", "1/1/2010", freq="Y")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        result = ts + ts[::2]
+        expected = ts + ts
+        expected.iloc[1::2] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        result = ts + _permute(ts[::2])
+        tm.assert_series_equal(result, expected)
+
+        msg = "Input has different freq=D from Period\\(freq=Y-DEC\\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            ts + ts.asfreq("D", how="end")
+
+    @pytest.mark.parametrize(
+        "target_add,input_value,expected_value",
+        [
+            ("!", ["hello", "world"], ["hello!", "world!"]),
+            ("m", ["hello", "world"], ["hellom", "worldm"]),
+        ],
+    )
+    def test_string_addition(self, target_add, input_value, expected_value):
+        # GH28658 - ensure adding 'm' does not raise an error
+        a = Series(input_value)
+
+        result = a + target_add
+        expected = Series(expected_value)
+        tm.assert_series_equal(result, expected)
+
+    def test_divmod(self):
+        # GH#25557
+        a = Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"])
+        b = Series([2, np.nan, 1, np.nan], index=["a", "b", "d", "e"])
+
+        result = a.divmod(b)
+        expected = divmod(a, b)
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+        result = a.rdivmod(b)
+        expected = divmod(b, a)
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+    @pytest.mark.parametrize("index", [None, range(9)])
+    def test_series_integer_mod(self, index):
+        # GH#24396
+        s1 = Series(range(1, 10))
+        s2 = Series("foo", index=index)
+
+        msg = "not all arguments converted during string formatting|mod not"
+
+        with pytest.raises((TypeError, NotImplementedError), match=msg):
+            s2 % s1
+
+    def test_add_with_duplicate_index(self):
+        # GH14227
+        s1 = Series([1, 2], index=[1, 1])
+        s2 = Series([10, 10], index=[1, 2])
+        result = s1 + s2
+        expected = Series([11, 12, np.nan], index=[1, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_add_na_handling(self):
+        ser = Series(
+            [Decimal("1.3"), Decimal("2.3")], index=[date(2012, 1, 1), date(2012, 1, 2)]
+        )
+
+        result = ser + ser.shift(1)
+        result2 = ser.shift(1) + ser
+        assert isna(result.iloc[0])
+        assert isna(result2.iloc[0])
+
+    def test_add_corner_cases(self, datetime_series):
+        empty = Series([], index=Index([]), dtype=np.float64)
+
+        result = datetime_series + empty
+        assert np.isnan(result).all()
+
+        result = empty + empty.copy()
+        assert len(result) == 0
+
+    def test_add_float_plus_int(self, datetime_series):
+        # float + int
+        int_ts = datetime_series.astype(int)[:-5]
+        added = datetime_series + int_ts
+        expected = Series(
+            datetime_series.values[:-5] + int_ts.values,
+            index=datetime_series.index[:-5],
+            name="ts",
+        )
+        tm.assert_series_equal(added[:-5], expected)
+
+    def test_mul_empty_int_corner_case(self):
+        s1 = Series([], [], dtype=np.int32)
+        s2 = Series({"x": 0.0})
+        tm.assert_series_equal(s1 * s2, Series([np.nan], index=["x"]))
+
+    def test_sub_datetimelike_align(self):
+        # GH#7500
+        # datetimelike ops need to align
+        dt = Series(date_range("2012-1-1", periods=3, freq="D"))
+        dt.iloc[2] = np.nan
+        dt2 = dt[::-1]
+
+        expected = Series([timedelta(0), timedelta(0), pd.NaT])
+        # name is reset
+        result = dt2 - dt
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(expected, name=0)
+        result = (dt2.to_frame() - dt.to_frame())[0]
+        tm.assert_series_equal(result, expected)
+
+    def test_alignment_doesnt_change_tz(self):
+        # GH#33671
+        dti = date_range("2016-01-01", periods=10, tz="CET")
+        dti_utc = dti.tz_convert("UTC")
+        ser = Series(10, index=dti)
+        ser_utc = Series(10, index=dti_utc)
+
+        # we don't care about the result, just that original indexes are unchanged
+        ser * ser_utc
+
+        assert ser.index is dti
+        assert ser_utc.index is dti_utc
+
+    def test_alignment_categorical(self):
+        # GH13365
+        cat = Categorical(["3z53", "3z53", "LoJG", "LoJG", "LoJG", "N503"])
+        ser1 = Series(2, index=cat)
+        ser2 = Series(2, index=cat[:-1])
+        result = ser1 * ser2
+
+        exp_index = ["3z53"] * 4 + ["LoJG"] * 9 + ["N503"]
+        exp_index = pd.CategoricalIndex(exp_index, categories=cat.categories)
+        exp_values = [4.0] * 13 + [np.nan]
+        expected = Series(exp_values, exp_index)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_arithmetic_with_duplicate_index(self):
+        # GH#8363
+        # integer ops with a non-unique index
+        index = [2, 2, 3, 3, 4]
+        ser = Series(np.arange(1, 6, dtype="int64"), index=index)
+        other = Series(np.arange(5, dtype="int64"), index=index)
+        result = ser - other
+        expected = Series(1, index=[2, 2, 3, 3, 4])
+        tm.assert_series_equal(result, expected)
+
+        # GH#8363
+        # datetime ops with a non-unique index
+        ser = Series(date_range("20130101 09:00:00", periods=5), index=index)
+        other = Series(date_range("20130101", periods=5), index=index)
+        result = ser - other
+        expected = Series(Timedelta("9 hours"), index=[2, 2, 3, 3, 4])
+        tm.assert_series_equal(result, expected)
+
+    def test_masked_and_non_masked_propagate_na(self):
+        # GH#45810
+        ser1 = Series([0, np.nan], dtype="float")
+        ser2 = Series([0, 1], dtype="Int64")
+        result = ser1 * ser2
+        expected = Series([0, pd.NA], dtype="Float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_mask_div_propagate_na_for_non_na_dtype(self):
+        # GH#42630
+        ser1 = Series([15, pd.NA, 5, 4], dtype="Int64")
+        ser2 = Series([15, 5, np.nan, 4])
+        result = ser1 / ser2
+        expected = Series([1.0, pd.NA, pd.NA, 1.0], dtype="Float64")
+        tm.assert_series_equal(result, expected)
+
+        result = ser2 / ser1
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val, dtype", [(3, "Int64"), (3.5, "Float64")])
+    def test_add_list_to_masked_array(self, val, dtype):
+        # GH#22962
+        ser = Series([1, None, 3], dtype="Int64")
+        result = ser + [1, None, val]
+        expected = Series([2, None, 3 + val], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+        result = [1, None, val] + ser
+        tm.assert_series_equal(result, expected)
+
+    def test_add_list_to_masked_array_boolean(self, request):
+        # GH#22962
+        warning = (
+            UserWarning
+            if request.node.callspec.id == "numexpr" and NUMEXPR_INSTALLED
+            else None
+        )
+        ser = Series([True, None, False], dtype="boolean")
+        with tm.assert_produces_warning(warning):
+            result = ser + [True, None, True]
+        expected = Series([True, None, True], dtype="boolean")
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(warning):
+            result = [True, None, True] + ser
+        tm.assert_series_equal(result, expected)
+
+
+# ------------------------------------------------------------------
+# Comparisons
+
+
+class TestSeriesFlexComparison:
+    @pytest.mark.parametrize("axis", [0, None, "index"])
+    def test_comparison_flex_basic(self, axis, comparison_op):
+        left = Series(np.random.default_rng(2).standard_normal(10))
+        right = Series(np.random.default_rng(2).standard_normal(10))
+        result = getattr(left, comparison_op.__name__)(right, axis=axis)
+        expected = comparison_op(left, right)
+        tm.assert_series_equal(result, expected)
+
+    def test_comparison_bad_axis(self, comparison_op):
+        left = Series(np.random.default_rng(2).standard_normal(10))
+        right = Series(np.random.default_rng(2).standard_normal(10))
+
+        msg = "No axis named 1 for object type"
+        with pytest.raises(ValueError, match=msg):
+            getattr(left, comparison_op.__name__)(right, axis=1)
+
+    @pytest.mark.parametrize(
+        "values, op",
+        [
+            ([False, False, True, False], "eq"),
+            ([True, True, False, True], "ne"),
+            ([False, False, True, False], "le"),
+            ([False, False, False, False], "lt"),
+            ([False, True, True, False], "ge"),
+            ([False, True, False, False], "gt"),
+        ],
+    )
+    def test_comparison_flex_alignment(self, values, op):
+        left = Series([1, 3, 2], index=list("abc"))
+        right = Series([2, 2, 2], index=list("bcd"))
+        result = getattr(left, op)(right)
+        expected = Series(values, index=list("abcd"))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values, op, fill_value",
+        [
+            ([False, False, True, True], "eq", 2),
+            ([True, True, False, False], "ne", 2),
+            ([False, False, True, True], "le", 0),
+            ([False, False, False, True], "lt", 0),
+            ([True, True, True, False], "ge", 0),
+            ([True, True, False, False], "gt", 0),
+        ],
+    )
+    def test_comparison_flex_alignment_fill(self, values, op, fill_value):
+        left = Series([1, 3, 2], index=list("abc"))
+        right = Series([2, 2, 2], index=list("bcd"))
+        result = getattr(left, op)(right, fill_value=fill_value)
+        expected = Series(values, index=list("abcd"))
+        tm.assert_series_equal(result, expected)
+
+
+class TestSeriesComparison:
+    def test_comparison_different_length(self):
+        a = Series(["a", "b", "c"])
+        b = Series(["b", "a"])
+        msg = "only compare identically-labeled Series"
+        with pytest.raises(ValueError, match=msg):
+            a < b
+
+        a = Series([1, 2])
+        b = Series([2, 3, 4])
+        with pytest.raises(ValueError, match=msg):
+            a == b
+
+    @pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
+    def test_ser_flex_cmp_return_dtypes(self, opname):
+        # GH#15115
+        ser = Series([1, 3, 2], index=range(3))
+        const = 2
+        result = getattr(ser, opname)(const).dtypes
+        expected = np.dtype("bool")
+        assert result == expected
+
+    @pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
+    def test_ser_flex_cmp_return_dtypes_empty(self, opname):
+        # GH#15115 empty Series case
+        ser = Series([1, 3, 2], index=range(3))
+        empty = ser.iloc[:0]
+        const = 2
+        result = getattr(empty, opname)(const).dtypes
+        expected = np.dtype("bool")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "names", [(None, None, None), ("foo", "bar", None), ("baz", "baz", "baz")]
+    )
+    def test_ser_cmp_result_names(self, names, comparison_op):
+        # datetime64 dtype
+        op = comparison_op
+        dti = date_range("1949-06-07 03:00:00", freq="h", periods=5, name=names[0])
+        ser = Series(dti).rename(names[1])
+        result = op(ser, dti)
+        assert result.name == names[2]
+
+        # datetime64tz dtype
+        dti = dti.tz_localize("US/Central")
+        dti = pd.DatetimeIndex(dti, freq="infer")  # freq not preserved by tz_localize
+        ser = Series(dti).rename(names[1])
+        result = op(ser, dti)
+        assert result.name == names[2]
+
+        # timedelta64 dtype
+        tdi = dti - dti.shift(1)
+        ser = Series(tdi).rename(names[1])
+        result = op(ser, tdi)
+        assert result.name == names[2]
+
+        # interval dtype
+        if op in [operator.eq, operator.ne]:
+            # interval dtype comparisons not yet implemented
+            ii = pd.interval_range(start=0, periods=5, name=names[0])
+            ser = Series(ii).rename(names[1])
+            result = op(ser, ii)
+            assert result.name == names[2]
+
+        # categorical
+        if op in [operator.eq, operator.ne]:
+            # categorical dtype comparisons raise for inequalities
+            cidx = tdi.astype("category")
+            ser = Series(cidx).rename(names[1])
+            result = op(ser, cidx)
+            assert result.name == names[2]
+
+    def test_comparisons(self, using_infer_string):
+        s = Series(["a", "b", "c"])
+        s2 = Series([False, True, False])
+
+        # it works!
+        exp = Series([False, False, False])
+        if using_infer_string:
+            import pyarrow as pa
+
+            msg = "has no kernel"
+            # TODO(3.0) GH56008
+            with pytest.raises(pa.lib.ArrowNotImplementedError, match=msg):
+                s == s2
+            with tm.assert_produces_warning(
+                DeprecationWarning, match="comparison", check_stacklevel=False
+            ):
+                with pytest.raises(pa.lib.ArrowNotImplementedError, match=msg):
+                    s2 == s
+        else:
+            tm.assert_series_equal(s == s2, exp)
+            tm.assert_series_equal(s2 == s, exp)
+
+    # -----------------------------------------------------------------
+    # Categorical Dtype Comparisons
+
+    def test_categorical_comparisons(self):
+        # GH#8938
+        # allow equality comparisons
+        a = Series(list("abc"), dtype="category")
+        b = Series(list("abc"), dtype="object")
+        c = Series(["a", "b", "cc"], dtype="object")
+        d = Series(list("acb"), dtype="object")
+        e = Categorical(list("abc"))
+        f = Categorical(list("acb"))
+
+        # vs scalar
+        assert not (a == "a").all()
+        assert ((a != "a") == ~(a == "a")).all()
+
+        assert not ("a" == a).all()
+        assert (a == "a")[0]
+        assert ("a" == a)[0]
+        assert not ("a" != a)[0]
+
+        # vs list-like
+        assert (a == a).all()
+        assert not (a != a).all()
+
+        assert (a == list(a)).all()
+        assert (a == b).all()
+        assert (b == a).all()
+        assert ((~(a == b)) == (a != b)).all()
+        assert ((~(b == a)) == (b != a)).all()
+
+        assert not (a == c).all()
+        assert not (c == a).all()
+        assert not (a == d).all()
+        assert not (d == a).all()
+
+        # vs a cat-like
+        assert (a == e).all()
+        assert (e == a).all()
+        assert not (a == f).all()
+        assert not (f == a).all()
+
+        assert (~(a == e) == (a != e)).all()
+        assert (~(e == a) == (e != a)).all()
+        assert (~(a == f) == (a != f)).all()
+        assert (~(f == a) == (f != a)).all()
+
+        # non-equality is not comparable
+        msg = "can only compare equality or not"
+        with pytest.raises(TypeError, match=msg):
+            a < b
+        with pytest.raises(TypeError, match=msg):
+            b < a
+        with pytest.raises(TypeError, match=msg):
+            a > b
+        with pytest.raises(TypeError, match=msg):
+            b > a
+
+    def test_unequal_categorical_comparison_raises_type_error(self):
+        # unequal comparison should raise for unordered cats
+        cat = Series(Categorical(list("abc")))
+        msg = "can only compare equality or not"
+        with pytest.raises(TypeError, match=msg):
+            cat > "b"
+
+        cat = Series(Categorical(list("abc"), ordered=False))
+        with pytest.raises(TypeError, match=msg):
+            cat > "b"
+
+        # https://github.com/pandas-dev/pandas/issues/9836#issuecomment-92123057
+        # and following comparisons with scalars not in categories should raise
+        # for unequal comps, but not for equal/not equal
+        cat = Series(Categorical(list("abc"), ordered=True))
+
+        msg = "Invalid comparison between dtype=category and str"
+        with pytest.raises(TypeError, match=msg):
+            cat < "d"
+        with pytest.raises(TypeError, match=msg):
+            cat > "d"
+        with pytest.raises(TypeError, match=msg):
+            "d" < cat
+        with pytest.raises(TypeError, match=msg):
+            "d" > cat
+
+        tm.assert_series_equal(cat == "d", Series([False, False, False]))
+        tm.assert_series_equal(cat != "d", Series([True, True, True]))
+
+    # -----------------------------------------------------------------
+
+    def test_comparison_tuples(self):
+        # GH#11339
+        # comparisons vs tuple
+        s = Series([(1, 1), (1, 2)])
+
+        result = s == (1, 2)
+        expected = Series([False, True])
+        tm.assert_series_equal(result, expected)
+
+        result = s != (1, 2)
+        expected = Series([True, False])
+        tm.assert_series_equal(result, expected)
+
+        result = s == (0, 0)
+        expected = Series([False, False])
+        tm.assert_series_equal(result, expected)
+
+        result = s != (0, 0)
+        expected = Series([True, True])
+        tm.assert_series_equal(result, expected)
+
+        s = Series([(1, 1), (1, 1)])
+
+        result = s == (1, 1)
+        expected = Series([True, True])
+        tm.assert_series_equal(result, expected)
+
+        result = s != (1, 1)
+        expected = Series([False, False])
+        tm.assert_series_equal(result, expected)
+
+    def test_comparison_frozenset(self):
+        ser = Series([frozenset([1]), frozenset([1, 2])])
+
+        result = ser == frozenset([1])
+        expected = Series([True, False])
+        tm.assert_series_equal(result, expected)
+
+    def test_comparison_operators_with_nas(self, comparison_op):
+        ser = Series(bdate_range("1/1/2000", periods=10), dtype=object)
+        ser[::2] = np.nan
+
+        # test that comparisons work
+        val = ser[5]
+
+        result = comparison_op(ser, val)
+        expected = comparison_op(ser.dropna(), val).reindex(ser.index)
+
+        msg = "Downcasting object dtype arrays"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            if comparison_op is operator.ne:
+                expected = expected.fillna(True).astype(bool)
+            else:
+                expected = expected.fillna(False).astype(bool)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_ne(self):
+        ts = Series([3, 4, 5, 6, 7], [3, 4, 5, 6, 7], dtype=float)
+        expected = np.array([True, True, False, True, True])
+        tm.assert_numpy_array_equal(ts.index != 5, expected)
+        tm.assert_numpy_array_equal(~(ts.index == 5), expected)
+
+    @pytest.mark.parametrize(
+        "left, right",
+        [
+            (
+                Series([1, 2, 3], index=list("ABC"), name="x"),
+                Series([2, 2, 2], index=list("ABD"), name="x"),
+            ),
+            (
+                Series([1, 2, 3], index=list("ABC"), name="x"),
+                Series([2, 2, 2, 2], index=list("ABCD"), name="x"),
+            ),
+        ],
+    )
+    def test_comp_ops_df_compat(self, left, right, frame_or_series):
+        # GH 1134
+        # GH 50083 to clarify that index and columns must be identically labeled
+        if frame_or_series is not Series:
+            msg = (
+                rf"Can only compare identically-labeled \(both index and columns\) "
+                f"{frame_or_series.__name__} objects"
+            )
+            left = left.to_frame()
+            right = right.to_frame()
+        else:
+            msg = (
+                f"Can only compare identically-labeled {frame_or_series.__name__} "
+                f"objects"
+            )
+
+        with pytest.raises(ValueError, match=msg):
+            left == right
+        with pytest.raises(ValueError, match=msg):
+            right == left
+
+        with pytest.raises(ValueError, match=msg):
+            left != right
+        with pytest.raises(ValueError, match=msg):
+            right != left
+
+        with pytest.raises(ValueError, match=msg):
+            left < right
+        with pytest.raises(ValueError, match=msg):
+            right < left
+
+    def test_compare_series_interval_keyword(self):
+        # GH#25338
+        ser = Series(["IntervalA", "IntervalB", "IntervalC"])
+        result = ser == "IntervalA"
+        expected = Series([True, False, False])
+        tm.assert_series_equal(result, expected)
+
+
+# ------------------------------------------------------------------
+# Unsorted
+#  These arithmetic tests were previously in other files, eventually
+#  should be parametrized and put into tests.arithmetic
+
+
+class TestTimeSeriesArithmetic:
+    def test_series_add_tz_mismatch_converts_to_utc(self):
+        rng = date_range("1/1/2011", periods=100, freq="h", tz="utc")
+
+        perm = np.random.default_rng(2).permutation(100)[:90]
+        ser1 = Series(
+            np.random.default_rng(2).standard_normal(90),
+            index=rng.take(perm).tz_convert("US/Eastern"),
+        )
+
+        perm = np.random.default_rng(2).permutation(100)[:90]
+        ser2 = Series(
+            np.random.default_rng(2).standard_normal(90),
+            index=rng.take(perm).tz_convert("Europe/Berlin"),
+        )
+
+        result = ser1 + ser2
+
+        uts1 = ser1.tz_convert("utc")
+        uts2 = ser2.tz_convert("utc")
+        expected = uts1 + uts2
+
+        # sort since input indexes are not equal
+        expected = expected.sort_index()
+
+        assert result.index.tz is timezone.utc
+        tm.assert_series_equal(result, expected)
+
+    def test_series_add_aware_naive_raises(self):
+        rng = date_range("1/1/2011", periods=10, freq="h")
+        ser = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        ser_utc = ser.tz_localize("utc")
+
+        msg = "Cannot join tz-naive with tz-aware DatetimeIndex"
+        with pytest.raises(Exception, match=msg):
+            ser + ser_utc
+
+        with pytest.raises(Exception, match=msg):
+            ser_utc + ser
+
+    # TODO: belongs in tests/arithmetic?
+    def test_datetime_understood(self, unit):
+        # Ensures it doesn't fail to create the right series
+        # reported in issue#16726
+        series = Series(date_range("2012-01-01", periods=3, unit=unit))
+        offset = pd.offsets.DateOffset(days=6)
+        result = series - offset
+        exp_dti = pd.to_datetime(["2011-12-26", "2011-12-27", "2011-12-28"]).as_unit(
+            unit
+        )
+        expected = Series(exp_dti)
+        tm.assert_series_equal(result, expected)
+
+    def test_align_date_objects_with_datetimeindex(self):
+        rng = date_range("1/1/2000", periods=20)
+        ts = Series(np.random.default_rng(2).standard_normal(20), index=rng)
+
+        ts_slice = ts[5:]
+        ts2 = ts_slice.copy()
+        ts2.index = [x.date() for x in ts2.index]
+
+        result = ts + ts2
+        result2 = ts2 + ts
+        expected = ts + ts[5:]
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result2, expected)
+
+
+class TestNamePreservation:
+    @pytest.mark.parametrize("box", [list, tuple, np.array, Index, Series, pd.array])
+    @pytest.mark.parametrize("flex", [True, False])
+    def test_series_ops_name_retention(self, flex, box, names, all_binary_operators):
+        # GH#33930 consistent name-retention
+        op = all_binary_operators
+
+        left = Series(range(10), name=names[0])
+        right = Series(range(10), name=names[1])
+
+        name = op.__name__.strip("_")
+        is_logical = name in ["and", "rand", "xor", "rxor", "or", "ror"]
+
+        msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+        warn = None
+        if box in [list, tuple] and is_logical:
+            warn = FutureWarning
+
+        right = box(right)
+        if flex:
+            if is_logical:
+                # Series doesn't have these as flex methods
+                return
+            result = getattr(left, name)(right)
+        else:
+            # GH#37374 logical ops behaving as set ops deprecated
+            with tm.assert_produces_warning(warn, match=msg):
+                result = op(left, right)
+
+        assert isinstance(result, Series)
+        if box in [Index, Series]:
+            assert result.name is names[2] or result.name == names[2]
+        else:
+            assert result.name is names[0] or result.name == names[0]
+
+    def test_binop_maybe_preserve_name(self, datetime_series):
+        # names match, preserve
+        result = datetime_series * datetime_series
+        assert result.name == datetime_series.name
+        result = datetime_series.mul(datetime_series)
+        assert result.name == datetime_series.name
+
+        result = datetime_series * datetime_series[:-2]
+        assert result.name == datetime_series.name
+
+        # names don't match, don't preserve
+        cp = datetime_series.copy()
+        cp.name = "something else"
+        result = datetime_series + cp
+        assert result.name is None
+        result = datetime_series.add(cp)
+        assert result.name is None
+
+        ops = ["add", "sub", "mul", "div", "truediv", "floordiv", "mod", "pow"]
+        ops = ops + ["r" + op for op in ops]
+        for op in ops:
+            # names match, preserve
+            ser = datetime_series.copy()
+            result = getattr(ser, op)(ser)
+            assert result.name == datetime_series.name
+
+            # names don't match, don't preserve
+            cp = datetime_series.copy()
+            cp.name = "changed"
+            result = getattr(ser, op)(cp)
+            assert result.name is None
+
+    def test_scalarop_preserve_name(self, datetime_series):
+        result = datetime_series * 2
+        assert result.name == datetime_series.name
+
+
+class TestInplaceOperations:
+    @pytest.mark.parametrize(
+        "dtype1, dtype2, dtype_expected, dtype_mul",
+        (
+            ("Int64", "Int64", "Int64", "Int64"),
+            ("float", "float", "float", "float"),
+            ("Int64", "float", "Float64", "Float64"),
+            ("Int64", "Float64", "Float64", "Float64"),
+        ),
+    )
+    def test_series_inplace_ops(self, dtype1, dtype2, dtype_expected, dtype_mul):
+        # GH 37910
+
+        ser1 = Series([1], dtype=dtype1)
+        ser2 = Series([2], dtype=dtype2)
+        ser1 += ser2
+        expected = Series([3], dtype=dtype_expected)
+        tm.assert_series_equal(ser1, expected)
+
+        ser1 -= ser2
+        expected = Series([1], dtype=dtype_expected)
+        tm.assert_series_equal(ser1, expected)
+
+        ser1 *= ser2
+        expected = Series([2], dtype=dtype_mul)
+        tm.assert_series_equal(ser1, expected)
+
+
+def test_none_comparison(request, series_with_simple_index):
+    series = series_with_simple_index
+
+    if len(series) < 1:
+        request.applymarker(
+            pytest.mark.xfail(reason="Test doesn't make sense on empty data")
+        )
+
+    # bug brought up by #1079
+    # changed from TypeError in 0.17.0
+    series.iloc[0] = np.nan
+
+    # noinspection PyComparisonWithNone
+    result = series == None  # noqa: E711
+    assert not result.iat[0]
+    assert not result.iat[1]
+
+    # noinspection PyComparisonWithNone
+    result = series != None  # noqa: E711
+    assert result.iat[0]
+    assert result.iat[1]
+
+    result = None == series  # noqa: E711
+    assert not result.iat[0]
+    assert not result.iat[1]
+
+    result = None != series  # noqa: E711
+    assert result.iat[0]
+    assert result.iat[1]
+
+    if lib.is_np_dtype(series.dtype, "M") or isinstance(series.dtype, DatetimeTZDtype):
+        # Following DatetimeIndex (and Timestamp) convention,
+        # inequality comparisons with Series[datetime64] raise
+        msg = "Invalid comparison"
+        with pytest.raises(TypeError, match=msg):
+            None > series
+        with pytest.raises(TypeError, match=msg):
+            series > None
+    else:
+        result = None > series
+        assert not result.iat[0]
+        assert not result.iat[1]
+
+        result = series < None
+        assert not result.iat[0]
+        assert not result.iat[1]
+
+
+def test_series_varied_multiindex_alignment():
+    # GH 20414
+    s1 = Series(
+        range(8),
+        index=pd.MultiIndex.from_product(
+            [list("ab"), list("xy"), [1, 2]], names=["ab", "xy", "num"]
+        ),
+    )
+    s2 = Series(
+        [1000 * i for i in range(1, 5)],
+        index=pd.MultiIndex.from_product([list("xy"), [1, 2]], names=["xy", "num"]),
+    )
+    result = s1.loc[pd.IndexSlice[["a"], :, :]] + s2
+    expected = Series(
+        [1000, 2001, 3002, 4003],
+        index=pd.MultiIndex.from_tuples(
+            [("a", "x", 1), ("a", "x", 2), ("a", "y", 1), ("a", "y", 2)],
+            names=["ab", "xy", "num"],
+        ),
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_rmod_consistent_large_series():
+    # GH 29602
+    result = Series([2] * 10001).rmod(-1)
+    expected = Series([1] * 10001)
+
+    tm.assert_series_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_constructors.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..387be8398e4b281421317c844269fe45a10eb6bc
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_constructors.py
@@ -0,0 +1,2290 @@
+from collections import OrderedDict
+from collections.abc import Iterator
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+from dateutil.tz import tzoffset
+import numpy as np
+from numpy import ma
+import pytest
+
+from pandas._libs import (
+    iNaT,
+    lib,
+)
+from pandas.compat.numpy import np_version_gt2
+from pandas.errors import IntCastingNaNError
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    DatetimeTZDtype,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    NaT,
+    Period,
+    RangeIndex,
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    IntegerArray,
+    IntervalArray,
+    period_array,
+)
+from pandas.core.internals.blocks import NumpyBlock
+
+
+class TestSeriesConstructors:
+    def test_from_ints_with_non_nano_dt64_dtype(self, index_or_series):
+        values = np.arange(10)
+
+        res = index_or_series(values, dtype="M8[s]")
+        expected = index_or_series(values.astype("M8[s]"))
+        tm.assert_equal(res, expected)
+
+        res = index_or_series(list(values), dtype="M8[s]")
+        tm.assert_equal(res, expected)
+
+    def test_from_na_value_and_interval_of_datetime_dtype(self):
+        # GH#41805
+        ser = Series([None], dtype="interval[datetime64[ns]]")
+        assert ser.isna().all()
+        assert ser.dtype == "interval[datetime64[ns], right]"
+
+    def test_infer_with_date_and_datetime(self):
+        # GH#49341 pre-2.0 we inferred datetime-and-date to datetime64, which
+        #  was inconsistent with Index behavior
+        ts = Timestamp(2016, 1, 1)
+        vals = [ts.to_pydatetime(), ts.date()]
+
+        ser = Series(vals)
+        expected = Series(vals, dtype=object)
+        tm.assert_series_equal(ser, expected)
+
+        idx = Index(vals)
+        expected = Index(vals, dtype=object)
+        tm.assert_index_equal(idx, expected)
+
+    def test_unparsable_strings_with_dt64_dtype(self):
+        # pre-2.0 these would be silently ignored and come back with object dtype
+        vals = ["aa"]
+        msg = "^Unknown datetime string format, unable to parse: aa, at position 0$"
+        with pytest.raises(ValueError, match=msg):
+            Series(vals, dtype="datetime64[ns]")
+
+        with pytest.raises(ValueError, match=msg):
+            Series(np.array(vals, dtype=object), dtype="datetime64[ns]")
+
+    @pytest.mark.parametrize(
+        "constructor",
+        [
+            # NOTE: some overlap with test_constructor_empty but that test does not
+            # test for None or an empty generator.
+            # test_constructor_pass_none tests None but only with the index also
+            # passed.
+            (lambda idx: Series(index=idx)),
+            (lambda idx: Series(None, index=idx)),
+            (lambda idx: Series({}, index=idx)),
+            (lambda idx: Series((), index=idx)),
+            (lambda idx: Series([], index=idx)),
+            (lambda idx: Series((_ for _ in []), index=idx)),
+            (lambda idx: Series(data=None, index=idx)),
+            (lambda idx: Series(data={}, index=idx)),
+            (lambda idx: Series(data=(), index=idx)),
+            (lambda idx: Series(data=[], index=idx)),
+            (lambda idx: Series(data=(_ for _ in []), index=idx)),
+        ],
+    )
+    @pytest.mark.parametrize("empty_index", [None, []])
+    def test_empty_constructor(self, constructor, empty_index):
+        # GH 49573 (addition of empty_index parameter)
+        expected = Series(index=empty_index)
+        result = constructor(empty_index)
+
+        assert result.dtype == object
+        assert len(result.index) == 0
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+    def test_invalid_dtype(self):
+        # GH15520
+        msg = "not understood"
+        invalid_list = [Timestamp, "Timestamp", list]
+        for dtype in invalid_list:
+            with pytest.raises(TypeError, match=msg):
+                Series([], name="time", dtype=dtype)
+
+    def test_invalid_compound_dtype(self):
+        # GH#13296
+        c_dtype = np.dtype([("a", "i8"), ("b", "f4")])
+        cdt_arr = np.array([(1, 0.4), (256, -13)], dtype=c_dtype)
+
+        with pytest.raises(ValueError, match="Use DataFrame instead"):
+            Series(cdt_arr, index=["A", "B"])
+
+    def test_scalar_conversion(self):
+        # Pass in scalar is disabled
+        scalar = Series(0.5)
+        assert not isinstance(scalar, float)
+
+    def test_scalar_extension_dtype(self, ea_scalar_and_dtype):
+        # GH 28401
+
+        ea_scalar, ea_dtype = ea_scalar_and_dtype
+
+        ser = Series(ea_scalar, index=range(3))
+        expected = Series([ea_scalar] * 3, dtype=ea_dtype)
+
+        assert ser.dtype == ea_dtype
+        tm.assert_series_equal(ser, expected)
+
+    def test_constructor(self, datetime_series, using_infer_string):
+        empty_series = Series()
+        assert datetime_series.index._is_all_dates
+
+        # Pass in Series
+        derived = Series(datetime_series)
+        assert derived.index._is_all_dates
+
+        tm.assert_index_equal(derived.index, datetime_series.index)
+        # Ensure new index is not created
+        assert id(datetime_series.index) == id(derived.index)
+
+        # Mixed type Series
+        mixed = Series(["hello", np.nan], index=[0, 1])
+        assert mixed.dtype == np.object_ if not using_infer_string else "string"
+        assert np.isnan(mixed[1])
+
+        assert not empty_series.index._is_all_dates
+        assert not Series().index._is_all_dates
+
+        # exception raised is of type ValueError GH35744
+        with pytest.raises(
+            ValueError,
+            match=r"Data must be 1-dimensional, got ndarray of shape \(3, 3\) instead",
+        ):
+            Series(np.random.default_rng(2).standard_normal((3, 3)), index=np.arange(3))
+
+        mixed.name = "Series"
+        rs = Series(mixed).name
+        xp = "Series"
+        assert rs == xp
+
+        # raise on MultiIndex GH4187
+        m = MultiIndex.from_arrays([[1, 2], [3, 4]])
+        msg = "initializing a Series from a MultiIndex is not supported"
+        with pytest.raises(NotImplementedError, match=msg):
+            Series(m)
+
+    def test_constructor_index_ndim_gt_1_raises(self):
+        # GH#18579
+        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=[3, 6, 9])
+        with pytest.raises(ValueError, match="Index data must be 1-dimensional"):
+            Series([1, 3, 2], index=df)
+
+    @pytest.mark.parametrize("input_class", [list, dict, OrderedDict])
+    def test_constructor_empty(self, input_class, using_infer_string):
+        empty = Series()
+        empty2 = Series(input_class())
+
+        # these are Index() and RangeIndex() which don't compare type equal
+        # but are just .equals
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
+
+        # With explicit dtype:
+        empty = Series(dtype="float64")
+        empty2 = Series(input_class(), dtype="float64")
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
+
+        # GH 18515 : with dtype=category:
+        empty = Series(dtype="category")
+        empty2 = Series(input_class(), dtype="category")
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
+
+        if input_class is not list:
+            # With index:
+            empty = Series(index=range(10))
+            empty2 = Series(input_class(), index=range(10))
+            tm.assert_series_equal(empty, empty2)
+
+            # With index and dtype float64:
+            empty = Series(np.nan, index=range(10))
+            empty2 = Series(input_class(), index=range(10), dtype="float64")
+            tm.assert_series_equal(empty, empty2)
+
+            # GH 19853 : with empty string, index and dtype str
+            empty = Series("", dtype=str, index=range(3))
+            if using_infer_string:
+                empty2 = Series("", index=range(3), dtype=object)
+            else:
+                empty2 = Series("", index=range(3))
+            tm.assert_series_equal(empty, empty2)
+
+    @pytest.mark.parametrize("input_arg", [np.nan, float("nan")])
+    def test_constructor_nan(self, input_arg):
+        empty = Series(dtype="float64", index=range(10))
+        empty2 = Series(input_arg, index=range(10))
+
+        tm.assert_series_equal(empty, empty2, check_index_type=False)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        ["f8", "i8", "M8[ns]", "m8[ns]", "category", "object", "datetime64[ns, UTC]"],
+    )
+    @pytest.mark.parametrize("index", [None, Index([])])
+    def test_constructor_dtype_only(self, dtype, index):
+        # GH-20865
+        result = Series(dtype=dtype, index=index)
+        assert result.dtype == dtype
+        assert len(result) == 0
+
+    def test_constructor_no_data_index_order(self):
+        result = Series(index=["b", "a", "c"])
+        assert result.index.tolist() == ["b", "a", "c"]
+
+    def test_constructor_no_data_string_type(self):
+        # GH 22477
+        result = Series(index=[1], dtype=str)
+        assert np.isnan(result.iloc[0])
+
+    @pytest.mark.parametrize("item", ["entry", "ѐ", 13])
+    def test_constructor_string_element_string_type(self, item):
+        # GH 22477
+        result = Series(item, index=[1], dtype=str)
+        assert result.iloc[0] == str(item)
+
+    def test_constructor_dtype_str_na_values(self, string_dtype):
+        # https://github.com/pandas-dev/pandas/issues/21083
+        ser = Series(["x", None], dtype=string_dtype)
+        result = ser.isna()
+        expected = Series([False, True])
+        tm.assert_series_equal(result, expected)
+        assert ser.iloc[1] is None
+
+        ser = Series(["x", np.nan], dtype=string_dtype)
+        assert np.isnan(ser.iloc[1])
+
+    def test_constructor_series(self):
+        index1 = ["d", "b", "a", "c"]
+        index2 = sorted(index1)
+        s1 = Series([4, 7, -5, 3], index=index1)
+        s2 = Series(s1, index=index2)
+
+        tm.assert_series_equal(s2, s1.sort_index())
+
+    def test_constructor_iterable(self):
+        # GH 21987
+        class Iter:
+            def __iter__(self) -> Iterator:
+                yield from range(10)
+
+        expected = Series(list(range(10)), dtype="int64")
+        result = Series(Iter(), dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_sequence(self):
+        # GH 21987
+        expected = Series(list(range(10)), dtype="int64")
+        result = Series(range(10), dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_single_str(self):
+        # GH 21987
+        expected = Series(["abc"])
+        result = Series("abc")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_list_like(self):
+        # make sure that we are coercing different
+        # list-likes to standard dtypes and not
+        # platform specific
+        expected = Series([1, 2, 3], dtype="int64")
+        for obj in [[1, 2, 3], (1, 2, 3), np.array([1, 2, 3], dtype="int64")]:
+            result = Series(obj, index=[0, 1, 2])
+            tm.assert_series_equal(result, expected)
+
+    def test_constructor_boolean_index(self):
+        # GH#18579
+        s1 = Series([1, 2, 3], index=[4, 5, 6])
+
+        index = s1 == 2
+        result = Series([1, 3, 2], index=index)
+        expected = Series([1, 3, 2], index=[False, True, False])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["bool", "int32", "int64", "float64"])
+    def test_constructor_index_dtype(self, dtype):
+        # GH 17088
+
+        s = Series(Index([0, 2, 4]), dtype=dtype)
+        assert s.dtype == dtype
+
+    @pytest.mark.parametrize(
+        "input_vals",
+        [
+            ([1, 2]),
+            (["1", "2"]),
+            (list(date_range("1/1/2011", periods=2, freq="h"))),
+            (list(date_range("1/1/2011", periods=2, freq="h", tz="US/Eastern"))),
+            ([Interval(left=0, right=5)]),
+        ],
+    )
+    def test_constructor_list_str(self, input_vals, string_dtype):
+        # GH 16605
+        # Ensure that data elements from a list are converted to strings
+        # when dtype is str, 'str', or 'U'
+        result = Series(input_vals, dtype=string_dtype)
+        expected = Series(input_vals).astype(string_dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_list_str_na(self, string_dtype):
+        result = Series([1.0, 2.0, np.nan], dtype=string_dtype)
+        expected = Series(["1.0", "2.0", np.nan], dtype=object)
+        tm.assert_series_equal(result, expected)
+        assert np.isnan(result[2])
+
+    def test_constructor_generator(self):
+        gen = (i for i in range(10))
+
+        result = Series(gen)
+        exp = Series(range(10))
+        tm.assert_series_equal(result, exp)
+
+        # same but with non-default index
+        gen = (i for i in range(10))
+        result = Series(gen, index=range(10, 20))
+        exp.index = range(10, 20)
+        tm.assert_series_equal(result, exp)
+
+    def test_constructor_map(self):
+        # GH8909
+        m = (x for x in range(10))
+
+        result = Series(m)
+        exp = Series(range(10))
+        tm.assert_series_equal(result, exp)
+
+        # same but with non-default index
+        m = (x for x in range(10))
+        result = Series(m, index=range(10, 20))
+        exp.index = range(10, 20)
+        tm.assert_series_equal(result, exp)
+
+    def test_constructor_categorical(self):
+        cat = Categorical([0, 1, 2, 0, 1, 2], ["a", "b", "c"])
+        res = Series(cat)
+        tm.assert_categorical_equal(res.values, cat)
+
+        # can cast to a new dtype
+        result = Series(Categorical([1, 2, 3]), dtype="int64")
+        expected = Series([1, 2, 3], dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_construct_from_categorical_with_dtype(self):
+        # GH12574
+        ser = Series(Categorical([1, 2, 3]), dtype="category")
+        assert isinstance(ser.dtype, CategoricalDtype)
+
+    def test_construct_intlist_values_category_dtype(self):
+        ser = Series([1, 2, 3], dtype="category")
+        assert isinstance(ser.dtype, CategoricalDtype)
+
+    def test_constructor_categorical_with_coercion(self):
+        factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"])
+        # test basic creation / coercion of categoricals
+        s = Series(factor, name="A")
+        assert s.dtype == "category"
+        assert len(s) == len(factor)
+
+        # in a frame
+        df = DataFrame({"A": factor})
+        result = df["A"]
+        tm.assert_series_equal(result, s)
+        result = df.iloc[:, 0]
+        tm.assert_series_equal(result, s)
+        assert len(df) == len(factor)
+
+        df = DataFrame({"A": s})
+        result = df["A"]
+        tm.assert_series_equal(result, s)
+        assert len(df) == len(factor)
+
+        # multiples
+        df = DataFrame({"A": s, "B": s, "C": 1})
+        result1 = df["A"]
+        result2 = df["B"]
+        tm.assert_series_equal(result1, s)
+        tm.assert_series_equal(result2, s, check_names=False)
+        assert result2.name == "B"
+        assert len(df) == len(factor)
+
+    def test_constructor_categorical_with_coercion2(self):
+        # GH8623
+        x = DataFrame(
+            [[1, "John P. Doe"], [2, "Jane Dove"], [1, "John P. Doe"]],
+            columns=["person_id", "person_name"],
+        )
+        x["person_name"] = Categorical(x.person_name)  # doing this breaks transform
+
+        expected = x.iloc[0].person_name
+        result = x.person_name.iloc[0]
+        assert result == expected
+
+        result = x.person_name[0]
+        assert result == expected
+
+        result = x.person_name.loc[0]
+        assert result == expected
+
+    def test_constructor_series_to_categorical(self):
+        # see GH#16524: test conversion of Series to Categorical
+        series = Series(["a", "b", "c"])
+
+        result = Series(series, dtype="category")
+        expected = Series(["a", "b", "c"], dtype="category")
+
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_categorical_dtype(self):
+        result = Series(
+            ["a", "b"], dtype=CategoricalDtype(["a", "b", "c"], ordered=True)
+        )
+        assert isinstance(result.dtype, CategoricalDtype)
+        tm.assert_index_equal(result.cat.categories, Index(["a", "b", "c"]))
+        assert result.cat.ordered
+
+        result = Series(["a", "b"], dtype=CategoricalDtype(["b", "a"]))
+        assert isinstance(result.dtype, CategoricalDtype)
+        tm.assert_index_equal(result.cat.categories, Index(["b", "a"]))
+        assert result.cat.ordered is False
+
+        # GH 19565 - Check broadcasting of scalar with Categorical dtype
+        result = Series(
+            "a", index=[0, 1], dtype=CategoricalDtype(["a", "b"], ordered=True)
+        )
+        expected = Series(
+            ["a", "a"], index=[0, 1], dtype=CategoricalDtype(["a", "b"], ordered=True)
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_categorical_string(self):
+        # GH 26336: the string 'category' maintains existing CategoricalDtype
+        cdt = CategoricalDtype(categories=list("dabc"), ordered=True)
+        expected = Series(list("abcabc"), dtype=cdt)
+
+        # Series(Categorical, dtype='category') keeps existing dtype
+        cat = Categorical(list("abcabc"), dtype=cdt)
+        result = Series(cat, dtype="category")
+        tm.assert_series_equal(result, expected)
+
+        # Series(Series[Categorical], dtype='category') keeps existing dtype
+        result = Series(result, dtype="category")
+        tm.assert_series_equal(result, expected)
+
+    def test_categorical_sideeffects_free(self):
+        # Passing a categorical to a Series and then changing values in either
+        # the series or the categorical should not change the values in the
+        # other one, IF you specify copy!
+        cat = Categorical(["a", "b", "c", "a"])
+        s = Series(cat, copy=True)
+        assert s.cat is not cat
+        s = s.cat.rename_categories([1, 2, 3])
+        exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
+        exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_)
+        tm.assert_numpy_array_equal(s.__array__(), exp_s)
+        tm.assert_numpy_array_equal(cat.__array__(), exp_cat)
+
+        # setting
+        s[0] = 2
+        exp_s2 = np.array([2, 2, 3, 1], dtype=np.int64)
+        tm.assert_numpy_array_equal(s.__array__(), exp_s2)
+        tm.assert_numpy_array_equal(cat.__array__(), exp_cat)
+
+        # however, copy is False by default
+        # so this WILL change values
+        cat = Categorical(["a", "b", "c", "a"])
+        s = Series(cat, copy=False)
+        assert s.values is cat
+        s = s.cat.rename_categories([1, 2, 3])
+        assert s.values is not cat
+        exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
+        tm.assert_numpy_array_equal(s.__array__(), exp_s)
+
+        s[0] = 2
+        exp_s2 = np.array([2, 2, 3, 1], dtype=np.int64)
+        tm.assert_numpy_array_equal(s.__array__(), exp_s2)
+
+    def test_unordered_compare_equal(self):
+        left = Series(["a", "b", "c"], dtype=CategoricalDtype(["a", "b"]))
+        right = Series(Categorical(["a", "b", np.nan], categories=["a", "b"]))
+        tm.assert_series_equal(left, right)
+
+    def test_constructor_maskedarray(self):
+        data = ma.masked_all((3,), dtype=float)
+        result = Series(data)
+        expected = Series([np.nan, np.nan, np.nan])
+        tm.assert_series_equal(result, expected)
+
+        data[0] = 0.0
+        data[2] = 2.0
+        index = ["a", "b", "c"]
+        result = Series(data, index=index)
+        expected = Series([0.0, np.nan, 2.0], index=index)
+        tm.assert_series_equal(result, expected)
+
+        data[1] = 1.0
+        result = Series(data, index=index)
+        expected = Series([0.0, 1.0, 2.0], index=index)
+        tm.assert_series_equal(result, expected)
+
+        data = ma.masked_all((3,), dtype=int)
+        result = Series(data)
+        expected = Series([np.nan, np.nan, np.nan], dtype=float)
+        tm.assert_series_equal(result, expected)
+
+        data[0] = 0
+        data[2] = 2
+        index = ["a", "b", "c"]
+        result = Series(data, index=index)
+        expected = Series([0, np.nan, 2], index=index, dtype=float)
+        tm.assert_series_equal(result, expected)
+
+        data[1] = 1
+        result = Series(data, index=index)
+        expected = Series([0, 1, 2], index=index, dtype=int)
+        with pytest.raises(AssertionError, match="Series classes are different"):
+            # TODO should this be raising at all?
+            # https://github.com/pandas-dev/pandas/issues/56131
+            tm.assert_series_equal(result, expected)
+
+        data = ma.masked_all((3,), dtype=bool)
+        result = Series(data)
+        expected = Series([np.nan, np.nan, np.nan], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        data[0] = True
+        data[2] = False
+        index = ["a", "b", "c"]
+        result = Series(data, index=index)
+        expected = Series([True, np.nan, False], index=index, dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        data[1] = True
+        result = Series(data, index=index)
+        expected = Series([True, True, False], index=index, dtype=bool)
+        with pytest.raises(AssertionError, match="Series classes are different"):
+            # TODO should this be raising at all?
+            # https://github.com/pandas-dev/pandas/issues/56131
+            tm.assert_series_equal(result, expected)
+
+        data = ma.masked_all((3,), dtype="M8[ns]")
+        result = Series(data)
+        expected = Series([iNaT, iNaT, iNaT], dtype="M8[ns]")
+        tm.assert_series_equal(result, expected)
+
+        data[0] = datetime(2001, 1, 1)
+        data[2] = datetime(2001, 1, 3)
+        index = ["a", "b", "c"]
+        result = Series(data, index=index)
+        expected = Series(
+            [datetime(2001, 1, 1), iNaT, datetime(2001, 1, 3)],
+            index=index,
+            dtype="M8[ns]",
+        )
+        tm.assert_series_equal(result, expected)
+
+        data[1] = datetime(2001, 1, 2)
+        result = Series(data, index=index)
+        expected = Series(
+            [datetime(2001, 1, 1), datetime(2001, 1, 2), datetime(2001, 1, 3)],
+            index=index,
+            dtype="M8[ns]",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_maskedarray_hardened(self):
+        # Check numpy masked arrays with hard masks -- from GH24574
+        data = ma.masked_all((3,), dtype=float).harden_mask()
+        result = Series(data)
+        expected = Series([np.nan, np.nan, np.nan])
+        tm.assert_series_equal(result, expected)
+
+    def test_series_ctor_plus_datetimeindex(self, using_copy_on_write):
+        rng = date_range("20090415", "20090519", freq="B")
+        data = {k: 1 for k in rng}
+
+        result = Series(data, index=rng)
+        if using_copy_on_write:
+            assert result.index.is_(rng)
+        else:
+            assert result.index is rng
+
+    def test_constructor_default_index(self):
+        s = Series([0, 1, 2])
+        tm.assert_index_equal(s.index, Index(range(3)), exact=True)
+
+    @pytest.mark.parametrize(
+        "input",
+        [
+            [1, 2, 3],
+            (1, 2, 3),
+            list(range(3)),
+            Categorical(["a", "b", "a"]),
+            (i for i in range(3)),
+            (x for x in range(3)),
+        ],
+    )
+    def test_constructor_index_mismatch(self, input):
+        # GH 19342
+        # test that construction of a Series with an index of different length
+        # raises an error
+        msg = r"Length of values \(3\) does not match length of index \(4\)"
+        with pytest.raises(ValueError, match=msg):
+            Series(input, index=np.arange(4))
+
+    def test_constructor_numpy_scalar(self):
+        # GH 19342
+        # construction with a numpy scalar
+        # should not raise
+        result = Series(np.array(100), index=np.arange(4), dtype="int64")
+        expected = Series(100, index=np.arange(4), dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_broadcast_list(self):
+        # GH 19342
+        # construction with single-element container and index
+        # should raise
+        msg = r"Length of values \(1\) does not match length of index \(3\)"
+        with pytest.raises(ValueError, match=msg):
+            Series(["foo"], index=["a", "b", "c"])
+
+    def test_constructor_corner(self):
+        df = DataFrame(range(5), index=date_range("2020-01-01", periods=5))
+        objs = [df, df]
+        s = Series(objs, index=[0, 1])
+        assert isinstance(s, Series)
+
+    def test_constructor_sanitize(self):
+        s = Series(np.array([1.0, 1.0, 8.0]), dtype="i8")
+        assert s.dtype == np.dtype("i8")
+
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(IntCastingNaNError, match=msg):
+            Series(np.array([1.0, 1.0, np.nan]), copy=True, dtype="i8")
+
+    def test_constructor_copy(self):
+        # GH15125
+        # test dtype parameter has no side effects on copy=True
+        for data in [[1.0], np.array([1.0])]:
+            x = Series(data)
+            y = Series(x, copy=True, dtype=float)
+
+            # copy=True maintains original data in Series
+            tm.assert_series_equal(x, y)
+
+            # changes to origin of copy does not affect the copy
+            x[0] = 2.0
+            assert not x.equals(y)
+            assert x[0] == 2.0
+            assert y[0] == 1.0
+
+    @td.skip_array_manager_invalid_test  # TODO(ArrayManager) rewrite test
+    @pytest.mark.parametrize(
+        "index",
+        [
+            date_range("20170101", periods=3, tz="US/Eastern"),
+            date_range("20170101", periods=3),
+            timedelta_range("1 day", periods=3),
+            period_range("2012Q1", periods=3, freq="Q"),
+            Index(list("abc")),
+            Index([1, 2, 3]),
+            RangeIndex(0, 3),
+        ],
+        ids=lambda x: type(x).__name__,
+    )
+    def test_constructor_limit_copies(self, index):
+        # GH 17449
+        # limit copies of input
+        s = Series(index)
+
+        # we make 1 copy; this is just a smoke test here
+        assert s._mgr.blocks[0].values is not index
+
+    def test_constructor_shallow_copy(self):
+        # constructing a Series from Series with copy=False should still
+        # give a "shallow" copy (share data, not attributes)
+        # https://github.com/pandas-dev/pandas/issues/49523
+        s = Series([1, 2, 3])
+        s_orig = s.copy()
+        s2 = Series(s)
+        assert s2._mgr is not s._mgr
+        # Overwriting index of s2 doesn't change s
+        s2.index = ["a", "b", "c"]
+        tm.assert_series_equal(s, s_orig)
+
+    def test_constructor_pass_none(self):
+        s = Series(None, index=range(5))
+        assert s.dtype == np.float64
+
+        s = Series(None, index=range(5), dtype=object)
+        assert s.dtype == np.object_
+
+        # GH 7431
+        # inference on the index
+        s = Series(index=np.array([None]))
+        expected = Series(index=Index([None]))
+        tm.assert_series_equal(s, expected)
+
+    def test_constructor_pass_nan_nat(self):
+        # GH 13467
+        exp = Series([np.nan, np.nan], dtype=np.float64)
+        assert exp.dtype == np.float64
+        tm.assert_series_equal(Series([np.nan, np.nan]), exp)
+        tm.assert_series_equal(Series(np.array([np.nan, np.nan])), exp)
+
+        exp = Series([NaT, NaT])
+        assert exp.dtype == "datetime64[ns]"
+        tm.assert_series_equal(Series([NaT, NaT]), exp)
+        tm.assert_series_equal(Series(np.array([NaT, NaT])), exp)
+
+        tm.assert_series_equal(Series([NaT, np.nan]), exp)
+        tm.assert_series_equal(Series(np.array([NaT, np.nan])), exp)
+
+        tm.assert_series_equal(Series([np.nan, NaT]), exp)
+        tm.assert_series_equal(Series(np.array([np.nan, NaT])), exp)
+
+    def test_constructor_cast(self):
+        msg = "could not convert string to float"
+        with pytest.raises(ValueError, match=msg):
+            Series(["a", "b", "c"], dtype=float)
+
+    def test_constructor_signed_int_overflow_raises(self):
+        # GH#41734 disallow silent overflow, enforced in 2.0
+        if np_version_gt2:
+            msg = "The elements provided in the data cannot all be casted to the dtype"
+            err = OverflowError
+        else:
+            msg = "Values are too large to be losslessly converted"
+            err = ValueError
+        with pytest.raises(err, match=msg):
+            Series([1, 200, 923442], dtype="int8")
+
+        with pytest.raises(err, match=msg):
+            Series([1, 200, 923442], dtype="uint8")
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            np.array([1], dtype=np.uint16),
+            np.array([1], dtype=np.uint32),
+            np.array([1], dtype=np.uint64),
+            [np.uint16(1)],
+            [np.uint32(1)],
+            [np.uint64(1)],
+        ],
+    )
+    def test_constructor_numpy_uints(self, values):
+        # GH#47294
+        value = values[0]
+        result = Series(values)
+
+        assert result[0].dtype == value.dtype
+        assert result[0] == value
+
+    def test_constructor_unsigned_dtype_overflow(self, any_unsigned_int_numpy_dtype):
+        # see gh-15832
+        if np_version_gt2:
+            msg = (
+                f"The elements provided in the data cannot "
+                f"all be casted to the dtype {any_unsigned_int_numpy_dtype}"
+            )
+        else:
+            msg = "Trying to coerce negative values to unsigned integers"
+        with pytest.raises(OverflowError, match=msg):
+            Series([-1], dtype=any_unsigned_int_numpy_dtype)
+
+    def test_constructor_floating_data_int_dtype(self, frame_or_series):
+        # GH#40110
+        arr = np.random.default_rng(2).standard_normal(2)
+
+        # Long-standing behavior (for Series, new in 2.0 for DataFrame)
+        #  has been to ignore the dtype on these;
+        #  not clear if this is what we want long-term
+        # expected = frame_or_series(arr)
+
+        # GH#49599 as of 2.0 we raise instead of silently retaining float dtype
+        msg = "Trying to coerce float values to integer"
+        with pytest.raises(ValueError, match=msg):
+            frame_or_series(arr, dtype="i8")
+
+        with pytest.raises(ValueError, match=msg):
+            frame_or_series(list(arr), dtype="i8")
+
+        # pre-2.0, when we had NaNs, we silently ignored the integer dtype
+        arr[0] = np.nan
+        # expected = frame_or_series(arr)
+
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(IntCastingNaNError, match=msg):
+            frame_or_series(arr, dtype="i8")
+
+        exc = IntCastingNaNError
+        if frame_or_series is Series:
+            # TODO: try to align these
+            exc = ValueError
+            msg = "cannot convert float NaN to integer"
+        with pytest.raises(exc, match=msg):
+            # same behavior if we pass list instead of the ndarray
+            frame_or_series(list(arr), dtype="i8")
+
+        # float array that can be losslessly cast to integers
+        arr = np.array([1.0, 2.0], dtype="float64")
+        expected = frame_or_series(arr.astype("i8"))
+
+        obj = frame_or_series(arr, dtype="i8")
+        tm.assert_equal(obj, expected)
+
+        obj = frame_or_series(list(arr), dtype="i8")
+        tm.assert_equal(obj, expected)
+
+    def test_constructor_coerce_float_fail(self, any_int_numpy_dtype):
+        # see gh-15832
+        # Updated: make sure we treat this list the same as we would treat
+        #  the equivalent ndarray
+        # GH#49599 pre-2.0 we silently retained float dtype, in 2.0 we raise
+        vals = [1, 2, 3.5]
+
+        msg = "Trying to coerce float values to integer"
+        with pytest.raises(ValueError, match=msg):
+            Series(vals, dtype=any_int_numpy_dtype)
+        with pytest.raises(ValueError, match=msg):
+            Series(np.array(vals), dtype=any_int_numpy_dtype)
+
+    def test_constructor_coerce_float_valid(self, float_numpy_dtype):
+        s = Series([1, 2, 3.5], dtype=float_numpy_dtype)
+        expected = Series([1, 2, 3.5]).astype(float_numpy_dtype)
+        tm.assert_series_equal(s, expected)
+
+    def test_constructor_invalid_coerce_ints_with_float_nan(self, any_int_numpy_dtype):
+        # GH 22585
+        # Updated: make sure we treat this list the same as we would treat the
+        # equivalent ndarray
+        vals = [1, 2, np.nan]
+        # pre-2.0 this would return with a float dtype, in 2.0 we raise
+
+        msg = "cannot convert float NaN to integer"
+        with pytest.raises(ValueError, match=msg):
+            Series(vals, dtype=any_int_numpy_dtype)
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(IntCastingNaNError, match=msg):
+            Series(np.array(vals), dtype=any_int_numpy_dtype)
+
+    def test_constructor_dtype_no_cast(self, using_copy_on_write, warn_copy_on_write):
+        # see gh-1572
+        s = Series([1, 2, 3])
+        s2 = Series(s, dtype=np.int64)
+
+        warn = FutureWarning if warn_copy_on_write else None
+        with tm.assert_produces_warning(warn):
+            s2[1] = 5
+        if using_copy_on_write:
+            assert s[1] == 2
+        else:
+            assert s[1] == 5
+
+    def test_constructor_datelike_coercion(self):
+        # GH 9477
+        # incorrectly inferring on dateimelike looking when object dtype is
+        # specified
+        s = Series([Timestamp("20130101"), "NOV"], dtype=object)
+        assert s.iloc[0] == Timestamp("20130101")
+        assert s.iloc[1] == "NOV"
+        assert s.dtype == object
+
+    def test_constructor_datelike_coercion2(self):
+        # the dtype was being reset on the slicing and re-inferred to datetime
+        # even thought the blocks are mixed
+        belly = "216 3T19".split()
+        wing1 = "2T15 4H19".split()
+        wing2 = "416 4T20".split()
+        mat = pd.to_datetime("2016-01-22 2019-09-07".split())
+        df = DataFrame({"wing1": wing1, "wing2": wing2, "mat": mat}, index=belly)
+
+        result = df.loc["3T19"]
+        assert result.dtype == object
+        result = df.loc["216"]
+        assert result.dtype == object
+
+    def test_constructor_mixed_int_and_timestamp(self, frame_or_series):
+        # specifically Timestamp with nanos, not datetimes
+        objs = [Timestamp(9), 10, NaT._value]
+        result = frame_or_series(objs, dtype="M8[ns]")
+
+        expected = frame_or_series([Timestamp(9), Timestamp(10), NaT])
+        tm.assert_equal(result, expected)
+
+    def test_constructor_datetimes_with_nulls(self):
+        # gh-15869
+        for arr in [
+            np.array([None, None, None, None, datetime.now(), None]),
+            np.array([None, None, datetime.now(), None]),
+        ]:
+            result = Series(arr)
+            assert result.dtype == "M8[ns]"
+
+    def test_constructor_dtype_datetime64(self):
+        s = Series(iNaT, dtype="M8[ns]", index=range(5))
+        assert isna(s).all()
+
+        # in theory this should be all nulls, but since
+        # we are not specifying a dtype is ambiguous
+        s = Series(iNaT, index=range(5))
+        assert not isna(s).all()
+
+        s = Series(np.nan, dtype="M8[ns]", index=range(5))
+        assert isna(s).all()
+
+        s = Series([datetime(2001, 1, 2, 0, 0), iNaT], dtype="M8[ns]")
+        assert isna(s[1])
+        assert s.dtype == "M8[ns]"
+
+        s = Series([datetime(2001, 1, 2, 0, 0), np.nan], dtype="M8[ns]")
+        assert isna(s[1])
+        assert s.dtype == "M8[ns]"
+
+    def test_constructor_dtype_datetime64_10(self):
+        # GH3416
+        pydates = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3)]
+        dates = [np.datetime64(x) for x in pydates]
+
+        ser = Series(dates)
+        assert ser.dtype == "M8[ns]"
+
+        ser.iloc[0] = np.nan
+        assert ser.dtype == "M8[ns]"
+
+        # GH3414 related
+        expected = Series(pydates, dtype="datetime64[ms]")
+
+        result = Series(Series(dates).astype(np.int64) / 1000000, dtype="M8[ms]")
+        tm.assert_series_equal(result, expected)
+
+        result = Series(dates, dtype="datetime64[ms]")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(
+            [NaT, datetime(2013, 1, 2), datetime(2013, 1, 3)], dtype="datetime64[ns]"
+        )
+        result = Series([np.nan] + dates[1:], dtype="datetime64[ns]")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dtype_datetime64_11(self):
+        pydates = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3)]
+        dates = [np.datetime64(x) for x in pydates]
+
+        dts = Series(dates, dtype="datetime64[ns]")
+
+        # valid astype
+        dts.astype("int64")
+
+        # invalid casting
+        msg = r"Converting from datetime64\[ns\] to int32 is not supported"
+        with pytest.raises(TypeError, match=msg):
+            dts.astype("int32")
+
+        # ints are ok
+        # we test with np.int64 to get similar results on
+        # windows / 32-bit platforms
+        result = Series(dts, dtype=np.int64)
+        expected = Series(dts.astype(np.int64))
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dtype_datetime64_9(self):
+        # invalid dates can be help as object
+        result = Series([datetime(2, 1, 1)])
+        assert result[0] == datetime(2, 1, 1, 0, 0)
+
+        result = Series([datetime(3000, 1, 1)])
+        assert result[0] == datetime(3000, 1, 1, 0, 0)
+
+    def test_constructor_dtype_datetime64_8(self):
+        # don't mix types
+        result = Series([Timestamp("20130101"), 1], index=["a", "b"])
+        assert result["a"] == Timestamp("20130101")
+        assert result["b"] == 1
+
+    def test_constructor_dtype_datetime64_7(self):
+        # GH6529
+        # coerce datetime64 non-ns properly
+        dates = date_range("01-Jan-2015", "01-Dec-2015", freq="ME")
+        values2 = dates.view(np.ndarray).astype("datetime64[ns]")
+        expected = Series(values2, index=dates)
+
+        for unit in ["s", "D", "ms", "us", "ns"]:
+            dtype = np.dtype(f"M8[{unit}]")
+            values1 = dates.view(np.ndarray).astype(dtype)
+            result = Series(values1, dates)
+            if unit == "D":
+                # for unit="D" we cast to nearest-supported reso, i.e. "s"
+                dtype = np.dtype("M8[s]")
+            assert result.dtype == dtype
+            tm.assert_series_equal(result, expected.astype(dtype))
+
+        # GH 13876
+        # coerce to non-ns to object properly
+        expected = Series(values2, index=dates, dtype=object)
+        for dtype in ["s", "D", "ms", "us", "ns"]:
+            values1 = dates.view(np.ndarray).astype(f"M8[{dtype}]")
+            result = Series(values1, index=dates, dtype=object)
+            tm.assert_series_equal(result, expected)
+
+        # leave datetime.date alone
+        dates2 = np.array([d.date() for d in dates.to_pydatetime()], dtype=object)
+        series1 = Series(dates2, dates)
+        tm.assert_numpy_array_equal(series1.values, dates2)
+        assert series1.dtype == object
+
+    def test_constructor_dtype_datetime64_6(self):
+        # as of 2.0, these no longer infer datetime64 based on the strings,
+        #  matching the Index behavior
+
+        ser = Series([None, NaT, "2013-08-05 15:30:00.000001"])
+        assert ser.dtype == object
+
+        ser = Series([np.nan, NaT, "2013-08-05 15:30:00.000001"])
+        assert ser.dtype == object
+
+        ser = Series([NaT, None, "2013-08-05 15:30:00.000001"])
+        assert ser.dtype == object
+
+        ser = Series([NaT, np.nan, "2013-08-05 15:30:00.000001"])
+        assert ser.dtype == object
+
+    def test_constructor_dtype_datetime64_5(self):
+        # tz-aware (UTC and other tz's)
+        # GH 8411
+        dr = date_range("20130101", periods=3)
+        assert Series(dr).iloc[0].tz is None
+        dr = date_range("20130101", periods=3, tz="UTC")
+        assert str(Series(dr).iloc[0].tz) == "UTC"
+        dr = date_range("20130101", periods=3, tz="US/Eastern")
+        assert str(Series(dr).iloc[0].tz) == "US/Eastern"
+
+    def test_constructor_dtype_datetime64_4(self):
+        # non-convertible
+        ser = Series([1479596223000, -1479590, NaT])
+        assert ser.dtype == "object"
+        assert ser[2] is NaT
+        assert "NaT" in str(ser)
+
+    def test_constructor_dtype_datetime64_3(self):
+        # if we passed a NaT it remains
+        ser = Series([datetime(2010, 1, 1), datetime(2, 1, 1), NaT])
+        assert ser.dtype == "object"
+        assert ser[2] is NaT
+        assert "NaT" in str(ser)
+
+    def test_constructor_dtype_datetime64_2(self):
+        # if we passed a nan it remains
+        ser = Series([datetime(2010, 1, 1), datetime(2, 1, 1), np.nan])
+        assert ser.dtype == "object"
+        assert ser[2] is np.nan
+        assert "NaN" in str(ser)
+
+    def test_constructor_with_datetime_tz(self):
+        # 8260
+        # support datetime64 with tz
+
+        dr = date_range("20130101", periods=3, tz="US/Eastern")
+        s = Series(dr)
+        assert s.dtype.name == "datetime64[ns, US/Eastern]"
+        assert s.dtype == "datetime64[ns, US/Eastern]"
+        assert isinstance(s.dtype, DatetimeTZDtype)
+        assert "datetime64[ns, US/Eastern]" in str(s)
+
+        # export
+        result = s.values
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == "datetime64[ns]"
+
+        exp = DatetimeIndex(result)
+        exp = exp.tz_localize("UTC").tz_convert(tz=s.dt.tz)
+        tm.assert_index_equal(dr, exp)
+
+        # indexing
+        result = s.iloc[0]
+        assert result == Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern")
+        result = s[0]
+        assert result == Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern")
+
+        result = s[Series([True, True, False], index=s.index)]
+        tm.assert_series_equal(result, s[0:2])
+
+        result = s.iloc[0:1]
+        tm.assert_series_equal(result, Series(dr[0:1]))
+
+        # concat
+        result = pd.concat([s.iloc[0:1], s.iloc[1:]])
+        tm.assert_series_equal(result, s)
+
+        # short str
+        assert "datetime64[ns, US/Eastern]" in str(s)
+
+        # formatting with NaT
+        result = s.shift()
+        assert "datetime64[ns, US/Eastern]" in str(result)
+        assert "NaT" in str(result)
+
+        result = DatetimeIndex(s, freq="infer")
+        tm.assert_index_equal(result, dr)
+
+    def test_constructor_with_datetime_tz5(self):
+        # long str
+        ser = Series(date_range("20130101", periods=1000, tz="US/Eastern"))
+        assert "datetime64[ns, US/Eastern]" in str(ser)
+
+    def test_constructor_with_datetime_tz4(self):
+        # inference
+        ser = Series(
+            [
+                Timestamp("2013-01-01 13:00:00-0800", tz="US/Pacific"),
+                Timestamp("2013-01-02 14:00:00-0800", tz="US/Pacific"),
+            ]
+        )
+        assert ser.dtype == "datetime64[ns, US/Pacific]"
+        assert lib.infer_dtype(ser, skipna=True) == "datetime64"
+
+    def test_constructor_with_datetime_tz3(self):
+        ser = Series(
+            [
+                Timestamp("2013-01-01 13:00:00-0800", tz="US/Pacific"),
+                Timestamp("2013-01-02 14:00:00-0800", tz="US/Eastern"),
+            ]
+        )
+        assert ser.dtype == "object"
+        assert lib.infer_dtype(ser, skipna=True) == "datetime"
+
+    def test_constructor_with_datetime_tz2(self):
+        # with all NaT
+        ser = Series(NaT, index=[0, 1], dtype="datetime64[ns, US/Eastern]")
+        dti = DatetimeIndex(["NaT", "NaT"], tz="US/Eastern").as_unit("ns")
+        expected = Series(dti)
+        tm.assert_series_equal(ser, expected)
+
+    def test_constructor_no_partial_datetime_casting(self):
+        # GH#40111
+        vals = [
+            "nan",
+            Timestamp("1990-01-01"),
+            "2015-03-14T16:15:14.123-08:00",
+            "2019-03-04T21:56:32.620-07:00",
+            None,
+        ]
+        ser = Series(vals)
+        assert all(ser[i] is vals[i] for i in range(len(vals)))
+
+    @pytest.mark.parametrize("arr_dtype", [np.int64, np.float64])
+    @pytest.mark.parametrize("kind", ["M", "m"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_construction_to_datetimelike_unit(self, arr_dtype, kind, unit):
+        # tests all units
+        # gh-19223
+        # TODO: GH#19223 was about .astype, doesn't belong here
+        dtype = f"{kind}8[{unit}]"
+        arr = np.array([1, 2, 3], dtype=arr_dtype)
+        ser = Series(arr)
+        result = ser.astype(dtype)
+
+        expected = Series(arr.astype(dtype))
+
+        if unit in ["ns", "us", "ms", "s"]:
+            assert result.dtype == dtype
+            assert expected.dtype == dtype
+        else:
+            # Otherwise we cast to nearest-supported unit, i.e. seconds
+            assert result.dtype == f"{kind}8[s]"
+            assert expected.dtype == f"{kind}8[s]"
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("arg", ["2013-01-01 00:00:00", NaT, np.nan, None])
+    def test_constructor_with_naive_string_and_datetimetz_dtype(self, arg):
+        # GH 17415: With naive string
+        result = Series([arg], dtype="datetime64[ns, CET]")
+        expected = Series(Timestamp(arg)).dt.tz_localize("CET")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_datetime64_bigendian(self):
+        # GH#30976
+        ms = np.datetime64(1, "ms")
+        arr = np.array([np.datetime64(1, "ms")], dtype=">M8[ms]")
+
+        result = Series(arr)
+        expected = Series([Timestamp(ms)]).astype("M8[ms]")
+        assert expected.dtype == "M8[ms]"
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("interval_constructor", [IntervalIndex, IntervalArray])
+    def test_construction_interval(self, interval_constructor):
+        # construction from interval & array of intervals
+        intervals = interval_constructor.from_breaks(np.arange(3), closed="right")
+        result = Series(intervals)
+        assert result.dtype == "interval[int64, right]"
+        tm.assert_index_equal(Index(result.values), Index(intervals))
+
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_infer_interval(self, data_constructor):
+        # GH 23563: consistent closed results in interval dtype
+        data = [Interval(0, 1), Interval(0, 2), None]
+        result = Series(data_constructor(data))
+        expected = Series(IntervalArray(data))
+        assert result.dtype == "interval[float64, right]"
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_interval_mixed_closed(self, data_constructor):
+        # GH 23563: mixed closed results in object dtype (not interval dtype)
+        data = [Interval(0, 1, closed="both"), Interval(0, 2, closed="neither")]
+        result = Series(data_constructor(data))
+        assert result.dtype == object
+        assert result.tolist() == data
+
+    def test_construction_consistency(self):
+        # make sure that we are not re-localizing upon construction
+        # GH 14928
+        ser = Series(date_range("20130101", periods=3, tz="US/Eastern"))
+
+        result = Series(ser, dtype=ser.dtype)
+        tm.assert_series_equal(result, ser)
+
+        result = Series(ser.dt.tz_convert("UTC"), dtype=ser.dtype)
+        tm.assert_series_equal(result, ser)
+
+        # Pre-2.0 dt64 values were treated as utc, which was inconsistent
+        #  with DatetimeIndex, which treats them as wall times, see GH#33401
+        result = Series(ser.values, dtype=ser.dtype)
+        expected = Series(ser.values).dt.tz_localize(ser.dtype.tz)
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(None):
+            # one suggested alternative to the deprecated (changed in 2.0) usage
+            middle = Series(ser.values).dt.tz_localize("UTC")
+            result = middle.dt.tz_convert(ser.dtype.tz)
+        tm.assert_series_equal(result, ser)
+
+        with tm.assert_produces_warning(None):
+            # the other suggested alternative to the deprecated usage
+            result = Series(ser.values.view("int64"), dtype=ser.dtype)
+        tm.assert_series_equal(result, ser)
+
+    @pytest.mark.parametrize(
+        "data_constructor", [list, np.array], ids=["list", "ndarray[object]"]
+    )
+    def test_constructor_infer_period(self, data_constructor):
+        data = [Period("2000", "D"), Period("2001", "D"), None]
+        result = Series(data_constructor(data))
+        expected = Series(period_array(data))
+        tm.assert_series_equal(result, expected)
+        assert result.dtype == "Period[D]"
+
+    @pytest.mark.xfail(reason="PeriodDtype Series not supported yet")
+    def test_construct_from_ints_including_iNaT_scalar_period_dtype(self):
+        series = Series([0, 1000, 2000, pd._libs.iNaT], dtype="period[D]")
+
+        val = series[3]
+        assert isna(val)
+
+        series[2] = val
+        assert isna(series[2])
+
+    def test_constructor_period_incompatible_frequency(self):
+        data = [Period("2000", "D"), Period("2001", "Y")]
+        result = Series(data)
+        assert result.dtype == object
+        assert result.tolist() == data
+
+    def test_constructor_periodindex(self):
+        # GH7932
+        # converting a PeriodIndex when put in a Series
+
+        pi = period_range("20130101", periods=5, freq="D")
+        s = Series(pi)
+        assert s.dtype == "Period[D]"
+        with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+            expected = Series(pi.astype(object))
+        tm.assert_series_equal(s, expected)
+
+    def test_constructor_dict(self):
+        d = {"a": 0.0, "b": 1.0, "c": 2.0}
+
+        result = Series(d)
+        expected = Series(d, index=sorted(d.keys()))
+        tm.assert_series_equal(result, expected)
+
+        result = Series(d, index=["b", "c", "d", "a"])
+        expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"])
+        tm.assert_series_equal(result, expected)
+
+        pidx = period_range("2020-01-01", periods=10, freq="D")
+        d = {pidx[0]: 0, pidx[1]: 1}
+        result = Series(d, index=pidx)
+        expected = Series(np.nan, pidx, dtype=np.float64)
+        expected.iloc[0] = 0
+        expected.iloc[1] = 1
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_list_value_explicit_dtype(self):
+        # GH 18625
+        d = {"a": [[2], [3], [4]]}
+        result = Series(d, index=["a"], dtype="object")
+        expected = Series(d, index=["a"])
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_order(self):
+        # GH19018
+        # initialization ordering: by insertion order
+        d = {"b": 1, "a": 0, "c": 2}
+        result = Series(d)
+        expected = Series([1, 0, 2], index=list("bac"))
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_extension(self, ea_scalar_and_dtype, request):
+        ea_scalar, ea_dtype = ea_scalar_and_dtype
+        if isinstance(ea_scalar, Timestamp):
+            mark = pytest.mark.xfail(
+                reason="Construction from dict goes through "
+                "maybe_convert_objects which casts to nano"
+            )
+            request.applymarker(mark)
+        d = {"a": ea_scalar}
+        result = Series(d, index=["a"])
+        expected = Series(ea_scalar, index=["a"], dtype=ea_dtype)
+
+        assert result.dtype == ea_dtype
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("value", [2, np.nan, None, float("nan")])
+    def test_constructor_dict_nan_key(self, value):
+        # GH 18480
+        d = {1: "a", value: "b", float("nan"): "c", 4: "d"}
+        result = Series(d).sort_values()
+        expected = Series(["a", "b", "c", "d"], index=[1, value, np.nan, 4])
+        tm.assert_series_equal(result, expected)
+
+        # MultiIndex:
+        d = {(1, 1): "a", (2, np.nan): "b", (3, value): "c"}
+        result = Series(d).sort_values()
+        expected = Series(
+            ["a", "b", "c"], index=Index([(1, 1), (2, np.nan), (3, value)])
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_datetime64_index(self):
+        # GH 9456
+
+        dates_as_str = ["1984-02-19", "1988-11-06", "1989-12-03", "1990-03-15"]
+        values = [42544017.198965244, 1234565, 40512335.181958228, -1]
+
+        def create_data(constructor):
+            return dict(zip((constructor(x) for x in dates_as_str), values))
+
+        data_datetime64 = create_data(np.datetime64)
+        data_datetime = create_data(lambda x: datetime.strptime(x, "%Y-%m-%d"))
+        data_Timestamp = create_data(Timestamp)
+
+        expected = Series(values, (Timestamp(x) for x in dates_as_str))
+
+        result_datetime64 = Series(data_datetime64)
+        result_datetime = Series(data_datetime)
+        result_Timestamp = Series(data_Timestamp)
+
+        tm.assert_series_equal(result_datetime64, expected)
+        tm.assert_series_equal(result_datetime, expected)
+        tm.assert_series_equal(result_Timestamp, expected)
+
+    def test_constructor_dict_tuple_indexer(self):
+        # GH 12948
+        data = {(1, 1, None): -1.0}
+        result = Series(data)
+        expected = Series(
+            -1.0, index=MultiIndex(levels=[[1], [1], [np.nan]], codes=[[0], [0], [-1]])
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_mapping(self, non_dict_mapping_subclass):
+        # GH 29788
+        ndm = non_dict_mapping_subclass({3: "three"})
+        result = Series(ndm)
+        expected = Series(["three"], index=[3])
+
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_list_of_tuples(self):
+        data = [(1, 1), (2, 2), (2, 3)]
+        s = Series(data)
+        assert list(s) == data
+
+    def test_constructor_tuple_of_tuples(self):
+        data = ((1, 1), (2, 2), (2, 3))
+        s = Series(data)
+        assert tuple(s) == data
+
+    def test_constructor_dict_of_tuples(self):
+        data = {(1, 2): 3, (None, 5): 6}
+        result = Series(data).sort_values()
+        expected = Series([3, 6], index=MultiIndex.from_tuples([(1, 2), (None, 5)]))
+        tm.assert_series_equal(result, expected)
+
+    # https://github.com/pandas-dev/pandas/issues/22698
+    @pytest.mark.filterwarnings("ignore:elementwise comparison:FutureWarning")
+    def test_fromDict(self, using_infer_string):
+        data = {"a": 0, "b": 1, "c": 2, "d": 3}
+
+        series = Series(data)
+        tm.assert_is_sorted(series.index)
+
+        data = {"a": 0, "b": "1", "c": "2", "d": datetime.now()}
+        series = Series(data)
+        assert series.dtype == np.object_
+
+        data = {"a": 0, "b": "1", "c": "2", "d": "3"}
+        series = Series(data)
+        assert series.dtype == np.object_ if not using_infer_string else "string"
+
+        data = {"a": "0", "b": "1"}
+        series = Series(data, dtype=float)
+        assert series.dtype == np.float64
+
+    def test_fromValue(self, datetime_series, using_infer_string):
+        nans = Series(np.nan, index=datetime_series.index, dtype=np.float64)
+        assert nans.dtype == np.float64
+        assert len(nans) == len(datetime_series)
+
+        strings = Series("foo", index=datetime_series.index)
+        assert strings.dtype == np.object_ if not using_infer_string else "string"
+        assert len(strings) == len(datetime_series)
+
+        d = datetime.now()
+        dates = Series(d, index=datetime_series.index)
+        assert dates.dtype == "M8[us]"
+        assert len(dates) == len(datetime_series)
+
+        # GH12336
+        # Test construction of categorical series from value
+        categorical = Series(0, index=datetime_series.index, dtype="category")
+        expected = Series(0, index=datetime_series.index).astype("category")
+        assert categorical.dtype == "category"
+        assert len(categorical) == len(datetime_series)
+        tm.assert_series_equal(categorical, expected)
+
+    def test_constructor_dtype_timedelta64(self):
+        # basic
+        td = Series([timedelta(days=i) for i in range(3)])
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([timedelta(days=1)])
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([timedelta(days=1), timedelta(days=2), np.timedelta64(1, "s")])
+
+        assert td.dtype == "timedelta64[ns]"
+
+        # mixed with NaT
+        td = Series([timedelta(days=1), NaT], dtype="m8[ns]")
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([timedelta(days=1), np.nan], dtype="m8[ns]")
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([np.timedelta64(300000000), NaT], dtype="m8[ns]")
+        assert td.dtype == "timedelta64[ns]"
+
+        # improved inference
+        # GH5689
+        td = Series([np.timedelta64(300000000), NaT])
+        assert td.dtype == "timedelta64[ns]"
+
+        # because iNaT is int, not coerced to timedelta
+        td = Series([np.timedelta64(300000000), iNaT])
+        assert td.dtype == "object"
+
+        td = Series([np.timedelta64(300000000), np.nan])
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([NaT, np.timedelta64(300000000)])
+        assert td.dtype == "timedelta64[ns]"
+
+        td = Series([np.timedelta64(1, "s")])
+        assert td.dtype == "timedelta64[ns]"
+
+        # valid astype
+        td.astype("int64")
+
+        # invalid casting
+        msg = r"Converting from timedelta64\[ns\] to int32 is not supported"
+        with pytest.raises(TypeError, match=msg):
+            td.astype("int32")
+
+        # this is an invalid casting
+        msg = "|".join(
+            [
+                "Could not convert object to NumPy timedelta",
+                "Could not convert 'foo' to NumPy timedelta",
+            ]
+        )
+        with pytest.raises(ValueError, match=msg):
+            Series([timedelta(days=1), "foo"], dtype="m8[ns]")
+
+        # leave as object here
+        td = Series([timedelta(days=i) for i in range(3)] + ["foo"])
+        assert td.dtype == "object"
+
+        # as of 2.0, these no longer infer timedelta64 based on the strings,
+        #  matching Index behavior
+        ser = Series([None, NaT, "1 Day"])
+        assert ser.dtype == object
+
+        ser = Series([np.nan, NaT, "1 Day"])
+        assert ser.dtype == object
+
+        ser = Series([NaT, None, "1 Day"])
+        assert ser.dtype == object
+
+        ser = Series([NaT, np.nan, "1 Day"])
+        assert ser.dtype == object
+
+    # GH 16406
+    def test_constructor_mixed_tz(self):
+        s = Series([Timestamp("20130101"), Timestamp("20130101", tz="US/Eastern")])
+        expected = Series(
+            [Timestamp("20130101"), Timestamp("20130101", tz="US/Eastern")],
+            dtype="object",
+        )
+        tm.assert_series_equal(s, expected)
+
+    def test_NaT_scalar(self):
+        series = Series([0, 1000, 2000, iNaT], dtype="M8[ns]")
+
+        val = series[3]
+        assert isna(val)
+
+        series[2] = val
+        assert isna(series[2])
+
+    def test_NaT_cast(self):
+        # GH10747
+        result = Series([np.nan]).astype("M8[ns]")
+        expected = Series([NaT], dtype="M8[ns]")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_name_hashable(self):
+        for n in [777, 777.0, "name", datetime(2001, 11, 11), (1,), "\u05D0"]:
+            for data in [[1, 2, 3], np.ones(3), {"a": 0, "b": 1}]:
+                s = Series(data, name=n)
+                assert s.name == n
+
+    def test_constructor_name_unhashable(self):
+        msg = r"Series\.name must be a hashable type"
+        for n in [["name_list"], np.ones(2), {1: 2}]:
+            for data in [["name_list"], np.ones(2), {1: 2}]:
+                with pytest.raises(TypeError, match=msg):
+                    Series(data, name=n)
+
+    def test_auto_conversion(self):
+        series = Series(list(date_range("1/1/2000", periods=10)))
+        assert series.dtype == "M8[ns]"
+
+    def test_convert_non_ns(self):
+        # convert from a numpy array of non-ns timedelta64
+        arr = np.array([1, 2, 3], dtype="timedelta64[s]")
+        ser = Series(arr)
+        assert ser.dtype == arr.dtype
+
+        tdi = timedelta_range("00:00:01", periods=3, freq="s").as_unit("s")
+        expected = Series(tdi)
+        assert expected.dtype == arr.dtype
+        tm.assert_series_equal(ser, expected)
+
+        # convert from a numpy array of non-ns datetime64
+        arr = np.array(
+            ["2013-01-01", "2013-01-02", "2013-01-03"], dtype="datetime64[D]"
+        )
+        ser = Series(arr)
+        expected = Series(date_range("20130101", periods=3, freq="D"), dtype="M8[s]")
+        assert expected.dtype == "M8[s]"
+        tm.assert_series_equal(ser, expected)
+
+        arr = np.array(
+            ["2013-01-01 00:00:01", "2013-01-01 00:00:02", "2013-01-01 00:00:03"],
+            dtype="datetime64[s]",
+        )
+        ser = Series(arr)
+        expected = Series(
+            date_range("20130101 00:00:01", periods=3, freq="s"), dtype="M8[s]"
+        )
+        assert expected.dtype == "M8[s]"
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            date_range("1/1/2000", periods=10),
+            timedelta_range("1 day", periods=10),
+            period_range("2000-Q1", periods=10, freq="Q"),
+        ],
+        ids=lambda x: type(x).__name__,
+    )
+    def test_constructor_cant_cast_datetimelike(self, index):
+        # floats are not ok
+        # strip Index to convert PeriodIndex -> Period
+        # We don't care whether the error message says
+        # PeriodIndex or PeriodArray
+        msg = f"Cannot cast {type(index).__name__.rstrip('Index')}.*? to "
+
+        with pytest.raises(TypeError, match=msg):
+            Series(index, dtype=float)
+
+        # ints are ok
+        # we test with np.int64 to get similar results on
+        # windows / 32-bit platforms
+        result = Series(index, dtype=np.int64)
+        expected = Series(index.astype(np.int64))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            date_range("1/1/2000", periods=10),
+            timedelta_range("1 day", periods=10),
+            period_range("2000-Q1", periods=10, freq="Q"),
+        ],
+        ids=lambda x: type(x).__name__,
+    )
+    def test_constructor_cast_object(self, index):
+        s = Series(index, dtype=object)
+        exp = Series(index).astype(object)
+        tm.assert_series_equal(s, exp)
+
+        s = Series(Index(index, dtype=object), dtype=object)
+        exp = Series(index).astype(object)
+        tm.assert_series_equal(s, exp)
+
+        s = Series(index.astype(object), dtype=object)
+        exp = Series(index).astype(object)
+        tm.assert_series_equal(s, exp)
+
+    @pytest.mark.parametrize("dtype", [np.datetime64, np.timedelta64])
+    def test_constructor_generic_timestamp_no_frequency(self, dtype, request):
+        # see gh-15524, gh-15987
+        msg = "dtype has no unit. Please pass in"
+
+        if np.dtype(dtype).name not in ["timedelta64", "datetime64"]:
+            mark = pytest.mark.xfail(reason="GH#33890 Is assigned ns unit")
+            request.applymarker(mark)
+
+        with pytest.raises(ValueError, match=msg):
+            Series([], dtype=dtype)
+
+    @pytest.mark.parametrize("unit", ["ps", "as", "fs", "Y", "M", "W", "D", "h", "m"])
+    @pytest.mark.parametrize("kind", ["m", "M"])
+    def test_constructor_generic_timestamp_bad_frequency(self, kind, unit):
+        # see gh-15524, gh-15987
+        # as of 2.0 we raise on any non-supported unit rather than silently
+        #  cast to nanos; previously we only raised for frequencies higher
+        #  than ns
+        dtype = f"{kind}8[{unit}]"
+
+        msg = "dtype=.* is not supported. Supported resolutions are"
+        with pytest.raises(TypeError, match=msg):
+            Series([], dtype=dtype)
+
+        with pytest.raises(TypeError, match=msg):
+            # pre-2.0 the DataFrame cast raised but the Series case did not
+            DataFrame([[0]], dtype=dtype)
+
+    @pytest.mark.parametrize("dtype", [None, "uint8", "category"])
+    def test_constructor_range_dtype(self, dtype):
+        # GH 16804
+        expected = Series([0, 1, 2, 3, 4], dtype=dtype or "int64")
+        result = Series(range(5), dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_range_overflows(self):
+        # GH#30173 range objects that overflow int64
+        rng = range(2**63, 2**63 + 4)
+        ser = Series(rng)
+        expected = Series(list(rng))
+        tm.assert_series_equal(ser, expected)
+        assert list(ser) == list(rng)
+        assert ser.dtype == np.uint64
+
+        rng2 = range(2**63 + 4, 2**63, -1)
+        ser2 = Series(rng2)
+        expected2 = Series(list(rng2))
+        tm.assert_series_equal(ser2, expected2)
+        assert list(ser2) == list(rng2)
+        assert ser2.dtype == np.uint64
+
+        rng3 = range(-(2**63), -(2**63) - 4, -1)
+        ser3 = Series(rng3)
+        expected3 = Series(list(rng3))
+        tm.assert_series_equal(ser3, expected3)
+        assert list(ser3) == list(rng3)
+        assert ser3.dtype == object
+
+        rng4 = range(2**73, 2**73 + 4)
+        ser4 = Series(rng4)
+        expected4 = Series(list(rng4))
+        tm.assert_series_equal(ser4, expected4)
+        assert list(ser4) == list(rng4)
+        assert ser4.dtype == object
+
+    def test_constructor_tz_mixed_data(self):
+        # GH 13051
+        dt_list = [
+            Timestamp("2016-05-01 02:03:37"),
+            Timestamp("2016-04-30 19:03:37-0700", tz="US/Pacific"),
+        ]
+        result = Series(dt_list)
+        expected = Series(dt_list, dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("pydt", [True, False])
+    def test_constructor_data_aware_dtype_naive(self, tz_aware_fixture, pydt):
+        # GH#25843, GH#41555, GH#33401
+        tz = tz_aware_fixture
+        ts = Timestamp("2019", tz=tz)
+        if pydt:
+            ts = ts.to_pydatetime()
+
+        msg = (
+            "Cannot convert timezone-aware data to timezone-naive dtype. "
+            r"Use pd.Series\(values\).dt.tz_localize\(None\) instead."
+        )
+        with pytest.raises(ValueError, match=msg):
+            Series([ts], dtype="datetime64[ns]")
+
+        with pytest.raises(ValueError, match=msg):
+            Series(np.array([ts], dtype=object), dtype="datetime64[ns]")
+
+        with pytest.raises(ValueError, match=msg):
+            Series({0: ts}, dtype="datetime64[ns]")
+
+        msg = "Cannot unbox tzaware Timestamp to tznaive dtype"
+        with pytest.raises(TypeError, match=msg):
+            Series(ts, index=[0], dtype="datetime64[ns]")
+
+    def test_constructor_datetime64(self):
+        rng = date_range("1/1/2000 00:00:00", "1/1/2000 1:59:50", freq="10s")
+        dates = np.asarray(rng)
+
+        series = Series(dates)
+        assert np.issubdtype(series.dtype, np.dtype("M8[ns]"))
+
+    def test_constructor_datetimelike_scalar_to_string_dtype(
+        self, nullable_string_dtype
+    ):
+        # https://github.com/pandas-dev/pandas/pull/33846
+        result = Series("M", index=[1, 2, 3], dtype=nullable_string_dtype)
+        expected = Series(["M", "M", "M"], index=[1, 2, 3], dtype=nullable_string_dtype)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            [np.datetime64("2012-01-01"), np.datetime64("2013-01-01")],
+            ["2012-01-01", "2013-01-01"],
+        ],
+    )
+    def test_constructor_sparse_datetime64(self, values):
+        # https://github.com/pandas-dev/pandas/issues/35762
+        dtype = pd.SparseDtype("datetime64[ns]")
+        result = Series(values, dtype=dtype)
+        arr = pd.arrays.SparseArray(values, dtype=dtype)
+        expected = Series(arr)
+        tm.assert_series_equal(result, expected)
+
+    def test_construction_from_ordered_collection(self):
+        # https://github.com/pandas-dev/pandas/issues/36044
+        result = Series({"a": 1, "b": 2}.keys())
+        expected = Series(["a", "b"])
+        tm.assert_series_equal(result, expected)
+
+        result = Series({"a": 1, "b": 2}.values())
+        expected = Series([1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_construction_from_large_int_scalar_no_overflow(self):
+        # https://github.com/pandas-dev/pandas/issues/36291
+        n = 1_000_000_000_000_000_000_000
+        result = Series(n, index=[0])
+        expected = Series(n)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_list_of_periods_infers_period_dtype(self):
+        series = Series(list(period_range("2000-01-01", periods=10, freq="D")))
+        assert series.dtype == "Period[D]"
+
+        series = Series(
+            [Period("2011-01-01", freq="D"), Period("2011-02-01", freq="D")]
+        )
+        assert series.dtype == "Period[D]"
+
+    def test_constructor_subclass_dict(self, dict_subclass):
+        data = dict_subclass((x, 10.0 * x) for x in range(10))
+        series = Series(data)
+        expected = Series(dict(data.items()))
+        tm.assert_series_equal(series, expected)
+
+    def test_constructor_ordereddict(self):
+        # GH3283
+        data = OrderedDict(
+            (f"col{i}", np.random.default_rng(2).random()) for i in range(12)
+        )
+
+        series = Series(data)
+        expected = Series(list(data.values()), list(data.keys()))
+        tm.assert_series_equal(series, expected)
+
+        # Test with subclass
+        class A(OrderedDict):
+            pass
+
+        series = Series(A(data))
+        tm.assert_series_equal(series, expected)
+
+    def test_constructor_dict_multiindex(self):
+        d = {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0}
+        _d = sorted(d.items())
+        result = Series(d)
+        expected = Series(
+            [x[1] for x in _d], index=MultiIndex.from_tuples([x[0] for x in _d])
+        )
+        tm.assert_series_equal(result, expected)
+
+        d["z"] = 111.0
+        _d.insert(0, ("z", d["z"]))
+        result = Series(d)
+        expected = Series(
+            [x[1] for x in _d], index=Index([x[0] for x in _d], tupleize_cols=False)
+        )
+        result = result.reindex(index=expected.index)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_multiindex_reindex_flat(self):
+        # construction involves reindexing with a MultiIndex corner case
+        data = {("i", "i"): 0, ("i", "j"): 1, ("j", "i"): 2, "j": np.nan}
+        expected = Series(data)
+
+        result = Series(expected[:-1].to_dict(), index=expected.index)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_dict_timedelta_index(self):
+        # GH #12169 : Resample category data with timedelta index
+        # construct Series from dict as data and TimedeltaIndex as index
+        # will result NaN in result Series data
+        expected = Series(
+            data=["A", "B", "C"], index=pd.to_timedelta([0, 10, 20], unit="s")
+        )
+
+        result = Series(
+            data={
+                pd.to_timedelta(0, unit="s"): "A",
+                pd.to_timedelta(10, unit="s"): "B",
+                pd.to_timedelta(20, unit="s"): "C",
+            },
+            index=pd.to_timedelta([0, 10, 20], unit="s"),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_infer_index_tz(self):
+        values = [188.5, 328.25]
+        tzinfo = tzoffset(None, 7200)
+        index = [
+            datetime(2012, 5, 11, 11, tzinfo=tzinfo),
+            datetime(2012, 5, 11, 12, tzinfo=tzinfo),
+        ]
+        series = Series(data=values, index=index)
+
+        assert series.index.tz == tzinfo
+
+        # it works! GH#2443
+        repr(series.index[0])
+
+    def test_constructor_with_pandas_dtype(self):
+        # going through 2D->1D path
+        vals = [(1,), (2,), (3,)]
+        ser = Series(vals)
+        dtype = ser.array.dtype  # NumpyEADtype
+        ser2 = Series(vals, dtype=dtype)
+        tm.assert_series_equal(ser, ser2)
+
+    def test_constructor_int_dtype_missing_values(self):
+        # GH#43017
+        result = Series(index=[0], dtype="int64")
+        expected = Series(np.nan, index=[0], dtype="float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_bool_dtype_missing_values(self):
+        # GH#43018
+        result = Series(index=[0], dtype="bool")
+        expected = Series(True, index=[0], dtype="bool")
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_int64_dtype(self, any_int_dtype):
+        # GH#44923
+        result = Series(["0", "1", "2"], dtype=any_int_dtype)
+        expected = Series([0, 1, 2], dtype=any_int_dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_constructor_raise_on_lossy_conversion_of_strings(self):
+        # GH#44923
+        if not np_version_gt2:
+            raises = pytest.raises(
+                ValueError, match="string values cannot be losslessly cast to int8"
+            )
+        else:
+            raises = pytest.raises(
+                OverflowError, match="The elements provided in the data"
+            )
+        with raises:
+            Series(["128"], dtype="int8")
+
+    def test_constructor_dtype_timedelta_alternative_construct(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]")
+        expected = Series(pd.to_timedelta([1000000, 200000, 3000000], unit="ns"))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.xfail(
+        reason="Not clear what the correct expected behavior should be with "
+        "integers now that we support non-nano. ATM (2022-10-08) we treat ints "
+        "as nanoseconds, then cast to the requested dtype. xref #48312"
+    )
+    def test_constructor_dtype_timedelta_ns_s(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]")
+        expected = Series([1000000, 200000, 3000000], dtype="timedelta64[s]")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.xfail(
+        reason="Not clear what the correct expected behavior should be with "
+        "integers now that we support non-nano. ATM (2022-10-08) we treat ints "
+        "as nanoseconds, then cast to the requested dtype. xref #48312"
+    )
+    def test_constructor_dtype_timedelta_ns_s_astype_int64(self):
+        # GH#35465
+        result = Series([1000000, 200000, 3000000], dtype="timedelta64[ns]").astype(
+            "int64"
+        )
+        expected = Series([1000000, 200000, 3000000], dtype="timedelta64[s]").astype(
+            "int64"
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:elementwise comparison failed:DeprecationWarning"
+    )
+    @pytest.mark.parametrize("func", [Series, DataFrame, Index, pd.array])
+    def test_constructor_mismatched_null_nullable_dtype(
+        self, func, any_numeric_ea_dtype
+    ):
+        # GH#44514
+        msg = "|".join(
+            [
+                "cannot safely cast non-equivalent object",
+                r"int\(\) argument must be a string, a bytes-like object "
+                "or a (real )?number",
+                r"Cannot cast array data from dtype\('O'\) to dtype\('float64'\) "
+                "according to the rule 'safe'",
+                "object cannot be converted to a FloatingDtype",
+                "'values' contains non-numeric NA",
+            ]
+        )
+
+        for null in tm.NP_NAT_OBJECTS + [NaT]:
+            with pytest.raises(TypeError, match=msg):
+                func([null, 1.0, 3.0], dtype=any_numeric_ea_dtype)
+
+    def test_series_constructor_ea_int_from_bool(self):
+        # GH#42137
+        result = Series([True, False, True, pd.NA], dtype="Int64")
+        expected = Series([1, 0, 1, pd.NA], dtype="Int64")
+        tm.assert_series_equal(result, expected)
+
+        result = Series([True, False, True], dtype="Int64")
+        expected = Series([1, 0, 1], dtype="Int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_series_constructor_ea_int_from_string_bool(self):
+        # GH#42137
+        with pytest.raises(ValueError, match="invalid literal"):
+            Series(["True", "False", "True", pd.NA], dtype="Int64")
+
+    @pytest.mark.parametrize("val", [1, 1.0])
+    def test_series_constructor_overflow_uint_ea(self, val):
+        # GH#38798
+        max_val = np.iinfo(np.uint64).max - 1
+        result = Series([max_val, val], dtype="UInt64")
+        expected = Series(np.array([max_val, 1], dtype="uint64"), dtype="UInt64")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [1, 1.0])
+    def test_series_constructor_overflow_uint_ea_with_na(self, val):
+        # GH#38798
+        max_val = np.iinfo(np.uint64).max - 1
+        result = Series([max_val, val, pd.NA], dtype="UInt64")
+        expected = Series(
+            IntegerArray(
+                np.array([max_val, 1, 0], dtype="uint64"),
+                np.array([0, 0, 1], dtype=np.bool_),
+            )
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_series_constructor_overflow_uint_with_nan(self):
+        # GH#38798
+        max_val = np.iinfo(np.uint64).max - 1
+        result = Series([max_val, np.nan], dtype="UInt64")
+        expected = Series(
+            IntegerArray(
+                np.array([max_val, 1], dtype="uint64"),
+                np.array([0, 1], dtype=np.bool_),
+            )
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_series_constructor_ea_all_na(self):
+        # GH#38798
+        result = Series([np.nan, np.nan], dtype="UInt64")
+        expected = Series(
+            IntegerArray(
+                np.array([1, 1], dtype="uint64"),
+                np.array([1, 1], dtype=np.bool_),
+            )
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_series_from_index_dtype_equal_does_not_copy(self):
+        # GH#52008
+        idx = Index([1, 2, 3])
+        expected = idx.copy(deep=True)
+        ser = Series(idx, dtype="int64")
+        ser.iloc[0] = 100
+        tm.assert_index_equal(idx, expected)
+
+    def test_series_string_inference(self):
+        # GH#54430
+        pytest.importorskip("pyarrow")
+        dtype = "string[pyarrow_numpy]"
+        expected = Series(["a", "b"], dtype=dtype)
+        with pd.option_context("future.infer_string", True):
+            ser = Series(["a", "b"])
+        tm.assert_series_equal(ser, expected)
+
+        expected = Series(["a", 1], dtype="object")
+        with pd.option_context("future.infer_string", True):
+            ser = Series(["a", 1])
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("na_value", [None, np.nan, pd.NA])
+    def test_series_string_with_na_inference(self, na_value):
+        # GH#54430
+        pytest.importorskip("pyarrow")
+        dtype = "string[pyarrow_numpy]"
+        expected = Series(["a", na_value], dtype=dtype)
+        with pd.option_context("future.infer_string", True):
+            ser = Series(["a", na_value])
+        tm.assert_series_equal(ser, expected)
+
+    def test_series_string_inference_scalar(self):
+        # GH#54430
+        pytest.importorskip("pyarrow")
+        expected = Series("a", index=[1], dtype="string[pyarrow_numpy]")
+        with pd.option_context("future.infer_string", True):
+            ser = Series("a", index=[1])
+        tm.assert_series_equal(ser, expected)
+
+    def test_series_string_inference_array_string_dtype(self):
+        # GH#54496
+        pytest.importorskip("pyarrow")
+        expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+        with pd.option_context("future.infer_string", True):
+            ser = Series(np.array(["a", "b"]))
+        tm.assert_series_equal(ser, expected)
+
+    def test_series_string_inference_storage_definition(self):
+        # GH#54793
+        pytest.importorskip("pyarrow")
+        expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+        with pd.option_context("future.infer_string", True):
+            result = Series(["a", "b"], dtype="string")
+        tm.assert_series_equal(result, expected)
+
+    def test_series_constructor_infer_string_scalar(self):
+        # GH#55537
+        with pd.option_context("future.infer_string", True):
+            ser = Series("a", index=[1, 2], dtype="string[python]")
+        expected = Series(["a", "a"], index=[1, 2], dtype="string[python]")
+        tm.assert_series_equal(ser, expected)
+        assert ser.dtype.storage == "python"
+
+    def test_series_string_inference_na_first(self):
+        # GH#55655
+        pytest.importorskip("pyarrow")
+        expected = Series([pd.NA, "b"], dtype="string[pyarrow_numpy]")
+        with pd.option_context("future.infer_string", True):
+            result = Series([pd.NA, "b"])
+        tm.assert_series_equal(result, expected)
+
+    def test_inference_on_pandas_objects(self):
+        # GH#56012
+        ser = Series([Timestamp("2019-12-31")], dtype=object)
+        with tm.assert_produces_warning(None):
+            # This doesn't do inference
+            result = Series(ser)
+        assert result.dtype == np.object_
+
+        idx = Index([Timestamp("2019-12-31")], dtype=object)
+
+        with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+            result = Series(idx)
+        assert result.dtype != np.object_
+
+
+class TestSeriesConstructorIndexCoercion:
+    def test_series_constructor_datetimelike_index_coercion(self):
+        idx = date_range("2020-01-01", periods=5)
+        ser = Series(
+            np.random.default_rng(2).standard_normal(len(idx)), idx.astype(object)
+        )
+        # as of 2.0, we no longer silently cast the object-dtype index
+        #  to DatetimeIndex GH#39307, GH#23598
+        assert not isinstance(ser.index, DatetimeIndex)
+
+    @pytest.mark.parametrize("container", [None, np.array, Series, Index])
+    @pytest.mark.parametrize("data", [1.0, range(4)])
+    def test_series_constructor_infer_multiindex(self, container, data):
+        indexes = [["a", "a", "b", "b"], ["x", "y", "x", "y"]]
+        if container is not None:
+            indexes = [container(ind) for ind in indexes]
+
+        multi = Series(data, index=indexes)
+        assert isinstance(multi.index, MultiIndex)
+
+    # TODO: make this not cast to object in pandas 3.0
+    @pytest.mark.skipif(
+        not np_version_gt2, reason="StringDType only available in numpy 2 and above"
+    )
+    @pytest.mark.parametrize(
+        "data",
+        [
+            ["a", "b", "c"],
+            ["a", "b", np.nan],
+        ],
+    )
+    def test_np_string_array_object_cast(self, data):
+        from numpy.dtypes import StringDType
+
+        arr = np.array(data, dtype=StringDType())
+        res = Series(arr)
+        assert res.dtype == np.object_
+        assert (res == data).all()
+
+
+class TestSeriesConstructorInternals:
+    def test_constructor_no_pandas_array(self, using_array_manager):
+        ser = Series([1, 2, 3])
+        result = Series(ser.array)
+        tm.assert_series_equal(ser, result)
+        if not using_array_manager:
+            assert isinstance(result._mgr.blocks[0], NumpyBlock)
+            assert result._mgr.blocks[0].is_numeric
+
+    @td.skip_array_manager_invalid_test
+    def test_from_array(self):
+        result = Series(pd.array(["1h", "2h"], dtype="timedelta64[ns]"))
+        assert result._mgr.blocks[0].is_extension is False
+
+        result = Series(pd.array(["2015"], dtype="datetime64[ns]"))
+        assert result._mgr.blocks[0].is_extension is False
+
+    @td.skip_array_manager_invalid_test
+    def test_from_list_dtype(self):
+        result = Series(["1h", "2h"], dtype="timedelta64[ns]")
+        assert result._mgr.blocks[0].is_extension is False
+
+        result = Series(["2015"], dtype="datetime64[ns]")
+        assert result._mgr.blocks[0].is_extension is False
+
+
+def test_constructor(rand_series_with_duplicate_datetimeindex):
+    dups = rand_series_with_duplicate_datetimeindex
+    assert isinstance(dups, Series)
+    assert isinstance(dups.index, DatetimeIndex)
+
+
+@pytest.mark.parametrize(
+    "input_dict,expected",
+    [
+        ({0: 0}, np.array([[0]], dtype=np.int64)),
+        ({"a": "a"}, np.array([["a"]], dtype=object)),
+        ({1: 1}, np.array([[1]], dtype=np.int64)),
+    ],
+)
+def test_numpy_array(input_dict, expected):
+    result = np.array([Series(input_dict)])
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_index_ordered_dict_keys():
+    # GH 22077
+
+    param_index = OrderedDict(
+        [
+            ((("a", "b"), ("c", "d")), 1),
+            ((("a", None), ("c", "d")), 2),
+        ]
+    )
+    series = Series([1, 2], index=param_index.keys())
+    expected = Series(
+        [1, 2],
+        index=MultiIndex.from_tuples(
+            [(("a", "b"), ("c", "d")), (("a", None), ("c", "d"))]
+        ),
+    )
+    tm.assert_series_equal(series, expected)
+
+
+@pytest.mark.parametrize(
+    "input_list",
+    [
+        [1, complex("nan"), 2],
+        [1 + 1j, complex("nan"), 2 + 2j],
+    ],
+)
+def test_series_with_complex_nan(input_list):
+    # GH#53627
+    ser = Series(input_list)
+    result = Series(ser.array)
+    assert ser.dtype == "complex128"
+    tm.assert_series_equal(ser, result)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_cumulative.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_cumulative.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6f7b2a5e69e0a97e2f898c6a665372ba3ec2a6b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_cumulative.py
@@ -0,0 +1,157 @@
+"""
+Tests for Series cumulative operations.
+
+See also
+--------
+tests.frame.test_cumulative
+"""
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+methods = {
+    "cumsum": np.cumsum,
+    "cumprod": np.cumprod,
+    "cummin": np.minimum.accumulate,
+    "cummax": np.maximum.accumulate,
+}
+
+
+class TestSeriesCumulativeOps:
+    @pytest.mark.parametrize("func", [np.cumsum, np.cumprod])
+    def test_datetime_series(self, datetime_series, func):
+        tm.assert_numpy_array_equal(
+            func(datetime_series).values,
+            func(np.array(datetime_series)),
+            check_dtype=True,
+        )
+
+        # with missing values
+        ts = datetime_series.copy()
+        ts[::2] = np.nan
+
+        result = func(ts)[1::2]
+        expected = func(np.array(ts.dropna()))
+
+        tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)
+
+    @pytest.mark.parametrize("method", ["cummin", "cummax"])
+    def test_cummin_cummax(self, datetime_series, method):
+        ufunc = methods[method]
+
+        result = getattr(datetime_series, method)().values
+        expected = ufunc(np.array(datetime_series))
+
+        tm.assert_numpy_array_equal(result, expected)
+        ts = datetime_series.copy()
+        ts[::2] = np.nan
+        result = getattr(ts, method)()[1::2]
+        expected = ufunc(ts.dropna())
+
+        result.index = result.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            pd.Timedelta(0),
+            pd.Timestamp("1999-12-31"),
+            pd.Timestamp("1999-12-31").tz_localize("US/Pacific"),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "method, skipna, exp_tdi",
+        [
+            ["cummax", True, ["NaT", "2 days", "NaT", "2 days", "NaT", "3 days"]],
+            ["cummin", True, ["NaT", "2 days", "NaT", "1 days", "NaT", "1 days"]],
+            [
+                "cummax",
+                False,
+                ["NaT", "NaT", "NaT", "NaT", "NaT", "NaT"],
+            ],
+            [
+                "cummin",
+                False,
+                ["NaT", "NaT", "NaT", "NaT", "NaT", "NaT"],
+            ],
+        ],
+    )
+    def test_cummin_cummax_datetimelike(self, ts, method, skipna, exp_tdi):
+        # with ts==pd.Timedelta(0), we are testing td64; with naive Timestamp
+        #  we are testing datetime64[ns]; with Timestamp[US/Pacific]
+        #  we are testing dt64tz
+        tdi = pd.to_timedelta(["NaT", "2 days", "NaT", "1 days", "NaT", "3 days"])
+        ser = pd.Series(tdi + ts)
+
+        exp_tdi = pd.to_timedelta(exp_tdi)
+        expected = pd.Series(exp_tdi + ts)
+        result = getattr(ser, method)(skipna=skipna)
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "func, exp",
+        [
+            ("cummin", pd.Period("2012-1-1", freq="D")),
+            ("cummax", pd.Period("2012-1-2", freq="D")),
+        ],
+    )
+    def test_cummin_cummax_period(self, func, exp):
+        # GH#28385
+        ser = pd.Series(
+            [pd.Period("2012-1-1", freq="D"), pd.NaT, pd.Period("2012-1-2", freq="D")]
+        )
+        result = getattr(ser, func)(skipna=False)
+        expected = pd.Series([pd.Period("2012-1-1", freq="D"), pd.NaT, pd.NaT])
+        tm.assert_series_equal(result, expected)
+
+        result = getattr(ser, func)(skipna=True)
+        expected = pd.Series([pd.Period("2012-1-1", freq="D"), pd.NaT, exp])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "arg",
+        [
+            [False, False, False, True, True, False, False],
+            [False, False, False, False, False, False, False],
+        ],
+    )
+    @pytest.mark.parametrize(
+        "func", [lambda x: x, lambda x: ~x], ids=["identity", "inverse"]
+    )
+    @pytest.mark.parametrize("method", methods.keys())
+    def test_cummethods_bool(self, arg, func, method):
+        # GH#6270
+        # checking Series method vs the ufunc applied to the values
+
+        ser = func(pd.Series(arg))
+        ufunc = methods[method]
+
+        exp_vals = ufunc(ser.values)
+        expected = pd.Series(exp_vals)
+
+        result = getattr(ser, method)()
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "method, expected",
+        [
+            ["cumsum", pd.Series([0, 1, np.nan, 1], dtype=object)],
+            ["cumprod", pd.Series([False, 0, np.nan, 0])],
+            ["cummin", pd.Series([False, False, np.nan, False])],
+            ["cummax", pd.Series([False, True, np.nan, True])],
+        ],
+    )
+    def test_cummethods_bool_in_object_dtype(self, method, expected):
+        ser = pd.Series([False, True, np.nan, False])
+        result = getattr(ser, method)()
+        tm.assert_series_equal(result, expected)
+
+    def test_cumprod_timedelta(self):
+        # GH#48111
+        ser = pd.Series([pd.Timedelta(days=1), pd.Timedelta(days=3)])
+        with pytest.raises(TypeError, match="cumprod not supported for Timedelta"):
+            ser.cumprod()
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_formats.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_formats.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1c5018ea7961c5979b4f407f7096e81e2dda0c0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_formats.py
@@ -0,0 +1,577 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+    option_context,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesRepr:
+    def test_multilevel_name_print_0(self):
+        # GH#55415 None does not get printed, but 0 does
+        # (matching DataFrame and flat index behavior)
+        mi = pd.MultiIndex.from_product([range(2, 3), range(3, 4)], names=[0, None])
+        ser = Series(1.5, index=mi)
+
+        res = repr(ser)
+        expected = "0   \n2  3    1.5\ndtype: float64"
+        assert res == expected
+
+    def test_multilevel_name_print(self, lexsorted_two_level_string_multiindex):
+        index = lexsorted_two_level_string_multiindex
+        ser = Series(range(len(index)), index=index, name="sth")
+        expected = [
+            "first  second",
+            "foo    one       0",
+            "       two       1",
+            "       three     2",
+            "bar    one       3",
+            "       two       4",
+            "baz    two       5",
+            "       three     6",
+            "qux    one       7",
+            "       two       8",
+            "       three     9",
+            "Name: sth, dtype: int64",
+        ]
+        expected = "\n".join(expected)
+        assert repr(ser) == expected
+
+    def test_small_name_printing(self):
+        # Test small Series.
+        s = Series([0, 1, 2])
+
+        s.name = "test"
+        assert "Name: test" in repr(s)
+
+        s.name = None
+        assert "Name:" not in repr(s)
+
+    def test_big_name_printing(self):
+        # Test big Series (diff code path).
+        s = Series(range(1000))
+
+        s.name = "test"
+        assert "Name: test" in repr(s)
+
+        s.name = None
+        assert "Name:" not in repr(s)
+
+    def test_empty_name_printing(self):
+        s = Series(index=date_range("20010101", "20020101"), name="test", dtype=object)
+        assert "Name: test" in repr(s)
+
+    @pytest.mark.parametrize("args", [(), (0, -1)])
+    def test_float_range(self, args):
+        str(
+            Series(
+                np.random.default_rng(2).standard_normal(1000),
+                index=np.arange(1000, *args),
+            )
+        )
+
+    def test_empty_object(self):
+        # empty
+        str(Series(dtype=object))
+
+    def test_string(self, string_series):
+        str(string_series)
+        str(string_series.astype(int))
+
+        # with NaNs
+        string_series[5:7] = np.nan
+        str(string_series)
+
+    def test_object(self, object_series):
+        str(object_series)
+
+    def test_datetime(self, datetime_series):
+        str(datetime_series)
+        # with Nones
+        ots = datetime_series.astype("O")
+        ots[::2] = None
+        repr(ots)
+
+    @pytest.mark.parametrize(
+        "name",
+        [
+            "",
+            1,
+            1.2,
+            "foo",
+            "\u03B1\u03B2\u03B3",
+            "loooooooooooooooooooooooooooooooooooooooooooooooooooong",
+            ("foo", "bar", "baz"),
+            (1, 2),
+            ("foo", 1, 2.3),
+            ("\u03B1", "\u03B2", "\u03B3"),
+            ("\u03B1", "bar"),
+        ],
+    )
+    def test_various_names(self, name, string_series):
+        # various names
+        string_series.name = name
+        repr(string_series)
+
+    def test_tuple_name(self):
+        biggie = Series(
+            np.random.default_rng(2).standard_normal(1000),
+            index=np.arange(1000),
+            name=("foo", "bar", "baz"),
+        )
+        repr(biggie)
+
+    @pytest.mark.parametrize("arg", [100, 1001])
+    def test_tidy_repr_name_0(self, arg):
+        # tidy repr
+        ser = Series(np.random.default_rng(2).standard_normal(arg), name=0)
+        rep_str = repr(ser)
+        assert "Name: 0" in rep_str
+
+    @pytest.mark.xfail(
+        using_pyarrow_string_dtype(), reason="TODO: investigate why this is failing"
+    )
+    def test_newline(self):
+        ser = Series(["a\n\r\tb"], name="a\n\r\td", index=["a\n\r\tf"])
+        assert "\t" not in repr(ser)
+        assert "\r" not in repr(ser)
+        assert "a\n" not in repr(ser)
+
+    @pytest.mark.parametrize(
+        "name, expected",
+        [
+            ["foo", "Series([], Name: foo, dtype: int64)"],
+            [None, "Series([], dtype: int64)"],
+        ],
+    )
+    def test_empty_int64(self, name, expected):
+        # with empty series (#4651)
+        s = Series([], dtype=np.int64, name=name)
+        assert repr(s) == expected
+
+    def test_repr_bool_fails(self, capsys):
+        s = Series(
+            [
+                DataFrame(np.random.default_rng(2).standard_normal((2, 2)))
+                for i in range(5)
+            ]
+        )
+
+        # It works (with no Cython exception barf)!
+        repr(s)
+
+        captured = capsys.readouterr()
+        assert captured.err == ""
+
+    def test_repr_name_iterable_indexable(self):
+        s = Series([1, 2, 3], name=np.int64(3))
+
+        # it works!
+        repr(s)
+
+        s.name = ("\u05d0",) * 2
+        repr(s)
+
+    def test_repr_max_rows(self):
+        # GH 6863
+        with option_context("display.max_rows", None):
+            str(Series(range(1001)))  # should not raise exception
+
+    def test_unicode_string_with_unicode(self):
+        df = Series(["\u05d0"], name="\u05d1")
+        str(df)
+
+        ser = Series(["\u03c3"] * 10)
+        repr(ser)
+
+        ser2 = Series(["\u05d0"] * 1000)
+        ser2.name = "title1"
+        repr(ser2)
+
+    def test_str_to_bytes_raises(self):
+        # GH 26447
+        df = Series(["abc"], name="abc")
+        msg = "^'str' object cannot be interpreted as an integer$"
+        with pytest.raises(TypeError, match=msg):
+            bytes(df)
+
+    def test_timeseries_repr_object_dtype(self):
+        index = Index(
+            [datetime(2000, 1, 1) + timedelta(i) for i in range(1000)], dtype=object
+        )
+        ts = Series(np.random.default_rng(2).standard_normal(len(index)), index)
+        repr(ts)
+
+        ts = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        )
+        assert repr(ts).splitlines()[-1].startswith("Freq:")
+
+        ts2 = ts.iloc[np.random.default_rng(2).integers(0, len(ts) - 1, 400)]
+        repr(ts2).splitlines()[-1]
+
+    def test_latex_repr(self):
+        pytest.importorskip("jinja2")  # uses Styler implementation
+        result = r"""\begin{tabular}{ll}
+\toprule
+ & 0 \\
+\midrule
+0 & $\alpha$ \\
+1 & b \\
+2 & c \\
+\bottomrule
+\end{tabular}
+"""
+        with option_context(
+            "styler.format.escape", None, "styler.render.repr", "latex"
+        ):
+            s = Series([r"$\alpha$", "b", "c"])
+            assert result == s._repr_latex_()
+
+        assert s._repr_latex_() is None
+
+    def test_index_repr_in_frame_with_nan(self):
+        # see gh-25061
+        i = Index([1, np.nan])
+        s = Series([1, 2], index=i)
+        exp = """1.0    1\nNaN    2\ndtype: int64"""
+
+        assert repr(s) == exp
+
+    def test_format_pre_1900_dates(self):
+        rng = date_range("1/1/1850", "1/1/1950", freq="YE-DEC")
+        msg = "DatetimeIndex.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rng.format()
+        ts = Series(1, index=rng)
+        repr(ts)
+
+    def test_series_repr_nat(self):
+        series = Series([0, 1000, 2000, pd.NaT._value], dtype="M8[ns]")
+
+        result = repr(series)
+        expected = (
+            "0   1970-01-01 00:00:00.000000\n"
+            "1   1970-01-01 00:00:00.000001\n"
+            "2   1970-01-01 00:00:00.000002\n"
+            "3                          NaT\n"
+            "dtype: datetime64[ns]"
+        )
+        assert result == expected
+
+    def test_float_repr(self):
+        # GH#35603
+        # check float format when cast to object
+        ser = Series([1.0]).astype(object)
+        expected = "0    1.0\ndtype: object"
+        assert repr(ser) == expected
+
+    def test_different_null_objects(self):
+        # GH#45263
+        ser = Series([1, 2, 3, 4], [True, None, np.nan, pd.NaT])
+        result = repr(ser)
+        expected = "True    1\nNone    2\nNaN     3\nNaT     4\ndtype: int64"
+        assert result == expected
+
+
+class TestCategoricalRepr:
+    def test_categorical_repr_unicode(self):
+        # see gh-21002
+
+        class County:
+            name = "San Sebastián"
+            state = "PR"
+
+            def __repr__(self) -> str:
+                return self.name + ", " + self.state
+
+        cat = Categorical([County() for _ in range(61)])
+        idx = Index(cat)
+        ser = idx.to_series()
+
+        repr(ser)
+        str(ser)
+
+    def test_categorical_repr(self, using_infer_string):
+        a = Series(Categorical([1, 2, 3, 4]))
+        exp = (
+            "0    1\n1    2\n2    3\n3    4\n"
+            "dtype: category\nCategories (4, int64): [1, 2, 3, 4]"
+        )
+
+        assert exp == a.__str__()
+
+        a = Series(Categorical(["a", "b"] * 25))
+        if using_infer_string:
+            exp = (
+                "0     a\n1     b\n"
+                "     ..\n"
+                "48    a\n49    b\n"
+                "Length: 50, dtype: category\nCategories (2, string): [a, b]"
+            )
+        else:
+            exp = (
+                "0     a\n1     b\n"
+                "     ..\n"
+                "48    a\n49    b\n"
+                "Length: 50, dtype: category\nCategories (2, object): ['a', 'b']"
+            )
+        with option_context("display.max_rows", 5):
+            assert exp == repr(a)
+
+        levs = list("abcdefghijklmnopqrstuvwxyz")
+        a = Series(Categorical(["a", "b"], categories=levs, ordered=True))
+        if using_infer_string:
+            exp = (
+                "0    a\n1    b\n"
+                "dtype: category\n"
+                "Categories (26, string): [a < b < c < d ... w < x < y < z]"
+            )
+        else:
+            exp = (
+                "0    a\n1    b\n"
+                "dtype: category\n"
+                "Categories (26, object): ['a' < 'b' < 'c' < 'd' ... "
+                "'w' < 'x' < 'y' < 'z']"
+            )
+        assert exp == a.__str__()
+
+    def test_categorical_series_repr(self):
+        s = Series(Categorical([1, 2, 3]))
+        exp = """0    1
+1    2
+2    3
+dtype: category
+Categories (3, int64): [1, 2, 3]"""
+
+        assert repr(s) == exp
+
+        s = Series(Categorical(np.arange(10)))
+        exp = f"""0    0
+1    1
+2    2
+3    3
+4    4
+5    5
+6    6
+7    7
+8    8
+9    9
+dtype: category
+Categories (10, {np.dtype(int)}): [0, 1, 2, 3, ..., 6, 7, 8, 9]"""
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_ordered(self):
+        s = Series(Categorical([1, 2, 3], ordered=True))
+        exp = """0    1
+1    2
+2    3
+dtype: category
+Categories (3, int64): [1 < 2 < 3]"""
+
+        assert repr(s) == exp
+
+        s = Series(Categorical(np.arange(10), ordered=True))
+        exp = f"""0    0
+1    1
+2    2
+3    3
+4    4
+5    5
+6    6
+7    7
+8    8
+9    9
+dtype: category
+Categories (10, {np.dtype(int)}): [0 < 1 < 2 < 3 ... 6 < 7 < 8 < 9]"""
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_datetime(self):
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        s = Series(Categorical(idx))
+        exp = """0   2011-01-01 09:00:00
+1   2011-01-01 10:00:00
+2   2011-01-01 11:00:00
+3   2011-01-01 12:00:00
+4   2011-01-01 13:00:00
+dtype: category
+Categories (5, datetime64[ns]): [2011-01-01 09:00:00, 2011-01-01 10:00:00, 2011-01-01 11:00:00,
+                                 2011-01-01 12:00:00, 2011-01-01 13:00:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        s = Series(Categorical(idx))
+        exp = """0   2011-01-01 09:00:00-05:00
+1   2011-01-01 10:00:00-05:00
+2   2011-01-01 11:00:00-05:00
+3   2011-01-01 12:00:00-05:00
+4   2011-01-01 13:00:00-05:00
+dtype: category
+Categories (5, datetime64[ns, US/Eastern]): [2011-01-01 09:00:00-05:00, 2011-01-01 10:00:00-05:00,
+                                             2011-01-01 11:00:00-05:00, 2011-01-01 12:00:00-05:00,
+                                             2011-01-01 13:00:00-05:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_datetime_ordered(self):
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0   2011-01-01 09:00:00
+1   2011-01-01 10:00:00
+2   2011-01-01 11:00:00
+3   2011-01-01 12:00:00
+4   2011-01-01 13:00:00
+dtype: category
+Categories (5, datetime64[ns]): [2011-01-01 09:00:00 < 2011-01-01 10:00:00 < 2011-01-01 11:00:00 <
+                                 2011-01-01 12:00:00 < 2011-01-01 13:00:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0   2011-01-01 09:00:00-05:00
+1   2011-01-01 10:00:00-05:00
+2   2011-01-01 11:00:00-05:00
+3   2011-01-01 12:00:00-05:00
+4   2011-01-01 13:00:00-05:00
+dtype: category
+Categories (5, datetime64[ns, US/Eastern]): [2011-01-01 09:00:00-05:00 < 2011-01-01 10:00:00-05:00 <
+                                             2011-01-01 11:00:00-05:00 < 2011-01-01 12:00:00-05:00 <
+                                             2011-01-01 13:00:00-05:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_period(self):
+        idx = period_range("2011-01-01 09:00", freq="h", periods=5)
+        s = Series(Categorical(idx))
+        exp = """0    2011-01-01 09:00
+1    2011-01-01 10:00
+2    2011-01-01 11:00
+3    2011-01-01 12:00
+4    2011-01-01 13:00
+dtype: category
+Categories (5, period[h]): [2011-01-01 09:00, 2011-01-01 10:00, 2011-01-01 11:00, 2011-01-01 12:00,
+                            2011-01-01 13:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+        idx = period_range("2011-01", freq="M", periods=5)
+        s = Series(Categorical(idx))
+        exp = """0    2011-01
+1    2011-02
+2    2011-03
+3    2011-04
+4    2011-05
+dtype: category
+Categories (5, period[M]): [2011-01, 2011-02, 2011-03, 2011-04, 2011-05]"""
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_period_ordered(self):
+        idx = period_range("2011-01-01 09:00", freq="h", periods=5)
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0    2011-01-01 09:00
+1    2011-01-01 10:00
+2    2011-01-01 11:00
+3    2011-01-01 12:00
+4    2011-01-01 13:00
+dtype: category
+Categories (5, period[h]): [2011-01-01 09:00 < 2011-01-01 10:00 < 2011-01-01 11:00 < 2011-01-01 12:00 <
+                            2011-01-01 13:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+        idx = period_range("2011-01", freq="M", periods=5)
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0    2011-01
+1    2011-02
+2    2011-03
+3    2011-04
+4    2011-05
+dtype: category
+Categories (5, period[M]): [2011-01 < 2011-02 < 2011-03 < 2011-04 < 2011-05]"""
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_timedelta(self):
+        idx = timedelta_range("1 days", periods=5)
+        s = Series(Categorical(idx))
+        exp = """0   1 days
+1   2 days
+2   3 days
+3   4 days
+4   5 days
+dtype: category
+Categories (5, timedelta64[ns]): [1 days, 2 days, 3 days, 4 days, 5 days]"""
+
+        assert repr(s) == exp
+
+        idx = timedelta_range("1 hours", periods=10)
+        s = Series(Categorical(idx))
+        exp = """0   0 days 01:00:00
+1   1 days 01:00:00
+2   2 days 01:00:00
+3   3 days 01:00:00
+4   4 days 01:00:00
+5   5 days 01:00:00
+6   6 days 01:00:00
+7   7 days 01:00:00
+8   8 days 01:00:00
+9   9 days 01:00:00
+dtype: category
+Categories (10, timedelta64[ns]): [0 days 01:00:00, 1 days 01:00:00, 2 days 01:00:00,
+                                   3 days 01:00:00, ..., 6 days 01:00:00, 7 days 01:00:00,
+                                   8 days 01:00:00, 9 days 01:00:00]"""  # noqa: E501
+
+        assert repr(s) == exp
+
+    def test_categorical_series_repr_timedelta_ordered(self):
+        idx = timedelta_range("1 days", periods=5)
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0   1 days
+1   2 days
+2   3 days
+3   4 days
+4   5 days
+dtype: category
+Categories (5, timedelta64[ns]): [1 days < 2 days < 3 days < 4 days < 5 days]"""
+
+        assert repr(s) == exp
+
+        idx = timedelta_range("1 hours", periods=10)
+        s = Series(Categorical(idx, ordered=True))
+        exp = """0   0 days 01:00:00
+1   1 days 01:00:00
+2   2 days 01:00:00
+3   3 days 01:00:00
+4   4 days 01:00:00
+5   5 days 01:00:00
+6   6 days 01:00:00
+7   7 days 01:00:00
+8   8 days 01:00:00
+9   9 days 01:00:00
+dtype: category
+Categories (10, timedelta64[ns]): [0 days 01:00:00 < 1 days 01:00:00 < 2 days 01:00:00 <
+                                   3 days 01:00:00 ... 6 days 01:00:00 < 7 days 01:00:00 <
+                                   8 days 01:00:00 < 9 days 01:00:00]"""  # noqa: E501
+
+        assert repr(s) == exp
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_iteration.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_iteration.py
new file mode 100644
index 0000000000000000000000000000000000000000..edc82455234bba0203d817417e7bf122c876bfff
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_iteration.py
@@ -0,0 +1,35 @@
+class TestIteration:
+    def test_keys(self, datetime_series):
+        assert datetime_series.keys() is datetime_series.index
+
+    def test_iter_datetimes(self, datetime_series):
+        for i, val in enumerate(datetime_series):
+            # pylint: disable-next=unnecessary-list-index-lookup
+            assert val == datetime_series.iloc[i]
+
+    def test_iter_strings(self, string_series):
+        for i, val in enumerate(string_series):
+            # pylint: disable-next=unnecessary-list-index-lookup
+            assert val == string_series.iloc[i]
+
+    def test_iteritems_datetimes(self, datetime_series):
+        for idx, val in datetime_series.items():
+            assert val == datetime_series[idx]
+
+    def test_iteritems_strings(self, string_series):
+        for idx, val in string_series.items():
+            assert val == string_series[idx]
+
+        # assert is lazy (generators don't define reverse, lists do)
+        assert not hasattr(string_series.items(), "reverse")
+
+    def test_items_datetimes(self, datetime_series):
+        for idx, val in datetime_series.items():
+            assert val == datetime_series[idx]
+
+    def test_items_strings(self, string_series):
+        for idx, val in string_series.items():
+            assert val == string_series[idx]
+
+        # assert is lazy (generators don't define reverse, lists do)
+        assert not hasattr(string_series.items(), "reverse")
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_logical_ops.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_logical_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9c94e871bd4bf39e0a380ca1bc3806dc33154c2
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_logical_ops.py
@@ -0,0 +1,548 @@
+from datetime import datetime
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    bdate_range,
+)
+import pandas._testing as tm
+from pandas.core import ops
+
+
+class TestSeriesLogicalOps:
+    @pytest.mark.filterwarnings("ignore:Downcasting object dtype arrays:FutureWarning")
+    @pytest.mark.parametrize("bool_op", [operator.and_, operator.or_, operator.xor])
+    def test_bool_operators_with_nas(self, bool_op):
+        # boolean &, |, ^ should work with object arrays and propagate NAs
+        ser = Series(bdate_range("1/1/2000", periods=10), dtype=object)
+        ser[::2] = np.nan
+
+        mask = ser.isna()
+        filled = ser.fillna(ser[0])
+
+        result = bool_op(ser < ser[9], ser > ser[3])
+
+        expected = bool_op(filled < filled[9], filled > filled[3])
+        expected[mask] = False
+        tm.assert_series_equal(result, expected)
+
+    def test_logical_operators_bool_dtype_with_empty(self):
+        # GH#9016: support bitwise op for integer types
+        index = list("bca")
+
+        s_tft = Series([True, False, True], index=index)
+        s_fff = Series([False, False, False], index=index)
+        s_empty = Series([], dtype=object)
+
+        res = s_tft & s_empty
+        expected = s_fff.sort_index()
+        tm.assert_series_equal(res, expected)
+
+        res = s_tft | s_empty
+        expected = s_tft.sort_index()
+        tm.assert_series_equal(res, expected)
+
+    def test_logical_operators_int_dtype_with_int_dtype(self):
+        # GH#9016: support bitwise op for integer types
+
+        s_0123 = Series(range(4), dtype="int64")
+        s_3333 = Series([3] * 4)
+        s_4444 = Series([4] * 4)
+
+        res = s_0123 & s_3333
+        expected = Series(range(4), dtype="int64")
+        tm.assert_series_equal(res, expected)
+
+        res = s_0123 | s_4444
+        expected = Series(range(4, 8), dtype="int64")
+        tm.assert_series_equal(res, expected)
+
+        s_1111 = Series([1] * 4, dtype="int8")
+        res = s_0123 & s_1111
+        expected = Series([0, 1, 0, 1], dtype="int64")
+        tm.assert_series_equal(res, expected)
+
+        res = s_0123.astype(np.int16) | s_1111.astype(np.int32)
+        expected = Series([1, 1, 3, 3], dtype="int32")
+        tm.assert_series_equal(res, expected)
+
+    def test_logical_operators_int_dtype_with_int_scalar(self):
+        # GH#9016: support bitwise op for integer types
+        s_0123 = Series(range(4), dtype="int64")
+
+        res = s_0123 & 0
+        expected = Series([0] * 4)
+        tm.assert_series_equal(res, expected)
+
+        res = s_0123 & 1
+        expected = Series([0, 1, 0, 1])
+        tm.assert_series_equal(res, expected)
+
+    def test_logical_operators_int_dtype_with_float(self):
+        # GH#9016: support bitwise op for integer types
+        s_0123 = Series(range(4), dtype="int64")
+
+        warn_msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+
+        msg = "Cannot perform.+with a dtyped.+array and scalar of type"
+        with pytest.raises(TypeError, match=msg):
+            s_0123 & np.nan
+        with pytest.raises(TypeError, match=msg):
+            s_0123 & 3.14
+        msg = "unsupported operand type.+for &:"
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                s_0123 & [0.1, 4, 3.14, 2]
+        with pytest.raises(TypeError, match=msg):
+            s_0123 & np.array([0.1, 4, 3.14, 2])
+        with pytest.raises(TypeError, match=msg):
+            s_0123 & Series([0.1, 4, -3.14, 2])
+
+    def test_logical_operators_int_dtype_with_str(self):
+        s_1111 = Series([1] * 4, dtype="int8")
+
+        warn_msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+
+        msg = "Cannot perform 'and_' with a dtyped.+array and scalar of type"
+        with pytest.raises(TypeError, match=msg):
+            s_1111 & "a"
+        with pytest.raises(TypeError, match="unsupported operand.+for &"):
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                s_1111 & ["a", "b", "c", "d"]
+
+    def test_logical_operators_int_dtype_with_bool(self):
+        # GH#9016: support bitwise op for integer types
+        s_0123 = Series(range(4), dtype="int64")
+
+        expected = Series([False] * 4)
+
+        result = s_0123 & False
+        tm.assert_series_equal(result, expected)
+
+        warn_msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            result = s_0123 & [False]
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            result = s_0123 & (False,)
+        tm.assert_series_equal(result, expected)
+
+        result = s_0123 ^ False
+        expected = Series([False, True, True, True])
+        tm.assert_series_equal(result, expected)
+
+    def test_logical_operators_int_dtype_with_object(self, using_infer_string):
+        # GH#9016: support bitwise op for integer types
+        s_0123 = Series(range(4), dtype="int64")
+
+        result = s_0123 & Series([False, np.nan, False, False])
+        expected = Series([False] * 4)
+        tm.assert_series_equal(result, expected)
+
+        s_abNd = Series(["a", "b", np.nan, "d"])
+        if using_infer_string:
+            import pyarrow as pa
+
+            with pytest.raises(pa.lib.ArrowNotImplementedError, match="has no kernel"):
+                s_0123 & s_abNd
+        else:
+            with pytest.raises(TypeError, match="unsupported.* 'int' and 'str'"):
+                s_0123 & s_abNd
+
+    def test_logical_operators_bool_dtype_with_int(self):
+        index = list("bca")
+
+        s_tft = Series([True, False, True], index=index)
+        s_fff = Series([False, False, False], index=index)
+
+        res = s_tft & 0
+        expected = s_fff
+        tm.assert_series_equal(res, expected)
+
+        res = s_tft & 1
+        expected = s_tft
+        tm.assert_series_equal(res, expected)
+
+    def test_logical_ops_bool_dtype_with_ndarray(self):
+        # make sure we operate on ndarray the same as Series
+        left = Series([True, True, True, False, True])
+        right = [True, False, None, True, np.nan]
+
+        msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+
+        expected = Series([True, False, False, False, False])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = left & right
+        tm.assert_series_equal(result, expected)
+        result = left & np.array(right)
+        tm.assert_series_equal(result, expected)
+        result = left & Index(right)
+        tm.assert_series_equal(result, expected)
+        result = left & Series(right)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([True, True, True, True, True])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = left | right
+        tm.assert_series_equal(result, expected)
+        result = left | np.array(right)
+        tm.assert_series_equal(result, expected)
+        result = left | Index(right)
+        tm.assert_series_equal(result, expected)
+        result = left | Series(right)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([False, True, True, True, True])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = left ^ right
+        tm.assert_series_equal(result, expected)
+        result = left ^ np.array(right)
+        tm.assert_series_equal(result, expected)
+        result = left ^ Index(right)
+        tm.assert_series_equal(result, expected)
+        result = left ^ Series(right)
+        tm.assert_series_equal(result, expected)
+
+    def test_logical_operators_int_dtype_with_bool_dtype_and_reindex(self):
+        # GH#9016: support bitwise op for integer types
+
+        index = list("bca")
+
+        s_tft = Series([True, False, True], index=index)
+        s_tft = Series([True, False, True], index=index)
+        s_tff = Series([True, False, False], index=index)
+
+        s_0123 = Series(range(4), dtype="int64")
+
+        # s_0123 will be all false now because of reindexing like s_tft
+        expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
+        with tm.assert_produces_warning(FutureWarning):
+            result = s_tft & s_0123
+        tm.assert_series_equal(result, expected)
+
+        # GH 52538: Deprecate casting to object type when reindex is needed;
+        # matches DataFrame behavior
+        expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
+        with tm.assert_produces_warning(FutureWarning):
+            result = s_0123 & s_tft
+        tm.assert_series_equal(result, expected)
+
+        s_a0b1c0 = Series([1], list("b"))
+
+        with tm.assert_produces_warning(FutureWarning):
+            res = s_tft & s_a0b1c0
+        expected = s_tff.reindex(list("abc"))
+        tm.assert_series_equal(res, expected)
+
+        with tm.assert_produces_warning(FutureWarning):
+            res = s_tft | s_a0b1c0
+        expected = s_tft.reindex(list("abc"))
+        tm.assert_series_equal(res, expected)
+
+    def test_scalar_na_logical_ops_corners(self):
+        s = Series([2, 3, 4, 5, 6, 7, 8, 9, 10])
+
+        msg = "Cannot perform.+with a dtyped.+array and scalar of type"
+        with pytest.raises(TypeError, match=msg):
+            s & datetime(2005, 1, 1)
+
+        s = Series([2, 3, 4, 5, 6, 7, 8, 9, datetime(2005, 1, 1)])
+        s[::2] = np.nan
+
+        expected = Series(True, index=s.index)
+        expected[::2] = False
+
+        msg = (
+            r"Logical ops \(and, or, xor\) between Pandas objects and "
+            "dtype-less sequences"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s & list(s)
+        tm.assert_series_equal(result, expected)
+
+    def test_scalar_na_logical_ops_corners_aligns(self):
+        s = Series([2, 3, 4, 5, 6, 7, 8, 9, datetime(2005, 1, 1)])
+        s[::2] = np.nan
+        d = DataFrame({"A": s})
+
+        expected = DataFrame(False, index=range(9), columns=["A"] + list(range(9)))
+
+        result = s & d
+        tm.assert_frame_equal(result, expected)
+
+        result = d & s
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("op", [operator.and_, operator.or_, operator.xor])
+    def test_logical_ops_with_index(self, op):
+        # GH#22092, GH#19792
+        ser = Series([True, True, False, False])
+        idx1 = Index([True, False, True, False])
+        idx2 = Index([1, 0, 1, 0])
+
+        expected = Series([op(ser[n], idx1[n]) for n in range(len(ser))])
+
+        result = op(ser, idx1)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([op(ser[n], idx2[n]) for n in range(len(ser))], dtype=bool)
+
+        result = op(ser, idx2)
+        tm.assert_series_equal(result, expected)
+
+    def test_reversed_xor_with_index_returns_series(self):
+        # GH#22092, GH#19792 pre-2.0 these were aliased to setops
+        ser = Series([True, True, False, False])
+        idx1 = Index([True, False, True, False], dtype=bool)
+        idx2 = Index([1, 0, 1, 0])
+
+        expected = Series([False, True, True, False])
+        result = idx1 ^ ser
+        tm.assert_series_equal(result, expected)
+
+        result = idx2 ^ ser
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "op",
+        [
+            ops.rand_,
+            ops.ror_,
+        ],
+    )
+    def test_reversed_logical_op_with_index_returns_series(self, op):
+        # GH#22092, GH#19792
+        ser = Series([True, True, False, False])
+        idx1 = Index([True, False, True, False])
+        idx2 = Index([1, 0, 1, 0])
+
+        expected = Series(op(idx1.values, ser.values))
+        result = op(ser, idx1)
+        tm.assert_series_equal(result, expected)
+
+        expected = op(ser, Series(idx2))
+        result = op(ser, idx2)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "op, expected",
+        [
+            (ops.rand_, Series([False, False])),
+            (ops.ror_, Series([True, True])),
+            (ops.rxor, Series([True, True])),
+        ],
+    )
+    def test_reverse_ops_with_index(self, op, expected):
+        # https://github.com/pandas-dev/pandas/pull/23628
+        # multi-set Index ops are buggy, so let's avoid duplicates...
+        # GH#49503
+        ser = Series([True, False])
+        idx = Index([False, True])
+
+        result = op(ser, idx)
+        tm.assert_series_equal(result, expected)
+
+    def test_logical_ops_label_based(self, using_infer_string):
+        # GH#4947
+        # logical ops should be label based
+
+        a = Series([True, False, True], list("bca"))
+        b = Series([False, True, False], list("abc"))
+
+        expected = Series([False, True, False], list("abc"))
+        result = a & b
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([True, True, False], list("abc"))
+        result = a | b
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([True, False, False], list("abc"))
+        result = a ^ b
+        tm.assert_series_equal(result, expected)
+
+        # rhs is bigger
+        a = Series([True, False, True], list("bca"))
+        b = Series([False, True, False, True], list("abcd"))
+
+        expected = Series([False, True, False, False], list("abcd"))
+        result = a & b
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([True, True, False, False], list("abcd"))
+        result = a | b
+        tm.assert_series_equal(result, expected)
+
+        # filling
+
+        # vs empty
+        empty = Series([], dtype=object)
+
+        result = a & empty.copy()
+        expected = Series([False, False, False], list("abc"))
+        tm.assert_series_equal(result, expected)
+
+        result = a | empty.copy()
+        expected = Series([True, True, False], list("abc"))
+        tm.assert_series_equal(result, expected)
+
+        # vs non-matching
+        with tm.assert_produces_warning(FutureWarning):
+            result = a & Series([1], ["z"])
+        expected = Series([False, False, False, False], list("abcz"))
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning):
+            result = a | Series([1], ["z"])
+        expected = Series([True, True, False, False], list("abcz"))
+        tm.assert_series_equal(result, expected)
+
+        # identity
+        # we would like s[s|e] == s to hold for any e, whether empty or not
+        with tm.assert_produces_warning(FutureWarning):
+            for e in [
+                empty.copy(),
+                Series([1], ["z"]),
+                Series(np.nan, b.index),
+                Series(np.nan, a.index),
+            ]:
+                result = a[a | e]
+                tm.assert_series_equal(result, a[a])
+
+        for e in [Series(["z"])]:
+            warn = FutureWarning if using_infer_string else None
+            if using_infer_string:
+                import pyarrow as pa
+
+                with tm.assert_produces_warning(warn, match="Operation between non"):
+                    with pytest.raises(
+                        pa.lib.ArrowNotImplementedError, match="has no kernel"
+                    ):
+                        result = a[a | e]
+            else:
+                result = a[a | e]
+            tm.assert_series_equal(result, a[a])
+
+        # vs scalars
+        index = list("bca")
+        t = Series([True, False, True])
+
+        for v in [True, 1, 2]:
+            result = Series([True, False, True], index=index) | v
+            expected = Series([True, True, True], index=index)
+            tm.assert_series_equal(result, expected)
+
+        msg = "Cannot perform.+with a dtyped.+array and scalar of type"
+        for v in [np.nan, "foo"]:
+            with pytest.raises(TypeError, match=msg):
+                t | v
+
+        for v in [False, 0]:
+            result = Series([True, False, True], index=index) | v
+            expected = Series([True, False, True], index=index)
+            tm.assert_series_equal(result, expected)
+
+        for v in [True, 1]:
+            result = Series([True, False, True], index=index) & v
+            expected = Series([True, False, True], index=index)
+            tm.assert_series_equal(result, expected)
+
+        for v in [False, 0]:
+            result = Series([True, False, True], index=index) & v
+            expected = Series([False, False, False], index=index)
+            tm.assert_series_equal(result, expected)
+        msg = "Cannot perform.+with a dtyped.+array and scalar of type"
+        for v in [np.nan]:
+            with pytest.raises(TypeError, match=msg):
+                t & v
+
+    def test_logical_ops_df_compat(self):
+        # GH#1134
+        s1 = Series([True, False, True], index=list("ABC"), name="x")
+        s2 = Series([True, True, False], index=list("ABD"), name="x")
+
+        exp = Series([True, False, False, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s1 & s2, exp)
+        tm.assert_series_equal(s2 & s1, exp)
+
+        # True | np.nan => True
+        exp_or1 = Series([True, True, True, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s1 | s2, exp_or1)
+        # np.nan | True => np.nan, filled with False
+        exp_or = Series([True, True, False, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s2 | s1, exp_or)
+
+        # DataFrame doesn't fill nan with False
+        tm.assert_frame_equal(s1.to_frame() & s2.to_frame(), exp.to_frame())
+        tm.assert_frame_equal(s2.to_frame() & s1.to_frame(), exp.to_frame())
+
+        exp = DataFrame({"x": [True, True, np.nan, np.nan]}, index=list("ABCD"))
+        tm.assert_frame_equal(s1.to_frame() | s2.to_frame(), exp_or1.to_frame())
+        tm.assert_frame_equal(s2.to_frame() | s1.to_frame(), exp_or.to_frame())
+
+        # different length
+        s3 = Series([True, False, True], index=list("ABC"), name="x")
+        s4 = Series([True, True, True, True], index=list("ABCD"), name="x")
+
+        exp = Series([True, False, True, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s3 & s4, exp)
+        tm.assert_series_equal(s4 & s3, exp)
+
+        # np.nan | True => np.nan, filled with False
+        exp_or1 = Series([True, True, True, False], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s3 | s4, exp_or1)
+        # True | np.nan => True
+        exp_or = Series([True, True, True, True], index=list("ABCD"), name="x")
+        tm.assert_series_equal(s4 | s3, exp_or)
+
+        tm.assert_frame_equal(s3.to_frame() & s4.to_frame(), exp.to_frame())
+        tm.assert_frame_equal(s4.to_frame() & s3.to_frame(), exp.to_frame())
+
+        tm.assert_frame_equal(s3.to_frame() | s4.to_frame(), exp_or1.to_frame())
+        tm.assert_frame_equal(s4.to_frame() | s3.to_frame(), exp_or.to_frame())
+
+    @pytest.mark.xfail(reason="Will pass once #52839 deprecation is enforced")
+    def test_int_dtype_different_index_not_bool(self):
+        # GH 52500
+        ser1 = Series([1, 2, 3], index=[10, 11, 23], name="a")
+        ser2 = Series([10, 20, 30], index=[11, 10, 23], name="a")
+        result = np.bitwise_xor(ser1, ser2)
+        expected = Series([21, 8, 29], index=[10, 11, 23], name="a")
+        tm.assert_series_equal(result, expected)
+
+        result = ser1 ^ ser2
+        tm.assert_series_equal(result, expected)
+
+    def test_pyarrow_numpy_string_invalid(self):
+        # GH#56008
+        pytest.importorskip("pyarrow")
+        ser = Series([False, True])
+        ser2 = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+        result = ser == ser2
+        expected = Series(False, index=ser.index)
+        tm.assert_series_equal(result, expected)
+
+        result = ser != ser2
+        expected = Series(True, index=ser.index)
+        tm.assert_series_equal(result, expected)
+
+        with pytest.raises(TypeError, match="Invalid comparison"):
+            ser > ser2
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_missing.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_missing.py
new file mode 100644
index 0000000000000000000000000000000000000000..cafc69c4d0f20f42dc184366db0ac8933a512f54
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_missing.py
@@ -0,0 +1,105 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas._libs import iNaT
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Index,
+    NaT,
+    Series,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestSeriesMissingData:
+    def test_categorical_nan_handling(self):
+        # NaNs are represented as -1 in labels
+        s = Series(Categorical(["a", "b", np.nan, "a"]))
+        tm.assert_index_equal(s.cat.categories, Index(["a", "b"]))
+        tm.assert_numpy_array_equal(
+            s.values.codes, np.array([0, 1, -1, 0], dtype=np.int8)
+        )
+
+    def test_isna_for_inf(self):
+        s = Series(["a", np.inf, np.nan, pd.NA, 1.0])
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with pd.option_context("mode.use_inf_as_na", True):
+                r = s.isna()
+                dr = s.dropna()
+        e = Series([False, True, True, True, False])
+        de = Series(["a", 1.0], index=[0, 4])
+        tm.assert_series_equal(r, e)
+        tm.assert_series_equal(dr, de)
+
+    def test_timedelta64_nan(self):
+        td = Series([timedelta(days=i) for i in range(10)])
+
+        # nan ops on timedeltas
+        td1 = td.copy()
+        td1[0] = np.nan
+        assert isna(td1[0])
+        assert td1[0]._value == iNaT
+        td1[0] = td[0]
+        assert not isna(td1[0])
+
+        # GH#16674 iNaT is treated as an integer when given by the user
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            td1[1] = iNaT
+        assert not isna(td1[1])
+        assert td1.dtype == np.object_
+        assert td1[1] == iNaT
+        td1[1] = td[1]
+        assert not isna(td1[1])
+
+        td1[2] = NaT
+        assert isna(td1[2])
+        assert td1[2]._value == iNaT
+        td1[2] = td[2]
+        assert not isna(td1[2])
+
+        # boolean setting
+        # GH#2899 boolean setting
+        td3 = np.timedelta64(timedelta(days=3))
+        td7 = np.timedelta64(timedelta(days=7))
+        td[(td > td3) & (td < td7)] = np.nan
+        assert isna(td).sum() == 3
+
+    @pytest.mark.xfail(
+        reason="Chained inequality raises when trying to define 'selector'"
+    )
+    def test_logical_range_select(self, datetime_series):
+        # NumPy limitation =(
+        # https://github.com/pandas-dev/pandas/commit/9030dc021f07c76809848925cb34828f6c8484f3
+
+        selector = -0.5 <= datetime_series <= 0.5
+        expected = (datetime_series >= -0.5) & (datetime_series <= 0.5)
+        tm.assert_series_equal(selector, expected)
+
+    def test_valid(self, datetime_series):
+        ts = datetime_series.copy()
+        ts.index = ts.index._with_freq(None)
+        ts[::2] = np.nan
+
+        result = ts.dropna()
+        assert len(result) == ts.count()
+        tm.assert_series_equal(result, ts[1::2])
+        tm.assert_series_equal(result, ts[pd.notna(ts)])
+
+
+def test_hasnans_uncached_for_series():
+    # GH#19700
+    # set float64 dtype to avoid upcast when setting nan
+    idx = Index([0, 1], dtype="float64")
+    assert idx.hasnans is False
+    assert "hasnans" in idx._cache
+    ser = idx.to_series()
+    assert ser.hasnans is False
+    assert not hasattr(ser, "_cache")
+    ser.iloc[-1] = np.nan
+    assert ser.hasnans is True
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_npfuncs.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_npfuncs.py
new file mode 100644
index 0000000000000000000000000000000000000000..11a51c4700d5c1733e7136909d86d2ea7294dd8e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_npfuncs.py
@@ -0,0 +1,46 @@
+"""
+Tests for np.foo applied to Series, not necessarily ufuncs.
+"""
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestPtp:
+    def test_ptp(self):
+        # GH#21614
+        N = 1000
+        arr = np.random.default_rng(2).standard_normal(N)
+        ser = Series(arr)
+        assert np.ptp(ser) == np.ptp(arr)
+
+
+def test_numpy_unique(datetime_series):
+    # it works!
+    np.unique(datetime_series)
+
+
+@pytest.mark.parametrize("index", [["a", "b", "c", "d", "e"], None])
+def test_numpy_argwhere(index):
+    # GH#35331
+
+    s = Series(range(5), index=index, dtype=np.int64)
+
+    result = np.argwhere(s > 2).astype(np.int64)
+    expected = np.array([[3], [4]], dtype=np.int64)
+
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@td.skip_if_no("pyarrow")
+def test_log_arrow_backed_missing_value():
+    # GH#56285
+    ser = Series([1, 2, None], dtype="float64[pyarrow]")
+    result = np.log(ser)
+    expected = np.log(Series([1, 2, None], dtype="float64"))
+    tm.assert_series_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_reductions.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_reductions.py
new file mode 100644
index 0000000000000000000000000000000000000000..76353ab25fca6e5208f099b030aa308aeb8837c1
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_reductions.py
@@ -0,0 +1,218 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("operation, expected", [("min", "a"), ("max", "b")])
+def test_reductions_series_strings(operation, expected):
+    # GH#31746
+    ser = Series(["a", "b"], dtype="string")
+    res_operation_serie = getattr(ser, operation)()
+    assert res_operation_serie == expected
+
+
+@pytest.mark.parametrize("as_period", [True, False])
+def test_mode_extension_dtype(as_period):
+    # GH#41927 preserve dt64tz dtype
+    ser = Series([pd.Timestamp(1979, 4, n) for n in range(1, 5)])
+
+    if as_period:
+        ser = ser.dt.to_period("D")
+    else:
+        ser = ser.dt.tz_localize("US/Central")
+
+    res = ser.mode()
+    assert res.dtype == ser.dtype
+    tm.assert_series_equal(res, ser)
+
+
+def test_mode_nullable_dtype(any_numeric_ea_dtype):
+    # GH#55340
+    ser = Series([1, 3, 2, pd.NA, 3, 2, pd.NA], dtype=any_numeric_ea_dtype)
+    result = ser.mode(dropna=False)
+    expected = Series([2, 3, pd.NA], dtype=any_numeric_ea_dtype)
+    tm.assert_series_equal(result, expected)
+
+    result = ser.mode(dropna=True)
+    expected = Series([2, 3], dtype=any_numeric_ea_dtype)
+    tm.assert_series_equal(result, expected)
+
+    ser[-1] = pd.NA
+
+    result = ser.mode(dropna=True)
+    expected = Series([2, 3], dtype=any_numeric_ea_dtype)
+    tm.assert_series_equal(result, expected)
+
+    result = ser.mode(dropna=False)
+    expected = Series([pd.NA], dtype=any_numeric_ea_dtype)
+    tm.assert_series_equal(result, expected)
+
+
+def test_mode_infer_string():
+    # GH#56183
+    pytest.importorskip("pyarrow")
+    ser = Series(["a", "b"], dtype=object)
+    with pd.option_context("future.infer_string", True):
+        result = ser.mode()
+    expected = Series(["a", "b"], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_reductions_td64_with_nat():
+    # GH#8617
+    ser = Series([0, pd.NaT], dtype="m8[ns]")
+    exp = ser[0]
+    assert ser.median() == exp
+    assert ser.min() == exp
+    assert ser.max() == exp
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+def test_td64_sum_empty(skipna):
+    # GH#37151
+    ser = Series([], dtype="timedelta64[ns]")
+
+    result = ser.sum(skipna=skipna)
+    assert isinstance(result, pd.Timedelta)
+    assert result == pd.Timedelta(0)
+
+
+def test_td64_summation_overflow():
+    # GH#9442
+    ser = Series(pd.date_range("20130101", periods=100000, freq="h"))
+    ser[0] += pd.Timedelta("1s 1ms")
+
+    # mean
+    result = (ser - ser.min()).mean()
+    expected = pd.Timedelta((pd.TimedeltaIndex(ser - ser.min()).asi8 / len(ser)).sum())
+
+    # the computation is converted to float so
+    # might be some loss of precision
+    assert np.allclose(result._value / 1000, expected._value / 1000)
+
+    # sum
+    msg = "overflow in timedelta operation"
+    with pytest.raises(ValueError, match=msg):
+        (ser - ser.min()).sum()
+
+    s1 = ser[0:10000]
+    with pytest.raises(ValueError, match=msg):
+        (s1 - s1.min()).sum()
+    s2 = ser[0:1000]
+    (s2 - s2.min()).sum()
+
+
+def test_prod_numpy16_bug():
+    ser = Series([1.0, 1.0, 1.0], index=range(3))
+    result = ser.prod()
+
+    assert not isinstance(result, Series)
+
+
+@pytest.mark.parametrize("func", [np.any, np.all])
+@pytest.mark.parametrize("kwargs", [{"keepdims": True}, {"out": object()}])
+def test_validate_any_all_out_keepdims_raises(kwargs, func):
+    ser = Series([1, 2])
+    param = next(iter(kwargs))
+    name = func.__name__
+
+    msg = (
+        f"the '{param}' parameter is not "
+        "supported in the pandas "
+        rf"implementation of {name}\(\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        func(ser, **kwargs)
+
+
+def test_validate_sum_initial():
+    ser = Series([1, 2])
+    msg = (
+        r"the 'initial' parameter is not "
+        r"supported in the pandas "
+        r"implementation of sum\(\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        np.sum(ser, initial=10)
+
+
+def test_validate_median_initial():
+    ser = Series([1, 2])
+    msg = (
+        r"the 'overwrite_input' parameter is not "
+        r"supported in the pandas "
+        r"implementation of median\(\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        # It seems like np.median doesn't dispatch, so we use the
+        # method instead of the ufunc.
+        ser.median(overwrite_input=True)
+
+
+def test_validate_stat_keepdims():
+    ser = Series([1, 2])
+    msg = (
+        r"the 'keepdims' parameter is not "
+        r"supported in the pandas "
+        r"implementation of sum\(\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        np.sum(ser, keepdims=True)
+
+
+def test_mean_with_convertible_string_raises(using_array_manager, using_infer_string):
+    # GH#44008
+    ser = Series(["1", "2"])
+    if using_infer_string:
+        msg = "does not support"
+        with pytest.raises(TypeError, match=msg):
+            ser.sum()
+    else:
+        assert ser.sum() == "12"
+    msg = "Could not convert string '12' to numeric|does not support"
+    with pytest.raises(TypeError, match=msg):
+        ser.mean()
+
+    df = ser.to_frame()
+    if not using_array_manager:
+        msg = r"Could not convert \['12'\] to numeric|does not support"
+    with pytest.raises(TypeError, match=msg):
+        df.mean()
+
+
+def test_mean_dont_convert_j_to_complex(using_array_manager):
+    # GH#36703
+    df = pd.DataFrame([{"db": "J", "numeric": 123}])
+    if using_array_manager:
+        msg = "Could not convert string 'J' to numeric"
+    else:
+        msg = r"Could not convert \['J'\] to numeric|does not support"
+    with pytest.raises(TypeError, match=msg):
+        df.mean()
+
+    with pytest.raises(TypeError, match=msg):
+        df.agg("mean")
+
+    msg = "Could not convert string 'J' to numeric|does not support"
+    with pytest.raises(TypeError, match=msg):
+        df["db"].mean()
+    msg = "Could not convert string 'J' to numeric|ufunc 'divide'"
+    with pytest.raises(TypeError, match=msg):
+        np.mean(df["db"].astype("string").array)
+
+
+def test_median_with_convertible_string_raises(using_array_manager):
+    # GH#34671 this _could_ return a string "2", but definitely not float 2.0
+    msg = r"Cannot convert \['1' '2' '3'\] to numeric|does not support"
+    ser = Series(["1", "2", "3"])
+    with pytest.raises(TypeError, match=msg):
+        ser.median()
+
+    if not using_array_manager:
+        msg = r"Cannot convert \[\['1' '2' '3'\]\] to numeric|does not support"
+    df = ser.to_frame()
+    with pytest.raises(TypeError, match=msg):
+        df.median()
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_subclass.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_subclass.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2d5afcf884b12b3007905061b7c503359e71a5d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_subclass.py
@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager|Passing a SingleBlockManager:DeprecationWarning"
+)
+
+
+class TestSeriesSubclassing:
+    @pytest.mark.parametrize(
+        "idx_method, indexer, exp_data, exp_idx",
+        [
+            ["loc", ["a", "b"], [1, 2], "ab"],
+            ["iloc", [2, 3], [3, 4], "cd"],
+        ],
+    )
+    def test_indexing_sliced(self, idx_method, indexer, exp_data, exp_idx):
+        s = tm.SubclassedSeries([1, 2, 3, 4], index=list("abcd"))
+        res = getattr(s, idx_method)[indexer]
+        exp = tm.SubclassedSeries(exp_data, index=list(exp_idx))
+        tm.assert_series_equal(res, exp)
+
+    def test_to_frame(self):
+        s = tm.SubclassedSeries([1, 2, 3, 4], index=list("abcd"), name="xxx")
+        res = s.to_frame()
+        exp = tm.SubclassedDataFrame({"xxx": [1, 2, 3, 4]}, index=list("abcd"))
+        tm.assert_frame_equal(res, exp)
+
+    def test_subclass_unstack(self):
+        # GH 15564
+        s = tm.SubclassedSeries([1, 2, 3, 4], index=[list("aabb"), list("xyxy")])
+
+        res = s.unstack()
+        exp = tm.SubclassedDataFrame({"x": [1, 3], "y": [2, 4]}, index=["a", "b"])
+
+        tm.assert_frame_equal(res, exp)
+
+    def test_subclass_empty_repr(self):
+        sub_series = tm.SubclassedSeries()
+        assert "SubclassedSeries" in repr(sub_series)
+
+    def test_asof(self):
+        N = 3
+        rng = pd.date_range("1/1/1990", periods=N, freq="53s")
+        s = tm.SubclassedSeries({"A": [np.nan, np.nan, np.nan]}, index=rng)
+
+        result = s.asof(rng[-2:])
+        assert isinstance(result, tm.SubclassedSeries)
+
+    def test_explode(self):
+        s = tm.SubclassedSeries([[1, 2, 3], "foo", [], [3, 4]])
+        result = s.explode()
+        assert isinstance(result, tm.SubclassedSeries)
+
+    def test_equals(self):
+        # https://github.com/pandas-dev/pandas/pull/34402
+        # allow subclass in both directions
+        s1 = pd.Series([1, 2, 3])
+        s2 = tm.SubclassedSeries([1, 2, 3])
+        assert s1.equals(s2)
+        assert s2.equals(s1)
+
+
+class SubclassedSeries(pd.Series):
+    @property
+    def _constructor(self):
+        def _new(*args, **kwargs):
+            # some constructor logic that accesses the Series' name
+            if self.name == "test":
+                return pd.Series(*args, **kwargs)
+            return SubclassedSeries(*args, **kwargs)
+
+        return _new
+
+
+def test_constructor_from_dict():
+    # https://github.com/pandas-dev/pandas/issues/52445
+    result = SubclassedSeries({"a": 1, "b": 2, "c": 3})
+    assert isinstance(result, SubclassedSeries)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_ufunc.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_ufunc.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d13ebf740eabb562fea10336a39edc36e431f5e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_ufunc.py
@@ -0,0 +1,460 @@
+from collections import deque
+import re
+import string
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import SparseArray
+
+
+@pytest.fixture(params=[np.add, np.logaddexp])
+def ufunc(request):
+    # dunder op
+    return request.param
+
+
+@pytest.fixture(params=[True, False], ids=["sparse", "dense"])
+def sparse(request):
+    return request.param
+
+
+@pytest.fixture
+def arrays_for_binary_ufunc():
+    """
+    A pair of random, length-100 integer-dtype arrays, that are mostly 0.
+    """
+    a1 = np.random.default_rng(2).integers(0, 10, 100, dtype="int64")
+    a2 = np.random.default_rng(2).integers(0, 10, 100, dtype="int64")
+    a1[::3] = 0
+    a2[::4] = 0
+    return a1, a2
+
+
+@pytest.mark.parametrize("ufunc", [np.positive, np.floor, np.exp])
+def test_unary_ufunc(ufunc, sparse):
+    # Test that ufunc(pd.Series) == pd.Series(ufunc)
+    arr = np.random.default_rng(2).integers(0, 10, 10, dtype="int64")
+    arr[::2] = 0
+    if sparse:
+        arr = SparseArray(arr, dtype=pd.SparseDtype("int64", 0))
+
+    index = list(string.ascii_letters[:10])
+    name = "name"
+    series = pd.Series(arr, index=index, name=name)
+
+    result = ufunc(series)
+    expected = pd.Series(ufunc(arr), index=index, name=name)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("flip", [True, False], ids=["flipped", "straight"])
+def test_binary_ufunc_with_array(flip, sparse, ufunc, arrays_for_binary_ufunc):
+    # Test that ufunc(pd.Series(a), array) == pd.Series(ufunc(a, b))
+    a1, a2 = arrays_for_binary_ufunc
+    if sparse:
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+
+    name = "name"  # op(pd.Series, array) preserves the name.
+    series = pd.Series(a1, name=name)
+    other = a2
+
+    array_args = (a1, a2)
+    series_args = (series, other)  # ufunc(series, array)
+
+    if flip:
+        array_args = reversed(array_args)
+        series_args = reversed(series_args)  # ufunc(array, series)
+
+    expected = pd.Series(ufunc(*array_args), name=name)
+    result = ufunc(*series_args)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("flip", [True, False], ids=["flipped", "straight"])
+def test_binary_ufunc_with_index(flip, sparse, ufunc, arrays_for_binary_ufunc):
+    # Test that
+    #   * func(pd.Series(a), pd.Series(b)) == pd.Series(ufunc(a, b))
+    #   * ufunc(Index, pd.Series) dispatches to pd.Series (returns a pd.Series)
+    a1, a2 = arrays_for_binary_ufunc
+    if sparse:
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+
+    name = "name"  # op(pd.Series, array) preserves the name.
+    series = pd.Series(a1, name=name)
+
+    other = pd.Index(a2, name=name).astype("int64")
+
+    array_args = (a1, a2)
+    series_args = (series, other)  # ufunc(series, array)
+
+    if flip:
+        array_args = reversed(array_args)
+        series_args = reversed(series_args)  # ufunc(array, series)
+
+    expected = pd.Series(ufunc(*array_args), name=name)
+    result = ufunc(*series_args)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("shuffle", [True, False], ids=["unaligned", "aligned"])
+@pytest.mark.parametrize("flip", [True, False], ids=["flipped", "straight"])
+def test_binary_ufunc_with_series(
+    flip, shuffle, sparse, ufunc, arrays_for_binary_ufunc
+):
+    # Test that
+    #   * func(pd.Series(a), pd.Series(b)) == pd.Series(ufunc(a, b))
+    #   with alignment between the indices
+    a1, a2 = arrays_for_binary_ufunc
+    if sparse:
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+
+    name = "name"  # op(pd.Series, array) preserves the name.
+    series = pd.Series(a1, name=name)
+    other = pd.Series(a2, name=name)
+
+    idx = np.random.default_rng(2).permutation(len(a1))
+
+    if shuffle:
+        other = other.take(idx)
+        if flip:
+            index = other.align(series)[0].index
+        else:
+            index = series.align(other)[0].index
+    else:
+        index = series.index
+
+    array_args = (a1, a2)
+    series_args = (series, other)  # ufunc(series, array)
+
+    if flip:
+        array_args = tuple(reversed(array_args))
+        series_args = tuple(reversed(series_args))  # ufunc(array, series)
+
+    expected = pd.Series(ufunc(*array_args), index=index, name=name)
+    result = ufunc(*series_args)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("flip", [True, False])
+def test_binary_ufunc_scalar(ufunc, sparse, flip, arrays_for_binary_ufunc):
+    # Test that
+    #   * ufunc(pd.Series, scalar) == pd.Series(ufunc(array, scalar))
+    #   * ufunc(pd.Series, scalar) == ufunc(scalar, pd.Series)
+    arr, _ = arrays_for_binary_ufunc
+    if sparse:
+        arr = SparseArray(arr)
+    other = 2
+    series = pd.Series(arr, name="name")
+
+    series_args = (series, other)
+    array_args = (arr, other)
+
+    if flip:
+        series_args = tuple(reversed(series_args))
+        array_args = tuple(reversed(array_args))
+
+    expected = pd.Series(ufunc(*array_args), name="name")
+    result = ufunc(*series_args)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ufunc", [np.divmod])  # TODO: np.modf, np.frexp
+@pytest.mark.parametrize("shuffle", [True, False])
+@pytest.mark.filterwarnings("ignore:divide by zero:RuntimeWarning")
+def test_multiple_output_binary_ufuncs(ufunc, sparse, shuffle, arrays_for_binary_ufunc):
+    # Test that
+    #  the same conditions from binary_ufunc_scalar apply to
+    #  ufuncs with multiple outputs.
+
+    a1, a2 = arrays_for_binary_ufunc
+    # work around https://github.com/pandas-dev/pandas/issues/26987
+    a1[a1 == 0] = 1
+    a2[a2 == 0] = 1
+
+    if sparse:
+        a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+        a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+
+    s1 = pd.Series(a1)
+    s2 = pd.Series(a2)
+
+    if shuffle:
+        # ensure we align before applying the ufunc
+        s2 = s2.sample(frac=1)
+
+    expected = ufunc(a1, a2)
+    assert isinstance(expected, tuple)
+
+    result = ufunc(s1, s2)
+    assert isinstance(result, tuple)
+    tm.assert_series_equal(result[0], pd.Series(expected[0]))
+    tm.assert_series_equal(result[1], pd.Series(expected[1]))
+
+
+def test_multiple_output_ufunc(sparse, arrays_for_binary_ufunc):
+    # Test that the same conditions from unary input apply to multi-output
+    # ufuncs
+    arr, _ = arrays_for_binary_ufunc
+
+    if sparse:
+        arr = SparseArray(arr)
+
+    series = pd.Series(arr, name="name")
+    result = np.modf(series)
+    expected = np.modf(arr)
+
+    assert isinstance(result, tuple)
+    assert isinstance(expected, tuple)
+
+    tm.assert_series_equal(result[0], pd.Series(expected[0], name="name"))
+    tm.assert_series_equal(result[1], pd.Series(expected[1], name="name"))
+
+
+def test_binary_ufunc_drops_series_name(ufunc, sparse, arrays_for_binary_ufunc):
+    # Drop the names when they differ.
+    a1, a2 = arrays_for_binary_ufunc
+    s1 = pd.Series(a1, name="a")
+    s2 = pd.Series(a2, name="b")
+
+    result = ufunc(s1, s2)
+    assert result.name is None
+
+
+def test_object_series_ok():
+    class Dummy:
+        def __init__(self, value) -> None:
+            self.value = value
+
+        def __add__(self, other):
+            return self.value + other.value
+
+    arr = np.array([Dummy(0), Dummy(1)])
+    ser = pd.Series(arr)
+    tm.assert_series_equal(np.add(ser, ser), pd.Series(np.add(ser, arr)))
+    tm.assert_series_equal(np.add(ser, Dummy(1)), pd.Series(np.add(ser, Dummy(1))))
+
+
+@pytest.fixture(
+    params=[
+        pd.array([1, 3, 2], dtype=np.int64),
+        pd.array([1, 3, 2], dtype="Int64"),
+        pd.array([1, 3, 2], dtype="Float32"),
+        pd.array([1, 10, 2], dtype="Sparse[int]"),
+        pd.to_datetime(["2000", "2010", "2001"]),
+        pd.to_datetime(["2000", "2010", "2001"]).tz_localize("CET"),
+        pd.to_datetime(["2000", "2010", "2001"]).to_period(freq="D"),
+        pd.to_timedelta(["1 Day", "3 Days", "2 Days"]),
+        pd.IntervalIndex([pd.Interval(0, 1), pd.Interval(2, 3), pd.Interval(1, 2)]),
+    ],
+    ids=lambda x: str(x.dtype),
+)
+def values_for_np_reduce(request):
+    # min/max tests assume that these are monotonic increasing
+    return request.param
+
+
+class TestNumpyReductions:
+    # TODO: cases with NAs, axis kwarg for DataFrame
+
+    def test_multiply(self, values_for_np_reduce, box_with_array, request):
+        box = box_with_array
+        values = values_for_np_reduce
+
+        with tm.assert_produces_warning(None):
+            obj = box(values)
+
+        if isinstance(values, pd.core.arrays.SparseArray):
+            mark = pytest.mark.xfail(reason="SparseArray has no 'prod'")
+            request.applymarker(mark)
+
+        if values.dtype.kind in "iuf":
+            result = np.multiply.reduce(obj)
+            if box is pd.DataFrame:
+                expected = obj.prod(numeric_only=False)
+                tm.assert_series_equal(result, expected)
+            elif box is pd.Index:
+                # Index has no 'prod'
+                expected = obj._values.prod()
+                assert result == expected
+            else:
+                expected = obj.prod()
+                assert result == expected
+        else:
+            msg = "|".join(
+                [
+                    "does not support reduction",
+                    "unsupported operand type",
+                    "ufunc 'multiply' cannot use operands",
+                ]
+            )
+            with pytest.raises(TypeError, match=msg):
+                np.multiply.reduce(obj)
+
+    def test_add(self, values_for_np_reduce, box_with_array):
+        box = box_with_array
+        values = values_for_np_reduce
+
+        with tm.assert_produces_warning(None):
+            obj = box(values)
+
+        if values.dtype.kind in "miuf":
+            result = np.add.reduce(obj)
+            if box is pd.DataFrame:
+                expected = obj.sum(numeric_only=False)
+                tm.assert_series_equal(result, expected)
+            elif box is pd.Index:
+                # Index has no 'sum'
+                expected = obj._values.sum()
+                assert result == expected
+            else:
+                expected = obj.sum()
+                assert result == expected
+        else:
+            msg = "|".join(
+                [
+                    "does not support reduction",
+                    "unsupported operand type",
+                    "ufunc 'add' cannot use operands",
+                ]
+            )
+            with pytest.raises(TypeError, match=msg):
+                np.add.reduce(obj)
+
+    def test_max(self, values_for_np_reduce, box_with_array):
+        box = box_with_array
+        values = values_for_np_reduce
+
+        same_type = True
+        if box is pd.Index and values.dtype.kind in ["i", "f"]:
+            # ATM Index casts to object, so we get python ints/floats
+            same_type = False
+
+        with tm.assert_produces_warning(None):
+            obj = box(values)
+
+        result = np.maximum.reduce(obj)
+        if box is pd.DataFrame:
+            # TODO: cases with axis kwarg
+            expected = obj.max(numeric_only=False)
+            tm.assert_series_equal(result, expected)
+        else:
+            expected = values[1]
+            assert result == expected
+            if same_type:
+                # check we have e.g. Timestamp instead of dt64
+                assert type(result) == type(expected)
+
+    def test_min(self, values_for_np_reduce, box_with_array):
+        box = box_with_array
+        values = values_for_np_reduce
+
+        same_type = True
+        if box is pd.Index and values.dtype.kind in ["i", "f"]:
+            # ATM Index casts to object, so we get python ints/floats
+            same_type = False
+
+        with tm.assert_produces_warning(None):
+            obj = box(values)
+
+        result = np.minimum.reduce(obj)
+        if box is pd.DataFrame:
+            expected = obj.min(numeric_only=False)
+            tm.assert_series_equal(result, expected)
+        else:
+            expected = values[0]
+            assert result == expected
+            if same_type:
+                # check we have e.g. Timestamp instead of dt64
+                assert type(result) == type(expected)
+
+
+@pytest.mark.parametrize("type_", [list, deque, tuple])
+def test_binary_ufunc_other_types(type_):
+    a = pd.Series([1, 2, 3], name="name")
+    b = type_([3, 4, 5])
+
+    result = np.add(a, b)
+    expected = pd.Series(np.add(a.to_numpy(), b), name="name")
+    tm.assert_series_equal(result, expected)
+
+
+def test_object_dtype_ok():
+    class Thing:
+        def __init__(self, value) -> None:
+            self.value = value
+
+        def __add__(self, other):
+            other = getattr(other, "value", other)
+            return type(self)(self.value + other)
+
+        def __eq__(self, other) -> bool:
+            return type(other) is Thing and self.value == other.value
+
+        def __repr__(self) -> str:
+            return f"Thing({self.value})"
+
+    s = pd.Series([Thing(1), Thing(2)])
+    result = np.add(s, Thing(1))
+    expected = pd.Series([Thing(2), Thing(3)])
+    tm.assert_series_equal(result, expected)
+
+
+def test_outer():
+    # https://github.com/pandas-dev/pandas/issues/27186
+    ser = pd.Series([1, 2, 3])
+    obj = np.array([1, 2, 3])
+
+    with pytest.raises(NotImplementedError, match=""):
+        np.subtract.outer(ser, obj)
+
+
+def test_np_matmul():
+    # GH26650
+    df1 = pd.DataFrame(data=[[-1, 1, 10]])
+    df2 = pd.DataFrame(data=[-1, 1, 10])
+    expected = pd.DataFrame(data=[102])
+
+    result = np.matmul(df1, df2)
+    tm.assert_frame_equal(expected, result)
+
+
+def test_array_ufuncs_for_many_arguments():
+    # GH39853
+    def add3(x, y, z):
+        return x + y + z
+
+    ufunc = np.frompyfunc(add3, 3, 1)
+    ser = pd.Series([1, 2])
+
+    result = ufunc(ser, ser, 1)
+    expected = pd.Series([3, 5], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+    df = pd.DataFrame([[1, 2]])
+
+    msg = (
+        "Cannot apply ufunc <ufunc 'add3 (vectorized)'> "
+        "to mixed DataFrame and Series inputs."
+    )
+    with pytest.raises(NotImplementedError, match=re.escape(msg)):
+        ufunc(ser, ser, df)
+
+
+# TODO(CoW) see https://github.com/pandas-dev/pandas/pull/51082
+@td.skip_copy_on_write_not_yet_implemented
+def test_np_fix():
+    # np.fix is not a ufunc but is composed of several ufunc calls under the hood
+    # with `out` and `where` keywords
+    ser = pd.Series([-1.5, -0.5, 0.5, 1.5])
+    result = np.fix(ser)
+    expected = pd.Series([-1.0, -0.0, 0.0, 1.0])
+    tm.assert_series_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_unary.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_unary.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f153788e413c5e9198dc35867bc628823555dbf
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_unary.py
@@ -0,0 +1,50 @@
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesUnaryOps:
+    # __neg__, __pos__, __invert__
+
+    def test_neg(self):
+        ser = Series(range(5), dtype="float64", name="series")
+        tm.assert_series_equal(-ser, -1 * ser)
+
+    def test_invert(self):
+        ser = Series(range(5), dtype="float64", name="series")
+        tm.assert_series_equal(-(ser < 0), ~(ser < 0))
+
+    @pytest.mark.parametrize(
+        "source, neg_target, abs_target",
+        [
+            ([1, 2, 3], [-1, -2, -3], [1, 2, 3]),
+            ([1, 2, None], [-1, -2, None], [1, 2, None]),
+        ],
+    )
+    def test_all_numeric_unary_operators(
+        self, any_numeric_ea_dtype, source, neg_target, abs_target
+    ):
+        # GH38794
+        dtype = any_numeric_ea_dtype
+        ser = Series(source, dtype=dtype)
+        neg_result, pos_result, abs_result = -ser, +ser, abs(ser)
+        if dtype.startswith("U"):
+            neg_target = -Series(source, dtype=dtype)
+        else:
+            neg_target = Series(neg_target, dtype=dtype)
+
+        abs_target = Series(abs_target, dtype=dtype)
+
+        tm.assert_series_equal(neg_result, neg_target)
+        tm.assert_series_equal(pos_result, ser)
+        tm.assert_series_equal(abs_result, abs_target)
+
+    @pytest.mark.parametrize("op", ["__neg__", "__abs__"])
+    def test_unary_float_op_mask(self, float_ea_dtype, op):
+        dtype = float_ea_dtype
+        ser = Series([1.1, 2.2, 3.3], dtype=dtype)
+        result = getattr(ser, op)()
+        target = result.copy(deep=True)
+        ser[0] = None
+        tm.assert_series_equal(result, target)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/series/test_validate.py b/venv/lib/python3.10/site-packages/pandas/tests/series/test_validate.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c867f7582b7d3250bf5e009ffbf7545da404712
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/series/test_validate.py
@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        "reset_index",
+        "_set_name",
+        "sort_values",
+        "sort_index",
+        "rename",
+        "dropna",
+        "drop_duplicates",
+    ],
+)
+@pytest.mark.parametrize("inplace", [1, "True", [1, 2, 3], 5.0])
+def test_validate_bool_args(string_series, func, inplace):
+    """Tests for error handling related to data types of method arguments."""
+    msg = 'For argument "inplace" expected type bool'
+    kwargs = {"inplace": inplace}
+
+    if func == "_set_name":
+        kwargs["name"] = "hello"
+
+    with pytest.raises(ValueError, match=msg):
+        getattr(string_series, func)(**kwargs)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_year.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_year.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b7a1025cc19c9c1c966b9448ceffdb12dcd8159
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_year.py
@@ -0,0 +1,215 @@
+"""
+Tests for the following offsets:
+- BYearBegin
+- BYearEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    BYearBegin,
+    BYearEnd,
+)
+
+
+class TestBYearBegin:
+    def test_misspecified(self):
+        msg = "Month must go from 1 to 12"
+        with pytest.raises(ValueError, match=msg):
+            BYearBegin(month=13)
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=13)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2009, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2011, 1, 1): datetime(2011, 1, 3),
+                datetime(2011, 1, 3): datetime(2012, 1, 2),
+                datetime(2005, 12, 30): datetime(2006, 1, 2),
+                datetime(2005, 12, 31): datetime(2006, 1, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2005, 12, 30): datetime(2006, 1, 2),
+                datetime(2005, 12, 31): datetime(2006, 1, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 1, 2),
+                datetime(2009, 1, 4): datetime(2009, 1, 1),
+                datetime(2009, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 6, 30): datetime(2008, 1, 1),
+                datetime(2008, 12, 31): datetime(2008, 1, 1),
+                datetime(2006, 12, 29): datetime(2006, 1, 2),
+                datetime(2006, 12, 30): datetime(2006, 1, 2),
+                datetime(2006, 1, 1): datetime(2005, 1, 3),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 1, 3),
+                datetime(2007, 6, 30): datetime(2006, 1, 2),
+                datetime(2008, 12, 31): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestBYearEnd:
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2009, 12, 31),
+                datetime(2005, 12, 30): datetime(2006, 12, 29),
+                datetime(2005, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2008, 12, 31),
+                datetime(2005, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+                datetime(2008, 6, 30): datetime(2007, 12, 31),
+                datetime(2008, 12, 31): datetime(2007, 12, 31),
+                datetime(2006, 12, 29): datetime(2005, 12, 30),
+                datetime(2006, 12, 30): datetime(2006, 12, 29),
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 12, 30),
+                datetime(2008, 6, 30): datetime(2006, 12, 29),
+                datetime(2008, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (BYearEnd(), datetime(2007, 12, 31), True),
+        (BYearEnd(), datetime(2008, 1, 1), False),
+        (BYearEnd(), datetime(2006, 12, 31), False),
+        (BYearEnd(), datetime(2006, 12, 29), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+class TestBYearEndLagged:
+    def test_bad_month_fail(self):
+        msg = "Month must go from 1 to 12"
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=13)
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=0)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearEnd(month=6),
+            {
+                datetime(2008, 1, 1): datetime(2008, 6, 30),
+                datetime(2007, 6, 30): datetime(2008, 6, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(n=-1, month=6),
+            {
+                datetime(2008, 1, 1): datetime(2007, 6, 29),
+                datetime(2007, 6, 30): datetime(2007, 6, 29),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_roll(self):
+        offset = BYearEnd(month=6)
+        date = datetime(2009, 11, 30)
+
+        assert offset.rollforward(date) == datetime(2010, 6, 30)
+        assert offset.rollback(date) == datetime(2009, 6, 30)
+
+    on_offset_cases = [
+        (BYearEnd(month=2), datetime(2007, 2, 28), True),
+        (BYearEnd(month=6), datetime(2007, 6, 30), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_common.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa4e22f71ad66147d5b9893ead4dc250d1de0ed3
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_common.py
@@ -0,0 +1,268 @@
+from datetime import datetime
+
+from dateutil.tz.tz import tzlocal
+import pytest
+
+from pandas._libs.tslibs import (
+    OutOfBoundsDatetime,
+    Timestamp,
+)
+from pandas.compat import (
+    IS64,
+    is_platform_windows,
+)
+
+from pandas.tseries.offsets import (
+    FY5253,
+    BDay,
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BusinessHour,
+    BYearBegin,
+    BYearEnd,
+    CBMonthBegin,
+    CBMonthEnd,
+    CDay,
+    CustomBusinessHour,
+    DateOffset,
+    FY5253Quarter,
+    LastWeekOfMonth,
+    MonthBegin,
+    MonthEnd,
+    QuarterEnd,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Week,
+    WeekOfMonth,
+    YearBegin,
+    YearEnd,
+)
+
+
+def _get_offset(klass, value=1, normalize=False):
+    # create instance from offset class
+    if klass is FY5253:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is FY5253Quarter:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            qtr_with_extra_week=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is LastWeekOfMonth:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is WeekOfMonth:
+        klass = klass(n=value, week=1, weekday=5, normalize=normalize)
+    elif klass is Week:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is DateOffset:
+        klass = klass(days=value, normalize=normalize)
+    else:
+        klass = klass(value, normalize=normalize)
+    return klass
+
+
+@pytest.fixture(
+    params=[
+        BDay,
+        BusinessHour,
+        BMonthEnd,
+        BMonthBegin,
+        BQuarterEnd,
+        BQuarterBegin,
+        BYearEnd,
+        BYearBegin,
+        CDay,
+        CustomBusinessHour,
+        CBMonthEnd,
+        CBMonthBegin,
+        MonthEnd,
+        MonthBegin,
+        SemiMonthBegin,
+        SemiMonthEnd,
+        QuarterEnd,
+        LastWeekOfMonth,
+        WeekOfMonth,
+        Week,
+        YearBegin,
+        YearEnd,
+        FY5253,
+        FY5253Quarter,
+        DateOffset,
+    ]
+)
+def _offset(request):
+    return request.param
+
+
+@pytest.fixture
+def dt(_offset):
+    if _offset in (CBMonthBegin, CBMonthEnd, BDay):
+        return Timestamp(2008, 1, 1)
+    elif _offset is (CustomBusinessHour, BusinessHour):
+        return Timestamp(2014, 7, 1, 10, 00)
+    return Timestamp(2008, 1, 2)
+
+
+def test_apply_out_of_range(request, tz_naive_fixture, _offset):
+    tz = tz_naive_fixture
+
+    # try to create an out-of-bounds result timestamp; if we can't create
+    # the offset skip
+    try:
+        if _offset in (BusinessHour, CustomBusinessHour):
+            # Using 10000 in BusinessHour fails in tz check because of DST
+            # difference
+            offset = _get_offset(_offset, value=100000)
+        else:
+            offset = _get_offset(_offset, value=10000)
+
+        result = Timestamp("20080101") + offset
+        assert isinstance(result, datetime)
+        assert result.tzinfo is None
+
+        # Check tz is preserved
+        t = Timestamp("20080101", tz=tz)
+        result = t + offset
+        assert isinstance(result, datetime)
+        if tz is not None:
+            assert t.tzinfo is not None
+
+        if isinstance(tz, tzlocal) and not IS64 and _offset is not DateOffset:
+            # If we hit OutOfBoundsDatetime on non-64 bit machines
+            # we'll drop out of the try clause before the next test
+            request.applymarker(
+                pytest.mark.xfail(reason="OverflowError inside tzlocal past 2038")
+            )
+        elif (
+            isinstance(tz, tzlocal)
+            and is_platform_windows()
+            and _offset in (QuarterEnd, BQuarterBegin, BQuarterEnd)
+        ):
+            request.applymarker(
+                pytest.mark.xfail(reason="After GH#49737 t.tzinfo is None on CI")
+            )
+        assert str(t.tzinfo) == str(result.tzinfo)
+
+    except OutOfBoundsDatetime:
+        pass
+    except (ValueError, KeyError):
+        # we are creating an invalid offset
+        # so ignore
+        pass
+
+
+def test_offsets_compare_equal(_offset):
+    # root cause of GH#456: __ne__ was not implemented
+    offset1 = _offset()
+    offset2 = _offset()
+    assert not offset1 != offset2
+    assert offset1 == offset2
+
+
+@pytest.mark.parametrize(
+    "date, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay(2)],
+        [Timestamp(2014, 7, 1, 10, 00), BusinessHour(n=3)],
+        [
+            Timestamp(2014, 7, 1, 10),
+            CustomBusinessHour(
+                holidays=["2014-06-27", Timestamp(2014, 6, 30), Timestamp("2014-07-02")]
+            ),
+        ],
+        [Timestamp(2008, 1, 2), SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth(2)],
+    ],
+)
+def test_rsub(date, offset2):
+    assert date - offset2 == (-offset2)._apply(date)
+
+
+@pytest.mark.parametrize(
+    "date, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay(2)],
+        [Timestamp(2014, 7, 1, 10, 00), BusinessHour(n=3)],
+        [
+            Timestamp(2014, 7, 1, 10),
+            CustomBusinessHour(
+                holidays=["2014-06-27", Timestamp(2014, 6, 30), Timestamp("2014-07-02")]
+            ),
+        ],
+        [Timestamp(2008, 1, 2), SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth(2)],
+    ],
+)
+def test_radd(date, offset2):
+    assert date + offset2 == offset2 + date
+
+
+@pytest.mark.parametrize(
+    "date, offset_box, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay, BDay(2)],
+        [Timestamp(2008, 1, 2), SemiMonthEnd, SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin, SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week, Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth, WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth, LastWeekOfMonth(2)],
+    ],
+)
+def test_sub(date, offset_box, offset2):
+    off = offset2
+    msg = "Cannot subtract datetime from offset"
+    with pytest.raises(TypeError, match=msg):
+        off - date
+
+    assert 2 * off - off == off
+    assert date - offset2 == date + offset_box(-2)
+    assert date - offset2 == date - (2 * off - off)
+
+
+@pytest.mark.parametrize(
+    "offset_box, offset1",
+    [
+        [BDay, BDay()],
+        [LastWeekOfMonth, LastWeekOfMonth()],
+        [WeekOfMonth, WeekOfMonth()],
+        [Week, Week()],
+        [SemiMonthBegin, SemiMonthBegin()],
+        [SemiMonthEnd, SemiMonthEnd()],
+        [CustomBusinessHour, CustomBusinessHour(weekmask="Tue Wed Thu Fri")],
+        [BusinessHour, BusinessHour()],
+    ],
+)
+def test_Mult1(offset_box, offset1):
+    dt = Timestamp(2008, 1, 2)
+    assert dt + 10 * offset1 == dt + offset_box(10)
+    assert dt + 5 * offset1 == dt + offset_box(5)
+
+
+def test_compare_str(_offset):
+    # GH#23524
+    # comparing to strings that cannot be cast to DateOffsets should
+    #  not raise for __eq__ or __ne__
+    off = _get_offset(_offset)
+
+    assert not off == "infer"
+    assert off != "foo"
+    # Note: inequalities are only implemented for Tick subclasses;
+    #  tests for this are in test_ticks
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_day.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_day.py
new file mode 100644
index 0000000000000000000000000000000000000000..519fb712d041534b6e96e41539fb7660e6c14114
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_day.py
@@ -0,0 +1,98 @@
+"""
+Tests for offsets.CustomBusinessDay / CDay
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import CDay
+
+from pandas import (
+    _testing as tm,
+    read_pickle,
+)
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries.holiday import USFederalHolidayCalendar
+
+
+@pytest.fixture
+def offset():
+    return CDay()
+
+
+@pytest.fixture
+def offset2():
+    return CDay(2)
+
+
+class TestCustomBusinessDay:
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<CustomBusinessDay>"
+        assert repr(offset2) == "<2 * CustomBusinessDays>"
+
+        expected = "<BusinessDay: offset=datetime.timedelta(days=1)>"
+        assert repr(offset + timedelta(1)) == expected
+
+    def test_holidays(self):
+        # Define a TradingDay offset
+        holidays = ["2012-05-01", datetime(2013, 5, 1), np.datetime64("2014-05-01")]
+        tday = CDay(holidays=holidays)
+        for year in range(2012, 2015):
+            dt = datetime(year, 4, 30)
+            xp = datetime(year, 5, 2)
+            rs = dt + tday
+            assert rs == xp
+
+    def test_weekmask(self):
+        weekmask_saudi = "Sat Sun Mon Tue Wed"  # Thu-Fri Weekend
+        weekmask_uae = "1111001"  # Fri-Sat Weekend
+        weekmask_egypt = [1, 1, 1, 1, 0, 0, 1]  # Fri-Sat Weekend
+        bday_saudi = CDay(weekmask=weekmask_saudi)
+        bday_uae = CDay(weekmask=weekmask_uae)
+        bday_egypt = CDay(weekmask=weekmask_egypt)
+        dt = datetime(2013, 5, 1)
+        xp_saudi = datetime(2013, 5, 4)
+        xp_uae = datetime(2013, 5, 2)
+        xp_egypt = datetime(2013, 5, 2)
+        assert xp_saudi == dt + bday_saudi
+        assert xp_uae == dt + bday_uae
+        assert xp_egypt == dt + bday_egypt
+        xp2 = datetime(2013, 5, 5)
+        assert xp2 == dt + 2 * bday_saudi
+        assert xp2 == dt + 2 * bday_uae
+        assert xp2 == dt + 2 * bday_egypt
+
+    def test_weekmask_and_holidays(self):
+        weekmask_egypt = "Sun Mon Tue Wed Thu"  # Fri-Sat Weekend
+        holidays = ["2012-05-01", datetime(2013, 5, 1), np.datetime64("2014-05-01")]
+        bday_egypt = CDay(holidays=holidays, weekmask=weekmask_egypt)
+        dt = datetime(2013, 4, 30)
+        xp_egypt = datetime(2013, 5, 5)
+        assert xp_egypt == dt + 2 * bday_egypt
+
+    @pytest.mark.filterwarnings("ignore:Non:pandas.errors.PerformanceWarning")
+    def test_calendar(self):
+        calendar = USFederalHolidayCalendar()
+        dt = datetime(2014, 1, 17)
+        assert_offset_equal(CDay(calendar=calendar), dt, datetime(2014, 1, 21))
+
+    def test_roundtrip_pickle(self, offset, offset2):
+        def _check_roundtrip(obj):
+            unpickled = tm.round_trip_pickle(obj)
+            assert unpickled == obj
+
+        _check_roundtrip(offset)
+        _check_roundtrip(offset2)
+        _check_roundtrip(offset * 2)
+
+    def test_pickle_compat_0_14_1(self, datapath):
+        hdays = [datetime(2013, 1, 1) for ele in range(4)]
+        pth = datapath("tseries", "offsets", "data", "cday-0.14.1.pickle")
+        cday0_14_1 = read_pickle(pth)
+        cday = CDay(holidays=hdays)
+        assert cday == cday0_14_1
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_easter.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_easter.py
new file mode 100644
index 0000000000000000000000000000000000000000..d11a72cc1b9d54387a37d8e4102249c415c4b46e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_easter.py
@@ -0,0 +1,33 @@
+"""
+Tests for the following offsets:
+- Easter
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries.offsets import Easter
+
+
+class TestEaster:
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (Easter(), datetime(2010, 1, 1), datetime(2010, 4, 4)),
+            (Easter(), datetime(2010, 4, 5), datetime(2011, 4, 24)),
+            (Easter(2), datetime(2010, 1, 1), datetime(2011, 4, 24)),
+            (Easter(), datetime(2010, 4, 4), datetime(2011, 4, 24)),
+            (Easter(2), datetime(2010, 4, 4), datetime(2012, 4, 8)),
+            (-Easter(), datetime(2011, 1, 1), datetime(2010, 4, 4)),
+            (-Easter(), datetime(2010, 4, 5), datetime(2010, 4, 4)),
+            (-Easter(2), datetime(2011, 1, 1), datetime(2009, 4, 12)),
+            (-Easter(), datetime(2010, 4, 4), datetime(2009, 4, 12)),
+            (-Easter(2), datetime(2010, 4, 4), datetime(2008, 3, 23)),
+        ],
+    )
+    def test_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_index.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a62944556d11b536f7a64e49d4a9ff11e90ec0e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_index.py
@@ -0,0 +1,57 @@
+"""
+Tests for offset behavior with indices.
+"""
+import pytest
+
+from pandas import (
+    Series,
+    date_range,
+)
+
+from pandas.tseries.offsets import (
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BYearBegin,
+    BYearEnd,
+    MonthBegin,
+    MonthEnd,
+    QuarterBegin,
+    QuarterEnd,
+    YearBegin,
+    YearEnd,
+)
+
+
+@pytest.mark.parametrize("n", [-2, 1])
+@pytest.mark.parametrize(
+    "cls",
+    [
+        MonthBegin,
+        MonthEnd,
+        BMonthBegin,
+        BMonthEnd,
+        QuarterBegin,
+        QuarterEnd,
+        BQuarterBegin,
+        BQuarterEnd,
+        YearBegin,
+        YearEnd,
+        BYearBegin,
+        BYearEnd,
+    ],
+)
+def test_apply_index(cls, n):
+    offset = cls(n=n)
+    rng = date_range(start="1/1/2000", periods=100000, freq="min")
+    ser = Series(rng)
+
+    res = rng + offset
+    assert res.freq is None  # not retained
+    assert res[0] == rng[0] + offset
+    assert res[-1] == rng[-1] + offset
+    res2 = ser + offset
+    # apply_index is only for indexes, not series, so no res2_v2
+    assert res2.iloc[0] == ser.iloc[0] + offset
+    assert res2.iloc[-1] == ser.iloc[-1] + offset
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_offsets_properties.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_offsets_properties.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b4fa9292c4031c8c2acec0e1f34fd871bcb50bd
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_offsets_properties.py
@@ -0,0 +1,60 @@
+"""
+Behavioral based tests for offsets and date_range.
+
+This file is adapted from https://github.com/pandas-dev/pandas/pull/18761 -
+which was more ambitious but less idiomatic in its use of Hypothesis.
+
+You may wish to consult the previous version for inspiration on further
+tests, or when trying to pin down the bugs exposed by the tests below.
+"""
+from hypothesis import (
+    assume,
+    given,
+)
+import pytest
+import pytz
+
+import pandas as pd
+from pandas._testing._hypothesis import (
+    DATETIME_JAN_1_1900_OPTIONAL_TZ,
+    YQM_OFFSET,
+)
+
+# ----------------------------------------------------------------
+# Offset-specific behaviour tests
+
+
+@pytest.mark.arm_slow
+@given(DATETIME_JAN_1_1900_OPTIONAL_TZ, YQM_OFFSET)
+def test_on_offset_implementations(dt, offset):
+    assume(not offset.normalize)
+    # check that the class-specific implementations of is_on_offset match
+    # the general case definition:
+    #   (dt + offset) - offset == dt
+    try:
+        compare = (dt + offset) - offset
+    except (pytz.NonExistentTimeError, pytz.AmbiguousTimeError):
+        # When dt + offset does not exist or is DST-ambiguous, assume(False) to
+        # indicate to hypothesis that this is not a valid test case
+        # DST-ambiguous example (GH41906):
+        # dt = datetime.datetime(1900, 1, 1, tzinfo=pytz.timezone('Africa/Kinshasa'))
+        # offset = MonthBegin(66)
+        assume(False)
+
+    assert offset.is_on_offset(dt) == (compare == dt)
+
+
+@given(YQM_OFFSET)
+def test_shift_across_dst(offset):
+    # GH#18319 check that 1) timezone is correctly normalized and
+    # 2) that hour is not incorrectly changed by this normalization
+    assume(not offset.normalize)
+
+    # Note that dti includes a transition across DST boundary
+    dti = pd.date_range(
+        start="2017-10-30 12:00:00", end="2017-11-06", freq="D", tz="US/Eastern"
+    )
+    assert (dti.hour == 12).all()  # we haven't screwed up yet
+
+    res = dti + offset
+    assert (res.hour == 12).all()
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_quarter.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_quarter.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fd3ba0a5fb87996a4e07fd25569e7161cb08930
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_quarter.py
@@ -0,0 +1,303 @@
+"""
+Tests for the following offsets:
+- QuarterBegin
+- QuarterEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    QuarterBegin,
+    QuarterEnd,
+)
+
+
+@pytest.mark.parametrize("klass", (QuarterBegin, QuarterEnd))
+def test_quarterly_dont_normalize(klass):
+    date = datetime(2012, 3, 31, 5, 30)
+    result = date + klass()
+    assert result.time() == date.time()
+
+
+@pytest.mark.parametrize("offset", [QuarterBegin(), QuarterEnd()])
+@pytest.mark.parametrize(
+    "date",
+    [
+        datetime(2016, m, d)
+        for m in [10, 11, 12]
+        for d in [1, 2, 3, 28, 29, 30, 31]
+        if not (m == 11 and d == 31)
+    ],
+)
+def test_on_offset(offset, date):
+    res = offset.is_on_offset(date)
+    slow_version = date == (date + offset) - offset
+    assert res == slow_version
+
+
+class TestQuarterBegin:
+    def test_repr(self):
+        expected = "<QuarterBegin: startingMonth=3>"
+        assert repr(QuarterBegin()) == expected
+        expected = "<QuarterBegin: startingMonth=3>"
+        assert repr(QuarterBegin(startingMonth=3)) == expected
+        expected = "<QuarterBegin: startingMonth=1>"
+        assert repr(QuarterBegin(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "QuarterBegin.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert QuarterBegin(startingMonth=1).is_anchored()
+            assert QuarterBegin().is_anchored()
+            assert not QuarterBegin(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = QuarterBegin(n=-1, startingMonth=1)
+        assert datetime(2010, 2, 1) + offset == datetime(2010, 1, 1)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1),
+            {
+                datetime(2007, 12, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 1): datetime(2008, 4, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2008, 3, 31): datetime(2008, 4, 1),
+                datetime(2008, 4, 15): datetime(2008, 7, 1),
+                datetime(2008, 4, 1): datetime(2008, 7, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2008, 1, 15): datetime(2008, 2, 1),
+                datetime(2008, 2, 29): datetime(2008, 5, 1),
+                datetime(2008, 3, 15): datetime(2008, 5, 1),
+                datetime(2008, 3, 31): datetime(2008, 5, 1),
+                datetime(2008, 4, 15): datetime(2008, 5, 1),
+                datetime(2008, 4, 30): datetime(2008, 5, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 12, 1): datetime(2009, 1, 1),
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2008, 3, 31): datetime(2008, 4, 1),
+                datetime(2008, 4, 15): datetime(2008, 7, 1),
+                datetime(2008, 4, 30): datetime(2008, 7, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 1),
+                datetime(2008, 1, 31): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 1, 1),
+                datetime(2008, 2, 29): datetime(2008, 1, 1),
+                datetime(2008, 3, 15): datetime(2008, 1, 1),
+                datetime(2008, 3, 31): datetime(2008, 1, 1),
+                datetime(2008, 4, 15): datetime(2008, 4, 1),
+                datetime(2008, 4, 30): datetime(2008, 4, 1),
+                datetime(2008, 7, 1): datetime(2008, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 7, 1),
+                datetime(2008, 2, 15): datetime(2008, 7, 1),
+                datetime(2008, 2, 29): datetime(2008, 7, 1),
+                datetime(2008, 3, 15): datetime(2008, 7, 1),
+                datetime(2008, 3, 31): datetime(2008, 7, 1),
+                datetime(2008, 4, 15): datetime(2008, 10, 1),
+                datetime(2008, 4, 1): datetime(2008, 10, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestQuarterEnd:
+    def test_repr(self):
+        expected = "<QuarterEnd: startingMonth=3>"
+        assert repr(QuarterEnd()) == expected
+        expected = "<QuarterEnd: startingMonth=3>"
+        assert repr(QuarterEnd(startingMonth=3)) == expected
+        expected = "<QuarterEnd: startingMonth=1>"
+        assert repr(QuarterEnd(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "QuarterEnd.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert QuarterEnd(startingMonth=1).is_anchored()
+            assert QuarterEnd().is_anchored()
+            assert not QuarterEnd(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = QuarterEnd(n=-1, startingMonth=1)
+        assert datetime(2010, 2, 1) + offset == datetime(2010, 1, 31)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 4, 30),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 7, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2008, 2, 15): datetime(2008, 2, 29),
+                datetime(2008, 2, 29): datetime(2008, 5, 31),
+                datetime(2008, 3, 15): datetime(2008, 5, 31),
+                datetime(2008, 3, 31): datetime(2008, 5, 31),
+                datetime(2008, 4, 15): datetime(2008, 5, 31),
+                datetime(2008, 4, 30): datetime(2008, 5, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 4, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 31),
+                datetime(2008, 1, 31): datetime(2007, 10, 31),
+                datetime(2008, 2, 15): datetime(2008, 1, 31),
+                datetime(2008, 2, 29): datetime(2008, 1, 31),
+                datetime(2008, 3, 15): datetime(2008, 1, 31),
+                datetime(2008, 3, 31): datetime(2008, 1, 31),
+                datetime(2008, 4, 15): datetime(2008, 1, 31),
+                datetime(2008, 4, 30): datetime(2008, 1, 31),
+                datetime(2008, 7, 1): datetime(2008, 4, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 31): datetime(2008, 7, 31),
+                datetime(2008, 2, 15): datetime(2008, 7, 31),
+                datetime(2008, 2, 29): datetime(2008, 7, 31),
+                datetime(2008, 3, 15): datetime(2008, 7, 31),
+                datetime(2008, 3, 31): datetime(2008, 7, 31),
+                datetime(2008, 4, 15): datetime(2008, 7, 31),
+                datetime(2008, 4, 30): datetime(2008, 10, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 1, 31), True),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 12, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 2, 29), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 3, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 4, 30), True),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 5, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 6, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 1, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 12, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 2, 29), True),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 3, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 4, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 5, 31), True),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 6, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 1, 31), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 12, 31), True),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 2, 29), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 3, 31), True),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 4, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 5, 31), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 6, 30), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_ticks.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_ticks.py
new file mode 100644
index 0000000000000000000000000000000000000000..399b7038d3426a9f3e4916927bd7e38ac3996531
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_ticks.py
@@ -0,0 +1,405 @@
+"""
+Tests for offsets.Tick and subclasses
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+from hypothesis import (
+    assume,
+    example,
+    given,
+)
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import delta_to_tick
+from pandas.errors import OutOfBoundsTimedelta
+
+from pandas import (
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas._testing._hypothesis import INT_NEG_999_TO_POS_999
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries import offsets
+from pandas.tseries.offsets import (
+    Hour,
+    Micro,
+    Milli,
+    Minute,
+    Nano,
+    Second,
+)
+
+# ---------------------------------------------------------------------
+# Test Helpers
+
+tick_classes = [Hour, Minute, Second, Milli, Micro, Nano]
+
+
+# ---------------------------------------------------------------------
+
+
+def test_apply_ticks():
+    result = offsets.Hour(3) + offsets.Hour(4)
+    exp = offsets.Hour(7)
+    assert result == exp
+
+
+def test_delta_to_tick():
+    delta = timedelta(3)
+
+    tick = delta_to_tick(delta)
+    assert tick == offsets.Day(3)
+
+    td = Timedelta(nanoseconds=5)
+    tick = delta_to_tick(td)
+    assert tick == Nano(5)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+@example(n=2, m=3)
+@example(n=800, m=300)
+@example(n=1000, m=5)
+@given(n=INT_NEG_999_TO_POS_999, m=INT_NEG_999_TO_POS_999)
+def test_tick_add_sub(cls, n, m):
+    # For all Tick subclasses and all integers n, m, we should have
+    # tick(n) + tick(m) == tick(n+m)
+    # tick(n) - tick(m) == tick(n-m)
+    left = cls(n)
+    right = cls(m)
+    expected = cls(n + m)
+
+    assert left + right == expected
+
+    expected = cls(n - m)
+    assert left - right == expected
+
+
+@pytest.mark.arm_slow
+@pytest.mark.parametrize("cls", tick_classes)
+@example(n=2, m=3)
+@given(n=INT_NEG_999_TO_POS_999, m=INT_NEG_999_TO_POS_999)
+def test_tick_equality(cls, n, m):
+    assume(m != n)
+    # tick == tock iff tick.n == tock.n
+    left = cls(n)
+    right = cls(m)
+    assert left != right
+
+    right = cls(n)
+    assert left == right
+    assert not left != right
+
+    if n != 0:
+        assert cls(n) != cls(-n)
+
+
+# ---------------------------------------------------------------------
+
+
+def test_Hour():
+    assert_offset_equal(Hour(), datetime(2010, 1, 1), datetime(2010, 1, 1, 1))
+    assert_offset_equal(Hour(-1), datetime(2010, 1, 1, 1), datetime(2010, 1, 1))
+    assert_offset_equal(2 * Hour(), datetime(2010, 1, 1), datetime(2010, 1, 1, 2))
+    assert_offset_equal(-1 * Hour(), datetime(2010, 1, 1, 1), datetime(2010, 1, 1))
+
+    assert Hour(3) + Hour(2) == Hour(5)
+    assert Hour(3) - Hour(2) == Hour()
+
+    assert Hour(4) != Hour(1)
+
+
+def test_Minute():
+    assert_offset_equal(Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 1))
+    assert_offset_equal(Minute(-1), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
+    assert_offset_equal(2 * Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 2))
+    assert_offset_equal(-1 * Minute(), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
+
+    assert Minute(3) + Minute(2) == Minute(5)
+    assert Minute(3) - Minute(2) == Minute()
+    assert Minute(5) != Minute()
+
+
+def test_Second():
+    assert_offset_equal(Second(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 1))
+    assert_offset_equal(Second(-1), datetime(2010, 1, 1, 0, 0, 1), datetime(2010, 1, 1))
+    assert_offset_equal(
+        2 * Second(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 2)
+    )
+    assert_offset_equal(
+        -1 * Second(), datetime(2010, 1, 1, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert Second(3) + Second(2) == Second(5)
+    assert Second(3) - Second(2) == Second()
+
+
+def test_Millisecond():
+    assert_offset_equal(
+        Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 1000)
+    )
+    assert_offset_equal(
+        Milli(-1), datetime(2010, 1, 1, 0, 0, 0, 1000), datetime(2010, 1, 1)
+    )
+    assert_offset_equal(
+        Milli(2), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2000)
+    )
+    assert_offset_equal(
+        2 * Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2000)
+    )
+    assert_offset_equal(
+        -1 * Milli(), datetime(2010, 1, 1, 0, 0, 0, 1000), datetime(2010, 1, 1)
+    )
+
+    assert Milli(3) + Milli(2) == Milli(5)
+    assert Milli(3) - Milli(2) == Milli()
+
+
+def test_MillisecondTimestampArithmetic():
+    assert_offset_equal(
+        Milli(), Timestamp("2010-01-01"), Timestamp("2010-01-01 00:00:00.001")
+    )
+    assert_offset_equal(
+        Milli(-1), Timestamp("2010-01-01 00:00:00.001"), Timestamp("2010-01-01")
+    )
+
+
+def test_Microsecond():
+    assert_offset_equal(Micro(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 1))
+    assert_offset_equal(
+        Micro(-1), datetime(2010, 1, 1, 0, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert_offset_equal(
+        2 * Micro(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2)
+    )
+    assert_offset_equal(
+        -1 * Micro(), datetime(2010, 1, 1, 0, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert Micro(3) + Micro(2) == Micro(5)
+    assert Micro(3) - Micro(2) == Micro()
+
+
+def test_NanosecondGeneric():
+    timestamp = Timestamp(datetime(2010, 1, 1))
+    assert timestamp.nanosecond == 0
+
+    result = timestamp + Nano(10)
+    assert result.nanosecond == 10
+
+    reverse_result = Nano(10) + timestamp
+    assert reverse_result.nanosecond == 10
+
+
+def test_Nanosecond():
+    timestamp = Timestamp(datetime(2010, 1, 1))
+    assert_offset_equal(Nano(), timestamp, timestamp + np.timedelta64(1, "ns"))
+    assert_offset_equal(Nano(-1), timestamp + np.timedelta64(1, "ns"), timestamp)
+    assert_offset_equal(2 * Nano(), timestamp, timestamp + np.timedelta64(2, "ns"))
+    assert_offset_equal(-1 * Nano(), timestamp + np.timedelta64(1, "ns"), timestamp)
+
+    assert Nano(3) + Nano(2) == Nano(5)
+    assert Nano(3) - Nano(2) == Nano()
+
+    # GH9284
+    assert Nano(1) + Nano(10) == Nano(11)
+    assert Nano(5) + Micro(1) == Nano(1005)
+    assert Micro(5) + Nano(1) == Nano(5001)
+
+
+@pytest.mark.parametrize(
+    "kls, expected",
+    [
+        (Hour, Timedelta(hours=5)),
+        (Minute, Timedelta(hours=2, minutes=3)),
+        (Second, Timedelta(hours=2, seconds=3)),
+        (Milli, Timedelta(hours=2, milliseconds=3)),
+        (Micro, Timedelta(hours=2, microseconds=3)),
+        (Nano, Timedelta(hours=2, nanoseconds=3)),
+    ],
+)
+def test_tick_addition(kls, expected):
+    offset = kls(3)
+    td = Timedelta(hours=2)
+
+    for other in [td, td.to_pytimedelta(), td.to_timedelta64()]:
+        result = offset + other
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = other + offset
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+
+def test_tick_delta_overflow():
+    # GH#55503 raise OutOfBoundsTimedelta, not OverflowError
+    tick = offsets.Day(10**9)
+    msg = "Cannot cast 1000000000 days 00:00:00 to unit='ns' without overflow"
+    depr_msg = "Day.delta is deprecated"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            tick.delta
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_division(cls):
+    off = cls(10)
+
+    assert off / cls(5) == 2
+    assert off / 2 == cls(5)
+    assert off / 2.0 == cls(5)
+
+    assert off / off._as_pd_timedelta == 1
+    assert off / off._as_pd_timedelta.to_timedelta64() == 1
+
+    assert off / Nano(1) == off._as_pd_timedelta / Nano(1)._as_pd_timedelta
+
+    if cls is not Nano:
+        # A case where we end up with a smaller class
+        result = off / 1000
+        assert isinstance(result, offsets.Tick)
+        assert not isinstance(result, cls)
+        assert result._as_pd_timedelta == off._as_pd_timedelta / 1000
+
+    if cls._nanos_inc < Timedelta(seconds=1)._value:
+        # Case where we end up with a bigger class
+        result = off / 0.001
+        assert isinstance(result, offsets.Tick)
+        assert not isinstance(result, cls)
+        assert result._as_pd_timedelta == off._as_pd_timedelta / 0.001
+
+
+def test_tick_mul_float():
+    off = Micro(2)
+
+    # Case where we retain type
+    result = off * 1.5
+    expected = Micro(3)
+    assert result == expected
+    assert isinstance(result, Micro)
+
+    # Case where we bump up to the next type
+    result = off * 1.25
+    expected = Nano(2500)
+    assert result == expected
+    assert isinstance(result, Nano)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_rdiv(cls):
+    off = cls(10)
+    delta = off._as_pd_timedelta
+    td64 = delta.to_timedelta64()
+    instance__type = ".".join([cls.__module__, cls.__name__])
+    msg = (
+        "unsupported operand type\\(s\\) for \\/: 'int'|'float' and "
+        f"'{instance__type}'"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        2 / off
+    with pytest.raises(TypeError, match=msg):
+        2.0 / off
+
+    assert (td64 * 2.5) / off == 2.5
+
+    if cls is not Nano:
+        # skip pytimedelta for Nano since it gets dropped
+        assert (delta.to_pytimedelta() * 2) / off == 2
+
+    result = np.array([2 * td64, td64]) / off
+    expected = np.array([2.0, 1.0])
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("cls1", tick_classes)
+@pytest.mark.parametrize("cls2", tick_classes)
+def test_tick_zero(cls1, cls2):
+    assert cls1(0) == cls2(0)
+    assert cls1(0) + cls2(0) == cls1(0)
+
+    if cls1 is not Nano:
+        assert cls1(2) + cls2(0) == cls1(2)
+
+    if cls1 is Nano:
+        assert cls1(2) + Nano(0) == cls1(2)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_equalities(cls):
+    assert cls() == cls(1)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_offset(cls):
+    msg = f"{cls.__name__}.is_anchored is deprecated "
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert not cls().is_anchored()
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_compare_ticks(cls):
+    three = cls(3)
+    four = cls(4)
+
+    assert three < cls(4)
+    assert cls(3) < four
+    assert four > cls(3)
+    assert cls(4) > three
+    assert cls(3) == cls(3)
+    assert cls(3) != cls(4)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_compare_ticks_to_strs(cls):
+    # GH#23524
+    off = cls(19)
+
+    # These tests should work with any strings, but we particularly are
+    #  interested in "infer" as that comparison is convenient to make in
+    #  Datetime/Timedelta Array/Index constructors
+    assert not off == "infer"
+    assert not "foo" == off
+
+    instance_type = ".".join([cls.__module__, cls.__name__])
+    msg = (
+        "'<'|'<='|'>'|'>=' not supported between instances of "
+        f"'str' and '{instance_type}'|'{instance_type}' and 'str'"
+    )
+
+    for left, right in [("infer", off), (off, "infer")]:
+        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("cls", tick_classes)
+def test_compare_ticks_to_timedeltalike(cls):
+    off = cls(19)
+
+    td = off._as_pd_timedelta
+
+    others = [td, td.to_timedelta64()]
+    if cls is not Nano:
+        others.append(td.to_pytimedelta())
+
+    for other in others:
+        assert off == other
+        assert not off != other
+        assert not off < other
+        assert not off > other
+        assert off <= other
+        assert off >= other
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_week.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_week.py
new file mode 100644
index 0000000000000000000000000000000000000000..0cd6f769769ae3c3ae39f6b4a8f10641cd297715
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_week.py
@@ -0,0 +1,351 @@
+"""
+Tests for the following offsets:
+- Week
+- WeekOfMonth
+- LastWeekOfMonth
+"""
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.offsets import (
+    Day,
+    LastWeekOfMonth,
+    Week,
+    WeekOfMonth,
+)
+
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    WeekDay,
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+
+class TestWeek:
+    def test_repr(self):
+        assert repr(Week(weekday=0)) == "<Week: weekday=0>"
+        assert repr(Week(n=-1, weekday=0)) == "<-1 * Week: weekday=0>"
+        assert repr(Week(n=-2, weekday=0)) == "<-2 * Weeks: weekday=0>"
+
+    def test_corner(self):
+        with pytest.raises(ValueError, match="Day must be"):
+            Week(weekday=7)
+
+        with pytest.raises(ValueError, match="Day must be"):
+            Week(weekday=-1)
+
+    def test_is_anchored(self):
+        msg = "Week.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert Week(weekday=0).is_anchored()
+            assert not Week().is_anchored()
+            assert not Week(2, weekday=2).is_anchored()
+            assert not Week(2).is_anchored()
+
+    offset_cases = []
+    # not business week
+    offset_cases.append(
+        (
+            Week(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 8),
+                datetime(2008, 1, 4): datetime(2008, 1, 11),
+                datetime(2008, 1, 5): datetime(2008, 1, 12),
+                datetime(2008, 1, 6): datetime(2008, 1, 13),
+                datetime(2008, 1, 7): datetime(2008, 1, 14),
+            },
+        )
+    )
+
+    # Mon
+    offset_cases.append(
+        (
+            Week(weekday=0),
+            {
+                datetime(2007, 12, 31): datetime(2008, 1, 7),
+                datetime(2008, 1, 4): datetime(2008, 1, 7),
+                datetime(2008, 1, 5): datetime(2008, 1, 7),
+                datetime(2008, 1, 6): datetime(2008, 1, 7),
+                datetime(2008, 1, 7): datetime(2008, 1, 14),
+            },
+        )
+    )
+
+    # n=0 -> roll forward. Mon
+    offset_cases.append(
+        (
+            Week(0, weekday=0),
+            {
+                datetime(2007, 12, 31): datetime(2007, 12, 31),
+                datetime(2008, 1, 4): datetime(2008, 1, 7),
+                datetime(2008, 1, 5): datetime(2008, 1, 7),
+                datetime(2008, 1, 6): datetime(2008, 1, 7),
+                datetime(2008, 1, 7): datetime(2008, 1, 7),
+            },
+        )
+    )
+
+    # n=0 -> roll forward. Mon
+    offset_cases.append(
+        (
+            Week(-2, weekday=1),
+            {
+                datetime(2010, 4, 6): datetime(2010, 3, 23),
+                datetime(2010, 4, 8): datetime(2010, 3, 30),
+                datetime(2010, 4, 5): datetime(2010, 3, 23),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    @pytest.mark.parametrize("weekday", range(7))
+    def test_is_on_offset(self, weekday):
+        offset = Week(weekday=weekday)
+
+        for day in range(1, 8):
+            date = datetime(2008, 1, day)
+            expected = day % 7 == weekday
+        assert_is_on_offset(offset, date, expected)
+
+    @pytest.mark.parametrize(
+        "n,date",
+        [
+            (2, "1862-01-13 09:03:34.873477378+0210"),
+            (-2, "1856-10-24 16:18:36.556360110-0717"),
+        ],
+    )
+    def test_is_on_offset_weekday_none(self, n, date):
+        # GH 18510 Week with weekday = None, normalize = False
+        # should always be is_on_offset
+        offset = Week(n=n, weekday=None)
+        ts = Timestamp(date, tz="Africa/Lusaka")
+        fast = offset.is_on_offset(ts)
+        slow = (ts + offset) - offset == ts
+        assert fast == slow
+
+    def test_week_add_invalid(self):
+        # Week with weekday should raise TypeError and _not_ AttributeError
+        #  when adding invalid offset
+        offset = Week(weekday=1)
+        other = Day()
+        with pytest.raises(TypeError, match="Cannot add"):
+            offset + other
+
+
+class TestWeekOfMonth:
+    def test_constructor(self):
+        with pytest.raises(ValueError, match="^Week"):
+            WeekOfMonth(n=1, week=4, weekday=0)
+
+        with pytest.raises(ValueError, match="^Week"):
+            WeekOfMonth(n=1, week=-1, weekday=0)
+
+        with pytest.raises(ValueError, match="^Day"):
+            WeekOfMonth(n=1, week=0, weekday=-1)
+
+        with pytest.raises(ValueError, match="^Day"):
+            WeekOfMonth(n=1, week=0, weekday=-7)
+
+    def test_repr(self):
+        assert (
+            repr(WeekOfMonth(weekday=1, week=2)) == "<WeekOfMonth: week=2, weekday=1>"
+        )
+
+    def test_offset(self):
+        date1 = datetime(2011, 1, 4)  # 1st Tuesday of Month
+        date2 = datetime(2011, 1, 11)  # 2nd Tuesday of Month
+        date3 = datetime(2011, 1, 18)  # 3rd Tuesday of Month
+        date4 = datetime(2011, 1, 25)  # 4th Tuesday of Month
+
+        # see for loop for structure
+        test_cases = [
+            (-2, 2, 1, date1, datetime(2010, 11, 16)),
+            (-2, 2, 1, date2, datetime(2010, 11, 16)),
+            (-2, 2, 1, date3, datetime(2010, 11, 16)),
+            (-2, 2, 1, date4, datetime(2010, 12, 21)),
+            (-1, 2, 1, date1, datetime(2010, 12, 21)),
+            (-1, 2, 1, date2, datetime(2010, 12, 21)),
+            (-1, 2, 1, date3, datetime(2010, 12, 21)),
+            (-1, 2, 1, date4, datetime(2011, 1, 18)),
+            (0, 0, 1, date1, datetime(2011, 1, 4)),
+            (0, 0, 1, date2, datetime(2011, 2, 1)),
+            (0, 0, 1, date3, datetime(2011, 2, 1)),
+            (0, 0, 1, date4, datetime(2011, 2, 1)),
+            (0, 1, 1, date1, datetime(2011, 1, 11)),
+            (0, 1, 1, date2, datetime(2011, 1, 11)),
+            (0, 1, 1, date3, datetime(2011, 2, 8)),
+            (0, 1, 1, date4, datetime(2011, 2, 8)),
+            (0, 0, 1, date1, datetime(2011, 1, 4)),
+            (0, 1, 1, date2, datetime(2011, 1, 11)),
+            (0, 2, 1, date3, datetime(2011, 1, 18)),
+            (0, 3, 1, date4, datetime(2011, 1, 25)),
+            (1, 0, 0, date1, datetime(2011, 2, 7)),
+            (1, 0, 0, date2, datetime(2011, 2, 7)),
+            (1, 0, 0, date3, datetime(2011, 2, 7)),
+            (1, 0, 0, date4, datetime(2011, 2, 7)),
+            (1, 0, 1, date1, datetime(2011, 2, 1)),
+            (1, 0, 1, date2, datetime(2011, 2, 1)),
+            (1, 0, 1, date3, datetime(2011, 2, 1)),
+            (1, 0, 1, date4, datetime(2011, 2, 1)),
+            (1, 0, 2, date1, datetime(2011, 1, 5)),
+            (1, 0, 2, date2, datetime(2011, 2, 2)),
+            (1, 0, 2, date3, datetime(2011, 2, 2)),
+            (1, 0, 2, date4, datetime(2011, 2, 2)),
+            (1, 2, 1, date1, datetime(2011, 1, 18)),
+            (1, 2, 1, date2, datetime(2011, 1, 18)),
+            (1, 2, 1, date3, datetime(2011, 2, 15)),
+            (1, 2, 1, date4, datetime(2011, 2, 15)),
+            (2, 2, 1, date1, datetime(2011, 2, 15)),
+            (2, 2, 1, date2, datetime(2011, 2, 15)),
+            (2, 2, 1, date3, datetime(2011, 3, 15)),
+            (2, 2, 1, date4, datetime(2011, 3, 15)),
+        ]
+
+        for n, week, weekday, dt, expected in test_cases:
+            offset = WeekOfMonth(n, week=week, weekday=weekday)
+            assert_offset_equal(offset, dt, expected)
+
+        # try subtracting
+        result = datetime(2011, 2, 1) - WeekOfMonth(week=1, weekday=2)
+        assert result == datetime(2011, 1, 12)
+
+        result = datetime(2011, 2, 3) - WeekOfMonth(week=0, weekday=2)
+        assert result == datetime(2011, 2, 2)
+
+    on_offset_cases = [
+        (0, 0, datetime(2011, 2, 7), True),
+        (0, 0, datetime(2011, 2, 6), False),
+        (0, 0, datetime(2011, 2, 14), False),
+        (1, 0, datetime(2011, 2, 14), True),
+        (0, 1, datetime(2011, 2, 1), True),
+        (0, 1, datetime(2011, 2, 8), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        week, weekday, dt, expected = case
+        offset = WeekOfMonth(week=week, weekday=weekday)
+        assert offset.is_on_offset(dt) == expected
+
+    @pytest.mark.parametrize(
+        "n,week,date,tz",
+        [
+            (2, 2, "1916-05-15 01:14:49.583410462+0422", "Asia/Qyzylorda"),
+            (-3, 1, "1980-12-08 03:38:52.878321185+0500", "Asia/Oral"),
+        ],
+    )
+    def test_is_on_offset_nanoseconds(self, n, week, date, tz):
+        # GH 18864
+        # Make sure that nanoseconds don't trip up is_on_offset (and with it apply)
+        offset = WeekOfMonth(n=n, week=week, weekday=0)
+        ts = Timestamp(date, tz=tz)
+        fast = offset.is_on_offset(ts)
+        slow = (ts + offset) - offset == ts
+        assert fast == slow
+
+
+class TestLastWeekOfMonth:
+    def test_constructor(self):
+        with pytest.raises(ValueError, match="^N cannot be 0"):
+            LastWeekOfMonth(n=0, weekday=1)
+
+        with pytest.raises(ValueError, match="^Day"):
+            LastWeekOfMonth(n=1, weekday=-1)
+
+        with pytest.raises(ValueError, match="^Day"):
+            LastWeekOfMonth(n=1, weekday=7)
+
+    def test_offset(self):
+        # Saturday
+        last_sat = datetime(2013, 8, 31)
+        next_sat = datetime(2013, 9, 28)
+        offset_sat = LastWeekOfMonth(n=1, weekday=5)
+
+        one_day_before = last_sat + timedelta(days=-1)
+        assert one_day_before + offset_sat == last_sat
+
+        one_day_after = last_sat + timedelta(days=+1)
+        assert one_day_after + offset_sat == next_sat
+
+        # Test On that day
+        assert last_sat + offset_sat == next_sat
+
+        # Thursday
+
+        offset_thur = LastWeekOfMonth(n=1, weekday=3)
+        last_thurs = datetime(2013, 1, 31)
+        next_thurs = datetime(2013, 2, 28)
+
+        one_day_before = last_thurs + timedelta(days=-1)
+        assert one_day_before + offset_thur == last_thurs
+
+        one_day_after = last_thurs + timedelta(days=+1)
+        assert one_day_after + offset_thur == next_thurs
+
+        # Test on that day
+        assert last_thurs + offset_thur == next_thurs
+
+        three_before = last_thurs + timedelta(days=-3)
+        assert three_before + offset_thur == last_thurs
+
+        two_after = last_thurs + timedelta(days=+2)
+        assert two_after + offset_thur == next_thurs
+
+        offset_sunday = LastWeekOfMonth(n=1, weekday=WeekDay.SUN)
+        assert datetime(2013, 7, 31) + offset_sunday == datetime(2013, 8, 25)
+
+    on_offset_cases = [
+        (WeekDay.SUN, datetime(2013, 1, 27), True),
+        (WeekDay.SAT, datetime(2013, 3, 30), True),
+        (WeekDay.MON, datetime(2013, 2, 18), False),  # Not the last Mon
+        (WeekDay.SUN, datetime(2013, 2, 25), False),  # Not a SUN
+        (WeekDay.MON, datetime(2013, 2, 25), True),
+        (WeekDay.SAT, datetime(2013, 11, 30), True),
+        (WeekDay.SAT, datetime(2006, 8, 26), True),
+        (WeekDay.SAT, datetime(2007, 8, 25), True),
+        (WeekDay.SAT, datetime(2008, 8, 30), True),
+        (WeekDay.SAT, datetime(2009, 8, 29), True),
+        (WeekDay.SAT, datetime(2010, 8, 28), True),
+        (WeekDay.SAT, datetime(2011, 8, 27), True),
+        (WeekDay.SAT, datetime(2019, 8, 31), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        weekday, dt, expected = case
+        offset = LastWeekOfMonth(weekday=weekday)
+        assert offset.is_on_offset(dt) == expected
+
+    @pytest.mark.parametrize(
+        "n,weekday,date,tz",
+        [
+            (4, 6, "1917-05-27 20:55:27.084284178+0200", "Europe/Warsaw"),
+            (-4, 5, "2005-08-27 05:01:42.799392561-0500", "America/Rainy_River"),
+        ],
+    )
+    def test_last_week_of_month_on_offset(self, n, weekday, date, tz):
+        # GH 19036, GH 18977 _adjust_dst was incorrect for LastWeekOfMonth
+        offset = LastWeekOfMonth(n=n, weekday=weekday)
+        ts = Timestamp(date, tz=tz)
+        slow = (ts + offset) - offset == ts
+        fast = offset.is_on_offset(ts)
+        assert fast == slow
+
+    def test_repr(self):
+        assert (
+            repr(LastWeekOfMonth(n=2, weekday=1)) == "<2 * LastWeekOfMonths: weekday=1>"
+        )
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_year.py b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_year.py
new file mode 100644
index 0000000000000000000000000000000000000000..28cbdcf6abeccbbc02827d63c76aaa2f22b3c945
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_year.py
@@ -0,0 +1,339 @@
+"""
+Tests for the following offsets:
+- YearBegin
+- YearEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import Timestamp
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    YearBegin,
+    YearEnd,
+)
+
+
+class TestYearBegin:
+    def test_misspecified(self):
+        with pytest.raises(ValueError, match="Month must go from 1 to 12"):
+            YearBegin(month=13)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            YearBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2009, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2005, 12, 30): datetime(2006, 1, 1),
+                datetime(2005, 12, 31): datetime(2006, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2005, 12, 30): datetime(2006, 1, 1),
+                datetime(2005, 12, 31): datetime(2006, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(3),
+            {
+                datetime(2008, 1, 1): datetime(2011, 1, 1),
+                datetime(2008, 6, 30): datetime(2011, 1, 1),
+                datetime(2008, 12, 31): datetime(2011, 1, 1),
+                datetime(2005, 12, 30): datetime(2008, 1, 1),
+                datetime(2005, 12, 31): datetime(2008, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 1, 1),
+                datetime(2007, 1, 15): datetime(2007, 1, 1),
+                datetime(2008, 6, 30): datetime(2008, 1, 1),
+                datetime(2008, 12, 31): datetime(2008, 1, 1),
+                datetime(2006, 12, 29): datetime(2006, 1, 1),
+                datetime(2006, 12, 30): datetime(2006, 1, 1),
+                datetime(2007, 1, 1): datetime(2006, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 1, 1),
+                datetime(2008, 6, 30): datetime(2007, 1, 1),
+                datetime(2008, 12, 31): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(month=4),
+            {
+                datetime(2007, 4, 1): datetime(2008, 4, 1),
+                datetime(2007, 4, 15): datetime(2008, 4, 1),
+                datetime(2007, 3, 1): datetime(2007, 4, 1),
+                datetime(2007, 12, 15): datetime(2008, 4, 1),
+                datetime(2012, 1, 31): datetime(2012, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(0, month=4),
+            {
+                datetime(2007, 4, 1): datetime(2007, 4, 1),
+                datetime(2007, 3, 1): datetime(2007, 4, 1),
+                datetime(2007, 12, 15): datetime(2008, 4, 1),
+                datetime(2012, 1, 31): datetime(2012, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(4, month=4),
+            {
+                datetime(2007, 4, 1): datetime(2011, 4, 1),
+                datetime(2007, 4, 15): datetime(2011, 4, 1),
+                datetime(2007, 3, 1): datetime(2010, 4, 1),
+                datetime(2007, 12, 15): datetime(2011, 4, 1),
+                datetime(2012, 1, 31): datetime(2015, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(-1, month=4),
+            {
+                datetime(2007, 4, 1): datetime(2006, 4, 1),
+                datetime(2007, 3, 1): datetime(2006, 4, 1),
+                datetime(2007, 12, 15): datetime(2007, 4, 1),
+                datetime(2012, 1, 31): datetime(2011, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearBegin(-3, month=4),
+            {
+                datetime(2007, 4, 1): datetime(2004, 4, 1),
+                datetime(2007, 3, 1): datetime(2004, 4, 1),
+                datetime(2007, 12, 15): datetime(2005, 4, 1),
+                datetime(2012, 1, 31): datetime(2009, 4, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (YearBegin(), datetime(2007, 1, 3), False),
+        (YearBegin(), datetime(2008, 1, 1), True),
+        (YearBegin(), datetime(2006, 12, 31), False),
+        (YearBegin(), datetime(2006, 1, 2), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+class TestYearEnd:
+    def test_misspecified(self):
+        with pytest.raises(ValueError, match="Month must go from 1 to 12"):
+            YearEnd(month=13)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            YearEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2009, 12, 31),
+                datetime(2005, 12, 30): datetime(2005, 12, 31),
+                datetime(2005, 12, 31): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2008, 12, 31),
+                datetime(2005, 12, 30): datetime(2005, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+                datetime(2008, 6, 30): datetime(2007, 12, 31),
+                datetime(2008, 12, 31): datetime(2007, 12, 31),
+                datetime(2006, 12, 29): datetime(2005, 12, 31),
+                datetime(2006, 12, 30): datetime(2005, 12, 31),
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 12, 31),
+                datetime(2008, 6, 30): datetime(2006, 12, 31),
+                datetime(2008, 12, 31): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (YearEnd(), datetime(2007, 12, 31), True),
+        (YearEnd(), datetime(2008, 1, 1), False),
+        (YearEnd(), datetime(2006, 12, 31), True),
+        (YearEnd(), datetime(2006, 12, 29), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+class TestYearEndDiffMonth:
+    offset_cases = []
+    offset_cases.append(
+        (
+            YearEnd(month=3),
+            {
+                datetime(2008, 1, 1): datetime(2008, 3, 31),
+                datetime(2008, 2, 15): datetime(2008, 3, 31),
+                datetime(2008, 3, 31): datetime(2009, 3, 31),
+                datetime(2008, 3, 30): datetime(2008, 3, 31),
+                datetime(2005, 3, 31): datetime(2006, 3, 31),
+                datetime(2006, 7, 30): datetime(2007, 3, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(0, month=3),
+            {
+                datetime(2008, 1, 1): datetime(2008, 3, 31),
+                datetime(2008, 2, 28): datetime(2008, 3, 31),
+                datetime(2008, 3, 31): datetime(2008, 3, 31),
+                datetime(2005, 3, 30): datetime(2005, 3, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(-1, month=3),
+            {
+                datetime(2007, 1, 1): datetime(2006, 3, 31),
+                datetime(2008, 2, 28): datetime(2007, 3, 31),
+                datetime(2008, 3, 31): datetime(2007, 3, 31),
+                datetime(2006, 3, 29): datetime(2005, 3, 31),
+                datetime(2006, 3, 30): datetime(2005, 3, 31),
+                datetime(2007, 3, 1): datetime(2006, 3, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            YearEnd(-2, month=3),
+            {
+                datetime(2007, 1, 1): datetime(2005, 3, 31),
+                datetime(2008, 6, 30): datetime(2007, 3, 31),
+                datetime(2008, 3, 31): datetime(2006, 3, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (YearEnd(month=3), datetime(2007, 3, 31), True),
+        (YearEnd(month=3), datetime(2008, 1, 1), False),
+        (YearEnd(month=3), datetime(2006, 3, 31), True),
+        (YearEnd(month=3), datetime(2006, 3, 29), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+def test_add_out_of_pydatetime_range():
+    # GH#50348 don't raise in Timestamp.replace
+    ts = Timestamp(np.datetime64("-20000-12-31"))
+    off = YearEnd()
+
+    result = ts + off
+    # TODO(cython3): "arg: datetime" annotation will impose
+    # datetime limitations on Timestamp. The fused type below works in cy3
+    # ctypedef fused datetimelike:
+    #     _Timestamp
+    #     datetime
+    # expected = Timestamp(np.datetime64("-19999-12-31"))
+    # assert result == expected
+    assert result.year in (-19999, 1973)
+    assert result.month == 12
+    assert result.day == 31