diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..31ba26a6e809a2dc96b966f6e5a57b62dfab66ab
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_astype.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db426ea393a2aaccefbdc85a01ac9c9b3970bf4c
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_indexing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e38bf3f626332f90f44f043d7f618916ec744245
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_join.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_join.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1943e4105fe0684e618e5c7fa67d8a3a7ff73db8
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_join.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_numeric.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_numeric.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..694ba3a2cdf9b2db3ba3671eecfe0cfeab4ff2a5
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_numeric.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_setops.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..030bb35d6b4de2e181897630b89a2450e7a5a6b7
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_astype.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c2df6008de5d85789b026e947ac27a8036a9be7
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_astype.py
@@ -0,0 +1,95 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    to_datetime,
+    to_timedelta,
+)
+import pandas._testing as tm
+
+
+class TestAstype:
+    def test_astype_float64_to_uint64(self):
+        # GH#45309 used to incorrectly return Index with int64 dtype
+        idx = Index([0.0, 5.0, 10.0, 15.0, 20.0], dtype=np.float64)
+        result = idx.astype("u8")
+        expected = Index([0, 5, 10, 15, 20], dtype=np.uint64)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        idx_with_negatives = idx - 10
+        with pytest.raises(ValueError, match="losslessly"):
+            idx_with_negatives.astype(np.uint64)
+
+    def test_astype_float64_to_object(self):
+        float_index = Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=np.float64)
+        result = float_index.astype(object)
+        assert result.equals(float_index)
+        assert float_index.equals(result)
+        assert isinstance(result, Index) and result.dtype == object
+
+    def test_astype_float64_mixed_to_object(self):
+        # mixed int-float
+        idx = Index([1.5, 2, 3, 4, 5], dtype=np.float64)
+        idx.name = "foo"
+        result = idx.astype(object)
+        assert result.equals(idx)
+        assert idx.equals(result)
+        assert isinstance(result, Index) and result.dtype == object
+
+    @pytest.mark.parametrize("dtype", ["int16", "int32", "int64"])
+    def test_astype_float64_to_int_dtype(self, dtype):
+        # GH#12881
+        # a float astype int
+        idx = Index([0, 1, 2], dtype=np.float64)
+        result = idx.astype(dtype)
+        expected = Index([0, 1, 2], dtype=dtype)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        idx = Index([0, 1.1, 2], dtype=np.float64)
+        result = idx.astype(dtype)
+        expected = Index([0, 1, 2], dtype=dtype)
+        tm.assert_index_equal(result, expected, exact=True)
+
+    @pytest.mark.parametrize("dtype", ["float32", "float64"])
+    def test_astype_float64_to_float_dtype(self, dtype):
+        # GH#12881
+        # a float astype int
+        idx = Index([0, 1, 2], dtype=np.float64)
+        result = idx.astype(dtype)
+        assert isinstance(result, Index) and result.dtype == dtype
+
+    @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
+    def test_astype_float_to_datetimelike(self, dtype):
+        # GH#49660 pre-2.0 Index.astype from floating to M8/m8/Period raised,
+        #  inconsistent with Series.astype
+        idx = Index([0, 1.1, 2], dtype=np.float64)
+
+        result = idx.astype(dtype)
+        if dtype[0] == "M":
+            expected = to_datetime(idx.values)
+        else:
+            expected = to_timedelta(idx.values)
+        tm.assert_index_equal(result, expected)
+
+        # check that we match Series behavior
+        result = idx.to_series().set_axis(range(3)).astype(dtype)
+        expected = expected.to_series().set_axis(range(3))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [int, "int16", "int32", "int64"])
+    @pytest.mark.parametrize("non_finite", [np.inf, np.nan])
+    def test_cannot_cast_inf_to_int(self, non_finite, dtype):
+        # GH#13149
+        idx = Index([1, 2, non_finite], dtype=np.float64)
+
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(ValueError, match=msg):
+            idx.astype(dtype)
+
+    def test_astype_from_object(self):
+        index = Index([1.0, np.nan, 0.2], dtype="object")
+        result = index.astype(float)
+        expected = Index([1.0, np.nan, 0.2], dtype=np.float64)
+        assert result.dtype == expected.dtype
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_indexing.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd28d519313ed36228040361dfbb2a8dccf77be5
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_indexing.py
@@ -0,0 +1,611 @@
+import numpy as np
+import pytest
+
+from pandas.errors import InvalidIndexError
+
+from pandas import (
+    NA,
+    Index,
+    RangeIndex,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowExtensionArray,
+    FloatingArray,
+)
+
+
+@pytest.fixture
+def index_large():
+    # large values used in Index[uint64] tests where no compat needed with Int64/Float64
+    large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
+    return Index(large, dtype=np.uint64)
+
+
+class TestGetLoc:
+    def test_get_loc(self):
+        index = Index([0, 1, 2])
+        assert index.get_loc(1) == 1
+
+    def test_get_loc_raises_bad_label(self):
+        index = Index([0, 1, 2])
+        with pytest.raises(InvalidIndexError, match=r"\[1, 2\]"):
+            index.get_loc([1, 2])
+
+    def test_get_loc_float64(self):
+        idx = Index([0.0, 1.0, 2.0], dtype=np.float64)
+
+        with pytest.raises(KeyError, match="^'foo'$"):
+            idx.get_loc("foo")
+        with pytest.raises(KeyError, match=r"^1\.5$"):
+            idx.get_loc(1.5)
+        with pytest.raises(KeyError, match="^True$"):
+            idx.get_loc(True)
+        with pytest.raises(KeyError, match="^False$"):
+            idx.get_loc(False)
+
+    def test_get_loc_na(self):
+        idx = Index([np.nan, 1, 2], dtype=np.float64)
+        assert idx.get_loc(1) == 1
+        assert idx.get_loc(np.nan) == 0
+
+        idx = Index([np.nan, 1, np.nan], dtype=np.float64)
+        assert idx.get_loc(1) == 1
+
+        # representable by slice [0:2:2]
+        msg = "'Cannot get left slice bound for non-unique label: nan'"
+        with pytest.raises(KeyError, match=msg):
+            idx.slice_locs(np.nan)
+        # not representable by slice
+        idx = Index([np.nan, 1, np.nan, np.nan], dtype=np.float64)
+        assert idx.get_loc(1) == 1
+        msg = "'Cannot get left slice bound for non-unique label: nan"
+        with pytest.raises(KeyError, match=msg):
+            idx.slice_locs(np.nan)
+
+    def test_get_loc_missing_nan(self):
+        # GH#8569
+        idx = Index([1, 2], dtype=np.float64)
+        assert idx.get_loc(1) == 0
+        with pytest.raises(KeyError, match=r"^3$"):
+            idx.get_loc(3)
+        with pytest.raises(KeyError, match="^nan$"):
+            idx.get_loc(np.nan)
+        with pytest.raises(InvalidIndexError, match=r"\[nan\]"):
+            # listlike/non-hashable raises TypeError
+            idx.get_loc([np.nan])
+
+    @pytest.mark.parametrize("vals", [[1], [1.0], [Timestamp("2019-12-31")], ["test"]])
+    def test_get_loc_float_index_nan_with_method(self, vals):
+        # GH#39382
+        idx = Index(vals)
+        with pytest.raises(KeyError, match="nan"):
+            idx.get_loc(np.nan)
+
+    @pytest.mark.parametrize("dtype", ["f8", "i8", "u8"])
+    def test_get_loc_numericindex_none_raises(self, dtype):
+        # case that goes through searchsorted and key is non-comparable to values
+        arr = np.arange(10**7, dtype=dtype)
+        idx = Index(arr)
+        with pytest.raises(KeyError, match="None"):
+            idx.get_loc(None)
+
+    def test_get_loc_overflows(self):
+        # unique but non-monotonic goes through IndexEngine.mapping.get_item
+        idx = Index([0, 2, 1])
+
+        val = np.iinfo(np.int64).max + 1
+
+        with pytest.raises(KeyError, match=str(val)):
+            idx.get_loc(val)
+        with pytest.raises(KeyError, match=str(val)):
+            idx._engine.get_loc(val)
+
+
+class TestGetIndexer:
+    def test_get_indexer(self):
+        index1 = Index([1, 2, 3, 4, 5])
+        index2 = Index([2, 4, 6])
+
+        r1 = index1.get_indexer(index2)
+        e1 = np.array([1, 3, -1], dtype=np.intp)
+        tm.assert_almost_equal(r1, e1)
+
+    @pytest.mark.parametrize("reverse", [True, False])
+    @pytest.mark.parametrize(
+        "expected,method",
+        [
+            (np.array([-1, 0, 0, 1, 1], dtype=np.intp), "pad"),
+            (np.array([-1, 0, 0, 1, 1], dtype=np.intp), "ffill"),
+            (np.array([0, 0, 1, 1, 2], dtype=np.intp), "backfill"),
+            (np.array([0, 0, 1, 1, 2], dtype=np.intp), "bfill"),
+        ],
+    )
+    def test_get_indexer_methods(self, reverse, expected, method):
+        index1 = Index([1, 2, 3, 4, 5])
+        index2 = Index([2, 4, 6])
+
+        if reverse:
+            index1 = index1[::-1]
+            expected = expected[::-1]
+
+        result = index2.get_indexer(index1, method=method)
+        tm.assert_almost_equal(result, expected)
+
+    def test_get_indexer_invalid(self):
+        # GH10411
+        index = Index(np.arange(10))
+
+        with pytest.raises(ValueError, match="tolerance argument"):
+            index.get_indexer([1, 0], tolerance=1)
+
+        with pytest.raises(ValueError, match="limit argument"):
+            index.get_indexer([1, 0], limit=1)
+
+    @pytest.mark.parametrize(
+        "method, tolerance, indexer, expected",
+        [
+            ("pad", None, [0, 5, 9], [0, 5, 9]),
+            ("backfill", None, [0, 5, 9], [0, 5, 9]),
+            ("nearest", None, [0, 5, 9], [0, 5, 9]),
+            ("pad", 0, [0, 5, 9], [0, 5, 9]),
+            ("backfill", 0, [0, 5, 9], [0, 5, 9]),
+            ("nearest", 0, [0, 5, 9], [0, 5, 9]),
+            ("pad", None, [0.2, 1.8, 8.5], [0, 1, 8]),
+            ("backfill", None, [0.2, 1.8, 8.5], [1, 2, 9]),
+            ("nearest", None, [0.2, 1.8, 8.5], [0, 2, 9]),
+            ("pad", 1, [0.2, 1.8, 8.5], [0, 1, 8]),
+            ("backfill", 1, [0.2, 1.8, 8.5], [1, 2, 9]),
+            ("nearest", 1, [0.2, 1.8, 8.5], [0, 2, 9]),
+            ("pad", 0.2, [0.2, 1.8, 8.5], [0, -1, -1]),
+            ("backfill", 0.2, [0.2, 1.8, 8.5], [-1, 2, -1]),
+            ("nearest", 0.2, [0.2, 1.8, 8.5], [0, 2, -1]),
+        ],
+    )
+    def test_get_indexer_nearest(self, method, tolerance, indexer, expected):
+        index = Index(np.arange(10))
+
+        actual = index.get_indexer(indexer, method=method, tolerance=tolerance)
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    @pytest.mark.parametrize("listtype", [list, tuple, Series, np.array])
+    @pytest.mark.parametrize(
+        "tolerance, expected",
+        list(
+            zip(
+                [[0.3, 0.3, 0.1], [0.2, 0.1, 0.1], [0.1, 0.5, 0.5]],
+                [[0, 2, -1], [0, -1, -1], [-1, 2, 9]],
+            )
+        ),
+    )
+    def test_get_indexer_nearest_listlike_tolerance(
+        self, tolerance, expected, listtype
+    ):
+        index = Index(np.arange(10))
+
+        actual = index.get_indexer(
+            [0.2, 1.8, 8.5], method="nearest", tolerance=listtype(tolerance)
+        )
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    def test_get_indexer_nearest_error(self):
+        index = Index(np.arange(10))
+        with pytest.raises(ValueError, match="limit argument"):
+            index.get_indexer([1, 0], method="nearest", limit=1)
+
+        with pytest.raises(ValueError, match="tolerance size must match"):
+            index.get_indexer([1, 0], method="nearest", tolerance=[1, 2, 3])
+
+    @pytest.mark.parametrize(
+        "method,expected",
+        [("pad", [8, 7, 0]), ("backfill", [9, 8, 1]), ("nearest", [9, 7, 0])],
+    )
+    def test_get_indexer_nearest_decreasing(self, method, expected):
+        index = Index(np.arange(10))[::-1]
+
+        actual = index.get_indexer([0, 5, 9], method=method)
+        tm.assert_numpy_array_equal(actual, np.array([9, 4, 0], dtype=np.intp))
+
+        actual = index.get_indexer([0.2, 1.8, 8.5], method=method)
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    @pytest.mark.parametrize("idx_dtype", ["int64", "float64", "uint64", "range"])
+    @pytest.mark.parametrize("method", ["get_indexer", "get_indexer_non_unique"])
+    def test_get_indexer_numeric_index_boolean_target(self, method, idx_dtype):
+        # GH 16877
+
+        if idx_dtype == "range":
+            numeric_index = RangeIndex(4)
+        else:
+            numeric_index = Index(np.arange(4, dtype=idx_dtype))
+
+        other = Index([True, False, True])
+
+        result = getattr(numeric_index, method)(other)
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+        if method == "get_indexer":
+            tm.assert_numpy_array_equal(result, expected)
+        else:
+            missing = np.arange(3, dtype=np.intp)
+            tm.assert_numpy_array_equal(result[0], expected)
+            tm.assert_numpy_array_equal(result[1], missing)
+
+    @pytest.mark.parametrize("method", ["pad", "backfill", "nearest"])
+    def test_get_indexer_with_method_numeric_vs_bool(self, method):
+        left = Index([1, 2, 3])
+        right = Index([True, False])
+
+        with pytest.raises(TypeError, match="Cannot compare"):
+            left.get_indexer(right, method=method)
+
+        with pytest.raises(TypeError, match="Cannot compare"):
+            right.get_indexer(left, method=method)
+
+    def test_get_indexer_numeric_vs_bool(self):
+        left = Index([1, 2, 3])
+        right = Index([True, False])
+
+        res = left.get_indexer(right)
+        expected = -1 * np.ones(len(right), dtype=np.intp)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = right.get_indexer(left)
+        expected = -1 * np.ones(len(left), dtype=np.intp)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = left.get_indexer_non_unique(right)[0]
+        expected = -1 * np.ones(len(right), dtype=np.intp)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = right.get_indexer_non_unique(left)[0]
+        expected = -1 * np.ones(len(left), dtype=np.intp)
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_get_indexer_float64(self):
+        idx = Index([0.0, 1.0, 2.0], dtype=np.float64)
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
+        )
+
+        target = [-0.1, 0.5, 1.1]
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "pad"), np.array([-1, 0, 1], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "backfill"), np.array([0, 1, 2], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "nearest"), np.array([0, 1, 1], dtype=np.intp)
+        )
+
+    def test_get_indexer_nan(self):
+        # GH#7820
+        result = Index([1, 2, np.nan], dtype=np.float64).get_indexer([np.nan])
+        expected = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_int64(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        target = Index(np.arange(10), dtype=np.int64)
+        indexer = index.get_indexer(target)
+        expected = np.array([0, -1, 1, -1, 2, -1, 3, -1, 4, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+        target = Index(np.arange(10), dtype=np.int64)
+        indexer = index.get_indexer(target, method="pad")
+        expected = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+        target = Index(np.arange(10), dtype=np.int64)
+        indexer = index.get_indexer(target, method="backfill")
+        expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+    def test_get_indexer_uint64(self, index_large):
+        target = Index(np.arange(10).astype("uint64") * 5 + 2**63)
+        indexer = index_large.get_indexer(target)
+        expected = np.array([0, -1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+        target = Index(np.arange(10).astype("uint64") * 5 + 2**63)
+        indexer = index_large.get_indexer(target, method="pad")
+        expected = np.array([0, 0, 1, 2, 3, 4, 4, 4, 4, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+        target = Index(np.arange(10).astype("uint64") * 5 + 2**63)
+        indexer = index_large.get_indexer(target, method="backfill")
+        expected = np.array([0, 1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+    @pytest.mark.parametrize("val, val2", [(4, 5), (4, 4), (4, NA), (NA, NA)])
+    def test_get_loc_masked(self, val, val2, any_numeric_ea_and_arrow_dtype):
+        # GH#39133
+        idx = Index([1, 2, 3, val, val2], dtype=any_numeric_ea_and_arrow_dtype)
+        result = idx.get_loc(2)
+        assert result == 1
+
+        with pytest.raises(KeyError, match="9"):
+            idx.get_loc(9)
+
+    def test_get_loc_masked_na(self, any_numeric_ea_and_arrow_dtype):
+        # GH#39133
+        idx = Index([1, 2, NA], dtype=any_numeric_ea_and_arrow_dtype)
+        result = idx.get_loc(NA)
+        assert result == 2
+
+        idx = Index([1, 2, NA, NA], dtype=any_numeric_ea_and_arrow_dtype)
+        result = idx.get_loc(NA)
+        tm.assert_numpy_array_equal(result, np.array([False, False, True, True]))
+
+        idx = Index([1, 2, 3], dtype=any_numeric_ea_and_arrow_dtype)
+        with pytest.raises(KeyError, match="NA"):
+            idx.get_loc(NA)
+
+    def test_get_loc_masked_na_and_nan(self):
+        # GH#39133
+        idx = Index(
+            FloatingArray(
+                np.array([1, 2, 1, np.nan]), mask=np.array([False, False, True, False])
+            )
+        )
+        result = idx.get_loc(NA)
+        assert result == 2
+        result = idx.get_loc(np.nan)
+        assert result == 3
+
+        idx = Index(
+            FloatingArray(np.array([1, 2, 1.0]), mask=np.array([False, False, True]))
+        )
+        result = idx.get_loc(NA)
+        assert result == 2
+        with pytest.raises(KeyError, match="nan"):
+            idx.get_loc(np.nan)
+
+        idx = Index(
+            FloatingArray(
+                np.array([1, 2, np.nan]), mask=np.array([False, False, False])
+            )
+        )
+        result = idx.get_loc(np.nan)
+        assert result == 2
+        with pytest.raises(KeyError, match="NA"):
+            idx.get_loc(NA)
+
+    @pytest.mark.parametrize("val", [4, 2])
+    def test_get_indexer_masked_na(self, any_numeric_ea_and_arrow_dtype, val):
+        # GH#39133
+        idx = Index([1, 2, NA, 3, val], dtype=any_numeric_ea_and_arrow_dtype)
+        result = idx.get_indexer_for([1, NA, 5])
+        expected = np.array([0, 2, -1])
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+    @pytest.mark.parametrize("dtype", ["boolean", "bool[pyarrow]"])
+    def test_get_indexer_masked_na_boolean(self, dtype):
+        # GH#39133
+        if dtype == "bool[pyarrow]":
+            pytest.importorskip("pyarrow")
+        idx = Index([True, False, NA], dtype=dtype)
+        result = idx.get_loc(False)
+        assert result == 1
+        result = idx.get_loc(NA)
+        assert result == 2
+
+    def test_get_indexer_arrow_dictionary_target(self):
+        pa = pytest.importorskip("pyarrow")
+        target = Index(
+            ArrowExtensionArray(
+                pa.array([1, 2], type=pa.dictionary(pa.int8(), pa.int8()))
+            )
+        )
+        idx = Index([1])
+
+        result = idx.get_indexer(target)
+        expected = np.array([0, -1], dtype=np.int64)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result_1, result_2 = idx.get_indexer_non_unique(target)
+        expected_1, expected_2 = np.array([0, -1], dtype=np.int64), np.array(
+            [1], dtype=np.int64
+        )
+        tm.assert_numpy_array_equal(result_1, expected_1)
+        tm.assert_numpy_array_equal(result_2, expected_2)
+
+
+class TestWhere:
+    @pytest.mark.parametrize(
+        "index",
+        [
+            Index(np.arange(5, dtype="float64")),
+            Index(range(0, 20, 2), dtype=np.int64),
+            Index(np.arange(5, dtype="uint64")),
+        ],
+    )
+    def test_where(self, listlike_box, index):
+        cond = [True] * len(index)
+        expected = index
+        result = index.where(listlike_box(cond))
+
+        cond = [False] + [True] * (len(index) - 1)
+        expected = Index([index._na_value] + index[1:].tolist(), dtype=np.float64)
+        result = index.where(listlike_box(cond))
+        tm.assert_index_equal(result, expected)
+
+    def test_where_uint64(self):
+        idx = Index([0, 6, 2], dtype=np.uint64)
+        mask = np.array([False, True, False])
+        other = np.array([1], dtype=np.int64)
+
+        expected = Index([1, 6, 1], dtype=np.uint64)
+
+        result = idx.where(mask, other)
+        tm.assert_index_equal(result, expected)
+
+        result = idx.putmask(~mask, other)
+        tm.assert_index_equal(result, expected)
+
+    def test_where_infers_type_instead_of_trying_to_convert_string_to_float(self):
+        # GH 32413
+        index = Index([1, np.nan])
+        cond = index.notna()
+        other = Index(["a", "b"], dtype="string")
+
+        expected = Index([1.0, "b"])
+        result = index.where(cond, other)
+
+        tm.assert_index_equal(result, expected)
+
+
+class TestTake:
+    @pytest.mark.parametrize("idx_dtype", [np.float64, np.int64, np.uint64])
+    def test_take_preserve_name(self, idx_dtype):
+        index = Index([1, 2, 3, 4], dtype=idx_dtype, name="foo")
+        taken = index.take([3, 0, 1])
+        assert index.name == taken.name
+
+    def test_take_fill_value_float64(self):
+        # GH 12631
+        idx = Index([1.0, 2.0, 3.0], name="xxx", dtype=np.float64)
+        result = idx.take(np.array([1, 0, -1]))
+        expected = Index([2.0, 1.0, 3.0], dtype=np.float64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = Index([2.0, 1.0, np.nan], dtype=np.float64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = Index([2.0, 1.0, 3.0], dtype=np.float64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        msg = (
+            "When allow_fill=True and fill_value is not None, "
+            "all indices must be >= -1"
+        )
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        msg = "index -5 is out of bounds for (axis 0 with )?size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -5]))
+
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+    def test_take_fill_value_ints(self, dtype):
+        # see gh-12631
+        idx = Index([1, 2, 3], dtype=dtype, name="xxx")
+        result = idx.take(np.array([1, 0, -1]))
+        expected = Index([2, 1, 3], dtype=dtype, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        name = type(idx).__name__
+        msg = f"Unable to fill values because {name} cannot contain NA"
+
+        # fill_value=True
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -1]), fill_value=True)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = Index([2, 1, 3], dtype=dtype, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        msg = "index -5 is out of bounds for (axis 0 with )?size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -5]))
+
+
+class TestContains:
+    @pytest.mark.parametrize("dtype", [np.float64, np.int64, np.uint64])
+    def test_contains_none(self, dtype):
+        # GH#35788 should return False, not raise TypeError
+        index = Index([0, 1, 2, 3, 4], dtype=dtype)
+        assert None not in index
+
+    def test_contains_float64_nans(self):
+        index = Index([1.0, 2.0, np.nan], dtype=np.float64)
+        assert np.nan in index
+
+    def test_contains_float64_not_nans(self):
+        index = Index([1.0, 2.0, np.nan], dtype=np.float64)
+        assert 1.0 in index
+
+
+class TestSliceLocs:
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs(self, dtype):
+        index = Index(np.array([0, 1, 2, 5, 6, 7, 9, 10], dtype=dtype))
+        n = len(index)
+
+        assert index.slice_locs(start=2) == (2, n)
+        assert index.slice_locs(start=3) == (3, n)
+        assert index.slice_locs(3, 8) == (3, 6)
+        assert index.slice_locs(5, 10) == (3, n)
+        assert index.slice_locs(end=8) == (0, 6)
+        assert index.slice_locs(end=9) == (0, 7)
+
+        # reversed
+        index2 = index[::-1]
+        assert index2.slice_locs(8, 2) == (2, 6)
+        assert index2.slice_locs(7, 3) == (2, 5)
+
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs_float_locs(self, dtype):
+        index = Index(np.array([0, 1, 2, 5, 6, 7, 9, 10], dtype=dtype))
+        n = len(index)
+        assert index.slice_locs(5.0, 10.0) == (3, n)
+        assert index.slice_locs(4.5, 10.5) == (3, 8)
+
+        index2 = index[::-1]
+        assert index2.slice_locs(8.5, 1.5) == (2, 6)
+        assert index2.slice_locs(10.5, -1) == (0, n)
+
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs_dup_numeric(self, dtype):
+        index = Index(np.array([10, 12, 12, 14], dtype=dtype))
+        assert index.slice_locs(12, 12) == (1, 3)
+        assert index.slice_locs(11, 13) == (1, 3)
+
+        index2 = index[::-1]
+        assert index2.slice_locs(12, 12) == (1, 3)
+        assert index2.slice_locs(13, 11) == (1, 3)
+
+    def test_slice_locs_na(self):
+        index = Index([np.nan, 1, 2])
+        assert index.slice_locs(1) == (1, 3)
+        assert index.slice_locs(np.nan) == (0, 3)
+
+        index = Index([0, np.nan, np.nan, 1, 2])
+        assert index.slice_locs(np.nan) == (1, 5)
+
+    def test_slice_locs_na_raises(self):
+        index = Index([np.nan, 1, 2])
+        with pytest.raises(KeyError, match=""):
+            index.slice_locs(start=1.5)
+
+        with pytest.raises(KeyError, match=""):
+            index.slice_locs(end=1.5)
+
+
+class TestGetSliceBounds:
+    @pytest.mark.parametrize("side, expected", [("left", 4), ("right", 5)])
+    def test_get_slice_bounds_within(self, side, expected):
+        index = Index(range(6))
+        result = index.get_slice_bound(4, side=side)
+        assert result == expected
+
+    @pytest.mark.parametrize("side", ["left", "right"])
+    @pytest.mark.parametrize("bound, expected", [(-1, 0), (10, 6)])
+    def test_get_slice_bounds_outside(self, side, expected, bound):
+        index = Index(range(6))
+        result = index.get_slice_bound(bound, side=side)
+        assert result == expected
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_join.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..918d5052167356b1d51018434c03e6682f828872
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_join.py
@@ -0,0 +1,380 @@
+import numpy as np
+import pytest
+
+import pandas._testing as tm
+from pandas.core.indexes.api import Index
+
+
+class TestJoinInt64Index:
+    def test_join_non_unique(self):
+        left = Index([4, 4, 3, 3])
+
+        joined, lidx, ridx = left.join(left, return_indexers=True)
+
+        exp_joined = Index([4, 4, 4, 4, 3, 3, 3, 3])
+        tm.assert_index_equal(joined, exp_joined)
+
+        exp_lidx = np.array([0, 0, 1, 1, 2, 2, 3, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(lidx, exp_lidx)
+
+        exp_ridx = np.array([0, 1, 0, 1, 2, 3, 2, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(ridx, exp_ridx)
+
+    def test_join_inner(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        other = Index([7, 12, 25, 1, 2, 5], dtype=np.int64)
+        other_mono = Index([1, 2, 5, 7, 12, 25], dtype=np.int64)
+
+        # not monotonic
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
+
+        # no guarantee of sortedness, so sort for comparison purposes
+        ind = res.argsort()
+        res = res.take(ind)
+        lidx = lidx.take(ind)
+        ridx = ridx.take(ind)
+
+        eres = Index([2, 12], dtype=np.int64)
+        elidx = np.array([1, 6], dtype=np.intp)
+        eridx = np.array([4, 1], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index.join(other_mono, how="inner", return_indexers=True)
+
+        res2 = index.intersection(other_mono)
+        tm.assert_index_equal(res, res2)
+
+        elidx = np.array([1, 6], dtype=np.intp)
+        eridx = np.array([1, 4], dtype=np.intp)
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_left(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        other = Index([7, 12, 25, 1, 2, 5], dtype=np.int64)
+        other_mono = Index([1, 2, 5, 7, 12, 25], dtype=np.int64)
+
+        # not monotonic
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
+        eres = index
+        eridx = np.array([-1, 4, -1, -1, -1, -1, 1, -1, -1, -1], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index.join(other_mono, how="left", return_indexers=True)
+        eridx = np.array([-1, 1, -1, -1, -1, -1, 4, -1, -1, -1], dtype=np.intp)
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # non-unique
+        idx = Index([1, 1, 2, 5])
+        idx2 = Index([1, 2, 5, 7, 9])
+        res, lidx, ridx = idx2.join(idx, how="left", return_indexers=True)
+        eres = Index([1, 1, 2, 5, 7, 9])  # 1 is in idx2, so it should be x2
+        eridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+        elidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_right(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        other = Index([7, 12, 25, 1, 2, 5], dtype=np.int64)
+        other_mono = Index([1, 2, 5, 7, 12, 25], dtype=np.int64)
+
+        # not monotonic
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
+        eres = other
+        elidx = np.array([-1, 6, -1, -1, 1, -1], dtype=np.intp)
+
+        assert isinstance(other, Index) and other.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        assert ridx is None
+
+        # monotonic
+        res, lidx, ridx = index.join(other_mono, how="right", return_indexers=True)
+        eres = other_mono
+        elidx = np.array([-1, 1, -1, -1, 6, -1], dtype=np.intp)
+        assert isinstance(other, Index) and other.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        assert ridx is None
+
+        # non-unique
+        idx = Index([1, 1, 2, 5])
+        idx2 = Index([1, 2, 5, 7, 9])
+        res, lidx, ridx = idx.join(idx2, how="right", return_indexers=True)
+        eres = Index([1, 1, 2, 5, 7, 9])  # 1 is in idx2, so it should be x2
+        elidx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+        eridx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_non_int_index(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        other = Index([3, 6, 7, 8, 10], dtype=object)
+
+        outer = index.join(other, how="outer")
+        outer2 = other.join(index, how="outer")
+        expected = Index([0, 2, 3, 4, 6, 7, 8, 10, 12, 14, 16, 18])
+        tm.assert_index_equal(outer, outer2)
+        tm.assert_index_equal(outer, expected)
+
+        inner = index.join(other, how="inner")
+        inner2 = other.join(index, how="inner")
+        expected = Index([6, 8, 10])
+        tm.assert_index_equal(inner, inner2)
+        tm.assert_index_equal(inner, expected)
+
+        left = index.join(other, how="left")
+        tm.assert_index_equal(left, index.astype(object))
+
+        left2 = other.join(index, how="left")
+        tm.assert_index_equal(left2, other)
+
+        right = index.join(other, how="right")
+        tm.assert_index_equal(right, other)
+
+        right2 = other.join(index, how="right")
+        tm.assert_index_equal(right2, index.astype(object))
+
+    def test_join_outer(self):
+        index = Index(range(0, 20, 2), dtype=np.int64)
+        other = Index([7, 12, 25, 1, 2, 5], dtype=np.int64)
+        other_mono = Index([1, 2, 5, 7, 12, 25], dtype=np.int64)
+
+        # not monotonic
+        # guarantee of sortedness
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        eres = Index([0, 1, 2, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 25], dtype=np.int64)
+        elidx = np.array([0, -1, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, 9, -1], dtype=np.intp)
+        eridx = np.array(
+            [-1, 3, 4, -1, 5, -1, 0, -1, -1, 1, -1, -1, -1, 2], dtype=np.intp
+        )
+
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index.join(other_mono, how="outer", return_indexers=True)
+        noidx_res = index.join(other_mono, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        elidx = np.array([0, -1, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, 9, -1], dtype=np.intp)
+        eridx = np.array(
+            [-1, 0, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, -1, 5], dtype=np.intp
+        )
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+
+class TestJoinUInt64Index:
+    @pytest.fixture
+    def index_large(self):
+        # large values used in TestUInt64Index where no compat needed with int64/float64
+        large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
+        return Index(large, dtype=np.uint64)
+
+    def test_join_inner(self, index_large):
+        other = Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other_mono = Index(2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64"))
+
+        # not monotonic
+        res, lidx, ridx = index_large.join(other, how="inner", return_indexers=True)
+
+        # no guarantee of sortedness, so sort for comparison purposes
+        ind = res.argsort()
+        res = res.take(ind)
+        lidx = lidx.take(ind)
+        ridx = ridx.take(ind)
+
+        eres = Index(2**63 + np.array([10, 25], dtype="uint64"))
+        elidx = np.array([1, 4], dtype=np.intp)
+        eridx = np.array([5, 2], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index_large.join(
+            other_mono, how="inner", return_indexers=True
+        )
+
+        res2 = index_large.intersection(other_mono)
+        tm.assert_index_equal(res, res2)
+
+        elidx = np.array([1, 4], dtype=np.intp)
+        eridx = np.array([3, 5], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_left(self, index_large):
+        other = Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other_mono = Index(2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64"))
+
+        # not monotonic
+        res, lidx, ridx = index_large.join(other, how="left", return_indexers=True)
+        eres = index_large
+        eridx = np.array([-1, 5, -1, -1, 2], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index_large.join(other_mono, how="left", return_indexers=True)
+        eridx = np.array([-1, 3, -1, -1, 5], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # non-unique
+        idx = Index(2**63 + np.array([1, 1, 2, 5], dtype="uint64"))
+        idx2 = Index(2**63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
+        res, lidx, ridx = idx2.join(idx, how="left", return_indexers=True)
+
+        # 1 is in idx2, so it should be x2
+        eres = Index(2**63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
+        eridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+        elidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_right(self, index_large):
+        other = Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other_mono = Index(2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64"))
+
+        # not monotonic
+        res, lidx, ridx = index_large.join(other, how="right", return_indexers=True)
+        eres = other
+        elidx = np.array([-1, -1, 4, -1, -1, 1], dtype=np.intp)
+
+        tm.assert_numpy_array_equal(lidx, elidx)
+        assert isinstance(other, Index) and other.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        assert ridx is None
+
+        # monotonic
+        res, lidx, ridx = index_large.join(
+            other_mono, how="right", return_indexers=True
+        )
+        eres = other_mono
+        elidx = np.array([-1, -1, -1, 1, -1, 4], dtype=np.intp)
+
+        assert isinstance(other, Index) and other.dtype == np.uint64
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_index_equal(res, eres)
+        assert ridx is None
+
+        # non-unique
+        idx = Index(2**63 + np.array([1, 1, 2, 5], dtype="uint64"))
+        idx2 = Index(2**63 + np.array([1, 2, 5, 7, 9], dtype="uint64"))
+        res, lidx, ridx = idx.join(idx2, how="right", return_indexers=True)
+
+        # 1 is in idx2, so it should be x2
+        eres = Index(2**63 + np.array([1, 1, 2, 5, 7, 9], dtype="uint64"))
+        elidx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+        eridx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_non_int_index(self, index_large):
+        other = Index(
+            2**63 + np.array([1, 5, 7, 10, 20], dtype="uint64"), dtype=object
+        )
+
+        outer = index_large.join(other, how="outer")
+        outer2 = other.join(index_large, how="outer")
+        expected = Index(
+            2**63 + np.array([0, 1, 5, 7, 10, 15, 20, 25], dtype="uint64")
+        )
+        tm.assert_index_equal(outer, outer2)
+        tm.assert_index_equal(outer, expected)
+
+        inner = index_large.join(other, how="inner")
+        inner2 = other.join(index_large, how="inner")
+        expected = Index(2**63 + np.array([10, 20], dtype="uint64"))
+        tm.assert_index_equal(inner, inner2)
+        tm.assert_index_equal(inner, expected)
+
+        left = index_large.join(other, how="left")
+        tm.assert_index_equal(left, index_large.astype(object))
+
+        left2 = other.join(index_large, how="left")
+        tm.assert_index_equal(left2, other)
+
+        right = index_large.join(other, how="right")
+        tm.assert_index_equal(right, other)
+
+        right2 = other.join(index_large, how="right")
+        tm.assert_index_equal(right2, index_large.astype(object))
+
+    def test_join_outer(self, index_large):
+        other = Index(2**63 + np.array([7, 12, 25, 1, 2, 10], dtype="uint64"))
+        other_mono = Index(2**63 + np.array([1, 2, 7, 10, 12, 25], dtype="uint64"))
+
+        # not monotonic
+        # guarantee of sortedness
+        res, lidx, ridx = index_large.join(other, how="outer", return_indexers=True)
+        noidx_res = index_large.join(other, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        eres = Index(
+            2**63 + np.array([0, 1, 2, 7, 10, 12, 15, 20, 25], dtype="uint64")
+        )
+        elidx = np.array([0, -1, -1, -1, 1, -1, 2, 3, 4], dtype=np.intp)
+        eridx = np.array([-1, 3, 4, 0, 5, 1, -1, -1, 2], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # monotonic
+        res, lidx, ridx = index_large.join(
+            other_mono, how="outer", return_indexers=True
+        )
+        noidx_res = index_large.join(other_mono, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        elidx = np.array([0, -1, -1, -1, 1, -1, 2, 3, 4], dtype=np.intp)
+        eridx = np.array([-1, 0, 1, 2, 3, 4, -1, -1, 5], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.uint64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_setops.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_setops.py
new file mode 100644
index 0000000000000000000000000000000000000000..376b51dd98bb1b1c7c6c8a67914bc72f6c6c588d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/numeric/test_setops.py
@@ -0,0 +1,168 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+import pandas._testing as tm
+from pandas.core.indexes.api import (
+    Index,
+    RangeIndex,
+)
+
+
+@pytest.fixture
+def index_large():
+    # large values used in TestUInt64Index where no compat needed with int64/float64
+    large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
+    return Index(large, dtype=np.uint64)
+
+
+class TestSetOps:
+    @pytest.mark.parametrize("dtype", ["f8", "u8", "i8"])
+    def test_union_non_numeric(self, dtype):
+        # corner case, non-numeric
+        index = Index(np.arange(5, dtype=dtype), dtype=dtype)
+        assert index.dtype == dtype
+
+        other = Index([datetime.now() + timedelta(i) for i in range(4)], dtype=object)
+        result = index.union(other)
+        expected = Index(np.concatenate((index, other)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index)
+        expected = Index(np.concatenate((other, index)))
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection(self):
+        index = Index(range(5), dtype=np.int64)
+
+        other = Index([1, 2, 3, 4, 5])
+        result = index.intersection(other)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index)
+        expected = Index(
+            np.sort(np.asarray(np.intersect1d(index.values, other.values)))
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["int64", "uint64"])
+    def test_int_float_union_dtype(self, dtype):
+        # https://github.com/pandas-dev/pandas/issues/26778
+        # [u]int | float -> float
+        index = Index([0, 2, 3], dtype=dtype)
+        other = Index([0.5, 1.5], dtype=np.float64)
+        expected = Index([0.0, 0.5, 1.5, 2.0, 3.0], dtype=np.float64)
+        result = index.union(other)
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index)
+        tm.assert_index_equal(result, expected)
+
+    def test_range_float_union_dtype(self):
+        # https://github.com/pandas-dev/pandas/issues/26778
+        index = RangeIndex(start=0, stop=3)
+        other = Index([0.5, 1.5], dtype=np.float64)
+        result = index.union(other)
+        expected = Index([0.0, 0.5, 1, 1.5, 2.0], dtype=np.float64)
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index)
+        tm.assert_index_equal(result, expected)
+
+    def test_range_uint64_union_dtype(self):
+        # https://github.com/pandas-dev/pandas/issues/26778
+        index = RangeIndex(start=0, stop=3)
+        other = Index([0, 10], dtype=np.uint64)
+        result = index.union(other)
+        expected = Index([0, 1, 2, 10], dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index)
+        tm.assert_index_equal(result, expected)
+
+    def test_float64_index_difference(self):
+        # https://github.com/pandas-dev/pandas/issues/35217
+        float_index = Index([1.0, 2, 3])
+        string_index = Index(["1", "2", "3"])
+
+        result = float_index.difference(string_index)
+        tm.assert_index_equal(result, float_index)
+
+        result = string_index.difference(float_index)
+        tm.assert_index_equal(result, string_index)
+
+    def test_intersection_uint64_outside_int64_range(self, index_large):
+        other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20])
+        result = index_large.intersection(other)
+        expected = Index(np.sort(np.intersect1d(index_large.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index_large)
+        expected = Index(
+            np.sort(np.asarray(np.intersect1d(index_large.values, other.values)))
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "index2,keeps_name",
+        [
+            (Index([4, 7, 6, 5, 3], name="index"), True),
+            (Index([4, 7, 6, 5, 3], name="other"), False),
+        ],
+    )
+    def test_intersection_monotonic(self, index2, keeps_name, sort):
+        index1 = Index([5, 3, 2, 4, 1], name="index")
+        expected = Index([5, 3, 4])
+
+        if keeps_name:
+            expected.name = "index"
+
+        result = index1.intersection(index2, sort=sort)
+        if sort is None:
+            expected = expected.sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_symmetric_difference(self, sort):
+        # smoke
+        index1 = Index([5, 2, 3, 4], name="index1")
+        index2 = Index([2, 3, 4, 1])
+        result = index1.symmetric_difference(index2, sort=sort)
+        expected = Index([5, 1])
+        if sort is not None:
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result, expected.sort_values())
+        assert result.name is None
+        if sort is None:
+            expected = expected.sort_values()
+        tm.assert_index_equal(result, expected)
+
+
+class TestSetOpsSort:
+    @pytest.mark.parametrize("slice_", [slice(None), slice(0)])
+    def test_union_sort_other_special(self, slice_):
+        # https://github.com/pandas-dev/pandas/issues/24959
+
+        idx = Index([1, 0, 2])
+        # default, sort=None
+        other = idx[slice_]
+        tm.assert_index_equal(idx.union(other), idx)
+        tm.assert_index_equal(other.union(idx), idx)
+
+        # sort=False
+        tm.assert_index_equal(idx.union(other, sort=False), idx)
+
+    @pytest.mark.parametrize("slice_", [slice(None), slice(0)])
+    def test_union_sort_special_true(self, slice_):
+        idx = Index([1, 0, 2])
+        # default, sort=None
+        other = idx[slice_]
+
+        result = idx.union(other, sort=True)
+        expected = Index([0, 1, 2])
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21805649368fe5ff376fafa67e232f0004f63170
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_constructors.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..84eb6c06af284a448435a4706b11267e4d9619ea
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_formats.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_formats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69b78f099d3326ad7eeb9714eff0d4e6840ec4e6
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_formats.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_freq_attr.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_freq_attr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..daa38ba52dc874e8055b4147577a87a6d24eaa95
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_freq_attr.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_indexing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fbc480b4120e84c20e0b995d1a0b94e9c1c9ff3
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_join.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_join.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4e6c52139cce7d69f7206bde8aa608d665595de
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_join.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_monotonic.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_monotonic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..024dd61f7e3ebcf05f1a9f146ab8f625f92f5cdd
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_monotonic.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_partial_slicing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_partial_slicing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3341cb94abea82aeaa31160fd0dd55b44a70ce84
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_partial_slicing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8bb6c751588e8e3262b7144fc728ee24a9793d53
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period_range.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period_range.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ce4c637cf1b658774947f64d60d7a4397278485
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_period_range.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_pickle.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_pickle.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d31879773654ea5f558c1682ab0ff8774563cc1
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_pickle.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_resolution.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_resolution.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6caf6022bed587d5a0d20489e056f6c3f306287
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_resolution.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_scalar_compat.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_scalar_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c66b3eb7b58f1fbacc7b33ef0f413584db67f904
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_scalar_compat.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_searchsorted.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_searchsorted.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4dff1bdafd175ce9557c6db906a76c8657ba253a
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_searchsorted.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_setops.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68e590f53f435a3775a488a65b17b65393372d8e
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_tools.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_tools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b50a3fd69603708084c5d0aa1f210c440647bbec
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/__pycache__/test_tools.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0815a9223b22bf00fc7d27a87f8891c2f18a76d3
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_asfreq.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_asfreq.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d587294b188798b1e520607bf42d02fd954166e
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_asfreq.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_astype.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec788f44c6872eb4e18f2d8e5a882c05b812c8de
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_factorize.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_factorize.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6be748d2be240304161be8f3e57898b6ba7c76d8
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_factorize.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_fillna.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d37e79cd19b92491c56b06a1fb8ec198832c1247
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_fillna.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_insert.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_insert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7606682333f6efb50b47018875f913f5984d3fd
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_insert.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_is_full.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_is_full.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4bb4fac201841a4ba7bd66bcb430a1122fe64bdd
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_is_full.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_repeat.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_repeat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95de3ffc7533f344fe747aff8c7adc4ca961eb0a
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_repeat.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_shift.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_shift.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf3daa0ed9a5ebb59c64c557b190afde9da9fa85
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_shift.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_to_timestamp.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_to_timestamp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d5b85ea876bff2dbb44317eed12be1f48dd8fd5
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/__pycache__/test_to_timestamp.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_asfreq.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_asfreq.py
new file mode 100644
index 0000000000000000000000000000000000000000..865bae69d91c7960e286646e22d0fa2646333303
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_asfreq.py
@@ -0,0 +1,189 @@
+import re
+
+import pytest
+
+from pandas import (
+    PeriodIndex,
+    Series,
+    period_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+class TestPeriodIndex:
+    def test_asfreq(self):
+        pi1 = period_range(freq="Y", start="1/1/2001", end="1/1/2001")
+        pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
+        pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
+        pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")
+        pi5 = period_range(freq="h", start="1/1/2001", end="1/1/2001 00:00")
+        pi6 = period_range(freq="Min", start="1/1/2001", end="1/1/2001 00:00")
+        pi7 = period_range(freq="s", start="1/1/2001", end="1/1/2001 00:00:00")
+
+        assert pi1.asfreq("Q", "s") == pi2
+        assert pi1.asfreq("Q", "s") == pi2
+        assert pi1.asfreq("M", "start") == pi3
+        assert pi1.asfreq("D", "StarT") == pi4
+        assert pi1.asfreq("h", "beGIN") == pi5
+        assert pi1.asfreq("Min", "s") == pi6
+        assert pi1.asfreq("s", "s") == pi7
+
+        assert pi2.asfreq("Y", "s") == pi1
+        assert pi2.asfreq("M", "s") == pi3
+        assert pi2.asfreq("D", "s") == pi4
+        assert pi2.asfreq("h", "s") == pi5
+        assert pi2.asfreq("Min", "s") == pi6
+        assert pi2.asfreq("s", "s") == pi7
+
+        assert pi3.asfreq("Y", "s") == pi1
+        assert pi3.asfreq("Q", "s") == pi2
+        assert pi3.asfreq("D", "s") == pi4
+        assert pi3.asfreq("h", "s") == pi5
+        assert pi3.asfreq("Min", "s") == pi6
+        assert pi3.asfreq("s", "s") == pi7
+
+        assert pi4.asfreq("Y", "s") == pi1
+        assert pi4.asfreq("Q", "s") == pi2
+        assert pi4.asfreq("M", "s") == pi3
+        assert pi4.asfreq("h", "s") == pi5
+        assert pi4.asfreq("Min", "s") == pi6
+        assert pi4.asfreq("s", "s") == pi7
+
+        assert pi5.asfreq("Y", "s") == pi1
+        assert pi5.asfreq("Q", "s") == pi2
+        assert pi5.asfreq("M", "s") == pi3
+        assert pi5.asfreq("D", "s") == pi4
+        assert pi5.asfreq("Min", "s") == pi6
+        assert pi5.asfreq("s", "s") == pi7
+
+        assert pi6.asfreq("Y", "s") == pi1
+        assert pi6.asfreq("Q", "s") == pi2
+        assert pi6.asfreq("M", "s") == pi3
+        assert pi6.asfreq("D", "s") == pi4
+        assert pi6.asfreq("h", "s") == pi5
+        assert pi6.asfreq("s", "s") == pi7
+
+        assert pi7.asfreq("Y", "s") == pi1
+        assert pi7.asfreq("Q", "s") == pi2
+        assert pi7.asfreq("M", "s") == pi3
+        assert pi7.asfreq("D", "s") == pi4
+        assert pi7.asfreq("h", "s") == pi5
+        assert pi7.asfreq("Min", "s") == pi6
+
+        msg = "How must be one of S or E"
+        with pytest.raises(ValueError, match=msg):
+            pi7.asfreq("T", "foo")
+        result1 = pi1.asfreq("3M")
+        result2 = pi1.asfreq("M")
+        expected = period_range(freq="M", start="2001-12", end="2001-12")
+        tm.assert_numpy_array_equal(result1.asi8, expected.asi8)
+        assert result1.freqstr == "3M"
+        tm.assert_numpy_array_equal(result2.asi8, expected.asi8)
+        assert result2.freqstr == "M"
+
+    def test_asfreq_nat(self):
+        idx = PeriodIndex(["2011-01", "2011-02", "NaT", "2011-04"], freq="M")
+        result = idx.asfreq(freq="Q")
+        expected = PeriodIndex(["2011Q1", "2011Q1", "NaT", "2011Q2"], freq="Q")
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("freq", ["D", "3D"])
+    def test_asfreq_mult_pi(self, freq):
+        pi = PeriodIndex(["2001-01", "2001-02", "NaT", "2001-03"], freq="2M")
+
+        result = pi.asfreq(freq)
+        exp = PeriodIndex(["2001-02-28", "2001-03-31", "NaT", "2001-04-30"], freq=freq)
+        tm.assert_index_equal(result, exp)
+        assert result.freq == exp.freq
+
+        result = pi.asfreq(freq, how="S")
+        exp = PeriodIndex(["2001-01-01", "2001-02-01", "NaT", "2001-03-01"], freq=freq)
+        tm.assert_index_equal(result, exp)
+        assert result.freq == exp.freq
+
+    def test_asfreq_combined_pi(self):
+        pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="h")
+        exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="25h")
+        for freq, how in zip(["1D1h", "1h1D"], ["S", "E"]):
+            result = pi.asfreq(freq, how=how)
+            tm.assert_index_equal(result, exp)
+            assert result.freq == exp.freq
+
+        for freq in ["1D1h", "1h1D"]:
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
+            result = pi.asfreq("h")
+            exp = PeriodIndex(["2001-01-02 00:00", "2001-01-03 02:00", "NaT"], freq="h")
+            tm.assert_index_equal(result, exp)
+            assert result.freq == exp.freq
+
+            pi = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq=freq)
+            result = pi.asfreq("h", how="S")
+            exp = PeriodIndex(["2001-01-01 00:00", "2001-01-02 02:00", "NaT"], freq="h")
+            tm.assert_index_equal(result, exp)
+            assert result.freq == exp.freq
+
+    def test_astype_asfreq(self):
+        pi1 = PeriodIndex(["2011-01-01", "2011-02-01", "2011-03-01"], freq="D")
+        exp = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
+        tm.assert_index_equal(pi1.asfreq("M"), exp)
+        tm.assert_index_equal(pi1.astype("period[M]"), exp)
+
+        exp = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="3M")
+        tm.assert_index_equal(pi1.asfreq("3M"), exp)
+        tm.assert_index_equal(pi1.astype("period[3M]"), exp)
+
+    def test_asfreq_with_different_n(self):
+        ser = Series([1, 2], index=PeriodIndex(["2020-01", "2020-03"], freq="2M"))
+        result = ser.asfreq("M")
+
+        excepted = Series([1, 2], index=PeriodIndex(["2020-02", "2020-04"], freq="M"))
+        tm.assert_series_equal(result, excepted)
+
+    @pytest.mark.parametrize(
+        "freq",
+        [
+            "2BMS",
+            "2YS-MAR",
+            "2bh",
+        ],
+    )
+    def test_pi_asfreq_not_supported_frequency(self, freq):
+        # GH#55785
+        msg = f"{freq[1:]} is not supported as period frequency"
+
+        pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+        with pytest.raises(ValueError, match=msg):
+            pi.asfreq(freq=freq)
+
+    @pytest.mark.parametrize(
+        "freq",
+        [
+            "2BME",
+            "2YE-MAR",
+            "2QE",
+        ],
+    )
+    def test_pi_asfreq_invalid_frequency(self, freq):
+        # GH#55785
+        msg = f"Invalid frequency: {freq}"
+
+        pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+        with pytest.raises(ValueError, match=msg):
+            pi.asfreq(freq=freq)
+
+    @pytest.mark.parametrize(
+        "freq",
+        [
+            offsets.MonthBegin(2),
+            offsets.BusinessMonthEnd(2),
+        ],
+    )
+    def test_pi_asfreq_invalid_baseoffset(self, freq):
+        # GH#56945
+        msg = re.escape(f"{freq} is not supported as period frequency")
+
+        pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+        with pytest.raises(ValueError, match=msg):
+            pi.asfreq(freq=freq)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_astype.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..d545bfd2fae0f7034c8cb62a8955c8b3c0ba0d6d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_astype.py
@@ -0,0 +1,151 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodIndexAsType:
+    @pytest.mark.parametrize("dtype", [float, "timedelta64", "timedelta64[ns]"])
+    def test_astype_raises(self, dtype):
+        # GH#13149, GH#13209
+        idx = PeriodIndex(["2016-05-16", "NaT", NaT, np.nan], freq="D")
+        msg = "Cannot cast PeriodIndex to dtype"
+        with pytest.raises(TypeError, match=msg):
+            idx.astype(dtype)
+
+    def test_astype_conversion(self):
+        # GH#13149, GH#13209
+        idx = PeriodIndex(["2016-05-16", "NaT", NaT, np.nan], freq="D", name="idx")
+
+        result = idx.astype(object)
+        expected = Index(
+            [Period("2016-05-16", freq="D")] + [Period(NaT, freq="D")] * 3,
+            dtype="object",
+            name="idx",
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype(np.int64)
+        expected = Index(
+            [16937] + [-9223372036854775808] * 3, dtype=np.int64, name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype(str)
+        expected = Index([str(x) for x in idx], name="idx", dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        idx = period_range("1990", "2009", freq="Y", name="idx")
+        result = idx.astype("i8")
+        tm.assert_index_equal(result, Index(idx.asi8, name="idx"))
+        tm.assert_numpy_array_equal(result.values, idx.asi8)
+
+    def test_astype_uint(self):
+        arr = period_range("2000", periods=2, name="idx")
+
+        with pytest.raises(TypeError, match=r"Do obj.astype\('int64'\)"):
+            arr.astype("uint64")
+        with pytest.raises(TypeError, match=r"Do obj.astype\('int64'\)"):
+            arr.astype("uint32")
+
+    def test_astype_object(self):
+        idx = PeriodIndex([], freq="M")
+
+        exp = np.array([], dtype=object)
+        tm.assert_numpy_array_equal(idx.astype(object).values, exp)
+        tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
+
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
+
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
+        tm.assert_numpy_array_equal(idx.astype(object).values, exp)
+        tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
+
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
+        tm.assert_numpy_array_equal(idx.astype(object).values, exp)
+        tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
+
+    # TODO: de-duplicate this version (from test_ops) with the one above
+    # (from test_period)
+    def test_astype_object2(self):
+        idx = period_range(start="2013-01-01", periods=4, freq="M", name="idx")
+        expected_list = [
+            Period("2013-01-31", freq="M"),
+            Period("2013-02-28", freq="M"),
+            Period("2013-03-31", freq="M"),
+            Period("2013-04-30", freq="M"),
+        ]
+        expected = Index(expected_list, dtype=object, name="idx")
+        result = idx.astype(object)
+        assert isinstance(result, Index)
+        assert result.dtype == object
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
+
+        idx = PeriodIndex(
+            ["2013-01-01", "2013-01-02", "NaT", "2013-01-04"], freq="D", name="idx"
+        )
+        expected_list = [
+            Period("2013-01-01", freq="D"),
+            Period("2013-01-02", freq="D"),
+            Period("NaT", freq="D"),
+            Period("2013-01-04", freq="D"),
+        ]
+        expected = Index(expected_list, dtype=object, name="idx")
+        result = idx.astype(object)
+        assert isinstance(result, Index)
+        assert result.dtype == object
+        tm.assert_index_equal(result, expected)
+        for i in [0, 1, 3]:
+            assert result[i] == expected[i]
+        assert result[2] is NaT
+        assert result.name == expected.name
+
+        result_list = idx.tolist()
+        for i in [0, 1, 3]:
+            assert result_list[i] == expected_list[i]
+        assert result_list[2] is NaT
+
+    def test_astype_category(self):
+        obj = period_range("2000", periods=2, name="idx")
+        result = obj.astype("category")
+        expected = CategoricalIndex(
+            [Period("2000-01-01", freq="D"), Period("2000-01-02", freq="D")], name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype("category")
+        expected = expected.values
+        tm.assert_categorical_equal(result, expected)
+
+    def test_astype_array_fallback(self):
+        obj = period_range("2000", periods=2, name="idx")
+        result = obj.astype(bool)
+        expected = Index(np.array([True, True]), name="idx")
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_period_astype_to_timestamp(self, unit):
+        # GH#55958
+        pi = PeriodIndex(["2011-01", "2011-02", "2011-03"], freq="M")
+
+        exp = DatetimeIndex(
+            ["2011-01-01", "2011-02-01", "2011-03-01"], tz="US/Eastern"
+        ).as_unit(unit)
+        res = pi.astype(f"datetime64[{unit}, US/Eastern]")
+        tm.assert_index_equal(res, exp)
+        assert res.freq == exp.freq
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_factorize.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_factorize.py
new file mode 100644
index 0000000000000000000000000000000000000000..1239eae6091b81dfcc1ac049996296f6af565df8
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_factorize.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+from pandas import PeriodIndex
+import pandas._testing as tm
+
+
+class TestFactorize:
+    def test_factorize_period(self):
+        idx1 = PeriodIndex(
+            ["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"],
+            freq="M",
+        )
+
+        exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.intp)
+        exp_idx = PeriodIndex(["2014-01", "2014-02", "2014-03"], freq="M")
+
+        arr, idx = idx1.factorize()
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
+
+        arr, idx = idx1.factorize(sort=True)
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
+
+    def test_factorize_period_nonmonotonic(self):
+        idx2 = PeriodIndex(
+            ["2014-03", "2014-03", "2014-02", "2014-01", "2014-03", "2014-01"],
+            freq="M",
+        )
+        exp_idx = PeriodIndex(["2014-01", "2014-02", "2014-03"], freq="M")
+
+        exp_arr = np.array([2, 2, 1, 0, 2, 0], dtype=np.intp)
+        arr, idx = idx2.factorize(sort=True)
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
+
+        exp_arr = np.array([0, 0, 1, 2, 0, 2], dtype=np.intp)
+        exp_idx = PeriodIndex(["2014-03", "2014-02", "2014-01"], freq="M")
+        arr, idx = idx2.factorize()
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_fillna.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed6b4686a06defdc3eac4e1f6427fb0569c2d48d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_fillna.py
@@ -0,0 +1,41 @@
+from pandas import (
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+)
+import pandas._testing as tm
+
+
+class TestFillNA:
+    def test_fillna_period(self):
+        # GH#11343
+        idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="h")
+
+        exp = PeriodIndex(
+            ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"], freq="h"
+        )
+        result = idx.fillna(Period("2011-01-01 10:00", freq="h"))
+        tm.assert_index_equal(result, exp)
+
+        exp = Index(
+            [
+                Period("2011-01-01 09:00", freq="h"),
+                "x",
+                Period("2011-01-01 11:00", freq="h"),
+            ],
+            dtype=object,
+        )
+        result = idx.fillna("x")
+        tm.assert_index_equal(result, exp)
+
+        exp = Index(
+            [
+                Period("2011-01-01 09:00", freq="h"),
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-01 11:00", freq="h"),
+            ],
+            dtype=object,
+        )
+        result = idx.fillna(Period("2011-01-01", freq="D"))
+        tm.assert_index_equal(result, exp)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_insert.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_insert.py
new file mode 100644
index 0000000000000000000000000000000000000000..32bbe09d925679579c1ec015b435870d1282e6b3
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_insert.py
@@ -0,0 +1,18 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NaT,
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestInsert:
+    @pytest.mark.parametrize("na", [np.nan, NaT, None])
+    def test_insert(self, na):
+        # GH#18295 (test missing)
+        expected = PeriodIndex(["2017Q1", NaT, "2017Q2", "2017Q3", "2017Q4"], freq="Q")
+        result = period_range("2017Q1", periods=4, freq="Q").insert(1, na)
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_is_full.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_is_full.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4105bedbe21d6dc85379f1a6eefb298db954056
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_is_full.py
@@ -0,0 +1,23 @@
+import pytest
+
+from pandas import PeriodIndex
+
+
+def test_is_full():
+    index = PeriodIndex([2005, 2007, 2009], freq="Y")
+    assert not index.is_full
+
+    index = PeriodIndex([2005, 2006, 2007], freq="Y")
+    assert index.is_full
+
+    index = PeriodIndex([2005, 2005, 2007], freq="Y")
+    assert not index.is_full
+
+    index = PeriodIndex([2005, 2005, 2006], freq="Y")
+    assert index.is_full
+
+    index = PeriodIndex([2006, 2005, 2005], freq="Y")
+    with pytest.raises(ValueError, match="Index is not monotonic"):
+        index.is_full
+
+    assert index[:0].is_full
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_repeat.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_repeat.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc344b06420d16a436c84a70f45a292cf6045856
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_repeat.py
@@ -0,0 +1,26 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestRepeat:
+    @pytest.mark.parametrize("use_numpy", [True, False])
+    @pytest.mark.parametrize(
+        "index",
+        [
+            period_range("2000-01-01", periods=3, freq="D"),
+            period_range("2001-01-01", periods=3, freq="2D"),
+            PeriodIndex(["2001-01", "NaT", "2003-01"], freq="M"),
+        ],
+    )
+    def test_repeat_freqstr(self, index, use_numpy):
+        # GH#10183
+        expected = PeriodIndex([per for per in index for _ in range(3)])
+        result = np.repeat(index, 3) if use_numpy else index.repeat(3)
+        tm.assert_index_equal(result, expected)
+        assert result.freqstr == index.freqstr
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_shift.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_shift.py
new file mode 100644
index 0000000000000000000000000000000000000000..fca3e3a559e1fe2e53571f5af919e9a0c49c4e68
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_shift.py
@@ -0,0 +1,122 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodIndexShift:
+    # ---------------------------------------------------------------
+    # PeriodIndex.shift is used by __add__ and __sub__
+
+    def test_pi_shift_ndarray(self):
+        idx = PeriodIndex(
+            ["2011-01", "2011-02", "NaT", "2011-04"], freq="M", name="idx"
+        )
+        result = idx.shift(np.array([1, 2, 3, 4]))
+        expected = PeriodIndex(
+            ["2011-02", "2011-04", "NaT", "2011-08"], freq="M", name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.shift(np.array([1, -2, 3, -4]))
+        expected = PeriodIndex(
+            ["2011-02", "2010-12", "NaT", "2010-12"], freq="M", name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_shift(self):
+        pi1 = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="Y", start="1/1/2002", end="12/1/2010")
+
+        tm.assert_index_equal(pi1.shift(0), pi1)
+
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="Y", start="1/1/2000", end="12/1/2008")
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+        pi1 = period_range(freq="M", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="M", start="2/1/2001", end="1/1/2010")
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = period_range(freq="M", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="M", start="12/1/2000", end="11/1/2009")
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+        pi1 = period_range(freq="D", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="D", start="1/2/2001", end="12/2/2009")
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = period_range(freq="D", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="D", start="12/31/2000", end="11/30/2009")
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+    def test_shift_corner_cases(self):
+        # GH#9903
+        idx = PeriodIndex([], name="xxx", freq="h")
+
+        msg = "`freq` argument is not supported for PeriodIndex.shift"
+        with pytest.raises(TypeError, match=msg):
+            # period shift doesn't accept freq
+            idx.shift(1, freq="h")
+
+        tm.assert_index_equal(idx.shift(0), idx)
+        tm.assert_index_equal(idx.shift(3), idx)
+
+        idx = PeriodIndex(
+            ["2011-01-01 10:00", "2011-01-01 11:00", "2011-01-01 12:00"],
+            name="xxx",
+            freq="h",
+        )
+        tm.assert_index_equal(idx.shift(0), idx)
+        exp = PeriodIndex(
+            ["2011-01-01 13:00", "2011-01-01 14:00", "2011-01-01 15:00"],
+            name="xxx",
+            freq="h",
+        )
+        tm.assert_index_equal(idx.shift(3), exp)
+        exp = PeriodIndex(
+            ["2011-01-01 07:00", "2011-01-01 08:00", "2011-01-01 09:00"],
+            name="xxx",
+            freq="h",
+        )
+        tm.assert_index_equal(idx.shift(-3), exp)
+
+    def test_shift_nat(self):
+        idx = PeriodIndex(
+            ["2011-01", "2011-02", "NaT", "2011-04"], freq="M", name="idx"
+        )
+        result = idx.shift(1)
+        expected = PeriodIndex(
+            ["2011-02", "2011-03", "NaT", "2011-05"], freq="M", name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+
+    def test_shift_gh8083(self):
+        # test shift for PeriodIndex
+        # GH#8083
+        drange = period_range("20130101", periods=5, freq="D")
+        result = drange.shift(1)
+        expected = PeriodIndex(
+            ["2013-01-02", "2013-01-03", "2013-01-04", "2013-01-05", "2013-01-06"],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_shift_periods(self):
+        # GH #22458 : argument 'n' was deprecated in favor of 'periods'
+        idx = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        tm.assert_index_equal(idx.shift(periods=0), idx)
+        tm.assert_index_equal(idx.shift(0), idx)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_to_timestamp.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_to_timestamp.py
new file mode 100644
index 0000000000000000000000000000000000000000..3867f9e3245dc10a90ab4fcb1458b861ee7e2f86
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/methods/test_to_timestamp.py
@@ -0,0 +1,142 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    PeriodIndex,
+    Timedelta,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestToTimestamp:
+    def test_to_timestamp_non_contiguous(self):
+        # GH#44100
+        dti = date_range("2021-10-18", periods=9, freq="D")
+        pi = dti.to_period()
+
+        result = pi[::2].to_timestamp()
+        expected = dti[::2]
+        tm.assert_index_equal(result, expected)
+
+        result = pi._data[::2].to_timestamp()
+        expected = dti._data[::2]
+        # TODO: can we get the freq to round-trip?
+        tm.assert_datetime_array_equal(result, expected, check_freq=False)
+
+        result = pi[::-1].to_timestamp()
+        expected = dti[::-1]
+        tm.assert_index_equal(result, expected)
+
+        result = pi._data[::-1].to_timestamp()
+        expected = dti._data[::-1]
+        tm.assert_datetime_array_equal(result, expected, check_freq=False)
+
+        result = pi[::2][::-1].to_timestamp()
+        expected = dti[::2][::-1]
+        tm.assert_index_equal(result, expected)
+
+        result = pi._data[::2][::-1].to_timestamp()
+        expected = dti._data[::2][::-1]
+        tm.assert_datetime_array_equal(result, expected, check_freq=False)
+
+    def test_to_timestamp_freq(self):
+        idx = period_range("2017", periods=12, freq="Y-DEC")
+        result = idx.to_timestamp()
+        expected = date_range("2017", periods=12, freq="YS-JAN")
+        tm.assert_index_equal(result, expected)
+
+    def test_to_timestamp_pi_nat(self):
+        # GH#7228
+        index = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")
+
+        result = index.to_timestamp("D")
+        expected = DatetimeIndex(
+            [NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)],
+            dtype="M8[ns]",
+            name="idx",
+        )
+        tm.assert_index_equal(result, expected)
+        assert result.name == "idx"
+
+        result2 = result.to_period(freq="M")
+        tm.assert_index_equal(result2, index)
+        assert result2.name == "idx"
+
+        result3 = result.to_period(freq="3M")
+        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
+        tm.assert_index_equal(result3, exp)
+        assert result3.freqstr == "3M"
+
+        msg = "Frequency must be positive, because it represents span: -2Y"
+        with pytest.raises(ValueError, match=msg):
+            result.to_period(freq="-2Y")
+
+    def test_to_timestamp_preserve_name(self):
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009", name="foo")
+        assert index.name == "foo"
+
+        conv = index.to_timestamp("D")
+        assert conv.name == "foo"
+
+    def test_to_timestamp_quarterly_bug(self):
+        years = np.arange(1960, 2000).repeat(4)
+        quarters = np.tile(list(range(1, 5)), 40)
+
+        pindex = PeriodIndex.from_fields(year=years, quarter=quarters)
+
+        stamps = pindex.to_timestamp("D", "end")
+        expected = DatetimeIndex([x.to_timestamp("D", "end") for x in pindex])
+        tm.assert_index_equal(stamps, expected)
+        assert stamps.freq == expected.freq
+
+    def test_to_timestamp_pi_mult(self):
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="2M", name="idx")
+
+        result = idx.to_timestamp()
+        expected = DatetimeIndex(
+            ["2011-01-01", "NaT", "2011-02-01"], dtype="M8[ns]", name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.to_timestamp(how="E")
+        expected = DatetimeIndex(
+            ["2011-02-28", "NaT", "2011-03-31"], dtype="M8[ns]", name="idx"
+        )
+        expected = expected + Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(result, expected)
+
+    def test_to_timestamp_pi_combined(self):
+        idx = period_range(start="2011", periods=2, freq="1D1h", name="idx")
+
+        result = idx.to_timestamp()
+        expected = DatetimeIndex(
+            ["2011-01-01 00:00", "2011-01-02 01:00"], dtype="M8[ns]", name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.to_timestamp(how="E")
+        expected = DatetimeIndex(
+            ["2011-01-02 00:59:59", "2011-01-03 01:59:59"], name="idx", dtype="M8[ns]"
+        )
+        expected = expected + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result, expected)
+
+        result = idx.to_timestamp(how="E", freq="h")
+        expected = DatetimeIndex(
+            ["2011-01-02 00:00", "2011-01-03 01:00"], dtype="M8[ns]", name="idx"
+        )
+        expected = expected + Timedelta(1, "h") - Timedelta(1, "ns")
+        tm.assert_index_equal(result, expected)
+
+    def test_to_timestamp_1703(self):
+        index = period_range("1/1/2012", periods=4, freq="D")
+
+        result = index.to_timestamp()
+        assert result[0] == Timestamp("1/1/2012")
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_constructors.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..892eb7b4a00d1ffbd9477194466bf9f2a2c522ff
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_constructors.py
@@ -0,0 +1,691 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.period import IncompatibleFrequency
+
+from pandas.core.dtypes.dtypes import PeriodDtype
+
+from pandas import (
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    date_range,
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import PeriodArray
+
+
+class TestPeriodIndexDisallowedFreqs:
+    @pytest.mark.parametrize(
+        "freq,freq_depr",
+        [
+            ("2M", "2ME"),
+            ("2Q-MAR", "2QE-MAR"),
+            ("2Y-FEB", "2YE-FEB"),
+            ("2M", "2me"),
+            ("2Q-MAR", "2qe-MAR"),
+            ("2Y-FEB", "2yE-feb"),
+        ],
+    )
+    def test_period_index_offsets_frequency_error_message(self, freq, freq_depr):
+        # GH#52064
+        msg = f"for Period, please use '{freq[1:]}' instead of '{freq_depr[1:]}'"
+
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2020-01-01", "2020-01-02"], freq=freq_depr)
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2020-01-01", end="2020-01-02", freq=freq_depr)
+
+    @pytest.mark.parametrize("freq_depr", ["2SME", "2sme", "2CBME", "2BYE", "2Bye"])
+    def test_period_index_frequency_invalid_freq(self, freq_depr):
+        # GH#9586
+        msg = f"Invalid frequency: {freq_depr[1:]}"
+
+        with pytest.raises(ValueError, match=msg):
+            period_range("2020-01", "2020-05", freq=freq_depr)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2020-01", "2020-05"], freq=freq_depr)
+
+    @pytest.mark.parametrize("freq", ["2BQE-SEP", "2BYE-MAR", "2BME"])
+    def test_period_index_from_datetime_index_invalid_freq(self, freq):
+        # GH#56899
+        msg = f"Invalid frequency: {freq[1:]}"
+
+        rng = date_range("01-Jan-2012", periods=8, freq=freq)
+        with pytest.raises(ValueError, match=msg):
+            rng.to_period()
+
+
+class TestPeriodIndex:
+    def test_from_ordinals(self):
+        Period(ordinal=-1000, freq="Y")
+        Period(ordinal=0, freq="Y")
+
+        msg = "The 'ordinal' keyword in PeriodIndex is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq="Y")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq="Y")
+        tm.assert_index_equal(idx1, idx2)
+
+        alt1 = PeriodIndex.from_ordinals([-1, 0, 1], freq="Y")
+        tm.assert_index_equal(alt1, idx1)
+
+        alt2 = PeriodIndex.from_ordinals(np.array([-1, 0, 1]), freq="Y")
+        tm.assert_index_equal(alt2, idx2)
+
+    def test_keyword_mismatch(self):
+        # GH#55961 we should get exactly one of data/ordinals/**fields
+        per = Period("2016-01-01", "D")
+        depr_msg1 = "The 'ordinal' keyword in PeriodIndex is deprecated"
+        depr_msg2 = "Constructing PeriodIndex from fields is deprecated"
+
+        err_msg1 = "Cannot pass both data and ordinal"
+        with pytest.raises(ValueError, match=err_msg1):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg1):
+                PeriodIndex(data=[per], ordinal=[per.ordinal], freq=per.freq)
+
+        err_msg2 = "Cannot pass both data and fields"
+        with pytest.raises(ValueError, match=err_msg2):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg2):
+                PeriodIndex(data=[per], year=[per.year], freq=per.freq)
+
+        err_msg3 = "Cannot pass both ordinal and fields"
+        with pytest.raises(ValueError, match=err_msg3):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg2):
+                PeriodIndex(ordinal=[per.ordinal], year=[per.year], freq=per.freq)
+
+    def test_construction_base_constructor(self):
+        # GH 13664
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
+
+        arr = [np.nan, NaT, Period("2011-03", freq="M")]
+        tm.assert_index_equal(Index(arr), PeriodIndex(arr))
+        tm.assert_index_equal(Index(np.array(arr)), PeriodIndex(np.array(arr)))
+
+        arr = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="D")]
+        tm.assert_index_equal(Index(arr), Index(arr, dtype=object))
+
+        tm.assert_index_equal(Index(np.array(arr)), Index(np.array(arr), dtype=object))
+
+    def test_base_constructor_with_period_dtype(self):
+        dtype = PeriodDtype("D")
+        values = ["2011-01-01", "2012-03-04", "2014-05-01"]
+        result = Index(values, dtype=dtype)
+
+        expected = PeriodIndex(values, dtype=dtype)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values_constructor", [list, np.array, PeriodIndex, PeriodArray._from_sequence]
+    )
+    def test_index_object_dtype(self, values_constructor):
+        # Index(periods, dtype=object) is an Index (not an PeriodIndex)
+        periods = [
+            Period("2011-01", freq="M"),
+            NaT,
+            Period("2011-03", freq="M"),
+        ]
+        values = values_constructor(periods)
+        result = Index(values, dtype=object)
+
+        assert type(result) is Index
+        tm.assert_numpy_array_equal(result.values, np.array(values))
+
+    def test_constructor_use_start_freq(self):
+        # GH #1118
+        msg1 = "Period with BDay freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg1):
+            p = Period("4/2/2012", freq="B")
+        msg2 = r"PeriodDtype\[B\] is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            expected = period_range(start="4/2/2012", periods=10, freq="B")
+
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            index = period_range(start=p, periods=10)
+        tm.assert_index_equal(index, expected)
+
+    def test_constructor_field_arrays(self):
+        # GH #1264
+
+        years = np.arange(1990, 2010).repeat(4)[2:-2]
+        quarters = np.tile(np.arange(1, 5), 20)[2:-2]
+
+        depr_msg = "Constructing PeriodIndex from fields is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            index = PeriodIndex(year=years, quarter=quarters, freq="Q-DEC")
+        expected = period_range("1990Q3", "2009Q2", freq="Q-DEC")
+        tm.assert_index_equal(index, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            index2 = PeriodIndex(year=years, quarter=quarters, freq="2Q-DEC")
+        tm.assert_numpy_array_equal(index.asi8, index2.asi8)
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            index = PeriodIndex(year=years, quarter=quarters)
+        tm.assert_index_equal(index, expected)
+
+        years = [2007, 2007, 2007]
+        months = [1, 2]
+
+        msg = "Mismatched Period array lengths"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                PeriodIndex(year=years, month=months, freq="M")
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                PeriodIndex(year=years, month=months, freq="2M")
+
+        years = [2007, 2007, 2007]
+        months = [1, 2, 3]
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            idx = PeriodIndex(year=years, month=months, freq="M")
+        exp = period_range("2007-01", periods=3, freq="M")
+        tm.assert_index_equal(idx, exp)
+
+    def test_constructor_nano(self):
+        idx = period_range(
+            start=Period(ordinal=1, freq="ns"),
+            end=Period(ordinal=4, freq="ns"),
+            freq="ns",
+        )
+        exp = PeriodIndex(
+            [
+                Period(ordinal=1, freq="ns"),
+                Period(ordinal=2, freq="ns"),
+                Period(ordinal=3, freq="ns"),
+                Period(ordinal=4, freq="ns"),
+            ],
+            freq="ns",
+        )
+        tm.assert_index_equal(idx, exp)
+
+    def test_constructor_arrays_negative_year(self):
+        years = np.arange(1960, 2000, dtype=np.int64).repeat(4)
+        quarters = np.tile(np.array([1, 2, 3, 4], dtype=np.int64), 40)
+
+        msg = "Constructing PeriodIndex from fields is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            pindex = PeriodIndex(year=years, quarter=quarters)
+
+        tm.assert_index_equal(pindex.year, Index(years))
+        tm.assert_index_equal(pindex.quarter, Index(quarters))
+
+        alt = PeriodIndex.from_fields(year=years, quarter=quarters)
+        tm.assert_index_equal(alt, pindex)
+
+    def test_constructor_invalid_quarters(self):
+        depr_msg = "Constructing PeriodIndex from fields is deprecated"
+        msg = "Quarter must be 1 <= q <= 4"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                PeriodIndex(
+                    year=range(2000, 2004), quarter=list(range(4)), freq="Q-DEC"
+                )
+
+    def test_period_range_fractional_period(self):
+        msg = "Non-integer 'periods' in pd.date_range, pd.timedelta_range"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = period_range("2007-01", periods=10.5, freq="M")
+        exp = period_range("2007-01", periods=10, freq="M")
+        tm.assert_index_equal(result, exp)
+
+    def test_constructor_with_without_freq(self):
+        # GH53687
+        start = Period("2002-01-01 00:00", freq="30min")
+        exp = period_range(start=start, periods=5, freq=start.freq)
+        result = period_range(start=start, periods=5)
+        tm.assert_index_equal(exp, result)
+
+    def test_constructor_fromarraylike(self):
+        idx = period_range("2007-01", periods=20, freq="M")
+
+        # values is an array of Period, thus can retrieve freq
+        tm.assert_index_equal(PeriodIndex(idx.values), idx)
+        tm.assert_index_equal(PeriodIndex(list(idx.values)), idx)
+
+        msg = "freq not specified and cannot be inferred"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(idx.asi8)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(list(idx.asi8))
+
+        msg = "'Period' object is not iterable"
+        with pytest.raises(TypeError, match=msg):
+            PeriodIndex(data=Period("2007", freq="Y"))
+
+        result = PeriodIndex(iter(idx))
+        tm.assert_index_equal(result, idx)
+
+        result = PeriodIndex(idx)
+        tm.assert_index_equal(result, idx)
+
+        result = PeriodIndex(idx, freq="M")
+        tm.assert_index_equal(result, idx)
+
+        result = PeriodIndex(idx, freq=offsets.MonthEnd())
+        tm.assert_index_equal(result, idx)
+        assert result.freq == "ME"
+
+        result = PeriodIndex(idx, freq="2M")
+        tm.assert_index_equal(result, idx.asfreq("2M"))
+        assert result.freq == "2ME"
+
+        result = PeriodIndex(idx, freq=offsets.MonthEnd(2))
+        tm.assert_index_equal(result, idx.asfreq("2M"))
+        assert result.freq == "2ME"
+
+        result = PeriodIndex(idx, freq="D")
+        exp = idx.asfreq("D", "e")
+        tm.assert_index_equal(result, exp)
+
+    def test_constructor_datetime64arr(self):
+        vals = np.arange(100000, 100000 + 10000, 100, dtype=np.int64)
+        vals = vals.view(np.dtype("M8[us]"))
+
+        pi = PeriodIndex(vals, freq="D")
+
+        expected = PeriodIndex(vals.astype("M8[ns]"), freq="D")
+        tm.assert_index_equal(pi, expected)
+
+    @pytest.mark.parametrize("box", [None, "series", "index"])
+    def test_constructor_datetime64arr_ok(self, box):
+        # https://github.com/pandas-dev/pandas/issues/23438
+        data = date_range("2017", periods=4, freq="ME")
+        if box is None:
+            data = data._values
+        elif box == "series":
+            data = Series(data)
+
+        result = PeriodIndex(data, freq="D")
+        expected = PeriodIndex(
+            ["2017-01-31", "2017-02-28", "2017-03-31", "2017-04-30"], freq="D"
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_dtype(self):
+        # passing a dtype with a tz should localize
+        idx = PeriodIndex(["2013-01", "2013-03"], dtype="period[M]")
+        exp = PeriodIndex(["2013-01", "2013-03"], freq="M")
+        tm.assert_index_equal(idx, exp)
+        assert idx.dtype == "period[M]"
+
+        idx = PeriodIndex(["2013-01-05", "2013-03-05"], dtype="period[3D]")
+        exp = PeriodIndex(["2013-01-05", "2013-03-05"], freq="3D")
+        tm.assert_index_equal(idx, exp)
+        assert idx.dtype == "period[3D]"
+
+        # if we already have a freq and its not the same, then asfreq
+        # (not changed)
+        idx = PeriodIndex(["2013-01-01", "2013-01-02"], freq="D")
+
+        res = PeriodIndex(idx, dtype="period[M]")
+        exp = PeriodIndex(["2013-01", "2013-01"], freq="M")
+        tm.assert_index_equal(res, exp)
+        assert res.dtype == "period[M]"
+
+        res = PeriodIndex(idx, freq="M")
+        tm.assert_index_equal(res, exp)
+        assert res.dtype == "period[M]"
+
+        msg = "specified freq and dtype are different"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(["2011-01"], freq="M", dtype="period[D]")
+
+    def test_constructor_empty(self):
+        idx = PeriodIndex([], freq="M")
+        assert isinstance(idx, PeriodIndex)
+        assert len(idx) == 0
+        assert idx.freq == "ME"
+
+        with pytest.raises(ValueError, match="freq not specified"):
+            PeriodIndex([])
+
+    def test_constructor_pi_nat(self):
+        idx = PeriodIndex(
+            [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")]
+        )
+        exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex(
+            np.array([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="M")])
+        )
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex(
+            [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
+        )
+        exp = PeriodIndex(["NaT", "NaT", "2011-01", "2011-01"], freq="M")
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex(
+            np.array(
+                [NaT, NaT, Period("2011-01", freq="M"), Period("2011-01", freq="M")]
+            )
+        )
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex([NaT, NaT, "2011-01", "2011-01"], freq="M")
+        tm.assert_index_equal(idx, exp)
+
+        with pytest.raises(ValueError, match="freq not specified"):
+            PeriodIndex([NaT, NaT])
+
+        with pytest.raises(ValueError, match="freq not specified"):
+            PeriodIndex(np.array([NaT, NaT]))
+
+        with pytest.raises(ValueError, match="freq not specified"):
+            PeriodIndex(["NaT", "NaT"])
+
+        with pytest.raises(ValueError, match="freq not specified"):
+            PeriodIndex(np.array(["NaT", "NaT"]))
+
+    def test_constructor_incompat_freq(self):
+        msg = "Input has different freq=D from PeriodIndex\\(freq=M\\)"
+
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex([Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")])
+
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(
+                np.array(
+                    [Period("2011-01", freq="M"), NaT, Period("2011-01", freq="D")]
+                )
+            )
+
+        # first element is NaT
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex([NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")])
+
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(
+                np.array(
+                    [NaT, Period("2011-01", freq="M"), Period("2011-01", freq="D")]
+                )
+            )
+
+    def test_constructor_mixed(self):
+        idx = PeriodIndex(["2011-01", NaT, Period("2011-01", freq="M")])
+        exp = PeriodIndex(["2011-01", "NaT", "2011-01"], freq="M")
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex(["NaT", NaT, Period("2011-01", freq="M")])
+        exp = PeriodIndex(["NaT", "NaT", "2011-01"], freq="M")
+        tm.assert_index_equal(idx, exp)
+
+        idx = PeriodIndex([Period("2011-01-01", freq="D"), NaT, "2012-01-01"])
+        exp = PeriodIndex(["2011-01-01", "NaT", "2012-01-01"], freq="D")
+        tm.assert_index_equal(idx, exp)
+
+    @pytest.mark.parametrize("floats", [[1.1, 2.1], np.array([1.1, 2.1])])
+    def test_constructor_floats(self, floats):
+        msg = "PeriodIndex does not allow floating point in construction"
+        with pytest.raises(TypeError, match=msg):
+            PeriodIndex(floats)
+
+    def test_constructor_year_and_quarter(self):
+        year = Series([2001, 2002, 2003])
+        quarter = year - 2000
+        msg = "Constructing PeriodIndex from fields is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx = PeriodIndex(year=year, quarter=quarter)
+        strs = [f"{t[0]:d}Q{t[1]:d}" for t in zip(quarter, year)]
+        lops = list(map(Period, strs))
+        p = PeriodIndex(lops)
+        tm.assert_index_equal(p, idx)
+
+    def test_constructor_freq_mult(self):
+        # GH #7811
+        pidx = period_range(start="2014-01", freq="2M", periods=4)
+        expected = PeriodIndex(["2014-01", "2014-03", "2014-05", "2014-07"], freq="2M")
+        tm.assert_index_equal(pidx, expected)
+
+        pidx = period_range(start="2014-01-02", end="2014-01-15", freq="3D")
+        expected = PeriodIndex(
+            ["2014-01-02", "2014-01-05", "2014-01-08", "2014-01-11", "2014-01-14"],
+            freq="3D",
+        )
+        tm.assert_index_equal(pidx, expected)
+
+        pidx = period_range(end="2014-01-01 17:00", freq="4h", periods=3)
+        expected = PeriodIndex(
+            ["2014-01-01 09:00", "2014-01-01 13:00", "2014-01-01 17:00"], freq="4h"
+        )
+        tm.assert_index_equal(pidx, expected)
+
+        msg = "Frequency must be positive, because it represents span: -1M"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2011-01"], freq="-1M")
+
+        msg = "Frequency must be positive, because it represents span: 0M"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(["2011-01"], freq="0M")
+
+        msg = "Frequency must be positive, because it represents span: 0M"
+        with pytest.raises(ValueError, match=msg):
+            period_range("2011-01", periods=3, freq="0M")
+
+    @pytest.mark.parametrize(
+        "freq_offset, freq_period",
+        [
+            ("YE", "Y"),
+            ("ME", "M"),
+            ("D", "D"),
+            ("min", "min"),
+            ("s", "s"),
+        ],
+    )
+    @pytest.mark.parametrize("mult", [1, 2, 3, 4, 5])
+    def test_constructor_freq_mult_dti_compat(self, mult, freq_offset, freq_period):
+        freqstr_offset = str(mult) + freq_offset
+        freqstr_period = str(mult) + freq_period
+        pidx = period_range(start="2014-04-01", freq=freqstr_period, periods=10)
+        expected = date_range(
+            start="2014-04-01", freq=freqstr_offset, periods=10
+        ).to_period(freqstr_period)
+        tm.assert_index_equal(pidx, expected)
+
+    @pytest.mark.parametrize("mult", [1, 2, 3, 4, 5])
+    def test_constructor_freq_mult_dti_compat_month(self, mult):
+        pidx = period_range(start="2014-04-01", freq=f"{mult}M", periods=10)
+        expected = date_range(
+            start="2014-04-01", freq=f"{mult}ME", periods=10
+        ).to_period(f"{mult}M")
+        tm.assert_index_equal(pidx, expected)
+
+    def test_constructor_freq_combined(self):
+        for freq in ["1D1h", "1h1D"]:
+            pidx = PeriodIndex(["2016-01-01", "2016-01-02"], freq=freq)
+            expected = PeriodIndex(["2016-01-01 00:00", "2016-01-02 00:00"], freq="25h")
+        for freq in ["1D1h", "1h1D"]:
+            pidx = period_range(start="2016-01-01", periods=2, freq=freq)
+            expected = PeriodIndex(["2016-01-01 00:00", "2016-01-02 01:00"], freq="25h")
+            tm.assert_index_equal(pidx, expected)
+
+    def test_period_range_length(self):
+        pi = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        assert len(pi) == 9
+
+        pi = period_range(freq="Q", start="1/1/2001", end="12/1/2009")
+        assert len(pi) == 4 * 9
+
+        pi = period_range(freq="M", start="1/1/2001", end="12/1/2009")
+        assert len(pi) == 12 * 9
+
+        pi = period_range(freq="D", start="1/1/2001", end="12/31/2009")
+        assert len(pi) == 365 * 9 + 2
+
+        msg = "Period with BDay freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            pi = period_range(freq="B", start="1/1/2001", end="12/31/2009")
+        assert len(pi) == 261 * 9
+
+        pi = period_range(freq="h", start="1/1/2001", end="12/31/2001 23:00")
+        assert len(pi) == 365 * 24
+
+        pi = period_range(freq="Min", start="1/1/2001", end="1/1/2001 23:59")
+        assert len(pi) == 24 * 60
+
+        pi = period_range(freq="s", start="1/1/2001", end="1/1/2001 23:59:59")
+        assert len(pi) == 24 * 60 * 60
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            start = Period("02-Apr-2005", "B")
+            i1 = period_range(start=start, periods=20)
+        assert len(i1) == 20
+        assert i1.freq == start.freq
+        assert i1[0] == start
+
+        end_intv = Period("2006-12-31", "W")
+        i1 = period_range(end=end_intv, periods=10)
+        assert len(i1) == 10
+        assert i1.freq == end_intv.freq
+        assert i1[-1] == end_intv
+
+        msg = "'w' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            end_intv = Period("2006-12-31", "1w")
+        i2 = period_range(end=end_intv, periods=10)
+        assert len(i1) == len(i2)
+        assert (i1 == i2).all()
+        assert i1.freq == i2.freq
+
+    def test_infer_freq_from_first_element(self):
+        msg = "Period with BDay freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            start = Period("02-Apr-2005", "B")
+            end_intv = Period("2005-05-01", "B")
+            period_range(start=start, end=end_intv)
+
+            # infer freq from first element
+            i2 = PeriodIndex([end_intv, Period("2005-05-05", "B")])
+        assert len(i2) == 2
+        assert i2[0] == end_intv
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            i2 = PeriodIndex(np.array([end_intv, Period("2005-05-05", "B")]))
+        assert len(i2) == 2
+        assert i2[0] == end_intv
+
+    def test_mixed_freq_raises(self):
+        # Mixed freq should fail
+        msg = "Period with BDay freq is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            end_intv = Period("2005-05-01", "B")
+
+        msg = "'w' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            vals = [end_intv, Period("2006-12-31", "w")]
+        msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
+        depr_msg = r"PeriodDtype\[B\] is deprecated"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                PeriodIndex(vals)
+        vals = np.array(vals)
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                PeriodIndex(vals)
+
+    @pytest.mark.parametrize(
+        "freq", ["M", "Q", "Y", "D", "B", "min", "s", "ms", "us", "ns", "h"]
+    )
+    @pytest.mark.filterwarnings(
+        r"ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_recreate_from_data(self, freq):
+        org = period_range(start="2001/04/01", freq=freq, periods=1)
+        idx = PeriodIndex(org.values, freq=freq)
+        tm.assert_index_equal(idx, org)
+
+    def test_map_with_string_constructor(self):
+        raw = [2005, 2007, 2009]
+        index = PeriodIndex(raw, freq="Y")
+
+        expected = Index([str(num) for num in raw])
+        res = index.map(str)
+
+        # should return an Index
+        assert isinstance(res, Index)
+
+        # preserve element types
+        assert all(isinstance(resi, str) for resi in res)
+
+        # lastly, values should compare equal
+        tm.assert_index_equal(res, expected)
+
+
+class TestSimpleNew:
+    def test_constructor_simple_new(self):
+        idx = period_range("2007-01", name="p", periods=2, freq="M")
+
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p")
+
+        result = idx._simple_new(idx._data, name="p")
+        tm.assert_index_equal(result, idx)
+
+        msg = "Should be numpy array of type i8"
+        with pytest.raises(AssertionError, match=msg):
+            # Need ndarray, not int64 Index
+            type(idx._data)._simple_new(Index(idx.asi8), dtype=idx.dtype)
+
+        arr = type(idx._data)._simple_new(idx.asi8, dtype=idx.dtype)
+        result = idx._simple_new(arr, name="p")
+        tm.assert_index_equal(result, idx)
+
+    def test_constructor_simple_new_empty(self):
+        # GH13079
+        idx = PeriodIndex([], freq="M", name="p")
+        with pytest.raises(AssertionError, match="<class .*PeriodIndex'>"):
+            idx._simple_new(idx, name="p")
+
+        result = idx._simple_new(idx._data, name="p")
+        tm.assert_index_equal(result, idx)
+
+    @pytest.mark.parametrize("floats", [[1.1, 2.1], np.array([1.1, 2.1])])
+    def test_period_index_simple_new_disallows_floats(self, floats):
+        with pytest.raises(AssertionError, match="<class "):
+            PeriodIndex._simple_new(floats)
+
+
+class TestShallowCopy:
+    def test_shallow_copy_empty(self):
+        # GH#13067
+        idx = PeriodIndex([], freq="M")
+        result = idx._view()
+        expected = idx
+
+        tm.assert_index_equal(result, expected)
+
+    def test_shallow_copy_disallow_i8(self):
+        # GH#24391
+        pi = period_range("2018-01-01", periods=3, freq="2D")
+        with pytest.raises(AssertionError, match="ndarray"):
+            pi._shallow_copy(pi.asi8)
+
+    def test_shallow_copy_requires_disallow_period_index(self):
+        pi = period_range("2018-01-01", periods=3, freq="2D")
+        with pytest.raises(AssertionError, match="PeriodIndex"):
+            pi._shallow_copy(pi)
+
+
+class TestSeriesPeriod:
+    def test_constructor_cant_cast_period(self):
+        msg = "Cannot cast PeriodIndex to dtype float64"
+        with pytest.raises(TypeError, match=msg):
+            Series(period_range("2000-01-01", periods=10, freq="D"), dtype=float)
+
+    def test_constructor_cast_object(self):
+        pi = period_range("1/1/2000", periods=10)
+        ser = Series(pi, dtype=PeriodDtype("D"))
+        exp = Series(pi)
+        tm.assert_series_equal(ser, exp)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_formats.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_formats.py
new file mode 100644
index 0000000000000000000000000000000000000000..81c79f7d18f2fc87bcbbac3159f873ddb76f9559
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_formats.py
@@ -0,0 +1,350 @@
+from contextlib import nullcontext
+from datetime import (
+    datetime,
+    time,
+)
+import locale
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    PeriodIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+def get_local_am_pm():
+    """Return the AM and PM strings returned by strftime in current locale."""
+    am_local = time(1).strftime("%p")
+    pm_local = time(13).strftime("%p")
+    return am_local, pm_local
+
+
+def test_get_values_for_csv():
+    index = PeriodIndex(["2017-01-01", "2017-01-02", "2017-01-03"], freq="D")
+
+    # First, with no arguments.
+    expected = np.array(["2017-01-01", "2017-01-02", "2017-01-03"], dtype=object)
+
+    result = index._get_values_for_csv()
+    tm.assert_numpy_array_equal(result, expected)
+
+    # No NaN values, so na_rep has no effect
+    result = index._get_values_for_csv(na_rep="pandas")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # Make sure date formatting works
+    expected = np.array(["01-2017-01", "01-2017-02", "01-2017-03"], dtype=object)
+
+    result = index._get_values_for_csv(date_format="%m-%Y-%d")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # NULL object handling should work
+    index = PeriodIndex(["2017-01-01", pd.NaT, "2017-01-03"], freq="D")
+    expected = np.array(["2017-01-01", "NaT", "2017-01-03"], dtype=object)
+
+    result = index._get_values_for_csv(na_rep="NaT")
+    tm.assert_numpy_array_equal(result, expected)
+
+    expected = np.array(["2017-01-01", "pandas", "2017-01-03"], dtype=object)
+
+    result = index._get_values_for_csv(na_rep="pandas")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+class TestPeriodIndexRendering:
+    def test_format_empty(self):
+        # GH#35712
+        empty_idx = PeriodIndex([], freq="Y")
+        msg = r"PeriodIndex\.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert empty_idx.format() == []
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert empty_idx.format(name=True) == [""]
+
+    @pytest.mark.parametrize("method", ["__repr__", "__str__"])
+    def test_representation(self, method):
+        # GH#7601
+        idx1 = PeriodIndex([], freq="D")
+        idx2 = PeriodIndex(["2011-01-01"], freq="D")
+        idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+        idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
+        idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="h")
+        idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
+        idx8 = pd.period_range("2013Q1", periods=2, freq="Q")
+        idx9 = pd.period_range("2013Q1", periods=3, freq="Q")
+        idx10 = PeriodIndex(["2011-01-01", "2011-02-01"], freq="3D")
+
+        exp1 = "PeriodIndex([], dtype='period[D]')"
+
+        exp2 = "PeriodIndex(['2011-01-01'], dtype='period[D]')"
+
+        exp3 = "PeriodIndex(['2011-01-01', '2011-01-02'], dtype='period[D]')"
+
+        exp4 = (
+            "PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'], "
+            "dtype='period[D]')"
+        )
+
+        exp5 = "PeriodIndex(['2011', '2012', '2013'], dtype='period[Y-DEC]')"
+
+        exp6 = (
+            "PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'], "
+            "dtype='period[h]')"
+        )
+
+        exp7 = "PeriodIndex(['2013Q1'], dtype='period[Q-DEC]')"
+
+        exp8 = "PeriodIndex(['2013Q1', '2013Q2'], dtype='period[Q-DEC]')"
+
+        exp9 = "PeriodIndex(['2013Q1', '2013Q2', '2013Q3'], dtype='period[Q-DEC]')"
+
+        exp10 = "PeriodIndex(['2011-01-01', '2011-02-01'], dtype='period[3D]')"
+
+        for idx, expected in zip(
+            [idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9, idx10],
+            [exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, exp9, exp10],
+        ):
+            result = getattr(idx, method)()
+            assert result == expected
+
+    # TODO: These are Series.__repr__ tests
+    def test_representation_to_series(self):
+        # GH#10971
+        idx1 = PeriodIndex([], freq="D")
+        idx2 = PeriodIndex(["2011-01-01"], freq="D")
+        idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+        idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
+        idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="h")
+
+        idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
+        idx8 = pd.period_range("2013Q1", periods=2, freq="Q")
+        idx9 = pd.period_range("2013Q1", periods=3, freq="Q")
+
+        exp1 = """Series([], dtype: period[D])"""
+
+        exp2 = """0    2011-01-01
+dtype: period[D]"""
+
+        exp3 = """0    2011-01-01
+1    2011-01-02
+dtype: period[D]"""
+
+        exp4 = """0    2011-01-01
+1    2011-01-02
+2    2011-01-03
+dtype: period[D]"""
+
+        exp5 = """0    2011
+1    2012
+2    2013
+dtype: period[Y-DEC]"""
+
+        exp6 = """0    2011-01-01 09:00
+1    2012-02-01 10:00
+2                 NaT
+dtype: period[h]"""
+
+        exp7 = """0    2013Q1
+dtype: period[Q-DEC]"""
+
+        exp8 = """0    2013Q1
+1    2013Q2
+dtype: period[Q-DEC]"""
+
+        exp9 = """0    2013Q1
+1    2013Q2
+2    2013Q3
+dtype: period[Q-DEC]"""
+
+        for idx, expected in zip(
+            [idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9],
+            [exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, exp9],
+        ):
+            result = repr(Series(idx))
+            assert result == expected
+
+    def test_summary(self):
+        # GH#9116
+        idx1 = PeriodIndex([], freq="D")
+        idx2 = PeriodIndex(["2011-01-01"], freq="D")
+        idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+        idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
+        idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="h")
+
+        idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
+        idx8 = pd.period_range("2013Q1", periods=2, freq="Q")
+        idx9 = pd.period_range("2013Q1", periods=3, freq="Q")
+
+        exp1 = """PeriodIndex: 0 entries
+Freq: D"""
+
+        exp2 = """PeriodIndex: 1 entries, 2011-01-01 to 2011-01-01
+Freq: D"""
+
+        exp3 = """PeriodIndex: 2 entries, 2011-01-01 to 2011-01-02
+Freq: D"""
+
+        exp4 = """PeriodIndex: 3 entries, 2011-01-01 to 2011-01-03
+Freq: D"""
+
+        exp5 = """PeriodIndex: 3 entries, 2011 to 2013
+Freq: Y-DEC"""
+
+        exp6 = """PeriodIndex: 3 entries, 2011-01-01 09:00 to NaT
+Freq: h"""
+
+        exp7 = """PeriodIndex: 1 entries, 2013Q1 to 2013Q1
+Freq: Q-DEC"""
+
+        exp8 = """PeriodIndex: 2 entries, 2013Q1 to 2013Q2
+Freq: Q-DEC"""
+
+        exp9 = """PeriodIndex: 3 entries, 2013Q1 to 2013Q3
+Freq: Q-DEC"""
+
+        for idx, expected in zip(
+            [idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9],
+            [exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, exp9],
+        ):
+            result = idx._summary()
+            assert result == expected
+
+
+class TestPeriodIndexFormat:
+    def test_period_format_and_strftime_default(self):
+        per = PeriodIndex([datetime(2003, 1, 1, 12), None], freq="h")
+
+        # Default formatting
+        msg = "PeriodIndex.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            formatted = per.format()
+        assert formatted[0] == "2003-01-01 12:00"  # default: minutes not shown
+        assert formatted[1] == "NaT"
+        # format is equivalent to strftime(None)...
+        assert formatted[0] == per.strftime(None)[0]
+        assert per.strftime(None)[1] is np.nan  # ...except for NaTs
+
+        # Same test with nanoseconds freq
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="ns")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            formatted = per.format()
+        assert (formatted == per.strftime(None)).all()
+        assert formatted[0] == "2003-01-01 12:01:01.123456789"
+        assert formatted[1] == "2003-01-01 12:01:01.123456790"
+
+    def test_period_custom(self):
+        # GH#46252 custom formatting directives %l (ms) and %u (us)
+        msg = "PeriodIndex.format is deprecated"
+
+        # 3 digits
+        per = pd.period_range("2003-01-01 12:01:01.123", periods=2, freq="ms")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123000 ns=123000000)"
+        assert formatted[1] == "03 12:01:01 (ms=124 us=124000 ns=124000000)"
+
+        # 6 digits
+        per = pd.period_range("2003-01-01 12:01:01.123456", periods=2, freq="us")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456000)"
+        assert formatted[1] == "03 12:01:01 (ms=123 us=123457 ns=123457000)"
+
+        # 9 digits
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="ns")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+        assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456789)"
+        assert formatted[1] == "03 12:01:01 (ms=123 us=123456 ns=123456790)"
+
+    def test_period_tz(self):
+        # Formatting periods created from a datetime with timezone.
+        msg = r"PeriodIndex\.format is deprecated"
+        # This timestamp is in 2013 in Europe/Paris but is 2012 in UTC
+        dt = pd.to_datetime(["2013-01-01 00:00:00+01:00"], utc=True)
+
+        # Converting to a period looses the timezone information
+        # Since tz is currently set as utc, we'll see 2012
+        with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+            per = dt.to_period(freq="h")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert per.format()[0] == "2012-12-31 23:00"
+
+        # If tz is currently set as paris before conversion, we'll see 2013
+        dt = dt.tz_convert("Europe/Paris")
+        with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+            per = dt.to_period(freq="h")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert per.format()[0] == "2013-01-01 00:00"
+
+    @pytest.mark.parametrize(
+        "locale_str",
+        [
+            pytest.param(None, id=str(locale.getlocale())),
+            "it_IT.utf8",
+            "it_IT",  # Note: encoding will be 'ISO8859-1'
+            "zh_CN.utf8",
+            "zh_CN",  # Note: encoding will be 'gb2312'
+        ],
+    )
+    def test_period_non_ascii_fmt(self, locale_str):
+        # GH#46468 non-ascii char in input format string leads to wrong output
+
+        # Skip if locale cannot be set
+        if locale_str is not None and not tm.can_set_locale(locale_str, locale.LC_ALL):
+            pytest.skip(f"Skipping as locale '{locale_str}' cannot be set on host.")
+
+        # Change locale temporarily for this test.
+        with tm.set_locale(locale_str, locale.LC_ALL) if locale_str else nullcontext():
+            # Scalar
+            per = pd.Period("2018-03-11 13:00", freq="h")
+            assert per.strftime("%y é") == "18 é"
+
+            # Index
+            per = pd.period_range("2003-01-01 01:00:00", periods=2, freq="12h")
+            msg = "PeriodIndex.format is deprecated"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                formatted = per.format(date_format="%y é")
+            assert formatted[0] == "03 é"
+            assert formatted[1] == "03 é"
+
+    @pytest.mark.parametrize(
+        "locale_str",
+        [
+            pytest.param(None, id=str(locale.getlocale())),
+            "it_IT.utf8",
+            "it_IT",  # Note: encoding will be 'ISO8859-1'
+            "zh_CN.utf8",
+            "zh_CN",  # Note: encoding will be 'gb2312'
+        ],
+    )
+    def test_period_custom_locale_directive(self, locale_str):
+        # GH#46319 locale-specific directive leads to non-utf8 c strftime char* result
+
+        # Skip if locale cannot be set
+        if locale_str is not None and not tm.can_set_locale(locale_str, locale.LC_ALL):
+            pytest.skip(f"Skipping as locale '{locale_str}' cannot be set on host.")
+
+        # Change locale temporarily for this test.
+        with tm.set_locale(locale_str, locale.LC_ALL) if locale_str else nullcontext():
+            # Get locale-specific reference
+            am_local, pm_local = get_local_am_pm()
+
+            # Scalar
+            per = pd.Period("2018-03-11 13:00", freq="h")
+            assert per.strftime("%p") == pm_local
+
+            # Index
+            per = pd.period_range("2003-01-01 01:00:00", periods=2, freq="12h")
+            msg = "PeriodIndex.format is deprecated"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                formatted = per.format(date_format="%y %I:%M:%S%p")
+            assert formatted[0] == f"03 01:00:00{am_local}"
+            assert formatted[1] == f"03 01:00:00{pm_local}"
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_freq_attr.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_freq_attr.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1ecffa4982bddc6a5289697da47df1453f332ad
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_freq_attr.py
@@ -0,0 +1,28 @@
+import pytest
+
+from pandas.compat import PY311
+
+from pandas import (
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestFreq:
+    def test_freq_setter_deprecated(self):
+        # GH#20678
+        idx = period_range("2018Q1", periods=4, freq="Q")
+
+        # no warning for getter
+        with tm.assert_produces_warning(None):
+            idx.freq
+
+        # warning for setter
+        msg = (
+            "property 'freq' of 'PeriodArray' object has no setter"
+            if PY311
+            else "can't set attribute"
+        )
+        with pytest.raises(AttributeError, match=msg):
+            idx.freq = offsets.Day()
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_indexing.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..2683e25eda618ecb6e28b9713473afc342c7244e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_indexing.py
@@ -0,0 +1,815 @@
+from datetime import datetime
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import period as libperiod
+from pandas.errors import InvalidIndexError
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    date_range,
+    notna,
+    period_range,
+)
+import pandas._testing as tm
+
+dti4 = date_range("2016-01-01", periods=4)
+dti = dti4[:-1]
+rng = pd.Index(range(3))
+
+
+@pytest.fixture(
+    params=[
+        dti,
+        dti.tz_localize("UTC"),
+        dti.to_period("W"),
+        dti - dti[0],
+        rng,
+        pd.Index([1, 2, 3]),
+        pd.Index([2.0, 3.0, 4.0]),
+        pd.Index([4, 5, 6], dtype="u8"),
+        pd.IntervalIndex.from_breaks(dti4),
+    ]
+)
+def non_comparable_idx(request):
+    # All have length 3
+    return request.param
+
+
+class TestGetItem:
+    def test_getitem_slice_keeps_name(self):
+        idx = period_range("20010101", periods=10, freq="D", name="bob")
+        assert idx.name == idx[1:].name
+
+    def test_getitem(self):
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+
+        for idx in [idx1]:
+            result = idx[0]
+            assert result == Period("2011-01-01", freq="D")
+
+            result = idx[-1]
+            assert result == Period("2011-01-31", freq="D")
+
+            result = idx[0:5]
+            expected = period_range("2011-01-01", "2011-01-05", freq="D", name="idx")
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx[0:10:2]
+            expected = PeriodIndex(
+                ["2011-01-01", "2011-01-03", "2011-01-05", "2011-01-07", "2011-01-09"],
+                freq="D",
+                name="idx",
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx[-20:-5:3]
+            expected = PeriodIndex(
+                ["2011-01-12", "2011-01-15", "2011-01-18", "2011-01-21", "2011-01-24"],
+                freq="D",
+                name="idx",
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx[4::-1]
+            expected = PeriodIndex(
+                ["2011-01-05", "2011-01-04", "2011-01-03", "2011-01-02", "2011-01-01"],
+                freq="D",
+                name="idx",
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+    def test_getitem_index(self):
+        idx = period_range("2007-01", periods=10, freq="M", name="x")
+
+        result = idx[[1, 3, 5]]
+        exp = PeriodIndex(["2007-02", "2007-04", "2007-06"], freq="M", name="x")
+        tm.assert_index_equal(result, exp)
+
+        result = idx[[True, True, False, False, False, True, True, False, False, False]]
+        exp = PeriodIndex(
+            ["2007-01", "2007-02", "2007-06", "2007-07"], freq="M", name="x"
+        )
+        tm.assert_index_equal(result, exp)
+
+    def test_getitem_partial(self):
+        rng = period_range("2007-01", periods=50, freq="M")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), rng)
+
+        with pytest.raises(KeyError, match=r"^'2006'$"):
+            ts["2006"]
+
+        result = ts["2008"]
+        assert (result.index.year == 2008).all()
+
+        result = ts["2008":"2009"]
+        assert len(result) == 24
+
+        result = ts["2008-1":"2009-12"]
+        assert len(result) == 24
+
+        result = ts["2008Q1":"2009Q4"]
+        assert len(result) == 24
+
+        result = ts[:"2009"]
+        assert len(result) == 36
+
+        result = ts["2009":]
+        assert len(result) == 50 - 24
+
+        exp = result
+        result = ts[24:]
+        tm.assert_series_equal(exp, result)
+
+        ts = pd.concat([ts[10:], ts[10:]])
+        msg = "left slice bound for non-unique label: '2008'"
+        with pytest.raises(KeyError, match=msg):
+            ts[slice("2008", "2009")]
+
+    def test_getitem_datetime(self):
+        rng = period_range(start="2012-01-01", periods=10, freq="W-MON")
+        ts = Series(range(len(rng)), index=rng)
+
+        dt1 = datetime(2011, 10, 2)
+        dt4 = datetime(2012, 4, 20)
+
+        rs = ts[dt1:dt4]
+        tm.assert_series_equal(rs, ts)
+
+    def test_getitem_nat(self):
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert idx[0] == Period("2011-01", freq="M")
+        assert idx[1] is NaT
+
+        s = Series([0, 1, 2], index=idx)
+        assert s[NaT] == 1
+
+        s = Series(idx, index=idx)
+        assert s[Period("2011-01", freq="M")] == Period("2011-01", freq="M")
+        assert s[NaT] is NaT
+
+    def test_getitem_list_periods(self):
+        # GH 7710
+        rng = period_range(start="2012-01-01", periods=10, freq="D")
+        ts = Series(range(len(rng)), index=rng)
+        exp = ts.iloc[[1]]
+        tm.assert_series_equal(ts[[Period("2012-01-02", freq="D")]], exp)
+
+    @pytest.mark.arm_slow
+    def test_getitem_seconds(self):
+        # GH#6716
+        didx = date_range(start="2013/01/01 09:00:00", freq="s", periods=4000)
+        pidx = period_range(start="2013/01/01 09:00:00", freq="s", periods=4000)
+
+        for idx in [didx, pidx]:
+            # getitem against index should raise ValueError
+            values = [
+                "2014",
+                "2013/02",
+                "2013/01/02",
+                "2013/02/01 9h",
+                "2013/02/01 09:00",
+            ]
+            for val in values:
+                # GH7116
+                # these show deprecations as we are trying
+                # to slice with non-integer indexers
+                with pytest.raises(IndexError, match="only integers, slices"):
+                    idx[val]
+
+            ser = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+            tm.assert_series_equal(ser["2013/01/01 10:00"], ser[3600:3660])
+            tm.assert_series_equal(ser["2013/01/01 9h"], ser[:3600])
+            for d in ["2013/01/01", "2013/01", "2013"]:
+                tm.assert_series_equal(ser[d], ser)
+
+    @pytest.mark.parametrize(
+        "idx_range",
+        [
+            date_range,
+            period_range,
+        ],
+    )
+    def test_getitem_day(self, idx_range):
+        # GH#6716
+        # Confirm DatetimeIndex and PeriodIndex works identically
+        # getitem against index should raise ValueError
+        idx = idx_range(start="2013/01/01", freq="D", periods=400)
+        values = [
+            "2014",
+            "2013/02",
+            "2013/01/02",
+            "2013/02/01 9h",
+            "2013/02/01 09:00",
+        ]
+        for val in values:
+            # GH7116
+            # these show deprecations as we are trying
+            # to slice with non-integer indexers
+            with pytest.raises(IndexError, match="only integers, slices"):
+                idx[val]
+
+        ser = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+        tm.assert_series_equal(ser["2013/01"], ser[0:31])
+        tm.assert_series_equal(ser["2013/02"], ser[31:59])
+        tm.assert_series_equal(ser["2014"], ser[365:])
+
+        invalid = ["2013/02/01 9h", "2013/02/01 09:00"]
+        for val in invalid:
+            with pytest.raises(KeyError, match=val):
+                ser[val]
+
+
+class TestGetLoc:
+    def test_get_loc_msg(self):
+        idx = period_range("2000-1-1", freq="Y", periods=10)
+        bad_period = Period("2012", "Y")
+        with pytest.raises(KeyError, match=r"^Period\('2012', 'Y-DEC'\)$"):
+            idx.get_loc(bad_period)
+
+        try:
+            idx.get_loc(bad_period)
+        except KeyError as inst:
+            assert inst.args[0] == bad_period
+
+    def test_get_loc_nat(self):
+        didx = DatetimeIndex(["2011-01-01", "NaT", "2011-01-03"])
+        pidx = PeriodIndex(["2011-01-01", "NaT", "2011-01-03"], freq="M")
+
+        # check DatetimeIndex compat
+        for idx in [didx, pidx]:
+            assert idx.get_loc(NaT) == 1
+            assert idx.get_loc(None) == 1
+            assert idx.get_loc(float("nan")) == 1
+            assert idx.get_loc(np.nan) == 1
+
+    def test_get_loc(self):
+        # GH 17717
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+
+        # get the location of p1/p2 from
+        # monotonic increasing PeriodIndex with non-duplicate
+        idx0 = PeriodIndex([p0, p1, p2])
+        expected_idx1_p1 = 1
+        expected_idx1_p2 = 2
+
+        assert idx0.get_loc(p1) == expected_idx1_p1
+        assert idx0.get_loc(str(p1)) == expected_idx1_p1
+        assert idx0.get_loc(p2) == expected_idx1_p2
+        assert idx0.get_loc(str(p2)) == expected_idx1_p2
+
+        msg = "Cannot interpret 'foo' as period"
+        with pytest.raises(KeyError, match=msg):
+            idx0.get_loc("foo")
+        with pytest.raises(KeyError, match=r"^1\.1$"):
+            idx0.get_loc(1.1)
+
+        with pytest.raises(InvalidIndexError, match=re.escape(str(idx0))):
+            idx0.get_loc(idx0)
+
+        # get the location of p1/p2 from
+        # monotonic increasing PeriodIndex with duplicate
+        idx1 = PeriodIndex([p1, p1, p2])
+        expected_idx1_p1 = slice(0, 2)
+        expected_idx1_p2 = 2
+
+        assert idx1.get_loc(p1) == expected_idx1_p1
+        assert idx1.get_loc(str(p1)) == expected_idx1_p1
+        assert idx1.get_loc(p2) == expected_idx1_p2
+        assert idx1.get_loc(str(p2)) == expected_idx1_p2
+
+        msg = "Cannot interpret 'foo' as period"
+        with pytest.raises(KeyError, match=msg):
+            idx1.get_loc("foo")
+
+        with pytest.raises(KeyError, match=r"^1\.1$"):
+            idx1.get_loc(1.1)
+
+        with pytest.raises(InvalidIndexError, match=re.escape(str(idx1))):
+            idx1.get_loc(idx1)
+
+        # get the location of p1/p2 from
+        # non-monotonic increasing/decreasing PeriodIndex with duplicate
+        idx2 = PeriodIndex([p2, p1, p2])
+        expected_idx2_p1 = 1
+        expected_idx2_p2 = np.array([True, False, True])
+
+        assert idx2.get_loc(p1) == expected_idx2_p1
+        assert idx2.get_loc(str(p1)) == expected_idx2_p1
+        tm.assert_numpy_array_equal(idx2.get_loc(p2), expected_idx2_p2)
+        tm.assert_numpy_array_equal(idx2.get_loc(str(p2)), expected_idx2_p2)
+
+    def test_get_loc_integer(self):
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        with pytest.raises(KeyError, match="16801"):
+            pi.get_loc(16801)
+
+        pi2 = dti.to_period("Y")  # duplicates, ordinals are all 46
+        with pytest.raises(KeyError, match="46"):
+            pi2.get_loc(46)
+
+    def test_get_loc_invalid_string_raises_keyerror(self):
+        # GH#34240
+        pi = period_range("2000", periods=3, name="A")
+        with pytest.raises(KeyError, match="A"):
+            pi.get_loc("A")
+
+        ser = Series([1, 2, 3], index=pi)
+        with pytest.raises(KeyError, match="A"):
+            ser.loc["A"]
+
+        with pytest.raises(KeyError, match="A"):
+            ser["A"]
+
+        assert "A" not in ser
+        assert "A" not in pi
+
+    def test_get_loc_mismatched_freq(self):
+        # see also test_get_indexer_mismatched_dtype testing we get analogous
+        # behavior for get_loc
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        pi2 = dti.to_period("W")
+        pi3 = pi.view(pi2.dtype)  # i.e. matching i8 representations
+
+        with pytest.raises(KeyError, match="W-SUN"):
+            pi.get_loc(pi2[0])
+
+        with pytest.raises(KeyError, match="W-SUN"):
+            # even though we have matching i8 values
+            pi.get_loc(pi3[0])
+
+
+class TestGetIndexer:
+    def test_get_indexer(self):
+        # GH 17717
+        p1 = Period("2017-09-01")
+        p2 = Period("2017-09-04")
+        p3 = Period("2017-09-07")
+
+        tp0 = Period("2017-08-31")
+        tp1 = Period("2017-09-02")
+        tp2 = Period("2017-09-05")
+        tp3 = Period("2017-09-09")
+
+        idx = PeriodIndex([p1, p2, p3])
+
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
+        )
+
+        target = PeriodIndex([tp0, tp1, tp2, tp3])
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "pad"), np.array([-1, 0, 1, 2], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "backfill"), np.array([0, 1, 2, -1], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "nearest"), np.array([0, 0, 1, 2], dtype=np.intp)
+        )
+
+        res = idx.get_indexer(target, "nearest", tolerance=Timedelta("1 day"))
+        tm.assert_numpy_array_equal(res, np.array([0, 0, 1, -1], dtype=np.intp))
+
+    def test_get_indexer_mismatched_dtype(self):
+        # Check that we return all -1s and do not raise or cast incorrectly
+
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        pi2 = dti.to_period("W")
+
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+
+        result = pi.get_indexer(dti)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # This should work in both directions
+        result = dti.get_indexer(pi)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pi.get_indexer(pi2)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # We expect the same from get_indexer_non_unique
+        result = pi.get_indexer_non_unique(dti)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = dti.get_indexer_non_unique(pi)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pi.get_indexer_non_unique(pi2)[0]
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_mismatched_dtype_different_length(self, non_comparable_idx):
+        # without method we aren't checking inequalities, so get all-missing
+        #  but do not raise
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+
+        other = non_comparable_idx
+
+        res = pi[:-1].get_indexer(other)
+        expected = -np.ones(other.shape, dtype=np.intp)
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("method", ["pad", "backfill", "nearest"])
+    def test_get_indexer_mismatched_dtype_with_method(self, non_comparable_idx, method):
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+
+        other = non_comparable_idx
+
+        msg = re.escape(f"Cannot compare dtypes {pi.dtype} and {other.dtype}")
+        with pytest.raises(TypeError, match=msg):
+            pi.get_indexer(other, method=method)
+
+        for dtype in ["object", "category"]:
+            other2 = other.astype(dtype)
+            if dtype == "object" and isinstance(other, PeriodIndex):
+                continue
+            # Two different error message patterns depending on dtypes
+            msg = "|".join(
+                [
+                    re.escape(msg)
+                    for msg in (
+                        f"Cannot compare dtypes {pi.dtype} and {other.dtype}",
+                        " not supported between instances of ",
+                    )
+                ]
+            )
+            with pytest.raises(TypeError, match=msg):
+                pi.get_indexer(other2, method=method)
+
+    def test_get_indexer_non_unique(self):
+        # GH 17717
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
+        p4 = Period("2017-09-05")
+
+        idx1 = PeriodIndex([p1, p2, p1])
+        idx2 = PeriodIndex([p2, p1, p3, p4])
+
+        result = idx1.get_indexer_non_unique(idx2)
+        expected_indexer = np.array([1, 0, 2, -1, -1], dtype=np.intp)
+        expected_missing = np.array([2, 3], dtype=np.intp)
+
+        tm.assert_numpy_array_equal(result[0], expected_indexer)
+        tm.assert_numpy_array_equal(result[1], expected_missing)
+
+    # TODO: This method came from test_period; de-dup with version above
+    def test_get_indexer2(self):
+        idx = period_range("2000-01-01", periods=3).asfreq("h", how="start")
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(idx), np.array([0, 1, 2], dtype=np.intp)
+        )
+
+        target = PeriodIndex(
+            ["1999-12-31T23", "2000-01-01T12", "2000-01-02T01"], freq="h"
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "pad"), np.array([-1, 0, 1], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "backfill"), np.array([0, 1, 2], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "nearest"), np.array([0, 1, 1], dtype=np.intp)
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "nearest", tolerance="1 hour"),
+            np.array([0, -1, 1], dtype=np.intp),
+        )
+
+        msg = "Input has different freq=None from PeriodArray\\(freq=h\\)"
+        with pytest.raises(ValueError, match=msg):
+            idx.get_indexer(target, "nearest", tolerance="1 minute")
+
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(target, "nearest", tolerance="1 day"),
+            np.array([0, 1, 1], dtype=np.intp),
+        )
+        tol_raw = [
+            Timedelta("1 hour"),
+            Timedelta("1 hour"),
+            np.timedelta64(1, "D"),
+        ]
+        tm.assert_numpy_array_equal(
+            idx.get_indexer(
+                target, "nearest", tolerance=[np.timedelta64(x) for x in tol_raw]
+            ),
+            np.array([0, -1, 1], dtype=np.intp),
+        )
+        tol_bad = [
+            Timedelta("2 hour").to_timedelta64(),
+            Timedelta("1 hour").to_timedelta64(),
+            np.timedelta64(1, "M"),
+        ]
+        with pytest.raises(
+            libperiod.IncompatibleFrequency, match="Input has different freq=None from"
+        ):
+            idx.get_indexer(target, "nearest", tolerance=tol_bad)
+
+
+class TestWhere:
+    def test_where(self, listlike_box):
+        i = period_range("20130101", periods=5, freq="D")
+        cond = [True] * len(i)
+        expected = i
+        result = i.where(listlike_box(cond))
+        tm.assert_index_equal(result, expected)
+
+        cond = [False] + [True] * (len(i) - 1)
+        expected = PeriodIndex([NaT] + i[1:].tolist(), freq="D")
+        result = i.where(listlike_box(cond))
+        tm.assert_index_equal(result, expected)
+
+    def test_where_other(self):
+        i = period_range("20130101", periods=5, freq="D")
+        for arr in [np.nan, NaT]:
+            result = i.where(notna(i), other=arr)
+            expected = i
+            tm.assert_index_equal(result, expected)
+
+        i2 = i.copy()
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
+        result = i.where(notna(i2), i2)
+        tm.assert_index_equal(result, i2)
+
+        i2 = i.copy()
+        i2 = PeriodIndex([NaT, NaT] + i[2:].tolist(), freq="D")
+        result = i.where(notna(i2), i2.values)
+        tm.assert_index_equal(result, i2)
+
+    def test_where_invalid_dtypes(self):
+        pi = period_range("20130101", periods=5, freq="D")
+
+        tail = pi[2:].tolist()
+        i2 = PeriodIndex([NaT, NaT] + tail, freq="D")
+        mask = notna(i2)
+
+        result = pi.where(mask, i2.asi8)
+        expected = pd.Index([NaT._value, NaT._value] + tail, dtype=object)
+        assert isinstance(expected[0], int)
+        tm.assert_index_equal(result, expected)
+
+        tdi = i2.asi8.view("timedelta64[ns]")
+        expected = pd.Index([tdi[0], tdi[1]] + tail, dtype=object)
+        assert isinstance(expected[0], np.timedelta64)
+        result = pi.where(mask, tdi)
+        tm.assert_index_equal(result, expected)
+
+        dti = i2.to_timestamp("s")
+        expected = pd.Index([dti[0], dti[1]] + tail, dtype=object)
+        assert expected[0] is NaT
+        result = pi.where(mask, dti)
+        tm.assert_index_equal(result, expected)
+
+        td = Timedelta(days=4)
+        expected = pd.Index([td, td] + tail, dtype=object)
+        assert expected[0] == td
+        result = pi.where(mask, td)
+        tm.assert_index_equal(result, expected)
+
+    def test_where_mismatched_nat(self):
+        pi = period_range("20130101", periods=5, freq="D")
+        cond = np.array([True, False, True, True, False])
+
+        tdnat = np.timedelta64("NaT", "ns")
+        expected = pd.Index([pi[0], tdnat, pi[2], pi[3], tdnat], dtype=object)
+        assert expected[1] is tdnat
+        result = pi.where(cond, tdnat)
+        tm.assert_index_equal(result, expected)
+
+
+class TestTake:
+    def test_take(self):
+        # GH#10295
+        idx1 = period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+
+        for idx in [idx1]:
+            result = idx.take([0])
+            assert result == Period("2011-01-01", freq="D")
+
+            result = idx.take([5])
+            assert result == Period("2011-01-06", freq="D")
+
+            result = idx.take([0, 1, 2])
+            expected = period_range("2011-01-01", "2011-01-03", freq="D", name="idx")
+            tm.assert_index_equal(result, expected)
+            assert result.freq == "D"
+            assert result.freq == expected.freq
+
+            result = idx.take([0, 2, 4])
+            expected = PeriodIndex(
+                ["2011-01-01", "2011-01-03", "2011-01-05"], freq="D", name="idx"
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx.take([7, 4, 1])
+            expected = PeriodIndex(
+                ["2011-01-08", "2011-01-05", "2011-01-02"], freq="D", name="idx"
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx.take([3, 2, 5])
+            expected = PeriodIndex(
+                ["2011-01-04", "2011-01-03", "2011-01-06"], freq="D", name="idx"
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+            result = idx.take([-3, 2, 5])
+            expected = PeriodIndex(
+                ["2011-01-29", "2011-01-03", "2011-01-06"], freq="D", name="idx"
+            )
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+            assert result.freq == "D"
+
+    def test_take_misc(self):
+        index = period_range(start="1/1/10", end="12/31/12", freq="D", name="idx")
+        expected = PeriodIndex(
+            [
+                datetime(2010, 1, 6),
+                datetime(2010, 1, 7),
+                datetime(2010, 1, 9),
+                datetime(2010, 1, 13),
+            ],
+            freq="D",
+            name="idx",
+        )
+
+        taken1 = index.take([5, 6, 8, 12])
+        taken2 = index[[5, 6, 8, 12]]
+
+        for taken in [taken1, taken2]:
+            tm.assert_index_equal(taken, expected)
+            assert isinstance(taken, PeriodIndex)
+            assert taken.freq == index.freq
+            assert taken.name == expected.name
+
+    def test_take_fill_value(self):
+        # GH#12631
+        idx = PeriodIndex(
+            ["2011-01-01", "2011-02-01", "2011-03-01"], name="xxx", freq="D"
+        )
+        result = idx.take(np.array([1, 0, -1]))
+        expected = PeriodIndex(
+            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
+        )
+        tm.assert_index_equal(result, expected)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = PeriodIndex(
+            ["2011-02-01", "2011-01-01", "NaT"], name="xxx", freq="D"
+        )
+        tm.assert_index_equal(result, expected)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = PeriodIndex(
+            ["2011-02-01", "2011-01-01", "2011-03-01"], name="xxx", freq="D"
+        )
+        tm.assert_index_equal(result, expected)
+
+        msg = (
+            "When allow_fill=True and fill_value is not None, "
+            "all indices must be >= -1"
+        )
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        msg = "index -5 is out of bounds for( axis 0 with)? size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -5]))
+
+
+class TestGetValue:
+    @pytest.mark.parametrize("freq", ["h", "D"])
+    def test_get_value_datetime_hourly(self, freq):
+        # get_loc and get_value should treat datetime objects symmetrically
+        # TODO: this test used to test get_value, which is removed in 2.0.
+        #  should this test be moved somewhere, or is what's left redundant?
+        dti = date_range("2016-01-01", periods=3, freq="MS")
+        pi = dti.to_period(freq)
+        ser = Series(range(7, 10), index=pi)
+
+        ts = dti[0]
+
+        assert pi.get_loc(ts) == 0
+        assert ser[ts] == 7
+        assert ser.loc[ts] == 7
+
+        ts2 = ts + Timedelta(hours=3)
+        if freq == "h":
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                pi.get_loc(ts2)
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                ser[ts2]
+            with pytest.raises(KeyError, match="2016-01-01 03:00"):
+                ser.loc[ts2]
+        else:
+            assert pi.get_loc(ts2) == 0
+            assert ser[ts2] == 7
+            assert ser.loc[ts2] == 7
+
+
+class TestContains:
+    def test_contains(self):
+        # GH 17717
+        p0 = Period("2017-09-01")
+        p1 = Period("2017-09-02")
+        p2 = Period("2017-09-03")
+        p3 = Period("2017-09-04")
+
+        ps0 = [p0, p1, p2]
+        idx0 = PeriodIndex(ps0)
+
+        for p in ps0:
+            assert p in idx0
+            assert str(p) in idx0
+
+        # GH#31172
+        # Higher-resolution period-like are _not_ considered as contained
+        key = "2017-09-01 00:00:01"
+        assert key not in idx0
+        with pytest.raises(KeyError, match=key):
+            idx0.get_loc(key)
+
+        assert "2017-09" in idx0
+
+        assert p3 not in idx0
+
+    def test_contains_freq_mismatch(self):
+        rng = period_range("2007-01", freq="M", periods=10)
+
+        assert Period("2007-01", freq="M") in rng
+        assert Period("2007-01", freq="D") not in rng
+        assert Period("2007-01", freq="2M") not in rng
+
+    def test_contains_nat(self):
+        # see gh-13582
+        idx = period_range("2007-01", freq="M", periods=10)
+        assert NaT not in idx
+        assert None not in idx
+        assert float("nan") not in idx
+        assert np.nan not in idx
+
+        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="M")
+        assert NaT in idx
+        assert None in idx
+        assert float("nan") in idx
+        assert np.nan in idx
+
+
+class TestAsOfLocs:
+    def test_asof_locs_mismatched_type(self):
+        dti = date_range("2016-01-01", periods=3)
+        pi = dti.to_period("D")
+        pi2 = dti.to_period("h")
+
+        mask = np.array([0, 1, 0], dtype=bool)
+
+        msg = "must be DatetimeIndex or PeriodIndex"
+        with pytest.raises(TypeError, match=msg):
+            pi.asof_locs(pd.Index(pi.asi8, dtype=np.int64), mask)
+
+        with pytest.raises(TypeError, match=msg):
+            pi.asof_locs(pd.Index(pi.asi8, dtype=np.float64), mask)
+
+        with pytest.raises(TypeError, match=msg):
+            # TimedeltaIndex
+            pi.asof_locs(dti - dti, mask)
+
+        msg = "Input has different freq=h"
+        with pytest.raises(libperiod.IncompatibleFrequency, match=msg):
+            pi.asof_locs(pi2, mask)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_join.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e659c1a632669c2b89d7ea0411de5c4c35108ad
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_join.py
@@ -0,0 +1,58 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    DataFrame,
+    Index,
+    PeriodIndex,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestJoin:
+    def test_join_outer_indexer(self):
+        pi = period_range("1/1/2000", "1/20/2000", freq="D")
+
+        result = pi._outer_indexer(pi)
+        tm.assert_extension_array_equal(result[0], pi._values)
+        tm.assert_numpy_array_equal(result[1], np.arange(len(pi), dtype=np.intp))
+        tm.assert_numpy_array_equal(result[2], np.arange(len(pi), dtype=np.intp))
+
+    def test_joins(self, join_type):
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+
+        joined = index.join(index[:-5], how=join_type)
+
+        assert isinstance(joined, PeriodIndex)
+        assert joined.freq == index.freq
+
+    def test_join_self(self, join_type):
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+
+        res = index.join(index, how=join_type)
+        assert index is res
+
+    def test_join_does_not_recur(self):
+        df = DataFrame(
+            np.ones((3, 2)),
+            index=date_range("2020-01-01", periods=3),
+            columns=period_range("2020-01-01", periods=2),
+        )
+        ser = df.iloc[:2, 0]
+
+        res = ser.index.join(df.columns, how="outer")
+        expected = Index(
+            [ser.index[0], ser.index[1], df.columns[0], df.columns[1]], object
+        )
+        tm.assert_index_equal(res, expected)
+
+    def test_join_mismatched_freq_raises(self):
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+        index3 = period_range("1/1/2000", "1/20/2000", freq="2D")
+        msg = r".*Input has different freq=2D from Period\(freq=D\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            index.join(index3)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_monotonic.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_monotonic.py
new file mode 100644
index 0000000000000000000000000000000000000000..15cb8f71cdcf3221800e6dca43390ae79114a9df
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_monotonic.py
@@ -0,0 +1,42 @@
+from pandas import (
+    Period,
+    PeriodIndex,
+)
+
+
+def test_is_monotonic_increasing():
+    # GH#17717
+    p0 = Period("2017-09-01")
+    p1 = Period("2017-09-02")
+    p2 = Period("2017-09-03")
+
+    idx_inc0 = PeriodIndex([p0, p1, p2])
+    idx_inc1 = PeriodIndex([p0, p1, p1])
+    idx_dec0 = PeriodIndex([p2, p1, p0])
+    idx_dec1 = PeriodIndex([p2, p1, p1])
+    idx = PeriodIndex([p1, p2, p0])
+
+    assert idx_inc0.is_monotonic_increasing is True
+    assert idx_inc1.is_monotonic_increasing is True
+    assert idx_dec0.is_monotonic_increasing is False
+    assert idx_dec1.is_monotonic_increasing is False
+    assert idx.is_monotonic_increasing is False
+
+
+def test_is_monotonic_decreasing():
+    # GH#17717
+    p0 = Period("2017-09-01")
+    p1 = Period("2017-09-02")
+    p2 = Period("2017-09-03")
+
+    idx_inc0 = PeriodIndex([p0, p1, p2])
+    idx_inc1 = PeriodIndex([p0, p1, p1])
+    idx_dec0 = PeriodIndex([p2, p1, p0])
+    idx_dec1 = PeriodIndex([p2, p1, p1])
+    idx = PeriodIndex([p1, p2, p0])
+
+    assert idx_inc0.is_monotonic_decreasing is False
+    assert idx_inc1.is_monotonic_decreasing is False
+    assert idx_dec0.is_monotonic_decreasing is True
+    assert idx_dec1.is_monotonic_decreasing is True
+    assert idx.is_monotonic_decreasing is False
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_partial_slicing.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_partial_slicing.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fab12f195dc03d43e952d5ee424955330933c0a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_partial_slicing.py
@@ -0,0 +1,198 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    PeriodIndex,
+    Series,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodIndex:
+    def test_getitem_periodindex_duplicates_string_slice(
+        self, using_copy_on_write, warn_copy_on_write
+    ):
+        # monotonic
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="Y-JUN")
+        ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+        original = ts.copy()
+
+        result = ts["2007"]
+        expected = ts[1:3]
+        tm.assert_series_equal(result, expected)
+        with tm.assert_cow_warning(warn_copy_on_write):
+            result[:] = 1
+        if using_copy_on_write:
+            tm.assert_series_equal(ts, original)
+        else:
+            assert (ts[1:3] == 1).all()
+
+        # not monotonic
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="Y-JUN")
+        ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+
+        result = ts["2007"]
+        expected = ts[idx == "2007"]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_periodindex_quarter_string(self):
+        pi = PeriodIndex(["2Q05", "3Q05", "4Q05", "1Q06", "2Q06"], freq="Q")
+        ser = Series(np.random.default_rng(2).random(len(pi)), index=pi).cumsum()
+        # Todo: fix these accessors!
+        assert ser["05Q4"] == ser.iloc[2]
+
+    def test_pindex_slice_index(self):
+        pi = period_range(start="1/1/10", end="12/31/12", freq="M")
+        s = Series(np.random.default_rng(2).random(len(pi)), index=pi)
+        res = s["2010"]
+        exp = s[0:12]
+        tm.assert_series_equal(res, exp)
+        res = s["2011"]
+        exp = s[12:24]
+        tm.assert_series_equal(res, exp)
+
+    @pytest.mark.parametrize("make_range", [date_range, period_range])
+    def test_range_slice_day(self, make_range):
+        # GH#6716
+        idx = make_range(start="2013/01/01", freq="D", periods=400)
+
+        msg = "slice indices must be integers or None or have an __index__ method"
+        # slices against index should raise IndexError
+        values = [
+            "2014",
+            "2013/02",
+            "2013/01/02",
+            "2013/02/01 9H",
+            "2013/02/01 09:00",
+        ]
+        for v in values:
+            with pytest.raises(TypeError, match=msg):
+                idx[v:]
+
+        s = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+
+        tm.assert_series_equal(s["2013/01/02":], s[1:])
+        tm.assert_series_equal(s["2013/01/02":"2013/01/05"], s[1:5])
+        tm.assert_series_equal(s["2013/02":], s[31:])
+        tm.assert_series_equal(s["2014":], s[365:])
+
+        invalid = ["2013/02/01 9H", "2013/02/01 09:00"]
+        for v in invalid:
+            with pytest.raises(TypeError, match=msg):
+                idx[v:]
+
+    @pytest.mark.parametrize("make_range", [date_range, period_range])
+    def test_range_slice_seconds(self, make_range):
+        # GH#6716
+        idx = make_range(start="2013/01/01 09:00:00", freq="s", periods=4000)
+        msg = "slice indices must be integers or None or have an __index__ method"
+
+        # slices against index should raise IndexError
+        values = [
+            "2014",
+            "2013/02",
+            "2013/01/02",
+            "2013/02/01 9H",
+            "2013/02/01 09:00",
+        ]
+        for v in values:
+            with pytest.raises(TypeError, match=msg):
+                idx[v:]
+
+        s = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+
+        tm.assert_series_equal(s["2013/01/01 09:05":"2013/01/01 09:10"], s[300:660])
+        tm.assert_series_equal(s["2013/01/01 10:00":"2013/01/01 10:05"], s[3600:3960])
+        tm.assert_series_equal(s["2013/01/01 10H":], s[3600:])
+        tm.assert_series_equal(s[:"2013/01/01 09:30"], s[:1860])
+        for d in ["2013/01/01", "2013/01", "2013"]:
+            tm.assert_series_equal(s[d:], s)
+
+    @pytest.mark.parametrize("make_range", [date_range, period_range])
+    def test_range_slice_outofbounds(self, make_range):
+        # GH#5407
+        idx = make_range(start="2013/10/01", freq="D", periods=10)
+
+        df = DataFrame({"units": [100 + i for i in range(10)]}, index=idx)
+        empty = DataFrame(index=idx[:0], columns=["units"])
+        empty["units"] = empty["units"].astype("int64")
+
+        tm.assert_frame_equal(df["2013/09/01":"2013/09/30"], empty)
+        tm.assert_frame_equal(df["2013/09/30":"2013/10/02"], df.iloc[:2])
+        tm.assert_frame_equal(df["2013/10/01":"2013/10/02"], df.iloc[:2])
+        tm.assert_frame_equal(df["2013/10/02":"2013/09/30"], empty)
+        tm.assert_frame_equal(df["2013/10/15":"2013/10/17"], empty)
+        tm.assert_frame_equal(df["2013-06":"2013-09"], empty)
+        tm.assert_frame_equal(df["2013-11":"2013-12"], empty)
+
+    @pytest.mark.parametrize("make_range", [date_range, period_range])
+    def test_maybe_cast_slice_bound(self, make_range, frame_or_series):
+        idx = make_range(start="2013/10/01", freq="D", periods=10)
+
+        obj = DataFrame({"units": [100 + i for i in range(10)]}, index=idx)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = (
+            f"cannot do slice indexing on {type(idx).__name__} with "
+            r"these indexers \[foo\] of type str"
+        )
+
+        # Check the lower-level calls are raising where expected.
+        with pytest.raises(TypeError, match=msg):
+            idx._maybe_cast_slice_bound("foo", "left")
+        with pytest.raises(TypeError, match=msg):
+            idx.get_slice_bound("foo", "left")
+
+        with pytest.raises(TypeError, match=msg):
+            obj["2013/09/30":"foo"]
+        with pytest.raises(TypeError, match=msg):
+            obj["foo":"2013/09/30"]
+        with pytest.raises(TypeError, match=msg):
+            obj.loc["2013/09/30":"foo"]
+        with pytest.raises(TypeError, match=msg):
+            obj.loc["foo":"2013/09/30"]
+
+    def test_partial_slice_doesnt_require_monotonicity(self):
+        # See also: DatetimeIndex test ofm the same name
+        dti = date_range("2014-01-01", periods=30, freq="30D")
+        pi = dti.to_period("D")
+
+        ser_montonic = Series(np.arange(30), index=pi)
+
+        shuffler = list(range(0, 30, 2)) + list(range(1, 31, 2))
+        ser = ser_montonic.iloc[shuffler]
+        nidx = ser.index
+
+        # Manually identified locations of year==2014
+        indexer_2014 = np.array(
+            [0, 1, 2, 3, 4, 5, 6, 15, 16, 17, 18, 19, 20], dtype=np.intp
+        )
+        assert (nidx[indexer_2014].year == 2014).all()
+        assert not (nidx[~indexer_2014].year == 2014).any()
+
+        result = nidx.get_loc("2014")
+        tm.assert_numpy_array_equal(result, indexer_2014)
+
+        expected = ser.iloc[indexer_2014]
+        result = ser.loc["2014"]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["2014"]
+        tm.assert_series_equal(result, expected)
+
+        # Manually identified locations where ser.index is within Mat 2015
+        indexer_may2015 = np.array([23], dtype=np.intp)
+        assert nidx[23].year == 2015 and nidx[23].month == 5
+
+        result = nidx.get_loc("May 2015")
+        tm.assert_numpy_array_equal(result, indexer_may2015)
+
+        expected = ser.iloc[indexer_may2015]
+        result = ser.loc["May 2015"]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["May 2015"]
+        tm.assert_series_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period.py
new file mode 100644
index 0000000000000000000000000000000000000000..77b8e76894647f25ea94f8bf1dce460d0b2a165f
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period.py
@@ -0,0 +1,231 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    date_range,
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodIndex:
+    def test_view_asi8(self):
+        idx = PeriodIndex([], freq="M")
+
+        exp = np.array([], dtype=np.int64)
+        tm.assert_numpy_array_equal(idx.view("i8"), exp)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
+
+        exp = np.array([492, -9223372036854775808], dtype=np.int64)
+        tm.assert_numpy_array_equal(idx.view("i8"), exp)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+        exp = np.array([14975, -9223372036854775808], dtype=np.int64)
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
+        tm.assert_numpy_array_equal(idx.view("i8"), exp)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+    def test_values(self):
+        idx = PeriodIndex([], freq="M")
+
+        exp = np.array([], dtype=object)
+        tm.assert_numpy_array_equal(idx.values, exp)
+        tm.assert_numpy_array_equal(idx.to_numpy(), exp)
+
+        exp = np.array([], dtype=np.int64)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+        idx = PeriodIndex(["2011-01", NaT], freq="M")
+
+        exp = np.array([Period("2011-01", freq="M"), NaT], dtype=object)
+        tm.assert_numpy_array_equal(idx.values, exp)
+        tm.assert_numpy_array_equal(idx.to_numpy(), exp)
+        exp = np.array([492, -9223372036854775808], dtype=np.int64)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+        idx = PeriodIndex(["2011-01-01", NaT], freq="D")
+
+        exp = np.array([Period("2011-01-01", freq="D"), NaT], dtype=object)
+        tm.assert_numpy_array_equal(idx.values, exp)
+        tm.assert_numpy_array_equal(idx.to_numpy(), exp)
+        exp = np.array([14975, -9223372036854775808], dtype=np.int64)
+        tm.assert_numpy_array_equal(idx.asi8, exp)
+
+    @pytest.mark.parametrize(
+        "field",
+        [
+            "year",
+            "month",
+            "day",
+            "hour",
+            "minute",
+            "second",
+            "weekofyear",
+            "week",
+            "dayofweek",
+            "day_of_week",
+            "dayofyear",
+            "day_of_year",
+            "quarter",
+            "qyear",
+            "days_in_month",
+        ],
+    )
+    @pytest.mark.parametrize(
+        "periodindex",
+        [
+            period_range(freq="Y", start="1/1/2001", end="12/1/2005"),
+            period_range(freq="Q", start="1/1/2001", end="12/1/2002"),
+            period_range(freq="M", start="1/1/2001", end="1/1/2002"),
+            period_range(freq="D", start="12/1/2001", end="6/1/2001"),
+            period_range(freq="h", start="12/31/2001", end="1/1/2002 23:00"),
+            period_range(freq="Min", start="12/31/2001", end="1/1/2002 00:20"),
+            period_range(
+                freq="s", start="12/31/2001 00:00:00", end="12/31/2001 00:05:00"
+            ),
+            period_range(end=Period("2006-12-31", "W"), periods=10),
+        ],
+    )
+    def test_fields(self, periodindex, field):
+        periods = list(periodindex)
+        ser = Series(periodindex)
+
+        field_idx = getattr(periodindex, field)
+        assert len(periodindex) == len(field_idx)
+        for x, val in zip(periods, field_idx):
+            assert getattr(x, field) == val
+
+        if len(ser) == 0:
+            return
+
+        field_s = getattr(ser.dt, field)
+        assert len(periodindex) == len(field_s)
+        for x, val in zip(periods, field_s):
+            assert getattr(x, field) == val
+
+    def test_is_(self):
+        create_index = lambda: period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        index = create_index()
+        assert index.is_(index)
+        assert not index.is_(create_index())
+        assert index.is_(index.view())
+        assert index.is_(index.view().view().view().view().view())
+        assert index.view().is_(index)
+        ind2 = index.view()
+        index.name = "Apple"
+        assert ind2.is_(index)
+        assert not index.is_(index[:])
+        assert not index.is_(index.asfreq("M"))
+        assert not index.is_(index.asfreq("Y"))
+
+        assert not index.is_(index - 2)
+        assert not index.is_(index - 0)
+
+    def test_index_unique(self):
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="Y-JUN")
+        expected = PeriodIndex([2000, 2007, 2009], freq="Y-JUN")
+        tm.assert_index_equal(idx.unique(), expected)
+        assert idx.nunique() == 3
+
+    def test_pindex_fieldaccessor_nat(self):
+        idx = PeriodIndex(
+            ["2011-01", "2011-02", "NaT", "2012-03", "2012-04"], freq="D", name="name"
+        )
+
+        exp = Index([2011, 2011, -1, 2012, 2012], dtype=np.int64, name="name")
+        tm.assert_index_equal(idx.year, exp)
+        exp = Index([1, 2, -1, 3, 4], dtype=np.int64, name="name")
+        tm.assert_index_equal(idx.month, exp)
+
+    def test_pindex_multiples(self):
+        expected = PeriodIndex(
+            ["2011-01", "2011-03", "2011-05", "2011-07", "2011-09", "2011-11"],
+            freq="2M",
+        )
+
+        pi = period_range(start="1/1/11", end="12/31/11", freq="2M")
+        tm.assert_index_equal(pi, expected)
+        assert pi.freq == offsets.MonthEnd(2)
+        assert pi.freqstr == "2M"
+
+        pi = period_range(start="1/1/11", periods=6, freq="2M")
+        tm.assert_index_equal(pi, expected)
+        assert pi.freq == offsets.MonthEnd(2)
+        assert pi.freqstr == "2M"
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    @pytest.mark.filterwarnings("ignore:Period with BDay freq:FutureWarning")
+    def test_iteration(self):
+        index = period_range(start="1/1/10", periods=4, freq="B")
+
+        result = list(index)
+        assert isinstance(result[0], Period)
+        assert result[0].freq == index.freq
+
+    def test_with_multi_index(self):
+        # #1705
+        index = date_range("1/1/2012", periods=4, freq="12h")
+        index_as_arrays = [index.to_period(freq="D"), index.hour]
+
+        s = Series([0, 1, 2, 3], index_as_arrays)
+
+        assert isinstance(s.index.levels[0], PeriodIndex)
+
+        assert isinstance(s.index.values[0][0], Period)
+
+    def test_map(self):
+        # test_map_dictlike generally tests
+
+        index = PeriodIndex([2005, 2007, 2009], freq="Y")
+        result = index.map(lambda x: x.ordinal)
+        exp = Index([x.ordinal for x in index])
+        tm.assert_index_equal(result, exp)
+
+
+def test_maybe_convert_timedelta():
+    pi = PeriodIndex(["2000", "2001"], freq="D")
+    offset = offsets.Day(2)
+    assert pi._maybe_convert_timedelta(offset) == 2
+    assert pi._maybe_convert_timedelta(2) == 2
+
+    offset = offsets.BusinessDay()
+    msg = r"Input has different freq=B from PeriodIndex\(freq=D\)"
+    with pytest.raises(ValueError, match=msg):
+        pi._maybe_convert_timedelta(offset)
+
+
+@pytest.mark.parametrize("array", [True, False])
+def test_dunder_array(array):
+    obj = PeriodIndex(["2000-01-01", "2001-01-01"], freq="D")
+    if array:
+        obj = obj._data
+
+    expected = np.array([obj[0], obj[1]], dtype=object)
+    result = np.array(obj)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.asarray(obj)
+    tm.assert_numpy_array_equal(result, expected)
+
+    expected = obj.asi8
+    for dtype in ["i8", "int64", np.int64]:
+        result = np.array(obj, dtype=dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.asarray(obj, dtype=dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+    for dtype in ["float64", "int32", "uint64"]:
+        msg = "argument must be"
+        with pytest.raises(TypeError, match=msg):
+            np.array(obj, dtype=dtype)
+        with pytest.raises(TypeError, match=msg):
+            np.array(obj, dtype=getattr(np, dtype))
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period_range.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period_range.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f8e6d07da8bf3c730ef1f82224388ba4b99ccb1
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_period_range.py
@@ -0,0 +1,241 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NaT,
+    Period,
+    PeriodIndex,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodRangeKeywords:
+    def test_required_arguments(self):
+        msg = (
+            "Of the three parameters: start, end, and periods, exactly two "
+            "must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range("2011-1-1", "2012-1-1", "B")
+
+    def test_required_arguments2(self):
+        start = Period("02-Apr-2005", "D")
+        msg = (
+            "Of the three parameters: start, end, and periods, exactly two "
+            "must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=start)
+
+    def test_required_arguments3(self):
+        # not enough params
+        msg = (
+            "Of the three parameters: start, end, and periods, "
+            "exactly two must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(end="2017Q1")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(periods=5)
+
+        with pytest.raises(ValueError, match=msg):
+            period_range()
+
+    def test_required_arguments_too_many(self):
+        msg = (
+            "Of the three parameters: start, end, and periods, "
+            "exactly two must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end="2018Q1", periods=8, freq="Q")
+
+    def test_start_end_non_nat(self):
+        # start/end NaT
+        msg = "start and end must not be NaT"
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=NaT, end="2018Q1")
+        with pytest.raises(ValueError, match=msg):
+            period_range(start=NaT, end="2018Q1", freq="Q")
+
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end=NaT)
+        with pytest.raises(ValueError, match=msg):
+            period_range(start="2017Q1", end=NaT, freq="Q")
+
+    def test_periods_requires_integer(self):
+        # invalid periods param
+        msg = "periods must be a number, got foo"
+        with pytest.raises(TypeError, match=msg):
+            period_range(start="2017Q1", periods="foo")
+
+
+class TestPeriodRange:
+    @pytest.mark.parametrize(
+        "freq_offset, freq_period",
+        [
+            ("D", "D"),
+            ("W", "W"),
+            ("QE", "Q"),
+            ("YE", "Y"),
+        ],
+    )
+    def test_construction_from_string(self, freq_offset, freq_period):
+        # non-empty
+        expected = date_range(
+            start="2017-01-01", periods=5, freq=freq_offset, name="foo"
+        ).to_period()
+        start, end = str(expected[0]), str(expected[-1])
+
+        result = period_range(start=start, end=end, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(start=start, periods=5, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(end=end, periods=5, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # empty
+        expected = PeriodIndex([], freq=freq_period, name="foo")
+
+        result = period_range(start=start, periods=0, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(end=end, periods=0, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(start=end, end=start, freq=freq_period, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_construction_from_string_monthly(self):
+        # non-empty
+        expected = date_range(
+            start="2017-01-01", periods=5, freq="ME", name="foo"
+        ).to_period()
+        start, end = str(expected[0]), str(expected[-1])
+
+        result = period_range(start=start, end=end, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(start=start, periods=5, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(end=end, periods=5, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # empty
+        expected = PeriodIndex([], freq="M", name="foo")
+
+        result = period_range(start=start, periods=0, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(end=end, periods=0, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(start=end, end=start, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_construction_from_period(self):
+        # upsampling
+        start, end = Period("2017Q1", freq="Q"), Period("2018Q1", freq="Q")
+        expected = date_range(
+            start="2017-03-31", end="2018-03-31", freq="ME", name="foo"
+        ).to_period()
+        result = period_range(start=start, end=end, freq="M", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # downsampling
+        start = Period("2017-1", freq="M")
+        end = Period("2019-12", freq="M")
+        expected = date_range(
+            start="2017-01-31", end="2019-12-31", freq="QE", name="foo"
+        ).to_period()
+        result = period_range(start=start, end=end, freq="Q", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # test for issue # 21793
+        start = Period("2017Q1", freq="Q")
+        end = Period("2018Q1", freq="Q")
+        idx = period_range(start=start, end=end, freq="Q", name="foo")
+        result = idx == idx.values
+        expected = np.array([True, True, True, True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+        # empty
+        expected = PeriodIndex([], freq="W", name="foo")
+
+        result = period_range(start=start, periods=0, freq="W", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(end=end, periods=0, freq="W", name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = period_range(start=end, end=start, freq="W", name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_mismatched_start_end_freq_raises(self):
+        depr_msg = "Period with BDay freq is deprecated"
+        msg = "'w' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            end_w = Period("2006-12-31", "1w")
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            start_b = Period("02-Apr-2005", "B")
+            end_b = Period("2005-05-01", "B")
+
+        msg = "start and end must have same freq"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                period_range(start=start_b, end=end_w)
+
+        # without mismatch we are OK
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            period_range(start=start_b, end=end_b)
+
+
+class TestPeriodRangeDisallowedFreqs:
+    def test_constructor_U(self):
+        # U was used as undefined period
+        with pytest.raises(ValueError, match="Invalid frequency: X"):
+            period_range("2007-1-1", periods=500, freq="X")
+
+    @pytest.mark.parametrize(
+        "freq,freq_depr",
+        [
+            ("2Y", "2A"),
+            ("2Y", "2a"),
+            ("2Y-AUG", "2A-AUG"),
+            ("2Y-AUG", "2A-aug"),
+        ],
+    )
+    def test_a_deprecated_from_time_series(self, freq, freq_depr):
+        # GH#52536
+        msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+        f"future version. Please use '{freq[1:]}' instead."
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
+
+    @pytest.mark.parametrize("freq_depr", ["2H", "2MIN", "2S", "2US", "2NS"])
+    def test_uppercase_freq_deprecated_from_time_series(self, freq_depr):
+        # GH#52536, GH#54939
+        msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+        f"future version. Please use '{freq_depr.lower()[1:]}' instead."
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            period_range("2020-01-01 00:00:00 00:00", periods=2, freq=freq_depr)
+
+    @pytest.mark.parametrize("freq_depr", ["2m", "2q-sep", "2y", "2w"])
+    def test_lowercase_freq_deprecated_from_time_series(self, freq_depr):
+        # GH#52536, GH#54939
+        msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+        f"future version. Please use '{freq_depr.upper()[1:]}' instead."
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_pickle.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_pickle.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d359fdabb6f1229e713e45452c6816d9f5743e9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_pickle.py
@@ -0,0 +1,26 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NaT,
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+class TestPickle:
+    @pytest.mark.parametrize("freq", ["D", "M", "Y"])
+    def test_pickle_round_trip(self, freq):
+        idx = PeriodIndex(["2016-05-16", "NaT", NaT, np.nan], freq=freq)
+        result = tm.round_trip_pickle(idx)
+        tm.assert_index_equal(result, idx)
+
+    def test_pickle_freq(self):
+        # GH#2891
+        prng = period_range("1/1/2011", "1/1/2012", freq="M")
+        new_prng = tm.round_trip_pickle(prng)
+        assert new_prng.freq == offsets.MonthEnd()
+        assert new_prng.freqstr == "M"
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_resolution.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_resolution.py
new file mode 100644
index 0000000000000000000000000000000000000000..680bdaa2e2a44c9603c6465274e4f4cea35e8701
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_resolution.py
@@ -0,0 +1,23 @@
+import pytest
+
+import pandas as pd
+
+
+class TestResolution:
+    @pytest.mark.parametrize(
+        "freq,expected",
+        [
+            ("Y", "year"),
+            ("Q", "quarter"),
+            ("M", "month"),
+            ("D", "day"),
+            ("h", "hour"),
+            ("min", "minute"),
+            ("s", "second"),
+            ("ms", "millisecond"),
+            ("us", "microsecond"),
+        ],
+    )
+    def test_resolution(self, freq, expected):
+        idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
+        assert idx.resolution == expected
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_scalar_compat.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_scalar_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8afd29ff31c558a7e99861852b08d86deaa9fac
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_scalar_compat.py
@@ -0,0 +1,38 @@
+"""Tests for PeriodIndex behaving like a vectorized Period scalar"""
+
+import pytest
+
+from pandas import (
+    Timedelta,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodIndexOps:
+    def test_start_time(self):
+        # GH#17157
+        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
+        expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
+        tm.assert_index_equal(index.start_time, expected_index)
+
+    def test_end_time(self):
+        # GH#17157
+        index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
+        expected_index = date_range("2016-01-01", end="2016-05-31", freq="ME")
+        expected_index += Timedelta(1, "D") - Timedelta(1, "ns")
+        tm.assert_index_equal(index.end_time, expected_index)
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_end_time_business_friday(self):
+        # GH#34449
+        pi = period_range("1990-01-05", freq="B", periods=1)
+        result = pi.end_time
+
+        dti = date_range("1990-01-05", freq="D", periods=1)._with_freq(None)
+        expected = dti + Timedelta(days=1, nanoseconds=-1)
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_searchsorted.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_searchsorted.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b02a2f35fd0193bbc8133373299a0ac2cea38ea
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_searchsorted.py
@@ -0,0 +1,80 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    NaT,
+    Period,
+    PeriodIndex,
+)
+import pandas._testing as tm
+
+
+class TestSearchsorted:
+    @pytest.mark.parametrize("freq", ["D", "2D"])
+    def test_searchsorted(self, freq):
+        pidx = PeriodIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+            freq=freq,
+        )
+
+        p1 = Period("2014-01-01", freq=freq)
+        assert pidx.searchsorted(p1) == 0
+
+        p2 = Period("2014-01-04", freq=freq)
+        assert pidx.searchsorted(p2) == 3
+
+        assert pidx.searchsorted(NaT) == 5
+
+        msg = "Input has different freq=h from PeriodArray"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            pidx.searchsorted(Period("2014-01-01", freq="h"))
+
+        msg = "Input has different freq=5D from PeriodArray"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            pidx.searchsorted(Period("2014-01-01", freq="5D"))
+
+    def test_searchsorted_different_argument_classes(self, listlike_box):
+        pidx = PeriodIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+            freq="D",
+        )
+        result = pidx.searchsorted(listlike_box(pidx))
+        expected = np.arange(len(pidx), dtype=result.dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pidx._data.searchsorted(listlike_box(pidx))
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_searchsorted_invalid(self):
+        pidx = PeriodIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+            freq="D",
+        )
+
+        other = np.array([0, 1], dtype=np.int64)
+
+        msg = "|".join(
+            [
+                "searchsorted requires compatible dtype or scalar",
+                "value should be a 'Period', 'NaT', or array of those. Got",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(other)
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(other.astype("timedelta64[ns]"))
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.timedelta64(4))
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.timedelta64("NaT", "ms"))
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.datetime64(4, "ns"))
+
+        with pytest.raises(TypeError, match=msg):
+            pidx.searchsorted(np.datetime64("NaT", "ns"))
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_setops.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_setops.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fa7e8cd0d2df5982cc0c798fbfba4e0230df367
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_setops.py
@@ -0,0 +1,363 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    PeriodIndex,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+def _permute(obj):
+    return obj.take(np.random.default_rng(2).permutation(len(obj)))
+
+
+class TestPeriodIndex:
+    def test_union(self, sort):
+        # union
+        other1 = period_range("1/1/2000", freq="D", periods=5)
+        rng1 = period_range("1/6/2000", freq="D", periods=5)
+        expected1 = PeriodIndex(
+            [
+                "2000-01-06",
+                "2000-01-07",
+                "2000-01-08",
+                "2000-01-09",
+                "2000-01-10",
+                "2000-01-01",
+                "2000-01-02",
+                "2000-01-03",
+                "2000-01-04",
+                "2000-01-05",
+            ],
+            freq="D",
+        )
+
+        rng2 = period_range("1/1/2000", freq="D", periods=5)
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = period_range("1/1/2000", freq="D", periods=8)
+
+        rng3 = period_range("1/1/2000", freq="D", periods=5)
+        other3 = PeriodIndex([], freq="D")
+        expected3 = period_range("1/1/2000", freq="D", periods=5)
+
+        rng4 = period_range("2000-01-01 09:00", freq="h", periods=5)
+        other4 = period_range("2000-01-02 09:00", freq="h", periods=5)
+        expected4 = PeriodIndex(
+            [
+                "2000-01-01 09:00",
+                "2000-01-01 10:00",
+                "2000-01-01 11:00",
+                "2000-01-01 12:00",
+                "2000-01-01 13:00",
+                "2000-01-02 09:00",
+                "2000-01-02 10:00",
+                "2000-01-02 11:00",
+                "2000-01-02 12:00",
+                "2000-01-02 13:00",
+            ],
+            freq="h",
+        )
+
+        rng5 = PeriodIndex(
+            ["2000-01-01 09:01", "2000-01-01 09:03", "2000-01-01 09:05"], freq="min"
+        )
+        other5 = PeriodIndex(
+            ["2000-01-01 09:01", "2000-01-01 09:05", "2000-01-01 09:08"], freq="min"
+        )
+        expected5 = PeriodIndex(
+            [
+                "2000-01-01 09:01",
+                "2000-01-01 09:03",
+                "2000-01-01 09:05",
+                "2000-01-01 09:08",
+            ],
+            freq="min",
+        )
+
+        rng6 = period_range("2000-01-01", freq="M", periods=7)
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = period_range("2000-01-01", freq="M", periods=10)
+
+        rng7 = period_range("2003-01-01", freq="Y", periods=5)
+        other7 = period_range("1998-01-01", freq="Y", periods=8)
+        expected7 = PeriodIndex(
+            [
+                "2003",
+                "2004",
+                "2005",
+                "2006",
+                "2007",
+                "1998",
+                "1999",
+                "2000",
+                "2001",
+                "2002",
+            ],
+            freq="Y",
+        )
+
+        rng8 = PeriodIndex(
+            ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"], freq="D"
+        )
+        other8 = period_range("1/6/2000", freq="D", periods=5)
+        expected8 = PeriodIndex(
+            [
+                "1/3/2000",
+                "1/2/2000",
+                "1/1/2000",
+                "1/5/2000",
+                "1/4/2000",
+                "1/6/2000",
+                "1/7/2000",
+                "1/8/2000",
+                "1/9/2000",
+                "1/10/2000",
+            ],
+            freq="D",
+        )
+
+        for rng, other, expected in [
+            (rng1, other1, expected1),
+            (rng2, other2, expected2),
+            (rng3, other3, expected3),
+            (rng4, other4, expected4),
+            (rng5, other5, expected5),
+            (rng6, other6, expected6),
+            (rng7, other7, expected7),
+            (rng8, other8, expected8),
+        ]:
+            result_union = rng.union(other, sort=sort)
+            if sort is None:
+                expected = expected.sort_values()
+            tm.assert_index_equal(result_union, expected)
+
+    def test_union_misc(self, sort):
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+
+        result = index[:-5].union(index[10:], sort=sort)
+        tm.assert_index_equal(result, index)
+
+        # not in order
+        result = _permute(index[:-5]).union(_permute(index[10:]), sort=sort)
+        if sort is False:
+            tm.assert_index_equal(result.sort_values(), index)
+        else:
+            tm.assert_index_equal(result, index)
+
+        # cast if different frequencies
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+        index2 = period_range("1/1/2000", "1/20/2000", freq="W-WED")
+        result = index.union(index2, sort=sort)
+        expected = index.astype(object).union(index2.astype(object), sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection(self, sort):
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+
+        result = index[:-5].intersection(index[10:], sort=sort)
+        tm.assert_index_equal(result, index[10:-5])
+
+        # not in order
+        left = _permute(index[:-5])
+        right = _permute(index[10:])
+        result = left.intersection(right, sort=sort)
+        if sort is False:
+            tm.assert_index_equal(result.sort_values(), index[10:-5])
+        else:
+            tm.assert_index_equal(result, index[10:-5])
+
+        # cast if different frequencies
+        index = period_range("1/1/2000", "1/20/2000", freq="D")
+        index2 = period_range("1/1/2000", "1/20/2000", freq="W-WED")
+
+        result = index.intersection(index2, sort=sort)
+        expected = pd.Index([], dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        index3 = period_range("1/1/2000", "1/20/2000", freq="2D")
+        result = index.intersection(index3, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection_cases(self, sort):
+        base = period_range("6/1/2000", "6/30/2000", freq="D", name="idx")
+
+        # if target has the same name, it is preserved
+        rng2 = period_range("5/15/2000", "6/20/2000", freq="D", name="idx")
+        expected2 = period_range("6/1/2000", "6/20/2000", freq="D", name="idx")
+
+        # if target name is different, it will be reset
+        rng3 = period_range("5/15/2000", "6/20/2000", freq="D", name="other")
+        expected3 = period_range("6/1/2000", "6/20/2000", freq="D", name=None)
+
+        rng4 = period_range("7/1/2000", "7/31/2000", freq="D", name="idx")
+        expected4 = PeriodIndex([], name="idx", freq="D")
+
+        for rng, expected in [
+            (rng2, expected2),
+            (rng3, expected3),
+            (rng4, expected4),
+        ]:
+            result = base.intersection(rng, sort=sort)
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+        # non-monotonic
+        base = PeriodIndex(
+            ["2011-01-05", "2011-01-04", "2011-01-02", "2011-01-03"],
+            freq="D",
+            name="idx",
+        )
+
+        rng2 = PeriodIndex(
+            ["2011-01-04", "2011-01-02", "2011-02-02", "2011-02-03"],
+            freq="D",
+            name="idx",
+        )
+        expected2 = PeriodIndex(["2011-01-04", "2011-01-02"], freq="D", name="idx")
+
+        rng3 = PeriodIndex(
+            ["2011-01-04", "2011-01-02", "2011-02-02", "2011-02-03"],
+            freq="D",
+            name="other",
+        )
+        expected3 = PeriodIndex(["2011-01-04", "2011-01-02"], freq="D", name=None)
+
+        rng4 = period_range("7/1/2000", "7/31/2000", freq="D", name="idx")
+        expected4 = PeriodIndex([], freq="D", name="idx")
+
+        for rng, expected in [
+            (rng2, expected2),
+            (rng3, expected3),
+            (rng4, expected4),
+        ]:
+            result = base.intersection(rng, sort=sort)
+            if sort is None:
+                expected = expected.sort_values()
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == "D"
+
+        # empty same freq
+        rng = date_range("6/1/2000", "6/15/2000", freq="min")
+        result = rng[0:0].intersection(rng)
+        assert len(result) == 0
+
+        result = rng.intersection(rng[0:0])
+        assert len(result) == 0
+
+    def test_difference(self, sort):
+        # diff
+        period_rng = ["1/3/2000", "1/2/2000", "1/1/2000", "1/5/2000", "1/4/2000"]
+        rng1 = PeriodIndex(period_rng, freq="D")
+        other1 = period_range("1/6/2000", freq="D", periods=5)
+        expected1 = rng1
+
+        rng2 = PeriodIndex(period_rng, freq="D")
+        other2 = period_range("1/4/2000", freq="D", periods=5)
+        expected2 = PeriodIndex(["1/3/2000", "1/2/2000", "1/1/2000"], freq="D")
+
+        rng3 = PeriodIndex(period_rng, freq="D")
+        other3 = PeriodIndex([], freq="D")
+        expected3 = rng3
+
+        period_rng = [
+            "2000-01-01 10:00",
+            "2000-01-01 09:00",
+            "2000-01-01 12:00",
+            "2000-01-01 11:00",
+            "2000-01-01 13:00",
+        ]
+        rng4 = PeriodIndex(period_rng, freq="h")
+        other4 = period_range("2000-01-02 09:00", freq="h", periods=5)
+        expected4 = rng4
+
+        rng5 = PeriodIndex(
+            ["2000-01-01 09:03", "2000-01-01 09:01", "2000-01-01 09:05"], freq="min"
+        )
+        other5 = PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="min")
+        expected5 = PeriodIndex(["2000-01-01 09:03"], freq="min")
+
+        period_rng = [
+            "2000-02-01",
+            "2000-01-01",
+            "2000-06-01",
+            "2000-07-01",
+            "2000-05-01",
+            "2000-03-01",
+            "2000-04-01",
+        ]
+        rng6 = PeriodIndex(period_rng, freq="M")
+        other6 = period_range("2000-04-01", freq="M", periods=7)
+        expected6 = PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
+
+        period_rng = ["2003", "2007", "2006", "2005", "2004"]
+        rng7 = PeriodIndex(period_rng, freq="Y")
+        other7 = period_range("1998-01-01", freq="Y", periods=8)
+        expected7 = PeriodIndex(["2007", "2006"], freq="Y")
+
+        for rng, other, expected in [
+            (rng1, other1, expected1),
+            (rng2, other2, expected2),
+            (rng3, other3, expected3),
+            (rng4, other4, expected4),
+            (rng5, other5, expected5),
+            (rng6, other6, expected6),
+            (rng7, other7, expected7),
+        ]:
+            result_difference = rng.difference(other, sort=sort)
+            if sort is None and len(other):
+                # We dont sort (yet?) when empty GH#24959
+                expected = expected.sort_values()
+            tm.assert_index_equal(result_difference, expected)
+
+    def test_difference_freq(self, sort):
+        # GH14323: difference of Period MUST preserve frequency
+        # but the ability to union results must be preserved
+
+        index = period_range("20160920", "20160925", freq="D")
+
+        other = period_range("20160921", "20160924", freq="D")
+        expected = PeriodIndex(["20160920", "20160925"], freq="D")
+        idx_diff = index.difference(other, sort)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+        other = period_range("20160922", "20160925", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = PeriodIndex(["20160920", "20160921"], freq="D")
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal("freq", idx_diff, expected)
+
+    def test_intersection_equal_duplicates(self):
+        # GH#38302
+        idx = period_range("2011-01-01", periods=2)
+        idx_dup = idx.append(idx)
+        result = idx_dup.intersection(idx_dup)
+        tm.assert_index_equal(result, idx)
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_union_duplicates(self):
+        # GH#36289
+        idx = period_range("2011-01-01", periods=2)
+        idx_dup = idx.append(idx)
+
+        idx2 = period_range("2011-01-02", periods=2)
+        idx2_dup = idx2.append(idx2)
+        result = idx_dup.union(idx2_dup)
+
+        expected = PeriodIndex(
+            [
+                "2011-01-01",
+                "2011-01-01",
+                "2011-01-02",
+                "2011-01-02",
+                "2011-01-03",
+                "2011-01-03",
+            ],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_tools.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..f507e64d88b06b5862de3e98c693ab9f85306116
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/period/test_tools.py
@@ -0,0 +1,52 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Period,
+    PeriodIndex,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestPeriodRepresentation:
+    """
+    Wish to match NumPy units
+    """
+
+    @pytest.mark.parametrize(
+        "freq, base_date",
+        [
+            ("W-THU", "1970-01-01"),
+            ("D", "1970-01-01"),
+            ("B", "1970-01-01"),
+            ("h", "1970-01-01"),
+            ("min", "1970-01-01"),
+            ("s", "1970-01-01"),
+            ("ms", "1970-01-01"),
+            ("us", "1970-01-01"),
+            ("ns", "1970-01-01"),
+            ("M", "1970-01"),
+            ("Y", 1970),
+        ],
+    )
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_freq(self, freq, base_date):
+        rng = period_range(start=base_date, periods=10, freq=freq)
+        exp = np.arange(10, dtype=np.int64)
+
+        tm.assert_numpy_array_equal(rng.asi8, exp)
+
+
+class TestPeriodIndexConversion:
+    def test_tolist(self):
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        rs = index.tolist()
+        for x in rs:
+            assert isinstance(x, Period)
+
+        recon = PeriodIndex(rs)
+        tm.assert_index_equal(index, recon)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__init__.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e732aefa9b87095ef9a5320622c06a906d148da
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_constructors.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..497ee2d902aa72edc810c665aa2003c14851b29f
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_indexing.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..520f6736a0792b4e837c9f0ba101764aff528e3d
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_join.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_join.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90f945a7c29d931408c41fd0449f282db578af46
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_join.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_range.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_range.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8dc91decfdf35f0f81750ae701037da3f6a7b805
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_range.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_setops.cpython-310.pyc b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce5c532f44b3574209d83c1258f471237af02d5c
Binary files /dev/null and b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_constructors.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e6f16075ae636a3aa14e7443097f426bd6f998a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_constructors.py
@@ -0,0 +1,164 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    RangeIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestRangeIndexConstructors:
+    @pytest.mark.parametrize("name", [None, "foo"])
+    @pytest.mark.parametrize(
+        "args, kwargs, start, stop, step",
+        [
+            ((5,), {}, 0, 5, 1),
+            ((1, 5), {}, 1, 5, 1),
+            ((1, 5, 2), {}, 1, 5, 2),
+            ((0,), {}, 0, 0, 1),
+            ((0, 0), {}, 0, 0, 1),
+            ((), {"start": 0}, 0, 0, 1),
+            ((), {"stop": 0}, 0, 0, 1),
+        ],
+    )
+    def test_constructor(self, args, kwargs, start, stop, step, name):
+        result = RangeIndex(*args, name=name, **kwargs)
+        expected = Index(np.arange(start, stop, step, dtype=np.int64), name=name)
+        assert isinstance(result, RangeIndex)
+        assert result.name is name
+        assert result._range == range(start, stop, step)
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+    def test_constructor_invalid_args(self):
+        msg = "RangeIndex\\(\\.\\.\\.\\) must be called with integers"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex()
+
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex(name="Foo")
+
+        # we don't allow on a bare Index
+        msg = (
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            r"kind, 0 was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Index(0)
+
+    @pytest.mark.parametrize(
+        "args",
+        [
+            Index(["a", "b"]),
+            Series(["a", "b"]),
+            np.array(["a", "b"]),
+            [],
+            np.arange(0, 10),
+            np.array([1]),
+            [1],
+        ],
+    )
+    def test_constructor_additional_invalid_args(self, args):
+        msg = f"Value needs to be a scalar value, was type {type(args).__name__}"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex(args)
+
+    @pytest.mark.parametrize("args", ["foo", datetime(2000, 1, 1, 0, 0)])
+    def test_constructor_invalid_args_wrong_type(self, args):
+        msg = f"Wrong type {type(args)} for value {args}"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex(args)
+
+    def test_constructor_same(self):
+        # pass thru w and w/o copy
+        index = RangeIndex(1, 5, 2)
+        result = RangeIndex(index, copy=False)
+        assert result.identical(index)
+
+        result = RangeIndex(index, copy=True)
+        tm.assert_index_equal(result, index, exact=True)
+
+        result = RangeIndex(index)
+        tm.assert_index_equal(result, index, exact=True)
+
+        with pytest.raises(
+            ValueError,
+            match="Incorrect `dtype` passed: expected signed integer, received float64",
+        ):
+            RangeIndex(index, dtype="float64")
+
+    def test_constructor_range_object(self):
+        result = RangeIndex(range(1, 5, 2))
+        expected = RangeIndex(1, 5, 2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_constructor_range(self):
+        result = RangeIndex.from_range(range(1, 5, 2))
+        expected = RangeIndex(1, 5, 2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = RangeIndex.from_range(range(5, 6))
+        expected = RangeIndex(5, 6, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # an invalid range
+        result = RangeIndex.from_range(range(5, 1))
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = RangeIndex.from_range(range(5))
+        expected = RangeIndex(0, 5, 1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = Index(range(1, 5, 2))
+        expected = RangeIndex(1, 5, 2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        msg = (
+            r"(RangeIndex.)?from_range\(\) got an unexpected keyword argument( 'copy')?"
+        )
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex.from_range(range(10), copy=True)
+
+    def test_constructor_name(self):
+        # GH#12288
+        orig = RangeIndex(10)
+        orig.name = "original"
+
+        copy = RangeIndex(orig)
+        copy.name = "copy"
+
+        assert orig.name == "original"
+        assert copy.name == "copy"
+
+        new = Index(copy)
+        assert new.name == "copy"
+
+        new.name = "new"
+        assert orig.name == "original"
+        assert copy.name == "copy"
+        assert new.name == "new"
+
+    def test_constructor_corner(self):
+        arr = np.array([1, 2, 3, 4], dtype=object)
+        index = RangeIndex(1, 5)
+        assert index.values.dtype == np.int64
+        expected = Index(arr).astype("int64")
+
+        tm.assert_index_equal(index, expected, exact="equiv")
+
+        # non-int raise Exception
+        with pytest.raises(TypeError, match=r"Wrong type \<class 'str'\>"):
+            RangeIndex("1", "10", "1")
+        with pytest.raises(TypeError, match=r"Wrong type \<class 'float'\>"):
+            RangeIndex(1.1, 10.2, 1.3)
+
+        # invalid passed type
+        with pytest.raises(
+            ValueError,
+            match="Incorrect `dtype` passed: expected signed integer, received float64",
+        ):
+            RangeIndex(1, 5, dtype="float64")
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_indexing.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..6202074a11d7883c6f6aa984c23d7964e9042eb0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_indexing.py
@@ -0,0 +1,137 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+class TestGetIndexer:
+    def test_get_indexer(self):
+        index = RangeIndex(start=0, stop=20, step=2)
+        target = RangeIndex(10)
+        indexer = index.get_indexer(target)
+        expected = np.array([0, -1, 1, -1, 2, -1, 3, -1, 4, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+    def test_get_indexer_pad(self):
+        index = RangeIndex(start=0, stop=20, step=2)
+        target = RangeIndex(10)
+        indexer = index.get_indexer(target, method="pad")
+        expected = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+    def test_get_indexer_backfill(self):
+        index = RangeIndex(start=0, stop=20, step=2)
+        target = RangeIndex(10)
+        indexer = index.get_indexer(target, method="backfill")
+        expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, expected)
+
+    def test_get_indexer_limit(self):
+        # GH#28631
+        idx = RangeIndex(4)
+        target = RangeIndex(6)
+        result = idx.get_indexer(target, method="pad", limit=1)
+        expected = np.array([0, 1, 2, 3, 3, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("stop", [0, -1, -2])
+    def test_get_indexer_decreasing(self, stop):
+        # GH#28678
+        index = RangeIndex(7, stop, -3)
+        result = index.get_indexer(range(9))
+        expected = np.array([-1, 2, -1, -1, 1, -1, -1, 0, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestTake:
+    def test_take_preserve_name(self):
+        index = RangeIndex(1, 5, name="foo")
+        taken = index.take([3, 0, 1])
+        assert index.name == taken.name
+
+    def test_take_fill_value(self):
+        # GH#12631
+        idx = RangeIndex(1, 4, name="xxx")
+        result = idx.take(np.array([1, 0, -1]))
+        expected = Index([2, 1, 3], dtype=np.int64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        # fill_value
+        msg = "Unable to fill values because RangeIndex cannot contain NA"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -1]), fill_value=True)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False, fill_value=True)
+        expected = Index([2, 1, 3], dtype=np.int64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+        msg = "Unable to fill values because RangeIndex cannot contain NA"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+    def test_take_raises_index_error(self):
+        idx = RangeIndex(1, 4, name="xxx")
+
+        msg = "index -5 is out of bounds for (axis 0 with )?size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -5]))
+
+        msg = "index -4 is out of bounds for (axis 0 with )?size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -4]))
+
+        # no errors
+        result = idx.take(np.array([1, -3]))
+        expected = Index([2, 1], dtype=np.int64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_accepts_empty_array(self):
+        idx = RangeIndex(1, 4, name="foo")
+        result = idx.take(np.array([]))
+        expected = Index([], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # empty index
+        idx = RangeIndex(0, name="foo")
+        result = idx.take(np.array([]))
+        expected = Index([], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_accepts_non_int64_array(self):
+        idx = RangeIndex(1, 4, name="foo")
+        result = idx.take(np.array([2, 1], dtype=np.uint32))
+        expected = Index([3, 2], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_when_index_has_step(self):
+        idx = RangeIndex(1, 11, 3, name="foo")  # [1, 4, 7, 10]
+        result = idx.take(np.array([1, 0, -1, -4]))
+        expected = Index([4, 1, 10, 1], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_when_index_has_negative_step(self):
+        idx = RangeIndex(11, -4, -2, name="foo")  # [11, 9, 7, 5, 3, 1, -1, -3]
+        result = idx.take(np.array([1, 0, -1, -8]))
+        expected = Index([9, 11, -3, 11], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+
+class TestWhere:
+    def test_where_putmask_range_cast(self):
+        # GH#43240
+        idx = RangeIndex(0, 5, name="test")
+
+        mask = np.array([True, True, False, False, False])
+        result = idx.putmask(mask, 10)
+        expected = Index([10, 10, 2, 3, 4], dtype=np.int64, name="test")
+        tm.assert_index_equal(result, expected)
+
+        result = idx.where(~mask, 10)
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_join.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..682b5c8def9ff0e00b533610c1d45a093e7d7a8d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_join.py
@@ -0,0 +1,177 @@
+import numpy as np
+
+from pandas import (
+    Index,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+class TestJoin:
+    def test_join_outer(self):
+        # join with Index[int64]
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
+
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        eres = Index(
+            [0, 2, 4, 6, 8, 10, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+        )
+        elidx = np.array(
+            [0, 1, 2, 3, 4, 5, 6, 7, -1, 8, -1, 9, -1, -1, -1, -1, -1, -1, -1],
+            dtype=np.intp,
+        )
+        eridx = np.array(
+            [-1, -1, -1, -1, -1, -1, -1, -1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+            dtype=np.intp,
+        )
+
+        assert isinstance(res, Index) and res.dtype == np.dtype(np.int64)
+        assert not isinstance(res, RangeIndex)
+        tm.assert_index_equal(res, eres, exact=True)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # join with RangeIndex
+        other = RangeIndex(25, 14, -1)
+
+        res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
+        noidx_res = index.join(other, how="outer")
+        tm.assert_index_equal(res, noidx_res)
+
+        assert isinstance(res, Index) and res.dtype == np.int64
+        assert not isinstance(res, RangeIndex)
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_inner(self):
+        # Join with non-RangeIndex
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
+
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
+
+        # no guarantee of sortedness, so sort for comparison purposes
+        ind = res.argsort()
+        res = res.take(ind)
+        lidx = lidx.take(ind)
+        ridx = ridx.take(ind)
+
+        eres = Index([16, 18])
+        elidx = np.array([8, 9], dtype=np.intp)
+        eridx = np.array([9, 7], dtype=np.intp)
+
+        assert isinstance(res, Index) and res.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # Join two RangeIndex
+        other = RangeIndex(25, 14, -1)
+
+        res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
+
+        assert isinstance(res, RangeIndex)
+        tm.assert_index_equal(res, eres, exact="equiv")
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_left(self):
+        # Join with Index[int64]
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
+
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
+        eres = index
+        eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 9, 7], dtype=np.intp)
+
+        assert isinstance(res, RangeIndex)
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+        # Join withRangeIndex
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
+
+        res, lidx, ridx = index.join(other, how="left", return_indexers=True)
+
+        assert isinstance(res, RangeIndex)
+        tm.assert_index_equal(res, eres)
+        assert lidx is None
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_right(self):
+        # Join with Index[int64]
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
+
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
+        eres = other
+        elidx = np.array([-1, -1, -1, -1, -1, -1, -1, 9, -1, 8, -1], dtype=np.intp)
+
+        assert isinstance(other, Index) and other.dtype == np.int64
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        assert ridx is None
+
+        # Join withRangeIndex
+        other = RangeIndex(25, 14, -1)
+
+        res, lidx, ridx = index.join(other, how="right", return_indexers=True)
+        eres = other
+
+        assert isinstance(other, RangeIndex)
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        assert ridx is None
+
+    def test_join_non_int_index(self):
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index([3, 6, 7, 8, 10], dtype=object)
+
+        outer = index.join(other, how="outer")
+        outer2 = other.join(index, how="outer")
+        expected = Index([0, 2, 3, 4, 6, 7, 8, 10, 12, 14, 16, 18])
+        tm.assert_index_equal(outer, outer2)
+        tm.assert_index_equal(outer, expected)
+
+        inner = index.join(other, how="inner")
+        inner2 = other.join(index, how="inner")
+        expected = Index([6, 8, 10])
+        tm.assert_index_equal(inner, inner2)
+        tm.assert_index_equal(inner, expected)
+
+        left = index.join(other, how="left")
+        tm.assert_index_equal(left, index.astype(object))
+
+        left2 = other.join(index, how="left")
+        tm.assert_index_equal(left2, other)
+
+        right = index.join(other, how="right")
+        tm.assert_index_equal(right, other)
+
+        right2 = other.join(index, how="right")
+        tm.assert_index_equal(right2, index.astype(object))
+
+    def test_join_non_unique(self):
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index([4, 4, 3, 3])
+
+        res, lidx, ridx = index.join(other, return_indexers=True)
+
+        eres = Index([0, 2, 4, 4, 6, 8, 10, 12, 14, 16, 18])
+        elidx = np.array([0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.intp)
+        eridx = np.array([-1, -1, 0, 1, -1, -1, -1, -1, -1, -1, -1], dtype=np.intp)
+
+        tm.assert_index_equal(res, eres)
+        tm.assert_numpy_array_equal(lidx, elidx)
+        tm.assert_numpy_array_equal(ridx, eridx)
+
+    def test_join_self(self, join_type):
+        index = RangeIndex(start=0, stop=20, step=2)
+        joined = index.join(index, how=join_type)
+        assert index is joined
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_range.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_range.py
new file mode 100644
index 0000000000000000000000000000000000000000..06e19eeca67663318709772ff23f76675545e19b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_range.py
@@ -0,0 +1,622 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import ensure_platform_int
+
+import pandas as pd
+from pandas import (
+    Index,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+class TestRangeIndex:
+    @pytest.fixture
+    def simple_index(self):
+        return RangeIndex(start=0, stop=20, step=2)
+
+    def test_constructor_unwraps_index(self):
+        result = RangeIndex(1, 3)
+        expected = np.array([1, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(result._data, expected)
+
+    def test_can_hold_identifiers(self, simple_index):
+        idx = simple_index
+        key = idx[0]
+        assert idx._can_hold_identifiers_and_holds_name(key) is False
+
+    def test_too_many_names(self, simple_index):
+        index = simple_index
+        with pytest.raises(ValueError, match="^Length"):
+            index.names = ["roger", "harold"]
+
+    @pytest.mark.parametrize(
+        "index, start, stop, step",
+        [
+            (RangeIndex(5), 0, 5, 1),
+            (RangeIndex(0, 5), 0, 5, 1),
+            (RangeIndex(5, step=2), 0, 5, 2),
+            (RangeIndex(1, 5, 2), 1, 5, 2),
+        ],
+    )
+    def test_start_stop_step_attrs(self, index, start, stop, step):
+        # GH 25710
+        assert index.start == start
+        assert index.stop == stop
+        assert index.step == step
+
+    def test_copy(self):
+        i = RangeIndex(5, name="Foo")
+        i_copy = i.copy()
+        assert i_copy is not i
+        assert i_copy.identical(i)
+        assert i_copy._range == range(0, 5, 1)
+        assert i_copy.name == "Foo"
+
+    def test_repr(self):
+        i = RangeIndex(5, name="Foo")
+        result = repr(i)
+        expected = "RangeIndex(start=0, stop=5, step=1, name='Foo')"
+        assert result == expected
+
+        result = eval(result)
+        tm.assert_index_equal(result, i, exact=True)
+
+        i = RangeIndex(5, 0, -1)
+        result = repr(i)
+        expected = "RangeIndex(start=5, stop=0, step=-1)"
+        assert result == expected
+
+        result = eval(result)
+        tm.assert_index_equal(result, i, exact=True)
+
+    def test_insert(self):
+        idx = RangeIndex(5, name="Foo")
+        result = idx[1:4]
+
+        # test 0th element
+        tm.assert_index_equal(idx[0:4], result.insert(0, idx[0]), exact="equiv")
+
+        # GH 18295 (test missing)
+        expected = Index([0, np.nan, 1, 2, 3, 4], dtype=np.float64)
+        for na in [np.nan, None, pd.NA]:
+            result = RangeIndex(5).insert(1, na)
+            tm.assert_index_equal(result, expected)
+
+        result = RangeIndex(5).insert(1, pd.NaT)
+        expected = Index([0, pd.NaT, 1, 2, 3, 4], dtype=object)
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_edges_preserves_rangeindex(self):
+        idx = Index(range(4, 9, 2))
+
+        result = idx.insert(0, 2)
+        expected = Index(range(2, 9, 2))
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.insert(3, 10)
+        expected = Index(range(4, 11, 2))
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_insert_middle_preserves_rangeindex(self):
+        # insert in the middle
+        idx = Index(range(0, 3, 2))
+        result = idx.insert(1, 1)
+        expected = Index(range(3))
+        tm.assert_index_equal(result, expected, exact=True)
+
+        idx = idx * 2
+        result = idx.insert(1, 2)
+        expected = expected * 2
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete(self):
+        idx = RangeIndex(5, name="Foo")
+        expected = idx[1:]
+        result = idx.delete(0)
+        tm.assert_index_equal(result, expected, exact=True)
+        assert result.name == expected.name
+
+        expected = idx[:-1]
+        result = idx.delete(-1)
+        tm.assert_index_equal(result, expected, exact=True)
+        assert result.name == expected.name
+
+        msg = "index 5 is out of bounds for axis 0 with size 5"
+        with pytest.raises((IndexError, ValueError), match=msg):
+            # either depending on numpy version
+            result = idx.delete(len(idx))
+
+    def test_delete_preserves_rangeindex(self):
+        idx = Index(range(2), name="foo")
+
+        result = idx.delete([1])
+        expected = Index(range(1), name="foo")
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(1)
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete_preserves_rangeindex_middle(self):
+        idx = Index(range(3), name="foo")
+        result = idx.delete(1)
+        expected = idx[::2]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(-2)
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete_preserves_rangeindex_list_at_end(self):
+        idx = RangeIndex(0, 6, 1)
+
+        loc = [2, 3, 4, 5]
+        result = idx.delete(loc)
+        expected = idx[:2]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(loc[::-1])
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete_preserves_rangeindex_list_middle(self):
+        idx = RangeIndex(0, 6, 1)
+
+        loc = [1, 2, 3, 4]
+        result = idx.delete(loc)
+        expected = RangeIndex(0, 6, 5)
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(loc[::-1])
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete_all_preserves_rangeindex(self):
+        idx = RangeIndex(0, 6, 1)
+
+        loc = [0, 1, 2, 3, 4, 5]
+        result = idx.delete(loc)
+        expected = idx[:0]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(loc[::-1])
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_delete_not_preserving_rangeindex(self):
+        idx = RangeIndex(0, 6, 1)
+
+        loc = [0, 3, 5]
+        result = idx.delete(loc)
+        expected = Index([1, 2, 4])
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.delete(loc[::-1])
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_view(self):
+        i = RangeIndex(0, name="Foo")
+        i_view = i.view()
+        assert i_view.name == "Foo"
+
+        i_view = i.view("i8")
+        tm.assert_numpy_array_equal(i.values, i_view)
+
+        msg = "Passing a type in RangeIndex.view is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            i_view = i.view(RangeIndex)
+        tm.assert_index_equal(i, i_view)
+
+    def test_dtype(self, simple_index):
+        index = simple_index
+        assert index.dtype == np.int64
+
+    def test_cache(self):
+        # GH 26565, GH26617, GH35432, GH53387
+        # This test checks whether _cache has been set.
+        # Calling RangeIndex._cache["_data"] creates an int64 array of the same length
+        # as the RangeIndex and stores it in _cache.
+        idx = RangeIndex(0, 100, 10)
+
+        assert idx._cache == {}
+
+        repr(idx)
+        assert idx._cache == {}
+
+        str(idx)
+        assert idx._cache == {}
+
+        idx.get_loc(20)
+        assert idx._cache == {}
+
+        90 in idx  # True
+        assert idx._cache == {}
+
+        91 in idx  # False
+        assert idx._cache == {}
+
+        idx.all()
+        assert idx._cache == {}
+
+        idx.any()
+        assert idx._cache == {}
+
+        for _ in idx:
+            pass
+        assert idx._cache == {}
+
+        msg = "RangeIndex.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            idx.format()
+        assert idx._cache == {}
+
+        df = pd.DataFrame({"a": range(10)}, index=idx)
+
+        # df.__repr__ should not populate index cache
+        str(df)
+        assert idx._cache == {}
+
+        df.loc[50]
+        assert idx._cache == {}
+
+        with pytest.raises(KeyError, match="51"):
+            df.loc[51]
+        assert idx._cache == {}
+
+        df.loc[10:50]
+        assert idx._cache == {}
+
+        df.iloc[5:10]
+        assert idx._cache == {}
+
+        # after calling take, _cache may contain other keys, but not "_data"
+        idx.take([3, 0, 1])
+        assert "_data" not in idx._cache
+
+        df.loc[[50]]
+        assert "_data" not in idx._cache
+
+        df.iloc[[5, 6, 7, 8, 9]]
+        assert "_data" not in idx._cache
+
+        # idx._cache should contain a _data entry after call to idx._data
+        idx._data
+        assert isinstance(idx._data, np.ndarray)
+        assert idx._data is idx._data  # check cached value is reused
+        assert "_data" in idx._cache
+        expected = np.arange(0, 100, 10, dtype="int64")
+        tm.assert_numpy_array_equal(idx._cache["_data"], expected)
+
+    def test_is_monotonic(self):
+        index = RangeIndex(0, 20, 2)
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is False
+        assert index._is_strictly_monotonic_increasing is True
+        assert index._is_strictly_monotonic_decreasing is False
+
+        index = RangeIndex(4, 0, -1)
+        assert index.is_monotonic_increasing is False
+        assert index._is_strictly_monotonic_increasing is False
+        assert index.is_monotonic_decreasing is True
+        assert index._is_strictly_monotonic_decreasing is True
+
+        index = RangeIndex(1, 2)
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is True
+        assert index._is_strictly_monotonic_increasing is True
+        assert index._is_strictly_monotonic_decreasing is True
+
+        index = RangeIndex(2, 1)
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is True
+        assert index._is_strictly_monotonic_increasing is True
+        assert index._is_strictly_monotonic_decreasing is True
+
+        index = RangeIndex(1, 1)
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_increasing is True
+        assert index.is_monotonic_decreasing is True
+        assert index._is_strictly_monotonic_increasing is True
+        assert index._is_strictly_monotonic_decreasing is True
+
+    @pytest.mark.parametrize(
+        "left,right",
+        [
+            (RangeIndex(0, 9, 2), RangeIndex(0, 10, 2)),
+            (RangeIndex(0), RangeIndex(1, -1, 3)),
+            (RangeIndex(1, 2, 3), RangeIndex(1, 3, 4)),
+            (RangeIndex(0, -9, -2), RangeIndex(0, -10, -2)),
+        ],
+    )
+    def test_equals_range(self, left, right):
+        assert left.equals(right)
+        assert right.equals(left)
+
+    def test_logical_compat(self, simple_index):
+        idx = simple_index
+        assert idx.all() == idx.values.all()
+        assert idx.any() == idx.values.any()
+
+    def test_identical(self, simple_index):
+        index = simple_index
+        i = Index(index.copy())
+        assert i.identical(index)
+
+        # we don't allow object dtype for RangeIndex
+        if isinstance(index, RangeIndex):
+            return
+
+        same_values_different_type = Index(i, dtype=object)
+        assert not i.identical(same_values_different_type)
+
+        i = index.copy(dtype=object)
+        i = i.rename("foo")
+        same_values = Index(i, dtype=object)
+        assert same_values.identical(index.copy(dtype=object))
+
+        assert not i.identical(index)
+        assert Index(same_values, name="foo", dtype=object).identical(i)
+
+        assert not index.copy(dtype=object).identical(index.copy(dtype="int64"))
+
+    def test_nbytes(self):
+        # memory savings vs int index
+        idx = RangeIndex(0, 1000)
+        assert idx.nbytes < Index(idx._values).nbytes / 10
+
+        # constant memory usage
+        i2 = RangeIndex(0, 10)
+        assert idx.nbytes == i2.nbytes
+
+    @pytest.mark.parametrize(
+        "start,stop,step",
+        [
+            # can't
+            ("foo", "bar", "baz"),
+            # shouldn't
+            ("0", "1", "2"),
+        ],
+    )
+    def test_cant_or_shouldnt_cast(self, start, stop, step):
+        msg = f"Wrong type {type(start)} for value {start}"
+        with pytest.raises(TypeError, match=msg):
+            RangeIndex(start, stop, step)
+
+    def test_view_index(self, simple_index):
+        index = simple_index
+        msg = "Passing a type in RangeIndex.view is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            index.view(Index)
+
+    def test_prevent_casting(self, simple_index):
+        index = simple_index
+        result = index.astype("O")
+        assert result.dtype == np.object_
+
+    def test_repr_roundtrip(self, simple_index):
+        index = simple_index
+        tm.assert_index_equal(eval(repr(index)), index)
+
+    def test_slice_keep_name(self):
+        idx = RangeIndex(1, 2, name="asdf")
+        assert idx.name == idx[1:].name
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            RangeIndex(start=0, stop=20, step=2, name="foo"),
+            RangeIndex(start=18, stop=-1, step=-2, name="bar"),
+        ],
+        ids=["index_inc", "index_dec"],
+    )
+    def test_has_duplicates(self, index):
+        assert index.is_unique
+        assert not index.has_duplicates
+
+    def test_extended_gcd(self, simple_index):
+        index = simple_index
+        result = index._extended_gcd(6, 10)
+        assert result[0] == result[1] * 6 + result[2] * 10
+        assert 2 == result[0]
+
+        result = index._extended_gcd(10, 6)
+        assert 2 == result[1] * 10 + result[2] * 6
+        assert 2 == result[0]
+
+    def test_min_fitting_element(self):
+        result = RangeIndex(0, 20, 2)._min_fitting_element(1)
+        assert 2 == result
+
+        result = RangeIndex(1, 6)._min_fitting_element(1)
+        assert 1 == result
+
+        result = RangeIndex(18, -2, -2)._min_fitting_element(1)
+        assert 2 == result
+
+        result = RangeIndex(5, 0, -1)._min_fitting_element(1)
+        assert 1 == result
+
+        big_num = 500000000000000000000000
+
+        result = RangeIndex(5, big_num * 2, 1)._min_fitting_element(big_num)
+        assert big_num == result
+
+    def test_slice_specialised(self, simple_index):
+        index = simple_index
+        index.name = "foo"
+
+        # scalar indexing
+        res = index[1]
+        expected = 2
+        assert res == expected
+
+        res = index[-1]
+        expected = 18
+        assert res == expected
+
+        # slicing
+        # slice value completion
+        index_slice = index[:]
+        expected = index
+        tm.assert_index_equal(index_slice, expected)
+
+        # positive slice values
+        index_slice = index[7:10:2]
+        expected = Index([14, 18], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        # negative slice values
+        index_slice = index[-1:-5:-2]
+        expected = Index([18, 14], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        # stop overshoot
+        index_slice = index[2:100:4]
+        expected = Index([4, 12], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        # reverse
+        index_slice = index[::-1]
+        expected = Index(index.values[::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        index_slice = index[-8::-1]
+        expected = Index([4, 2, 0], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        index_slice = index[-40::-1]
+        expected = Index(np.array([], dtype=np.int64), name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        index_slice = index[40::-1]
+        expected = Index(index.values[40::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+        index_slice = index[10::-1]
+        expected = Index(index.values[::-1], name="foo")
+        tm.assert_index_equal(index_slice, expected, exact="equiv")
+
+    @pytest.mark.parametrize("step", set(range(-5, 6)) - {0})
+    def test_len_specialised(self, step):
+        # make sure that our len is the same as np.arange calc
+        start, stop = (0, 5) if step > 0 else (5, 0)
+
+        arr = np.arange(start, stop, step)
+        index = RangeIndex(start, stop, step)
+        assert len(index) == len(arr)
+
+        index = RangeIndex(stop, start, step)
+        assert len(index) == 0
+
+    @pytest.mark.parametrize(
+        "indices, expected",
+        [
+            ([RangeIndex(1, 12, 5)], RangeIndex(1, 12, 5)),
+            ([RangeIndex(0, 6, 4)], RangeIndex(0, 6, 4)),
+            ([RangeIndex(1, 3), RangeIndex(3, 7)], RangeIndex(1, 7)),
+            ([RangeIndex(1, 5, 2), RangeIndex(5, 6)], RangeIndex(1, 6, 2)),
+            ([RangeIndex(1, 3, 2), RangeIndex(4, 7, 3)], RangeIndex(1, 7, 3)),
+            ([RangeIndex(-4, 3, 2), RangeIndex(4, 7, 2)], RangeIndex(-4, 7, 2)),
+            ([RangeIndex(-4, -8), RangeIndex(-8, -12)], RangeIndex(0, 0)),
+            ([RangeIndex(-4, -8), RangeIndex(3, -4)], RangeIndex(0, 0)),
+            ([RangeIndex(-4, -8), RangeIndex(3, 5)], RangeIndex(3, 5)),
+            ([RangeIndex(-4, -2), RangeIndex(3, 5)], Index([-4, -3, 3, 4])),
+            ([RangeIndex(-2), RangeIndex(3, 5)], RangeIndex(3, 5)),
+            ([RangeIndex(2), RangeIndex(2)], Index([0, 1, 0, 1])),
+            ([RangeIndex(2), RangeIndex(2, 5), RangeIndex(5, 8, 4)], RangeIndex(0, 6)),
+            (
+                [RangeIndex(2), RangeIndex(3, 5), RangeIndex(5, 8, 4)],
+                Index([0, 1, 3, 4, 5]),
+            ),
+            (
+                [RangeIndex(-2, 2), RangeIndex(2, 5), RangeIndex(5, 8, 4)],
+                RangeIndex(-2, 6),
+            ),
+            ([RangeIndex(3), Index([-1, 3, 15])], Index([0, 1, 2, -1, 3, 15])),
+            ([RangeIndex(3), Index([-1, 3.1, 15.0])], Index([0, 1, 2, -1, 3.1, 15.0])),
+            ([RangeIndex(3), Index(["a", None, 14])], Index([0, 1, 2, "a", None, 14])),
+            ([RangeIndex(3, 1), Index(["a", None, 14])], Index(["a", None, 14])),
+        ],
+    )
+    def test_append(self, indices, expected):
+        # GH16212
+        result = indices[0].append(indices[1:])
+        tm.assert_index_equal(result, expected, exact=True)
+
+        if len(indices) == 2:
+            # Append single item rather than list
+            result2 = indices[0].append(indices[1])
+            tm.assert_index_equal(result2, expected, exact=True)
+
+    def test_engineless_lookup(self):
+        # GH 16685
+        # Standard lookup on RangeIndex should not require the engine to be
+        # created
+        idx = RangeIndex(2, 10, 3)
+
+        assert idx.get_loc(5) == 1
+        tm.assert_numpy_array_equal(
+            idx.get_indexer([2, 8]), ensure_platform_int(np.array([0, 2]))
+        )
+        with pytest.raises(KeyError, match="3"):
+            idx.get_loc(3)
+
+        assert "_engine" not in idx._cache
+
+        # Different types of scalars can be excluded immediately, no need to
+        #  use the _engine
+        with pytest.raises(KeyError, match="'a'"):
+            idx.get_loc("a")
+
+        assert "_engine" not in idx._cache
+
+    def test_format_empty(self):
+        # GH35712
+        empty_idx = RangeIndex(0)
+        msg = r"RangeIndex\.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert empty_idx.format() == []
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert empty_idx.format(name=True) == [""]
+
+    @pytest.mark.parametrize(
+        "ri",
+        [
+            RangeIndex(0, -1, -1),
+            RangeIndex(0, 1, 1),
+            RangeIndex(1, 3, 2),
+            RangeIndex(0, -1, -2),
+            RangeIndex(-3, -5, -2),
+        ],
+    )
+    def test_append_len_one(self, ri):
+        # GH39401
+        result = ri.append([])
+        tm.assert_index_equal(result, ri, exact=True)
+
+    @pytest.mark.parametrize("base", [RangeIndex(0, 2), Index([0, 1])])
+    def test_isin_range(self, base):
+        # GH#41151
+        values = RangeIndex(0, 1)
+        result = base.isin(values)
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_sort_values_key(self):
+        # GH#43666, GH#52764
+        sort_order = {8: 2, 6: 0, 4: 8, 2: 10, 0: 12}
+        values = RangeIndex(0, 10, 2)
+        result = values.sort_values(key=lambda x: x.map(sort_order))
+        expected = Index([6, 8, 4, 2, 0], dtype="int64")
+        tm.assert_index_equal(result, expected, check_exact=True)
+
+        # check this matches the Series.sort_values behavior
+        ser = values.to_series()
+        result2 = ser.sort_values(key=lambda x: x.map(sort_order))
+        tm.assert_series_equal(result2, expected.to_series(), check_exact=True)
+
+    def test_range_index_rsub_by_const(self):
+        # GH#53255
+        result = 3 - RangeIndex(0, 4, 1)
+        expected = RangeIndex(3, -1, -1)
+        tm.assert_index_equal(result, expected)
diff --git a/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_setops.py b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_setops.py
new file mode 100644
index 0000000000000000000000000000000000000000..d417b8b743dc589bdf9d6acf5bde396a129ece23
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/pandas/tests/indexes/ranges/test_setops.py
@@ -0,0 +1,493 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+from hypothesis import (
+    assume,
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+class TestRangeIndexSetOps:
+    @pytest.mark.parametrize("dtype", [None, "int64", "uint64"])
+    def test_intersection_mismatched_dtype(self, dtype):
+        # check that we cast to float, not object
+        index = RangeIndex(start=0, stop=20, step=2, name="foo")
+        index = Index(index, dtype=dtype)
+
+        flt = index.astype(np.float64)
+
+        # bc index.equals(flt), we go through fastpath and get RangeIndex back
+        result = index.intersection(flt)
+        tm.assert_index_equal(result, index, exact=True)
+
+        result = flt.intersection(index)
+        tm.assert_index_equal(result, flt, exact=True)
+
+        # neither empty, not-equals
+        result = index.intersection(flt[1:])
+        tm.assert_index_equal(result, flt[1:], exact=True)
+
+        result = flt[1:].intersection(index)
+        tm.assert_index_equal(result, flt[1:], exact=True)
+
+        # empty other
+        result = index.intersection(flt[:0])
+        tm.assert_index_equal(result, flt[:0], exact=True)
+
+        result = flt[:0].intersection(index)
+        tm.assert_index_equal(result, flt[:0], exact=True)
+
+    def test_intersection_empty(self, sort, names):
+        # name retention on empty intersections
+        index = RangeIndex(start=0, stop=20, step=2, name=names[0])
+
+        # empty other
+        result = index.intersection(index[:0].rename(names[1]), sort=sort)
+        tm.assert_index_equal(result, index[:0].rename(names[2]), exact=True)
+
+        # empty self
+        result = index[:0].intersection(index.rename(names[1]), sort=sort)
+        tm.assert_index_equal(result, index[:0].rename(names[2]), exact=True)
+
+    def test_intersection(self, sort):
+        # intersect with Index with dtype int64
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index(np.arange(1, 6))
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index, sort=sort)
+        expected = Index(
+            np.sort(np.asarray(np.intersect1d(index.values, other.values)))
+        )
+        tm.assert_index_equal(result, expected)
+
+        # intersect with increasing RangeIndex
+        other = RangeIndex(1, 6)
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+        # intersect with decreasing RangeIndex
+        other = RangeIndex(5, 0, -1)
+        result = index.intersection(other, sort=sort)
+        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+        # reversed (GH 17296)
+        result = other.intersection(index, sort=sort)
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+        # GH 17296: intersect two decreasing RangeIndexes
+        first = RangeIndex(10, -2, -2)
+        other = RangeIndex(5, -4, -1)
+        expected = first.astype(int).intersection(other.astype(int), sort=sort)
+        result = first.intersection(other, sort=sort).astype(int)
+        tm.assert_index_equal(result, expected)
+
+        # reversed
+        result = other.intersection(first, sort=sort).astype(int)
+        tm.assert_index_equal(result, expected)
+
+        index = RangeIndex(5, name="foo")
+
+        # intersect of non-overlapping indices
+        other = RangeIndex(5, 10, 1, name="foo")
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        other = RangeIndex(-1, -5, -1)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+        # intersection of empty indices
+        other = RangeIndex(0, 0, 1)
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1)
+        tm.assert_index_equal(result, expected)
+
+        result = other.intersection(index, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection_non_overlapping_gcd(self, sort, names):
+        # intersection of non-overlapping values based on start value and gcd
+        index = RangeIndex(1, 10, 2, name=names[0])
+        other = RangeIndex(0, 10, 4, name=names[1])
+        result = index.intersection(other, sort=sort)
+        expected = RangeIndex(0, 0, 1, name=names[2])
+        tm.assert_index_equal(result, expected)
+
+    def test_union_noncomparable(self, sort):
+        # corner case, Index with non-int64 dtype
+        index = RangeIndex(start=0, stop=20, step=2)
+        other = Index([datetime.now() + timedelta(i) for i in range(4)], dtype=object)
+        result = index.union(other, sort=sort)
+        expected = Index(np.concatenate((index, other)))
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index, sort=sort)
+        expected = Index(np.concatenate((other, index)))
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "idx1, idx2, expected_sorted, expected_notsorted",
+        [
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(5, 20, 1),
+                RangeIndex(0, 20, 1),
+                RangeIndex(0, 20, 1),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                RangeIndex(10, 20, 1),
+                RangeIndex(0, 20, 1),
+                RangeIndex(0, 20, 1),
+            ),
+            (
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+                RangeIndex(0, -10, -1),
+            ),
+            (
+                RangeIndex(0, -10, -1),
+                RangeIndex(-10, -20, -1),
+                RangeIndex(-19, 1, 1),
+                RangeIndex(0, -20, -1),
+            ),
+            (
+                RangeIndex(0, 10, 2),
+                RangeIndex(1, 10, 2),
+                RangeIndex(0, 10, 1),
+                Index(list(range(0, 10, 2)) + list(range(1, 10, 2))),
+            ),
+            (
+                RangeIndex(0, 11, 2),
+                RangeIndex(1, 12, 2),
+                RangeIndex(0, 12, 1),
+                Index(list(range(0, 11, 2)) + list(range(1, 12, 2))),
+            ),
+            (
+                RangeIndex(0, 21, 4),
+                RangeIndex(-2, 24, 4),
+                RangeIndex(-2, 24, 2),
+                Index(list(range(0, 21, 4)) + list(range(-2, 24, 4))),
+            ),
+            (
+                RangeIndex(0, -20, -2),
+                RangeIndex(-1, -21, -2),
+                RangeIndex(-19, 1, 1),
+                Index(list(range(0, -20, -2)) + list(range(-1, -21, -2))),
+            ),
+            (
+                RangeIndex(0, 100, 5),
+                RangeIndex(0, 100, 20),
+                RangeIndex(0, 100, 5),
+                RangeIndex(0, 100, 5),
+            ),
+            (
+                RangeIndex(0, -100, -5),
+                RangeIndex(5, -100, -20),
+                RangeIndex(-95, 10, 5),
+                Index(list(range(0, -100, -5)) + [5]),
+            ),
+            (
+                RangeIndex(0, -11, -1),
+                RangeIndex(1, -12, -4),
+                RangeIndex(-11, 2, 1),
+                Index(list(range(0, -11, -1)) + [1, -11]),
+            ),
+            (RangeIndex(0), RangeIndex(0), RangeIndex(0), RangeIndex(0)),
+            (
+                RangeIndex(0, -10, -2),
+                RangeIndex(0),
+                RangeIndex(0, -10, -2),
+                RangeIndex(0, -10, -2),
+            ),
+            (
+                RangeIndex(0, 100, 2),
+                RangeIndex(100, 150, 200),
+                RangeIndex(0, 102, 2),
+                RangeIndex(0, 102, 2),
+            ),
+            (
+                RangeIndex(0, -100, -2),
+                RangeIndex(-100, 50, 102),
+                RangeIndex(-100, 4, 2),
+                Index(list(range(0, -100, -2)) + [-100, 2]),
+            ),
+            (
+                RangeIndex(0, -100, -1),
+                RangeIndex(0, -50, -3),
+                RangeIndex(-99, 1, 1),
+                RangeIndex(0, -100, -1),
+            ),
+            (
+                RangeIndex(0, 1, 1),
+                RangeIndex(5, 6, 10),
+                RangeIndex(0, 6, 5),
+                RangeIndex(0, 10, 5),
+            ),
+            (
+                RangeIndex(0, 10, 5),
+                RangeIndex(-5, -6, -20),
+                RangeIndex(-5, 10, 5),
+                Index([0, 5, -5]),
+            ),
+            (
+                RangeIndex(0, 3, 1),
+                RangeIndex(4, 5, 1),
+                Index([0, 1, 2, 4]),
+                Index([0, 1, 2, 4]),
+            ),
+            (
+                RangeIndex(0, 10, 1),
+                Index([], dtype=np.int64),
+                RangeIndex(0, 10, 1),
+                RangeIndex(0, 10, 1),
+            ),
+            (
+                RangeIndex(0),
+                Index([1, 5, 6]),
+                Index([1, 5, 6]),
+                Index([1, 5, 6]),
+            ),
+            # GH 43885
+            (
+                RangeIndex(0, 10),
+                RangeIndex(0, 5),
+                RangeIndex(0, 10),
+                RangeIndex(0, 10),
+            ),
+        ],
+        ids=lambda x: repr(x) if isinstance(x, RangeIndex) else x,
+    )
+    def test_union_sorted(self, idx1, idx2, expected_sorted, expected_notsorted):
+        res1 = idx1.union(idx2, sort=None)
+        tm.assert_index_equal(res1, expected_sorted, exact=True)
+
+        res1 = idx1.union(idx2, sort=False)
+        tm.assert_index_equal(res1, expected_notsorted, exact=True)
+
+        res2 = idx2.union(idx1, sort=None)
+        res3 = Index(idx1._values, name=idx1.name).union(idx2, sort=None)
+        tm.assert_index_equal(res2, expected_sorted, exact=True)
+        tm.assert_index_equal(res3, expected_sorted, exact="equiv")
+
+    def test_union_same_step_misaligned(self):
+        # GH#44019
+        left = RangeIndex(range(0, 20, 4))
+        right = RangeIndex(range(1, 21, 4))
+
+        result = left.union(right)
+        expected = Index([0, 1, 4, 5, 8, 9, 12, 13, 16, 17])
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_difference(self):
+        # GH#12034 Cases where we operate against another RangeIndex and may
+        #  get back another RangeIndex
+        obj = RangeIndex.from_range(range(1, 10), name="foo")
+
+        result = obj.difference(obj)
+        expected = RangeIndex.from_range(range(0), name="foo")
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = obj.difference(expected.rename("bar"))
+        tm.assert_index_equal(result, obj.rename(None), exact=True)
+
+        result = obj.difference(obj[:3])
+        tm.assert_index_equal(result, obj[3:], exact=True)
+
+        result = obj.difference(obj[-3:])
+        tm.assert_index_equal(result, obj[:-3], exact=True)
+
+        # Flipping the step of 'other' doesn't affect the result, but
+        #  flipping the stepof 'self' does when sort=None
+        result = obj[::-1].difference(obj[-3:])
+        tm.assert_index_equal(result, obj[:-3], exact=True)
+
+        result = obj[::-1].difference(obj[-3:], sort=False)
+        tm.assert_index_equal(result, obj[:-3][::-1], exact=True)
+
+        result = obj[::-1].difference(obj[-3:][::-1])
+        tm.assert_index_equal(result, obj[:-3], exact=True)
+
+        result = obj[::-1].difference(obj[-3:][::-1], sort=False)
+        tm.assert_index_equal(result, obj[:-3][::-1], exact=True)
+
+        result = obj.difference(obj[2:6])
+        expected = Index([1, 2, 7, 8, 9], name="foo")
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_difference_sort(self):
+        # GH#44085 ensure we respect the sort keyword
+
+        idx = Index(range(4))[::-1]
+        other = Index(range(3, 4))
+
+        result = idx.difference(other)
+        expected = Index(range(3))
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = idx.difference(other, sort=False)
+        expected = expected[::-1]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # case where the intersection is empty
+        other = range(10, 12)
+        result = idx.difference(other, sort=None)
+        expected = idx[::-1]
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_difference_mismatched_step(self):
+        obj = RangeIndex.from_range(range(1, 10), name="foo")
+
+        result = obj.difference(obj[::2])
+        expected = obj[1::2]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = obj[::-1].difference(obj[::2], sort=False)
+        tm.assert_index_equal(result, expected[::-1], exact=True)
+
+        result = obj.difference(obj[1::2])
+        expected = obj[::2]
+        tm.assert_index_equal(result, expected, exact=True)
+
+        result = obj[::-1].difference(obj[1::2], sort=False)
+        tm.assert_index_equal(result, expected[::-1], exact=True)
+
+    def test_difference_interior_overlap_endpoints_preserved(self):
+        left = RangeIndex(range(4))
+        right = RangeIndex(range(1, 3))
+
+        result = left.difference(right)
+        expected = RangeIndex(0, 4, 3)
+        assert expected.tolist() == [0, 3]
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_difference_endpoints_overlap_interior_preserved(self):
+        left = RangeIndex(-8, 20, 7)
+        right = RangeIndex(13, -9, -3)
+
+        result = left.difference(right)
+        expected = RangeIndex(-1, 13, 7)
+        assert expected.tolist() == [-1, 6]
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_difference_interior_non_preserving(self):
+        # case with intersection of length 1 but RangeIndex is not preserved
+        idx = Index(range(10))
+
+        other = idx[3:4]
+        result = idx.difference(other)
+        expected = Index([0, 1, 2, 4, 5, 6, 7, 8, 9])
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # case with other.step / self.step > 2
+        other = idx[::3]
+        result = idx.difference(other)
+        expected = Index([1, 2, 4, 5, 7, 8])
+        tm.assert_index_equal(result, expected, exact=True)
+
+        # cases with only reaching one end of left
+        obj = Index(range(20))
+        other = obj[:10:2]
+        result = obj.difference(other)
+        expected = Index([1, 3, 5, 7, 9] + list(range(10, 20)))
+        tm.assert_index_equal(result, expected, exact=True)
+
+        other = obj[1:11:2]
+        result = obj.difference(other)
+        expected = Index([0, 2, 4, 6, 8, 10] + list(range(11, 20)))
+        tm.assert_index_equal(result, expected, exact=True)
+
+    def test_symmetric_difference(self):
+        # GH#12034 Cases where we operate against another RangeIndex and may
+        #  get back another RangeIndex
+        left = RangeIndex.from_range(range(1, 10), name="foo")
+
+        result = left.symmetric_difference(left)
+        expected = RangeIndex.from_range(range(0), name="foo")
+        tm.assert_index_equal(result, expected)
+
+        result = left.symmetric_difference(expected.rename("bar"))
+        tm.assert_index_equal(result, left.rename(None))
+
+        result = left[:-2].symmetric_difference(left[2:])
+        expected = Index([1, 2, 8, 9], name="foo")
+        tm.assert_index_equal(result, expected, exact=True)
+
+        right = RangeIndex.from_range(range(10, 15))
+
+        result = left.symmetric_difference(right)
+        expected = RangeIndex.from_range(range(1, 15))
+        tm.assert_index_equal(result, expected)
+
+        result = left.symmetric_difference(right[1:])
+        expected = Index([1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14])
+        tm.assert_index_equal(result, expected, exact=True)
+
+
+def assert_range_or_not_is_rangelike(index):
+    """
+    Check that we either have a RangeIndex or that this index *cannot*
+    be represented as a RangeIndex.
+    """
+    if not isinstance(index, RangeIndex) and len(index) > 0:
+        diff = index[:-1] - index[1:]
+        assert not (diff == diff[0]).all()
+
+
+@given(
+    st.integers(-20, 20),
+    st.integers(-20, 20),
+    st.integers(-20, 20),
+    st.integers(-20, 20),
+    st.integers(-20, 20),
+    st.integers(-20, 20),
+)
+def test_range_difference(start1, stop1, step1, start2, stop2, step2):
+    # test that
+    #  a) we match Index[int64].difference and
+    #  b) we return RangeIndex whenever it is possible to do so.
+    assume(step1 != 0)
+    assume(step2 != 0)
+
+    left = RangeIndex(start1, stop1, step1)
+    right = RangeIndex(start2, stop2, step2)
+
+    result = left.difference(right, sort=None)
+    assert_range_or_not_is_rangelike(result)
+
+    left_int64 = Index(left.to_numpy())
+    right_int64 = Index(right.to_numpy())
+
+    alt = left_int64.difference(right_int64, sort=None)
+    tm.assert_index_equal(result, alt, exact="equiv")
+
+    result = left.difference(right, sort=False)
+    assert_range_or_not_is_rangelike(result)
+
+    alt = left_int64.difference(right_int64, sort=False)
+    tm.assert_index_equal(result, alt, exact="equiv")